foltik/dotfiles
1
0
Fork 0
mirror of https://github.com/Foltik/dotfiles synced 2024-11-24 12:26:05 -05:00
Code Issues Releases Wiki Activity
e2683fb159
dotfiles/lain/.emacs.d/config.org

28 KiB
Raw Blame History

Emacs Config

Font

Set the font to something nice that will display ligntures

(add-to-list 'default-frame-alist '(font . "Fira Code 12"))
(set-face-attribute 'default t :font "Fira Code 12")

Customize file

Makes it so the customize data isn't schlunked in my init.el

(setq custom-file (concat user-emacs-directory "_customize.el"))
(load custom-file t)

Remove menu bar

Disable the useless cruft at the top of the screen 

(menu-bar-mode 0)
(tool-bar-mode 0)
(scroll-bar-mode -1)

Show matching parenthesis

Shows matching parenthesis 

(require 'paren)
(setq show-paren-delay 0)
(show-paren-mode)

Show columns 

(setq column-number-mode t)

Transparency

Sets the window's transparency. The first number in the alpha section applies when the window is active, the second when it's inactive.

(set-frame-parameter (selected-frame) 'alpha 85)
(add-to-list 'default-frame-alist '(alpha . 85))

Scrolling 

(setq scroll-conservatively 100) ;; don't scroll a metric boatload when bottom is hit

Disable bell

Shut up, emacs.

(setq ring-bell-function 'ignore)

Relative line numbers

Use the default emacs relative line numbers, but switch to absolute lines when in insert mode.

(setq linum-format " %3d ")
(setq-default display-line-numbers 'relative
              display-line-numbers-widen t
              display-line-numbers-current-absolute t)

(defun foltz-relative-numbers ()
    (setq-local display-line-numbers 'relative))

(defun foltz-absolute-numbers ()
    (setq-local display-line-numbers t))

(add-hook 'evil-insert-state-entry-hook #'foltz-absolute-numbers)
(add-hook 'evil-insert-state-exit-hook #'foltz-relative-numbers)

(global-display-line-numbers-mode t)

y or n prompts

Make yes-or-no prompts ask for y or n instead

(defalias 'yes-or-no-p 'y-or-n-p)

Tabs are spaces?! 

(setq-default indent-tabs-mode nil)
(setq-default tab-width 4)
(setq indent-line-function 'insert-tab)

Keep backup files and lockfiles out of the way

By default, emacs makes files like file~ and #file# and clutters up my projects. Instead, store them in /tmp!

(setq backup-directory-alist
    `((".*" . ,temporary-file-directory)))
(setq auto-save-file-name-transforms
    `((".*" ,temporary-file-directory t)))
(setq create-lockfiles nil)

Customize the terminal

Use fish shell in ansi-term

(defadvice ansi-term (before force-bash)
    (interactive '("/usr/bin/fish")))
(ad-activate 'ansi-term)

Theme 

(defvar foltz-wal-theme-path "~/.cache/wal/colors.el")
(defun foltz-apply-theme ()
    (interactive)
    (load-file foltz-wal-theme-path))

(defun foltz-theme-callback (event)
  (foltz-apply-theme))

(if (file-exists-p foltz-wal-theme-path)
    (progn
       (require 'filenotify)
       (file-notify-add-watch foltz-wal-theme-path '(change) 'foltz-theme-callback)
       (foltz-apply-theme))
    (load-theme spacemacs-dark))

Auth storage location

Set stored auth tokens to be encrypted into emacs directory

(setq auth-sources '("~/.emacs.d/authinfo.gpg"))

Package Repo Config

Repo Location

Let's start by configuring the repositories

    (require 'package)

    (setq package-archives '(("gnu" . "https://elpa.gnu.org/packages/")
                             ("marmalade" . "https://marmalade-repo.org/packages/")
                             ("melpa-stable" . "https://stable.melpa.org/packages/")
                             ("melpa" . "https://melpa.org/packages/")
                             ("org" . "https://orgmode.org/elpa/")))
    (setq package-enable-at-startup nil)
    
    (package-initialize)

use-package

use-package for installing packages https://github.com/jwiegley/use-package

(unless (package-installed-p 'use-package)
    (package-refresh-contents)
    (package-install 'use-package))

(eval-when-compile
    (require 'use-package))

(setq use-package-compute-statistics t)
(setq use-package-always-ensure t)
(setq use-package-always-pin "melpa-stable")
(setq use-package-verbose t)

General Packages Configuration

Modeline cleanup

Adds support for :diminish in use-package declarations, basically hides a mode from the modeline.

(use-package diminish)

Keybind completion

Pops up a buffer that helps you navigate and complete commands

(use-package which-key
    :diminish
    :config
    (which-key-mode))

Keybind Manager

General manages my keybindings.

(use-package general
    :pin melpa)

Leader definitions

Create a leader key, like the \ in vim. In this case, SPC is used as a leader. Following the leader, different buttons bring you to different options. See here for which-key integration information

(general-create-definer foltz-leader-def
    :keymaps 'override
    :states 'normal
    :prefix "SPC"
        "m" '(:ignore t :which-key "major-mode...")
        "o" '(:ignore t :which-key "org-mode...")
        "p" '(:ignore t :which-key "projectile-mode...")
        "g" '(:ignore t :which-key "git...")
        "h" '(:ignore t :which-key "help...")
        "b" '(:ignore t :which-key "buffer...")
        "w" '(:ignore t :which-key "window...")
        "f" '(:ignore t :which-key "file..."))
m - major-modes 
(general-create-definer foltz-major-def
    :states 'normal
    :prefix "SPC m")
o - org-mode 
(general-create-definer foltz-org-def
    :keymaps 'override
    :states
'normal
    :prefix "SPC o")
p - projectile-mode

Since we will be binding the entire projectile-mode keymap to this, we don't actually need a definer.

g - git 
(general-create-definer foltz-git-def
    :states 'normal
    :keymaps 'override
    :prefix "SPC g")
h - help 
(general-create-definer foltz-help-def
    :states 'normal
    :keymaps 'override
    :prefix "SPC h")

(foltz-help-def
    "?" 'help-for-help
    "h" 'help-for-help
    "k" 'describe-key)
b - buffer 
(general-create-definer foltz-buffer-def
    :states 'normal
    :keymaps 'override
    :prefix "SPC b")

(foltz-buffer-def
    "i" 'ibuffer)
w - window 
(general-create-definer foltz-window-def
    :states 'normal
    :keymaps 'override
    :prefix "SPC w")

(foltz-window-def
    "o" 'delete-other-windows)
f - file 
(general-create-definer foltz-file-def
    :states 'normal
    :keymaps 'override
    :prefix "SPC f")

(defun foltz-config-visit ()
    (interactive)
    (find-file (concat user-emacs-directory "config.org")))

(defun foltz-config-reload ()
    (interactive)
    (org-babel-load-file
        (expand-file-name "config.org" user-emacs-directory)))

(foltz-file-def
    "w"   'save-buffer
    "r"   'revert-buffer
    "e"   '(:ignore t :which-key "emacs files")
    "e e" 'foltz-config-visit
    "e r" 'foltz-config-reload)

Vim

Evil is pretty much the entirety of Vim in Emacs. evil-org adds nice bindings to org-mode.

(use-package evil
    :after general
    :diminish undo-tree-mode
    :init
    (setq evil-want-integration nil)
    (setq evil-want-keybinding nil)

    :config
    (evil-mode t)

    :custom
    (evil-shift-width 4 "Set indent to 4 spaces"))

(use-package evil-leader
    :after evil
    :init
    (defun foltz-window-split ()
        (interactive)
        (evil-window-split)
        (evil-window-down 1))
    (defun foltz-window-vsplit ()
        (interactive)
        (evil-window-vsplit)
        (evil-window-right 1))

    :general
    (:keymaps 'override
     :states 'normal
     "U" 'undo-tree-visualize)
    (foltz-window-def
        "-" 'foltz-window-split
        "=" 'foltz-window-vsplit
        "h" 'evil-window-left
        "j" 'evil-window-down
        "k" 'evil-window-up
        "l" 'evil-window-right
        "H" 'evil-window-far-left
        "J" 'evil-window-move-very-bottom
        "K" 'evil-window-move-very-top
        "L" 'evil-window-far-right
        "<" 'evil-window-decrease-width
        ">" 'evil-window-increase-width
        "^" 'evil-window-decrease-height
        "%" 'evil-window-increase-height
        "n" 'evil-window-new
        "c" 'evil-window-delete
        "w" 'evil-window-next
        "W" 'evil-window-prev
        "r" 'evil-window-rotate-downwards
        "|" 'evil-window-set-width
        "_" 'evil-window-set-height)

    :config
    (global-evil-leader-mode))

(use-package evil-org
    :after (evil org)
    :hook (org-mode . evil-org-mode)
    :config
    (add-hook 'evil-org-mode (lambda () 
        (evil-org-set-key-theme
            '(textobjects insert navigation 
              additional shift todo calendar)))))

Startup dashboard

Show a cool custom buffer on startup

(use-package dashboard
    :diminish page-break-lines-mode

    :config
    (dashboard-setup-startup-hook)
    (setq initial-buffer-choice (lambda () (get-buffer "*dashboard*")))

    :custom
    (dashboard-startup-banner 'logo)
    (dashboard-banner-logo-title "Welcome to Electronic Macs")
    (dashboard-items
        '((recents . 5)
          (agenda)
          (bookmarks . 5)
          (registers . 5))))

Folder tree

A cool toggleable directory structure sidebar It also needs icon fonts, installed with M-x all-the-icons-install-fonts

(use-package all-the-icons)
(use-package neotree
    :after all-the-icons
    :commands neotree-toggle
    :general
    (:keymaps 'neotree-mode-map
     :states 'normal
     "RET" 'neotree-enter
     "TAB" 'neotree-quick-look
     "q"   'neotree-hide
     "g"   'neotree-refresh
     "A"   'neotree-stretch-toggle
     "H"   'neotree-hidden-file-toggle)
    (foltz-leader-def
        :states 'normal
        "t" 'neotree-toggle)
    :custom
    (neo-theme (if (display-graphic-p) 'icons 'arrow)))

Organization

Capture Templates

All of my capture templates, from tasks to bookmarks.

Refile Targets

Goodize the refiling targets to allow moving to subtrees

(defun foltz-org-capture-refile ()
    (interactive)
    (setq-local org-refile-targets '((nil :maxlevel . 5)))
    (setq-local org-refile-use-outline-path t)
    (org-refile))
Tasks 
(setq foltz-org-capture-task-templates 
  '(("t" "Todo")
    ("tg" "General" entry
        (file+headline "notes.org" "Todo")
        "** TODO %^{todo}\nNotes: %?\n")
    ("tt" "General (Date)" entry
        (file+olp+datetree "notes.org")
        "*** TODO %^{todo}\nDue: %^t\nNotes: %?\n")
    ("tT" "General (Date+Time)" entry
        (file+olp+datetree "notes.org")
        "*** TODO %^{todo}\nDue: %^T\nNotes: %?\n")
    ("ts" "School (Date)" entry
        (file+olp+datetree "notes.org")
        "*** TODO %^{todo}\nDue: %^t\nClass: %^{class}\nNotes: %?\n")
    ("tS" "School (Date+Time)" entry
        (file+olp+datetree "notes.org")
        "*** TODO %^{todo}\nDue: %^T\nClass: %^{class}\nNotes: %?\n")))
Bookmarks 
(setq foltz-org-capture-bookmark-templates 
  '(("b" "Bookmark" entry
        (file+headline "links.org" "Unsorted Links")
        "** [[%^{link}][%^{name}]]\nCreated: %U\nAbout: %^{description}%?\n")))
Personal 
(setq foltz-org-capture-personal-templates 
  '(("j" "Journal")
    ("jj" "Journal Entry" entry
        (file+olp+datetree "journal.org")
        "**** Today's Events\n%?")
    ("jt" "Thoughts" entry
        (file+headline "notes.org" "Thoughts")
        "** %^{summary}\n%U\n%?")
    ("jd" "Dream Journal Entry" entry
        (file+olp+datetree "dreams.org")
        "**** Dream\n%?")))
Protocol 
(setq foltz-org-capture-protocol-templates 
    '(("w" "Website" entry
        (file+headline "sites.org" "Unsorted Sites")
        "** [[%:link][%:description%?]]\nCreated: %U\nAbout: %^{description}%?\n%:initial")))
All

Tie it all together.

(setq foltz-org-capture-templates
    (append
        foltz-org-capture-task-templates
        foltz-org-capture-personal-templates
        foltz-org-capture-bookmark-templates
        foltz-org-capture-protocol-templates))

Structure Templates

Defines expansions with < followed by a string in org-mode.

Source Blocks 
(setq foltz-org-source-structure-templates '(
    ("el" "#+BEGIN_SRC emacs-lisp\n?\n#+END_SRC")))
All

Tie it all together.

(setq foltz-org-structure-templates
    (append
        foltz-org-source-structure-templates))

Org-mode

Keep org-mode up to date straight from the cow's utters. If the manual is not on your computer, it's here.

(use-package org
    :pin org
    :mode ("\\.org\\'" . org-mode)
    :hook ((org-mode . org-indent-mode)
           (org-capture-mode . evil-insert-state))

    :general
    (foltz-major-def
        :keymaps 'org-mode-map
        "e" 'org-export-dispatch
        "a" 'org-attach)
    (foltz-org-def
        "a" 'org-agenda
        "c" 'org-capture
        "l" 'org-store-link
        "b" 'org-switchb
        "r" 'foltz-org-capture-refile)
    
    :custom
    (org-directory "~/Documents/org")
    (org-agenda-files '("~/Documents/org/"))
    (org-default-notes-file "notes.org")
    (org-agenda-include-diary t)
    (org-src-window-setup 'current-window "Edit source code in the current window")
    (org-src-fontify-natively t "Highlight syntax in source blocks")
    (org-latex-to-pdf-process '("latexmk -f pdf %f") "Use pdflatex for export")
    (org-capture-templates foltz-org-capture-templates)
    (org-structure-template-alist (append org-structure-template-alist foltz-org-structure-templates)))

Pretty org-mode bullets

Make bullets look choice

(use-package org-bullets
    :hook (org-mode . org-bullets-mode))

Fuzzy Matching

Ivy, swiper, and counsel all provide fuzzy-matching on different emacs operations.

(use-package ivy
    :init
    ; Define some functions to bind to
    (defun foltz-kill-curr-buffer ()
        (interactive)
        (kill-buffer (current-buffer)))
    (defun foltz-kill-all-buffers ()
        (interactive)
        (mapc 'kill-buffer (buffer-list)))

    :general
    (foltz-buffer-def
        "b" 'ivy-switch-buffer
        "v" 'ivy-push-view
        "V" 'ivy-pop-view
        "c" 'foltz-kill-curr-buffer
        "C" 'foltz-kill-all-buffers)
    (:keymaps 'org-capture-mode-map
     :states 'normal
     "C-c C-w" 'foltz-org-capture-refile)

    :custom
    (ivy-use-virtual-buffers t)
    (ivy-count-format "%d/%d"))

(use-package swiper
    :after evil
    :general
    (:keymaps 'override 
     :states 'normal 
     "/" 'swiper
     "n" 'evil-search-previous
     "N" 'evil-search-next))

(use-package counsel
    :general
    ("M-x" 'counsel-M-x)
    (foltz-leader-def
        :states 'normal
        "x" 'counsel-M-x)
    (foltz-file-def
        "f" 'counsel-find-file)
    (foltz-help-def
        "k" 'counsel-descbinds
        "f" 'counsel-describe-function
        "v" 'counsel-describe-variable
        "l" 'counsel-find-library
        "a" 'counsel-apropos
        "s" 'counsel-info-lookup-symbol
        "u" 'counsel-unicode-char))

Avy

Hotkeys for jumping to characters with f

(use-package avy
    :general
    (:keymaps 'override
     :states 'normal
     "f" 'avy-goto-char-in-line
     "F" 'avy-goto-char))

Programming Packages Configuration

Autocomplete and Formatting

Company

company auto-completes stuff in the buffer, company-quickhelp shows documentation popups when idling on a completion candidate.

(use-package company
    :init
    (defun foltz-company-backend-with-yas (backend)
        (if (and (listp backend) (member 'company-yasnippet backend))
            backend
            (append
                (if (consp backend)
                    backend
                    (list backend))
                '(:with company-yasnippet))))
    (defun foltz-add-company-backend (backend)
        (let ((backend-with-yas (foltz-company-backend-with-yas backend)))
        (if (member backend-with-yas company-backends)
            backend
            (add-to-list 'company-backends backend-with-yas))))
    :hook (prog-mode . company-mode)
    :hook (cdlatex-mode . company-mode)
    :general
    (:keymaps 'company-active-map
     "C-SPC" 'company-abort)
    :custom
    (company-maximum-prefix-length 2)
    (company-idle-delay 0.2 "Decrease idle delay"))
    
(use-package company-quickhelp
    :hook (company-mode . company-quickhelp-mode))

Smart Parentheses

smartparens handles parens for languages that aren't lispy, and paredit handles the rest. Keybinds in M-x sp-cheat-sheet.

(use-package paredit
    :diminish
    :commands enable-paredit-mode)
     
(use-package smartparens
    :diminish
    :commands smartparens-strict-mode
    :config
    (require 'smartparens-config))

(use-package evil-smartparens
    :hook (smartparens-enabled . evil-smartparens-mode))

Smart Parentheses Modes

Picks a suitable parenthesis editing mode for the current major mode when entering any prog-mode.

(defun foltz-paren-mode ()
    (if (member major-mode 
          '(emacs-lisp-mode
            lisp-mode
            lisp-interaction-mode
            scheme-mode))
        (enable-paredit-mode)
        (smartparens-strict-mode)))

(add-hook 'prog-mode-hook #'foltz-paren-mode)

evil-surround

Use S and a delimiter to surround in visual mode.

(use-package evil-surround
    :after evil
    :diminish
    :config
    (global-evil-surround-mode 1))

ws-butler

Unobtrusively cleans up whitespace before EOLs as you edit, stopping the noisy commits generated from blanket trimming entire files.

(use-package ws-butler
    :hook (prog-mode . ws-butler-mode))

Prettification

pretty-mode

Redisplay parts of the Emacs buffer as pretty symbols.

(use-package pretty-mode
    :hook (prog-mode . pretty-mode)
    :config
    (pretty-deactivate-groups
        '(:equality :sub-and-superscripts))
    (pretty-activate-groups
        '(:greek :arithmetic-nary
          :ordering :ordering-double :ordering-triple
          :arrows :arrows-twoheaded :punctuation :logic :sets)))

prettify-symbols-mode

Built into emacs since 24.1

(add-hook 'python-mode-hook 'prettify-symbols-mode)
(add-hook 'python-mode-hook (lambda ()
    (mapc (lambda (pair) (push pair prettify-symbols-alist))
        '(;; Syntax
         ("in" .       #x2208)
         ("not in" .   #x2209)
         ("return" .   #x27fc)
         ("yield" .    #x27fb)
         ("for" .      #x2200)
         ;; Base Types
         ("int" .      #x2124)
         ("float" .    #x211d)
         ("str" .      #x1d54a)
         ("True" .     #x1d54b)
         ("False" .    #x1d53d)))))

Debugging and Disassembly

Realgud

Realgud is a modular frontend for many debuggers

(use-package realgud
    :commands 
    (realgud:gdb 
     realgud:lldb 
     realgud:node-inspect 
     realgud:pdb 
     realgud:trepan3k))

RMSBolt 

(use-package rmsbolt
    :pin melpa
    :commands rmsbolt-mode)

Syntax checking

Flycheck

Flycheck does syntax highlighting in a few languages

(use-package flycheck
    :hook (prog-mode . flycheck-mode))

Column 80 Highlight

Add a hotkey for highlighting column 80 and activate it in prog-mode

(use-package fill-column-indicator
    :init
    (setq fci-rule-use-dashes t)
    (setq fci-rule-column 80)
    :general
    (foltz-major-def
        :keymaps 'prog-mode-map
        "l" 'fci-mode
        "f" 'toggle-truncate-lines))

Snippets

Yasnippet adds support for custom snippets

(use-package yasnippet
    :commands yas-minor-mode
    :hook (prog-mode . yas-minor-mode)
    :custom
    (yas-snippet-dirs
      '("~/.emacs.d/snippets"
        "~/.emacs.d/elpa/yasnippet-snippets-0.6/snippets")))
;;;(use-package yasnippet-snippets)

Git

magit

It's magic git! Keybinds here

(use-package magit
    :general
    (foltz-git-def
        "s" 'magit-status
        "c" 'magit-commit
        "d" 'magit-diff
        "g" 'magit-grep)
    :config
    (use-package evil-magit
        :after evil))

magithub

Magic GitHub facilities for magit!

(use-package magithub
    :after magit
    :config
    (magithub-feature-autoinject t)
    :custom
    (magithub-clone-default-directory "~/Documents/dev"))

Projects

Projectile provides project-level features like make shortcuts and file switching

(use-package projectile
    :pin melpa
    :init
    (defun foltz-projectile-neotree () "Open NeoTree in the project root"
        (interactive)
        (let
            ((project-dir (projectile-project-root))
             (file-name   (buffer-file-name)))
        (neotree-toggle)
        (if project-dir
            (if (neo-global--window-exists-p)
                (progn
                    (neotree-dir project-dir)
                    (neotree-find file-name))))))

    (defun foltz-projectile-discover-projects (directory) "Add projects in dir to projectile cache"
        (interactive
            (list (read-directory-name "Starting directory: ")))
        (let ((subdirs (directory-files directory t)))
            (mapcar (lambda (dir)
                (when 
                    (and 
                        (file-directory-p dir)
                        (not (member (file-name-nondirectory dir) '(".." "."))))
                    (let ((default-directory dir) (projectile-cached-project-root dir))
                        (when (projectile-project-p)
                            (projectile-add-known-project (projectile-project-root))))))
                subdirs)))

    :config
    (projectile-mode 1)
    (foltz-projectile-discover-projects "~/Documents/dev")
    :general
    (:keymaps 'projectile-command-map
     "t" 'foltz-projectile-neotree)
    (foltz-leader-def
        :states 'normal
        "p" '(:keymap projectile-command-map))
    :custom
    (projectile-completion-system 'ivy)
    (projectile-project-search-path '("~/Documents/dev")))

Languages

Fish

Beter editing of scripts for the fish shell

(use-package fish-mode
    :mode "\\.fish\\'")

Markdown 

(use-package markdown-mode
    :mode "\\.md\\'")

Python

Jedi for autocompletion sources

(use-package company-jedi
    :init
    (defun foltz-add-company-python-backend ()
        (foltz-add-company-backend 'company-jedi))
    :hook (python-mode . foltz-add-company-python-backend))

Javascript

js2-mode improves the default js mode. Keybindings in this file.

(use-package js2-mode
    :mode "\\.js\\'"
    :interpreter "node")

Web-dev

Web-mode should give everything you need for a web-dev major mode. Company integration is done with company-web

(use-package web-mode
    :pin melpa
    :mode ("\\.html\\'"
           "\\.php\\'"
           "\\.blade\\.")
    :custom
    (web-mode-code-indent-offset 4)
    (web-mode-indent-style 4))
    
(use-package company-web
    :init
    (defun foltz-add-company-web-backend ()
        (foltz-add-company-backend 'company-web))
    :hook (web-mode . foltz-add-company-web-backend))

JSON

Just an enhanced json mode

(use-package json-mode
    :mode "\\.json\\'")

YAML

Enhanced yaml mode

(use-package yaml-mode
    :mode "\\.yaml\\'")

Arch PKGBUILD

For editing PKGBUILD files

(use-package pkgbuild-mode
    :mode ".*PKGBUILD\\'")

LaTeX

AUCTeX

AUCTeX is a major mode for editing tex, CDLaTeX adds some minor niceities to it. company-auctex for completion.

(use-package tex
    :defer t
    :ensure auctex
    :general
    (foltz-major-def
        :keymaps 'TeX-mode-map
        "e" 'TeX-command-run-all)
    :custom
    (TeX-auto-save t))
    
(use-package company-auctex
    :pin melpa
    :init
    (defun foltz-add-company-auctex-backend ()
        (foltz-add-company-backend 'company-auctex))
    :hook (LaTeX-mode . foltz-add-company-auctex-backend))

(use-package company-math
    :init
    (defun foltz-add-company-math-backends ()
        (foltz-add-company-backend 'company-math-symbols-latex)
        (foltz-add-company-backend 'company-math-symbols-unicode)
        (foltz-add-company-backend 'company-latex-commands))
    :hook ((cdlatex-mode . foltz-add-company-math-backends)
           (TeX-mode . foltz-add-company-math-backends)))
cdlatex
Environment 
(setq foltz-cdlatex-envs nil)
Commands 
(setq foltz-cdlatex-commands nil)
Math Symbols 
(setq foltz-cdlatex-symbols
  '((?I ("\\infty"))))
cdlatex

cdlatex adds better TeX-specific template expansions and other niceties.

(use-package cdlatex
    :hook (LaTeX-mode . cdlatex-mode)
    :custom
    (cdlatex-env-alist foltz-cdlatex-envs)
    (cdlatex-command-alist foltz-cdlatex-commands)
    (cdlatex-math-symbol-alist foltz-cdlatex-symbols))

Rust 

(use-package rust-mode
    :mode "\\.rs\\'"
    :general
    (foltz-major-def
        :keymaps 'rust-mode-map
        "TAB" 'rust-format-buffer))

(use-package flycheck-rust
    :pin melpa
    :hook (rust-mode . flycheck-rust-setup))

(use-package racer
    :hook ((rust-mode . racer-mode)
           (rust-mode . eldoc-mode))
    :custom
    (racer-cmd "~/.cargo/bin/racer")
    (racer-rust-src-path "~/.rustup/toolchains/nightly-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/src"))

(use-package cargo
    :hook (rust-mode . cargo-minor-mode)
    :general
    (foltz-major-def
        :keymaps 'rust-mode-map
        "b" 'cargo-process-build
        "r" 'cargo-process-run
        "t" 'cargo-process-test))

C/C++

Irony

Irony handles enhanced C/C++ operations powered by clang company-irony for company integration

(use-package irony
    :pin melpa
    :after counsel
    :hook ((c++-mode   . irony-mode)
           (c-mode     . irony-mode)
           (irony-mode . irony-cdb-autosetup-compile-options)))

(use-package company-irony
    :init
    (defun foltz-add-company-irony-backend ()
        (foltz-add-company-backend 'company-irony))
    :hook (irony-mode . foltz-add-company-irony-backend))

(use-package flycheck-irony
    :hook (irony-mode . flycheck-irony-setup))
Hotkeys 
(foltz-major-def
    :keymaps '(c++-mode-map c-mode-map)
    "r" 'rmsbolt-mode
    "c" 'rmsbolt-compile)