summary refs log tree commit diff
path: root/emacs.org
blob: f64dc62298beadf0b518544f542eef223999b924 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
#+TITLE:Emacs config
#+AUTHOR: Crazazy
#+PROPERTY: header-args :tangle yes :noweb yes :results silent
#+INCLUDE: ./style.org
Welp, here it goes. This is a literal config for my emacs setup
I will prbably copy-paste what I have in my literal config, and provide small, fun explanations along the way
For now, prepare this to be not the best documented literal config you've seen.
Also, if you just stumbled accross this at random, there is an easy tangle button at [[file:readme.org][readme.org]]
* Before we start lisping
  This emacs config's dependencies are mostly managed by [[https://nixos.org][nix]], therefore we have to make a nix file before we
  do any emacs configuring by ourselves
  We also add webkitgtk support for (eventual) web browsing support
  #+begin_src nix :tangle emacs.nix
    let
      sources = import ./nix/sources.nix;
      packageOverlay = final: old: {
        emacs = old.emacs.override {
          withXwidgets = true;
        };
        emacsWithPackages = final.emacs.pkgs.withPackages;
      };
    in
    import sources.emacs {
      # put 'packageOverlay' in the overlays array for XWidgets (whenever they are stable i guess...)
      pkgs = import <nixpkgs> { overlays = [ ]; };
      configDir = ./emacsconfig;
    }
  #+end_src
* Emacs configuring
  Now the real configuring begins!
  for some backwards compat purposes I have decided to but different config subjects into different files
  This won't matter too much as the nix framework is expecting multiple files anyway!
** The bases
   This is only better-defaults. It comes with ido-mode and some other defaults that I forgot to set in my
   init file that I stole from [[https://github.com/editor-bootstrap/emacs-bootstrap][emacs-bootstrap]] months ago
   #+begin_src emacs-lisp :mkdirp yes :tangle emacsconfig/base.el
     (use-package better-defaults)
   #+end_src
*** Multiple terminals
    By default, =term= only supports 1 terminal. This version supports multiple terminals
    #+begin_src emacs-lisp :tangle emacsconfig/base.el
      (defun new-term (program)
        "start a new terminal emulator in a new buffer"
        (interactive (list (read-from-minibuffer "Run program: "
                                                 (or explicit-shell-file-name
                                                     (getenv "ESHELL")
                                                     shell-file-name))))
        (let* ((term-list (seq-filter
                           (lambda (s) (string-match-p "terminal" (buffer-name s)))
                           (buffer-list)))
               (term-num (number-to-string (length term-list))))
          (set-buffer (make-term (concat "terminal-" term-num) program))
          (term-mode)
          (term-char-mode)
          (switch-to-buffer (concat "*terminal-" term-num "*"))))
    #+end_src
** Generally nice emacs tools
*** Magit
    Simple. Nice. default config. (almost)
    #+begin_src emacs-lisp :tangle emacsconfig/extras.el
      (use-package magit
        :init
        ;; import missing function
        (defun seq-keep (function sequence)
          "Apply FUNCTION to SEQUENCE and return the list of all the non-nil results"
          (delq nil (seq-map function sequence)))
        :config
        (magit-add-section-hook 'magit-status-sections-hook
                                'magit-insert-modules
                                'magit-insert-stashes
                                'append)
        :bind
        ("C-x g" . magit-status))
      (use-package forge
        :after magit)
    #+end_src
*** IRC
    I use IRC in emacs, with ERC. There is even a small macro so that I can easily join new servers
    with my preferred nickname
    #+begin_src emacs-lisp :tangle emacsconfig/extras.el
      (use-package erc
        :custom
        (erc-server-reconnect-attempts 10)
        (erc-nick "crazazy")
        (erc-autojoin-channels-alist '(("tilde.chat"
                                        "#cafe"
                                        "#meta")
                                       ("libera.chat"
                                        "#emacs"
                                        "#haskell"
                                        "#systemcrafters")))
        :config
        (defmacro irc-quickjoin (servername url &optional nick)
          "create a function to quickly join a server. Servers can be joined with M-x SERVERNAME-irc"
          `(defun ,(intern (concat (symbol-name servername) "-irc")) (password)
             (interactive (list (password-read "Password: ")))
             (erc-tls :server ,url
                      :nick ,(if nick
                                 nick
                               "crazazy")
                      :port 6697
                      :password password)))

        (irc-quickjoin tilde "eu.tilde.chat")
        (irc-quickjoin libera "irc.libera.chat"))
    #+end_src
*** Dashboard
    Gives me access to the most recent files I edited, and some other stuff that I don't really care about
    #+begin_src emacs-lisp :tangle emacsconfig/extras.el
      (use-package dashboard
        :config (dashboard-setup-startup-hook))
    #+end_src
*** Elfeed
    I don't use elfeed in emacs that much anymore, as I have switched to [[https://www.seamonkey-project.org/][seamonkey]] for my RSS needs.
    Here is my old config anyways. If you want to browse through some default news feel free to remove the last
    =:custom= option
    #+begin_src emacs-lisp :tangle emacsconfig/extras.el
      (use-package elfeed
        :bind
        ("C-x w" . elfeed)
        (:map elfeed-search-mode-map
              ("C-c a" . elfeed-add-feed)
              ("C-c u" . elfeed-update)
              ("C-c f" . elfeed-update-feed)
              ("C-c r" . elfeed-mark-all-as-read))
        :config
        (defun elfeed-mark-all-as-read ()
          (interactive)
          (mark-whole-buffer)
          (elfeed-search-untag-all-unread))
        :custom
        (elfeed-search-filter  "@6-months-ago +quality")
        (elfeed-feeds  '(("http://feeds.feedburner.com/tweakers/nieuws" NL tech exportable)
                         ("https://discourse.nixos.org/c/announcements/8.rss" nixos programming quality)
                         ("http://www.dnbradio.com/feeds" music podcasts)
                         ("https://codepen.io/spark/feed/" programming quality)
                         ("https://envs.net/~lucidiot/rsrsss/feed.xml" RSS quality)
                         ("https://falseknees.tumblr.com/rss" comics quality)
                         ("https://hackspace.raspberrypi.org/feed" tech programming)
                         ("https://lobste.rs/rss" programming)
                         ("https://news.rickcarlino.com/rss.rss" tech)
                         ("https://nu.nl/rss" NL news exportable)
                         ("https://planet.haskell.org/atom.xml" haskell programming)
                         ("https://planet.nixos.org/atom.xml" nixos programming quality)
                         ("https://reddit.com/r/dnb/.rss" reddit music)
                         ("https://reddit.com/r/programming/.rss" reddit programming)
                         ("https://reddit.com/r/realdubstep/.rss" reddit music)
                         ("https://reddit.com/r/thenetherlands/.rss" NL reddit)
                         ("https://sachachua.com/blog/category/emacs-news/feed" emacs quality programming)
                         ("https://webzine.puffy.cafe/atom.xml" openbsd tech quality programming)
                         ("https://www.fosskers.ca/en/rss" programming quality exportable)
                         ("https://xkcd.com/atom.xml" comics)))
        (elfeed-feeds nil)
        (elfeed-search-filter  ""))
    #+end_src
*** Org mode
    While the brunt of this file is relatively vanilla, There are still some things that I want to customize about the org-mode experience
    For now, I think it's best if I don't start depending on org-contrib, as it contains a lot of features and I would waste quite some time
    figuring out what all those features are.

    First of all, auto-indenting isn't enabled everywhere, so let's do that
    #+begin_src emacs-lisp :tangle emacsconfig/org.el
      (use-package org
        :custom
        (org-adapt-indentation t))
    #+end_src
**** Syntax highlighting for HTML exports
     Normally, when I export my document to an html file for the website, syntax highlighting isn't automatically turned on. htmlize changes this
     by putting some colorful spans in all my source code. No need to configure anything either
     #+begin_src emacs-lisp :tangle emacsconfig/org.el
       (use-package htmlize)
     #+end_src
**** Org roam                                                      :noexport:
     My parents are really urging me to take notes of stuff now. And I'm inclined to agree. I'll try and figure out what
     I need from my note taking program down the line, but for now here is a basic config
     Mostly stolen from [[https://systemcrafters.net/build-a-second-brain-in-emacs/][System crafters]]
     I will have to figure out what most of this does /exactly/ but from the description this all seems like
     stuff that I'd want for my note taking setup
     #+begin_src emacs-lisp :tangle no
       (use-package org-roam
         :ensure t
         :demand t  ;; Ensure org-roam is loaded by default
         :init
         (setq org-roam-v2-ack t)
         :custom
         (org-roam-directory "~/Documents/notes")
         (org-roam-completion-everywhere t)
         :bind (("C-c n l" . org-roam-buffer-toggle)
                ("C-c n f" . org-roam-node-find)
                ("C-c n i" . org-roam-node-insert)
                ("C-c n I" . org-roam-node-insert-immediate)
                ("C-c n p" . my/org-roam-find-project)
                ("C-c n t" . my/org-roam-capture-task)
                ("C-c n b" . my/org-roam-capture-inbox)
                :map org-mode-map
                ("C-M-i" . completion-at-point)
                :map org-roam-dailies-map
                ("Y" . org-roam-dailies-capture-yesterday)
                ("T" . org-roam-dailies-capture-tomorrow))
         :bind-keymap
         ("C-c n d" . org-roam-dailies-map)
         :config
         (require 'org-roam-dailies) ;; Ensure the keymap is available
         (org-roam-db-autosync-mode))

       (defun org-roam-node-insert-immediate (arg &rest args)
         (interactive "P")
         (let ((args (push arg args))
               (org-roam-capture-templates (list (append (car org-roam-capture-templates)
                                                         '(:immediate-finish t)))))
           (apply #'org-roam-node-insert args)))

       (defun my/org-roam-filter-by-tag (tag-name)
         (lambda (node)
           (member tag-name (org-roam-node-tags node))))

       (defun my/org-roam-list-notes-by-tag (tag-name)
         (mapcar #'org-roam-node-file
                 (seq-filter
                  (my/org-roam-filter-by-tag tag-name)
                  (org-roam-node-list))))

       (defun my/org-roam-refresh-agenda-list ()
         (interactive)
         (setq org-agenda-files (my/org-roam-list-notes-by-tag "Project")))

       ;; Build the agenda list the first time for the session
       (my/org-roam-refresh-agenda-list)

       (defun my/org-roam-project-finalize-hook ()
         "Adds the captured project file to `org-agenda-files' if the
       capture was not aborted."
         ;; Remove the hook since it was added temporarily
         (remove-hook 'org-capture-after-finalize-hook #'my/org-roam-project-finalize-hook)

         ;; Add project file to the agenda list if the capture was confirmed
         (unless org-note-abort
           (with-current-buffer (org-capture-get :buffer)
             (add-to-list 'org-agenda-files (buffer-file-name)))))

       (defun my/org-roam-find-project ()
         (interactive)
         ;; Add the project file to the agenda after capture is finished
         (add-hook 'org-capture-after-finalize-hook #'my/org-roam-project-finalize-hook)

         ;; Select a project file to open, creating it if necessary
         (org-roam-node-find
          nil
          nil
          (my/org-roam-filter-by-tag "Project")
          :templates
          '(("p" "project" plain "* Goals\n\n%?\n\n* Tasks\n\n** TODO Add initial tasks\n\n* Dates\n\n"
             :if-new (file+head "%<%Y%m%d%H%M%S>-${slug}.org" "#+title: ${title}\n#+category: ${title}\n#+filetags: Project")
             :unnarrowed t))))

       (defun my/org-roam-capture-inbox ()
         (interactive)
         (org-roam-capture- :node (org-roam-node-create)
                            :templates '(("i" "inbox" plain "* %?"
                                          :if-new (file+head "Inbox.org" "#+title: Inbox\n")))))

       (defun my/org-roam-capture-task ()
         (interactive)
         ;; Add the project file to the agenda after capture is finished
         (add-hook 'org-capture-after-finalize-hook #'my/org-roam-project-finalize-hook)

         ;; Capture the new task, creating the project file if necessary
         (org-roam-capture- :node (org-roam-node-read
                                   nil
                                   (my/org-roam-filter-by-tag "Project"))
                            :templates '(("p" "project" plain "** TODO %?"
                                          :if-new (file+head+olp "%<%Y%m%d%H%M%S>-${slug}.org"
                                                                 "#+title: ${title}\n#+category: ${title}\n#+filetags: Project"
                                                                 ("Tasks"))))))

       (defun my/org-roam-copy-todo-to-today ()
         (interactive)
         (let ((org-refile-keep t) ;; Set this to nil to delete the original!
               (org-roam-dailies-capture-templates
                '(("t" "tasks" entry "%?"
                   :if-new (file+head+olp "%<%Y-%m-%d>.org" "#+title: %<%Y-%m-%d>\n" ("Tasks")))))
               (org-after-refile-insert-hook #'save-buffer)
               today-file
               pos)
           (save-window-excursion
             (org-roam-dailies--capture (current-time) t)
             (setq today-file (buffer-file-name))
             (setq pos (point)))

           ;; Only refile if the target file is different than the current file
           (unless (equal (file-truename today-file)
                          (file-truename (buffer-file-name)))
             (org-refile nil nil (list "Tasks" today-file nil pos)))))

       (add-to-list 'org-after-todo-state-change-hook
                    (lambda ()
                      (when (equal org-state "DONE")
                        (my/org-roam-copy-todo-to-today))))

     #+end_src
**** Denote
     I used to want to try out org-roam, but nothing came of that. However, right now I do have notes in denote,
     and since emacs-ng doesn't work with denote anymore (since its stuck at version 28.0.50) I have to move to
     the default version of emacs
     #+begin_src emacs-lisp :tangle emacsconfig/org.el
       (use-package denote
         :ensure t
         :custom
         (denote-directory "~/Documents/notes/")
         (denote-file-type nil)
         (denote-prompts '(title keywords))
         (denote-date-prompt-use-org-read-date t)
         :bind
         (("C-c n n" . denote)
          ("C-c n N" . denote-type)
          ("C-c n d" . denote-date)
          ("C-c n s" . denote-subdirectory)
          ("C-c n t" . denote-template)
          ("C-c n r" . denote-rename-file)
          :map org-mode-map
          ("C-c n i" . denote-link)
          ("C-c n I" . denote-link-add-links)
          ("C-c n l" . denote-link-find-file)
          ("C-c n b" . denote-link-backlinks)))
     #+end_src
*** Evil mode
    I am originally a vim user, and the standard vim bindings have not left my hands yet,
    I am not a big configurer, so this is mostly just the standard configuration that [[https://github.com/emacs-evil/evil-collection#installation][evil-mode]] advices you to do
    #+begin_src emacs-lisp :tangle emacsconfig/evil.el
      (use-package evil
        :init
        (setq evil-want-integration t) ;; This is optional since it's already set to t by default.
        (setq evil-want-keybinding nil)
        :config
        (evil-define-key 'normal global-map "," 'evil-execute-in-god-state)
        (evil-mode 1))

      (use-package evil-collection
        :after evil
        :config
        (evil-collection-init))
    #+end_src
**** God-mode
     To further prove that I have no intentions at all to be busy with making evil bindings for eveything I find
     I have also installed god-mode to help me do effortless keybinding for those programs that don't have evil
     support
     #+begin_src emacs-lisp :tangle emacsconfig/evil.el
       (use-package evil-god-state
         :bind
         ("M-," . evil-god-state-bail))

       (use-package god-mode)
     #+end_src
**** Tree-sitter
     There is a pre-configured package that allows for easy tree-sitter support for a few languages. Nixos + tree-sitter
     is surprisingly painless, so I figured I'd just add it
     #+begin_src emacs-lisp :tangle emacsconfig/evil.el
       (use-package evil-tree-edit
         :hook
         (java-mode . evil-tree-edit-mode)
         (python-mode . evil-tree-edit-mode))
     #+end_src
*** Which-key
    Has god-mode support
    #+begin_src emacs-lisp :tangle emacsconfig/extras.el
      (use-package which-key
        :after god-mode
        :config
        (which-key-enable-god-mode-support)
        (which-key-mode))
    #+end_src
*** PDF-tools
    I don't want to be at the mercy of my browser to figure out how to read a PDF
    #+begin_src emacs-lisp :tangle emacsconfig/extras.el
      (use-package pdf-tools
        :config
        (add-to-list 'auto-mode-alist '("\\.pdf$" . pdf-view-mode)))
    #+end_src
** Programming-related emacs tools
   I do computer science, so from now and then I tend to program a bit. Here are all the tools I use to accomplish
   that stuff
*** Company
    Generally nice for auto-completion anywhere. I think here is also the place to note that I am not a huge fan
    of language-servers, as I've had bad experiences with them when I was still using vim
    #+begin_src emacs-lisp :tangle emacsconfig/extras.el
      (use-package company
        :hook
        (prog-mode . company-mode)
        :bind
        ("C-SPC" . company-complete))
    #+end_src
*** Matching of parentheses and other stuff
    "ERROR: Unmatched parenteses/braces/whatever" is really a thing I would prefer to never see again
    It has nix and lisp support, but other langages are fairly standards so not much configuration needed there
    #+begin_src emacs-lisp :tangle emacsconfig/extras.el
      (use-package smartparens
        :hook
        (emacs-lisp-mode . smartparens-mode)
        (nix-mode . smartparens-mode)
        (haskell-mode . smartparens-mode)
        (lisp-mode . smartparens-mode)
        :config
        (sp-with-modes '(lisp-mode emacs-lisp-mode)
          (sp-local-pair "'" nil :actions nil)
          (sp-local-pair "`" nil :actions nil))

        (sp-with-modes '(haskell-mode)
          (sp-local-pair "'" nil :actions nil))
        (sp-with-modes '(nix-mode)
          (sp-local-pair "'" nil :actions nil)
          (sp-local-pair "''" "''")))
    #+end_src
*** Languages
    Other than that, there are some language-specific setups that I want to do,which are a bit more complicated
    than just "editing a file"
**** Nix
     Nix is a fairly essential language here. Not just because I run NixOS, but also because it provides
     external packages (interpreters, compilers, tooling etc.) to the programs that need it
***** Nix mode
      This config is just part of editing nix config. It is supposed to come with company support, but
      the auto-completion backend turns out to not be that great. We'll see what I do with it
      #+begin_src emacs-lisp :tangle emacsconfig/nix.el
        (use-package nix-mode
          :mode "\\.nix\\'"
          :config
          ;; the company-nix backend is not available in melpa, but has no new dependencies
          (unless (package-installed-p 'company-nix)
            (with-temp-buffer
              (url-insert-file-contents "https://github.com/NixOS/nix-mode/raw/master/nix-company.el")
              (eval-buffer)))
          (add-hook 'nix-mode-hook (lambda ()
                                     (set (make-local-variable 'company-backends)
                                          '((company-nix))))))
      #+end_src
***** Nix package management
      I use nix-sandbox for managing nix package for other languages.
      One of the functions doesn't work that well for me so I replaced it with something that does
      #+begin_src emacs-lisp :tangle emacsconfig/nix.el
        (use-package nix-sandbox
          :demand
          :config
          (defun nix-executable-find (sandbox executable)
            "finds an EXECUTABLE in SANDBOX"
            (set (make-local-variable 'exec-path) (nix-exec-path sandbox))
            (executable-find executable))
      #+end_src
      Beyond that, there is a helper function that makes it easy to quickly define environments with the required
      packages for a programming language
      #+begin_src emacs-lisp :tangle emacsconfig/nix.el
        (defun intersperse (el ls) (if (cdr ls) `(,(car ls) ,el . ,(intersperse el (cdr ls))) ls))
        (defun nix-env-from-packages (name &rest packages)
          "create a nix environment from nix packages. returns the location of the environment"
          (interactive (append
                        (list (read-string "Environment name: " nil nil "nameless"))
                        (split-string (read-string "Packages: "))))
          (with-temp-buffer
            (insert (format "
                { pkgs ? import %s {}}:
                pkgs.mkShell {
                buildInputs = with pkgs;[
                %s
                ];
                }
                    " (or nix-nixpkgs-path "<nixpkgs>") (apply 'concat (intersperse "\n" packages))))
            (write-file (concat temporary-file-directory name "-env/shell.nix"))
            (nix-find-sandbox (concat temporary-file-directory name "-env")))))
      #+end_src
**** Python
     Python is a bit weird. It had no intentions at all to do things the way I wanted it to do things with
     use-package, so I had to find a weird work-arounds with add-hook and all that stuff
     #+begin_src emacs-lisp :tangle emacsconfig/python.el :padline no :noweb no-export
       (add-hook 'python-mode-hook (lambda ()
                                     <<el-python-config>>))

     #+end_src
     First we set an interpreter with nix, it comes with all the python autocompletion tools we need
     #+begin_src emacs-lisp :noweb-ref el-python-config :tangle no
       (setq python-shell-interpreter
             (nix-executable-find
              (nix-env-from-packages "python" "(python3.withPackages (p: with p; [pygame virtualenvwrapper pip sqlite jedi flake8 yapf autopep8 black]))")
              "python"))

     #+end_src
     Then we introduce elpy with so that it can use all the tools immidiately without downloading them
     #+begin_src emacs-lisp :noweb-ref el-python-config :tangle no
       (use-package elpy
         :config
         (elpy-enable)
         (setq elpy-rpc-python-command python-shell-interpreter))

     #+end_src
**** Haskell
     I have to use haskell in my new module, so there is now some haskell infra for that
     first we have to set up a nix environment for our haskell tools
     #+begin_src emacs-lisp :tangle emacsconfig/haskell.el
     #+end_src
     Then haskell-mode setup, which integrates company mode as well as the sandbox
     #+begin_src emacs-lisp :tangle emacsconfig/haskell.el
       (use-package haskell-mode
         :mode "\\.hs\\'"
         :after nix-sandbox
         :hook
         (haskell-mode . set-haskell-company-backends)
         (haskell-mode . haskell-indentation-mode)
         :config
         (setq haskell-env (nix-env-from-packages "Haskell"
                                                  "ghc"
                                                  "cabal-install"
                                                  "haskellPackages.fourmolu"))
         (setq haskell-process-wrapper-function
               (lambda (args)
                 (cons
                  (nix-executable-find haskell-env (car args))
                  (cdr args))))
         (defun set-haskell-company-backends ()
           (set (make-local-variable 'company-backends)
                '((dante-company company-files)))))
     #+end_src
     ormolu formats my haskell files, though I use fourmolu since I prefer prefixing chained infix functions
     #+begin_src emacs-lisp :tangle emacsconfig/haskell.el
       (use-package ormolu
         :after haskell-mode
         :hook
         (haskell-mode . ormolu-format-on-save-mode)
         (haskell-mode . (lambda ()
                           (set (make-local-variable 'ormolu-process-path)
                                (nix-executable-find haskell-env "fourmolu"))))
         :bind
         (:map haskell-mode-map
               ("C-c r" . ormolu-format-buffer)))
     #+end_src
     Finally, dante runs as background interpreter of my haskell codes and checks stuff for errors
     #+begin_src emacs-lisp :tangle emacsconfig/haskell.el
       (use-package dante
         :after haskell-mode
         :hook
         (haskell-mode . dante-mode)
         :custom
         ;; (dante-repl-command-line (list (nix-executable-find haskell-env "ghci")))
         (dante-methods '(nix-ghci bare-cabal bare-ghci)))
     #+end_src

**** Web stuff
     I also have made some basic webpages. I haven't gotten too deep into JS with emacs yet, so this section
     might expand later, but so far this is what I have
***** Web mode
      General xml stuff editing. Fairly standard
      #+begin_src emacs-lisp :tangle emacsconfig/web.el
        (use-package web-mode
          :mode (("\\.x?html?\\'" . web-mode)
                 ("\\.x[sm]l\\'"  . web-mode)
                 ("\\.css\\'"     . web-mode)
                 ("\\.jsx?\\'"    . web-mode)
                 ("\\.tsx?\\'"    . web-mode)
                 ("\\.json\\'"    . web-mode))
          :custom
          (web-mode-markup-indent-offset 2) ; HTML
          (web-mode-css-indent-offset 2)    ; CSS
          (web-mode-code-indent-offset 2)   ; JS/JSX/TS/TSX
          (web-mode-content-types-alist '(("jsx" . "\\.js[x]?\\'"))))
        (use-package elnode)

      #+end_src
***** Emmet mode
      for quickly inserting a whole XML tree
      #+begin_src emacs-lisp :tangle emacsconfig/web.el
        (use-package emmet-mode
          :hook
          (sgml-mode . emmet-mode)
          (web-mode . emmet-mode)
          (css-mode . emmet-mode)
          :bind
          (:map emmet-mode-keymap
                ("TAB" . emmet-dwim))
          :config
          (defun emmet-dwim (prefix)
            (interactive "p")
            (or
             (emmet-go-to-edit-point prefix)
             (emmet-expand-line prefix)
             (evil-jump-forward prefix))))
      #+end_src
** Other, less useful stuff
*** Themes
    I like to have a nice theme in my setup
    #+begin_src emacs-lisp :tangle emacsconfig/misc.el
      (load-theme 'leuven)
    #+end_src
    Also I want to theme my config exports
    #+begin_src emacs-lisp :tangle emacsconfig/extras.el
      (use-package htmlize)
    #+end_src
*** Discord
    My discord buddies /have/ to know I'm using emacs whenever I have my computer running
    #+begin_src emacs-lisp :tangle emacsconfig/misc.el
      (use-package elcord
        :config
        (elcord-mode))
    #+end_src
*** Emenu
    Since I'm using emacs as a daemon, it can also be benefical to make an application launcer
    #+begin_src emacs-lisp :tangle emacsconfig/misc.el
      (defun all-commands ()
        "does a completing read of all the programs accessible to you in $PATH"
        (let ((ls-output (mapcan (lambda (path)
                                   (when (file-readable-p path)
                                     (cl-remove-if (lambda (file)
                                                     (let ((fullpath (concat path "/" file)))
                                                       (or (file-directory-p fullpath)
                                                           (not (file-executable-p fullpath)))))
                                                   (directory-files path nil directory-files-no-dot-files-regexp nil))))
                                 (split-string (getenv "PATH") ":" t)))
              (alias-output (split-string (shell-command-to-string "alias -p | sed -E 's/^alias ([^=]*)=.*$/\\1/'") "\n")))
          (append ls-output alias-output)))

      (defun emenu (&optional command-list)
        "A dmenu-inspired application launcher using a separate emacs frame"
        (interactive)
        (with-selected-frame (make-frame '((name . "emenu")
                                           (minibuffer . only)
                                           (width . 151)
                                           (height . 1)))
          (unwind-protect
              (progn
                (call-process
                 (ido-completing-read "Command: " (or
                                                   command-list
                                                   (all-commands)))
                 nil
                 0)
                (keyboard-quit))
            (delete-frame))))
    #+end_src