Emacs Lisp

Emacs Lisp is the Lisp dialect used by GNU Emacs.

Almost all of Emacs itself is written in Elisp.

It allows you to:

• Configure Emacs
• Extend editor functionality
• Create packages
• Automate repetitive tasks

Learning Elisp allows you to:

• Understand how Emacs works internally
• Build custom commands
• Create major modes and minor modes
• Automate workflows
• Build complete editor extensions

Everything in Lisp is an expression.

Types:

• Atoms
• Lists

42
"hello"
(+ 1 2)
(message "Hello")

Expressions are evaluated immediately.

(+ 1 2)
;; => 3

Quoted expressions are treated as data.

'(+ 1 2)
;; => (+ 1 2)

Quote prevents evaluation.

(setq x 10)

x
;; => 10

'x
;; => x

Symbols store:

• value
• function definition
• property list

(symbolp 'car)

Global:

(setq x 10)

Local:

(let ((x 5))
  (+ x 1))

Constants:

(defconst pi 3.14)

Declared variables:

(defvar debug-mode nil)

(defun square (x)
  (* x x))

Call:

(square 5)

Interactive functions can be executed with M-x.

(defun hello ()
  (interactive)
  (message "Hello"))

Prompt user input.

(defun greet (name)
  (interactive "sName: ")
  (message "Hello %s" name))

Common specifiers:

• s → string
• n → number
• f → file
• b → buffer
• r → region

nil

• false
• empty list

t

• true

Everything except nil is truthy.

Buffers are text containers.

Examples:

• files
• temporary buffers
• internal buffers

(current-buffer)
(buffer-name)

Execute code inside another buffer.

(with-current-buffer "*scratch*"
  (insert "Hello"))

Useful for:

• temporary buffers
• package development
• asynchronous processes

Preserves point and cursor location.

(save-excursion
  (goto-char (point-min)))

• point → cursor position
• mark → secondary position
• region → selected text

(point)
(mark)
(region-beginning)
(region-end)

Hooks execute functions when events occur.

(add-hook
 'prog-mode-hook
 #'display-line-numbers-mode)

User configurable variables.

(defcustom my-option t
  "Option."
  :type 'boolean)

(setq-local fill-column 100)

Each buffer can hold different values.

Read:

(insert-file-contents "file.txt")

Write:

(with-temp-file "out.txt"
  (insert "hello"))

Alist:

((name . "Bob"))

Plist:

(:name "Bob")

Hash table:

(make-hash-table)

(lambda (x)
  (* x x))

Anonymous functions.

(let ((x 10))
  (lambda ()
    x))

Closures capture variables.

Enable modern lexical scope.

;;; -*- lexical-binding: t; -*-

Required for closures.

Macros generate code.

(defmacro my-when (cond &rest body)
  `(if ,cond
       (progn ,@body)))

Functions evaluate arguments.

Macros receive raw code.

(macroexpand-1 ...)

Syntax tables define parsing behavior.

They control:

• comments
• strings
• symbols
• words

(with-syntax-table ...)

Search:

(re-search-forward "[0-9]+")

Replace:

(replace-match "number")

Used heavily in text manipulation.

Frame:

Entire Emacs window.

Window:

Buffer pane.

(selected-frame)
(selected-window)

(copy-marker (point))

Markers follow buffer changes.

Temporary visual decorations.

(make-overlay ...)

Metadata attached directly to text.

(propertize
 "Warning"
 'face 'warning)

Hooks:

(add-hook ...)

Advice:

(advice-add ...)

Prefer hooks when possible.

Modify existing function behavior.

(advice-add
 'find-file
 :before
 #'my-function)

(make-process ...)

Non-blocking execution.

(make-process
 :sentinel ...)

Sentinel runs when process state changes.

(call-process ...)
(shell-command ...)

Prefer call-process for security.

(url-retrieve ...)

Built-in HTTP client.

ERT testing framework.

(require 'ert)

(ert-deftest my-test ()
 ...)

(byte-compile-file "my.el")

Benefits:

• faster loading
• compiler warnings

Produces:

• .eln files
• faster execution

Useful tools:

• debug-on-error
• edebug-defun
• debug-on-entry
• trace-function
• check-parens
• macroexpand-1

Example:

(setq debug-on-error t)

Avoid:

• append in loops
• repeated regex scans
• unnecessary allocations

Prefer:

(push item list)
(nreverse list)

Common mistakes:

• forgetting interactive
• forgetting lexical-binding
• using setq instead of let
• using shell-command unsafely
• misunderstanding quote
• modifying buffers without save-excursion

Tools:

• checkdoc
• package-lint
• byte compilation

Object system for Emacs Lisp.

Common Lisp extensions.

Useful:

• cl-loop
• cl-defstruct
• cl-defmethod
• cl-reduce

(require 'generator)

Functions:

• iter-defun
• iter-yield

gc-cons-threshold

Controls GC frequency.

Study source code from:

• GNU Emacs
• Org Mode
• Magit
• Projectile
• Vertico
• Consult
• Corfu

Build:

• major modes
• minor modes
• package managers
• syntax highlighters
• completion frameworks
• LSP integrations
• IDE extensions