lisp-in-python-2026-05-03

name	lisp-in-python-2026-05-03
description	Build a minimal Lisp interpreter in Python covering the eval-apply cycle, recursive descent parsing, lexical scoping, closures, special forms, and a REPL. Includes extension patterns for macros, continuations, and tail-call optimization. Use when building interpreters from scratch, studying programming language fundamentals, or learning homoiconicity and the eval-apply loop.

Lisp in Python — Minimal Interpreter Guide

Overview

Build a complete Scheme-like Lisp interpreter in ~200 lines of pure Python. The interpreter supports arithmetic, comparison, variables, user-defined functions with lexical scoping, conditionals, list operations, and a REPL — all using the eval-apply cycle that powers every Lisp implementation.

The design synthesizes six independent implementations studied across different approaches: Norvig's gold-standard Scheme subset, ByteGoblin's ultra-minimal 16-line proof of concept, Spatters' class-based type system, Zstix's step-by-step tutorial build, AlJamal's direct translation of McCarthy's original "Lisp in Lisp", and Misfra.me's Go implementation with tail-call optimization and call/cc.

When to Use

• Building a Lisp interpreter from scratch in Python
• Understanding how programming language interpreters work (parsing, evaluation, scoping)
• Learning the eval-apply cycle — the core mechanism of all Lisp implementations
• Implementing lexical scoping and closures
• Studying homoiconicity (code-as-data property of Lisp)
• Extending a minimal interpreter with advanced features (macros, continuations, tail-call optimization)

Core Concepts

Homoiconicity: In Lisp, code is data. Programs are represented as lists — the same data structure used for everything else. This means the interpreter can manipulate programs as data structures, enabling macros and metaprogramming. A program (+ 1 2) is just the list ['+', 1, 2].

S-expressions: The fundamental notation. Atoms (numbers, symbols) evaluate to values. Lists (proc arg1 arg2) represent function calls. Parentheses are not grouping — they denote list structure.

Eval-apply cycle: The interpreter has two operations. eval takes an expression and environment, returns a value. apply takes a procedure and argument values, returns a result. Eval dispatches on expression type; for procedure calls, it evals the operator and all arguments, then applies the result. Apply creates a new environment frame and calls eval on the body. This cycle is recursive until expressions reduce to atoms.

Lexical scoping: A function captures the environment where it was defined, not where it's called. Environments form a chain: each has an outer reference. Variable lookup walks from innermost outward. This enables proper closures — functions that remember their defining context.

Special forms vs procedures: Most expressions evaluate all sub-expressions before applying (applicative order). Special forms break this rule: quote returns its argument without evaluation, if evaluates only one branch, define doesn't evaluate the variable name. The eval function handles special forms explicitly before falling through to the general procedure-call case.

Usage Examples

Start the REPL:

python lispy.py

Run a file:

python lispy.py program.lisp

Basic expressions in the REPL:

lispy> (+ 1 2 3)
6

lispy> (define x 10)
x

lispy> (* x x)
100

lispy> (if (> x 5) "big" "small")
big

Define and call recursive functions:

lispy> (define fact (lambda (n) (if (<= n 1) 1 (* n (fact (- n 1))))))
fact

lispy> (fact 10)
3628800

lispy> (define fib (lambda (n) (if (< n 2) n (+ (fib (- n 1)) (fib (- n 2))))))
fib

lispy> (fib 10)
55

Higher-order functions and closures:

lispy> (define double (lambda (f) (lambda (x) (f (f x)))))
double

lispy> ((double (lambda (x) (* 2 x))) 5)
20

List operations:

lispy> (cons 0 (list 1 2 3))
(0 1 2 3)

lispy> (car (list 1 2 3))
1

lispy> (cdr (list 1 2 3))
(2 3)

lispy> (length (list 1 2 3 4))
4

lispy> (null? '())
#t

Multi-way conditionals and sequencing:

lispy> (cond ((= 1 2) "no") ((> 1 0) "yes") ("else" "default"))
yes

lispy> (begin (define a 1) (define b 2) (+ a b))
3

Advanced Topics

Interpreter Architecture: Eval-apply cycle, type system, parsing pipeline, environment model, procedure closures, special forms → Architecture

Source Comparisons: How each of the six implementations differs — Norvig's Scheme subset, ByteGoblin's 16-line proof, Spatters' typed approach, Zstix's tutorial, AlJamal's homoiconic Python, Misfra.me's Go with tail-call → Source Comparisons

The Complete Interpreter: Full ~200-line Python source with inline documentation, section-by-section breakdown, and running examples → Complete Interpreter

Extensions: Tail-call optimization, call/cc continuations, macros with quasiquote, strings, derived forms (let, when, unless, do), additional builtins → Extensions