Lisp
0 likes36 views
This document describes how to write your own Lisp interpreter in Clojure by building up the necessary components like evaluation, special forms, and environments. It outlines how to implement key parts like evaluation, special forms like IF and LAMBDA, defining variables, macros and macroexpansion. The goal is to allow writing your own Lisp that can evaluate functions recursively like computing factorials.
![Apply
(defn form-apply [proc args]
(letfn [(primitive? [p] (= (first p) 'primitive))
(procedure? [p] (= (first p) 'procedure)) ;<-- from lambda
(proc-params [p] (second p))
(proc-body [p] (nth p 2))
(proc-env [p] (nth p 3))]
(cond (primitive? proc) (apply (second proc) args) ;<-- magic
(procedure? proc) (eval-seq (proc-body proc)
(extend-env (proc-env proc)
(proc-params proc)
args)))))
6](https://image.slidesharecdn.com/lisp-210419024101/85/Lisp-6-320.jpg)
![Primitive expressions
true, 123, "words" nil
var, my-fn
(defn form-eval [exp env]
(cond (self-evaluating? exp) exp
(symbol? exp) (env-get exp env)
(defn self-evaluating? [x]
(or (number? x)
(string? x)
(nil? x)
(boolean? x)))
7](https://image.slidesharecdn.com/lisp-210419024101/85/Lisp-7-320.jpg)
![Enviroment
(defn env-find [var env action not-found] ...)
(defn env-get [var env] ...)
(defn env-set [var val env] ...)
(defn extend-env [env] ...)
9](https://image.slidesharecdn.com/lisp-210419024101/85/Lisp-9-320.jpg)
![Initial Enviroment
(defn setup-env []
(-> '()
(extend-env (keys primitive-procs)
(map #(list 'primitive %) (vals primitive-procs)))
(extend-env)
(built-in!)
(extend-env)))
(def primitive-procs {'true true
'+ +
'car first
...})
primitive-procs
10](https://image.slidesharecdn.com/lisp-210419024101/85/Lisp-10-320.jpg)
![quote
(quote 1) => 1
(quote a) => a
(quote (+ 1 1)) => (+ 1 1)
(defn form-eval [exp env]
(cond (self-evaluating? exp) exp
(symbol? exp) (env-get exp env)
(= (first exp) 'quote) (second exp)) ;;<- here
11](https://image.slidesharecdn.com/lisp-210419024101/85/Lisp-11-320.jpg)
![if
(if <cond-expr> expr else-expr)
(defn form-eval [exp env]
(let [exp (macroexpand exp env)]
(cond (self-evaluating? exp) exp
(symbol? exp) (env-get exp env)
(= (first exp) 'quote) (second exp)
(= (first exp) 'if) (eval-if exp env)))) ; <- here
(defn eval-if [exp env]
(let [[a0 a1 a2 a3] exp]
(if (form-eval a1 env)
(form-eval a2 env)
(form-eval a3 env))))
12](https://image.slidesharecdn.com/lisp-210419024101/85/Lisp-12-320.jpg)
![Why is "if" a special form?
Can we just write a if function?
(defn iif [condition stat else]
(if (true? condition)
expr
else-expr))
(iif true (+ 1 2) (* 0 0)) ;=> 3
(iif false (+ 1 2) (* 0 0)) ;=> 0
(iif true (+ 1 2) (/ 0 0)) ;=> Error: ArithmeticException Divide by zero
13](https://image.slidesharecdn.com/lisp-210419024101/85/Lisp-13-320.jpg)
![begin
(begin expr1 expr2 ...)
like "do" in clojure
(defn form-eval [exp env]
(cond (self-evaluating? exp) exp
(symbol? exp) (env-get exp env)
(= (first exp) 'quote) (second exp)
(= (first exp) 'if) (eval-if exp env)
(= (first exp) 'begin) (eval-seq (rest exp) env))) ; <-- here
(defn eval-seq [exp env]
(reduce #(form-eval %2 env) nil exp))
14](https://image.slidesharecdn.com/lisp-210419024101/85/Lisp-14-320.jpg)
![lambda
(lambda (x y) (+ x y))
(lambda () 5)
(defn form-eval [exp env]
(cond (self-evaluating? exp) exp
; ...
(= (first exp) 'lambda) (eval-lambda exp env)))) ;<- here
(defn eval-lambda [exp env]
(list 'procedure ;<-- this is for form-apply
(second exp)
(drop 2 exp)
env))
15](https://image.slidesharecdn.com/lisp-210419024101/85/Lisp-15-320.jpg)
![define
(define x 1)
(define (f x y) (+ x y))
(define f (lambda (x y) (+ x y)))
(defn form-eval [exp env]
(let [exp (macroexpand exp env)]
(cond (self-evaluating? exp) exp
; ...
(= (first exp) 'define) (eval-define exp env)))) ;<-- here
16](https://image.slidesharecdn.com/lisp-210419024101/85/Lisp-16-320.jpg)
![eval-define
(defn define-var [exp]
(if (seq? (second exp)) ;function?
(first (second exp)) ;it's a function so the var is function name
(second exp)))
(defn define-val [exp env]
(let [var (second exp)
make-lambda #(cons 'lambda (cons %1 %2))]
(if (seq? var) ;function?
(form-eval (make-lambda (rest var) (drop 2 exp)) env)
(form-eval (nth exp 2) env))))
(defn eval-define [exp env]
(let [var (define-var exp)
val (define-val exp env)]
(swap! (first env) assoc var val))) 17](https://image.slidesharecdn.com/lisp-210419024101/85/Lisp-17-320.jpg)
![set!
(define x 5)
(set! x 10)
(defn form-eval [exp env]
(cond (self-evaluating? exp) exp
;...
(= (first exp) 'set!) (eval-assignment exp env))) ;<-- here
(defn eval-assignment [exp env]
(let [[op var val] exp]
(env-set var val env)))
18](https://image.slidesharecdn.com/lisp-210419024101/85/Lisp-18-320.jpg)
![let*
(let* ((var val) ...) body)
(defn form-eval [exp env]
(cond (self-evaluating? exp) exp
;...
(= (first exp) 'let*) (eval-let* exp env))) ;<--here
(defn eval-let* [exp env]
(let [eenv (extend-env env)
[op vars body] exp]
(doseq [[b e] vars]
(swap! (first eenv) assoc b (form-eval e eenv)))
(form-eval body eenv)))
19](https://image.slidesharecdn.com/lisp-210419024101/85/Lisp-19-320.jpg)
![defmacro
(defmacro binding (lambda (args) body))
(defn form-eval [exp env]
(cond (self-evaluating? exp) exp
;...
(= (first exp) 'defmacro) (eval-defmacro exp env))); <-here
(defn eval-defmacro [exp env]
(let [[a0 a1 a2] exp
mbody (with-meta (form-eval a2 env) {:ismacro true})]
(swap! (first env) assoc a1 mbody)
"ok"))
20](https://image.slidesharecdn.com/lisp-210419024101/85/Lisp-20-320.jpg)
![macroexpand
(defn form-eval [exp env]
(let [exp (macroexpand exp env)] ;<--here
(cond (self-evaluating? exp) exp
(= (first exp) 'macroexpand) (macroexpand (second exp) env)))) ;<-- here
(defn macroexpand [exp env]
(loop [exp exp]
(if (is-macro-call exp env)
(let [mac (env-get (first exp) env)]
(recur (form-apply mac (rest exp))))
exp)))
21](https://image.slidesharecdn.com/lisp-210419024101/85/Lisp-21-320.jpg)
![macroexpand (cont.)
(defn is-macro-call [exp env]
(and (seq? exp)
(symbol? (first exp))
(env-find (first exp)
env
#(:ismacro (meta (get @% (first exp))))
#(identity false))))
22](https://image.slidesharecdn.com/lisp-210419024101/85/Lisp-22-320.jpg)
![apply else
(defn form-eval [exp env]
(let [exp (macroexpand exp env)]
(cond (self-evaluating? exp) exp
;...
:else (form-apply (form-eval (first exp) env) ;<-- here
(map #(form-eval % env) (rest exp)))))
23](https://image.slidesharecdn.com/lisp-210419024101/85/Lisp-23-320.jpg)
![apply
(defn form-apply [proc args]
(letfn [(primitive? [p] (= (first p) 'primitive))
(procedure? [p] (= (first p) 'procedure)) ;;<-- from lambda
(proc-params [p] (second p))
(proc-body [p] (nth p 2))
(proc-env [p] (nth p 3))]
(cond (primitive? proc) (apply (second proc) args) ;;<-- magic
(procedure? proc) (eval-seq (proc-body proc)
(extend-env (proc-env proc)
(proc-params proc)
args)))))
24](https://image.slidesharecdn.com/lisp-210419024101/85/Lisp-24-320.jpg)
Lisp
- 1. Write Your Own Lisp in Clojure Learn Lisp by making a Lisp 1
- 3. Demo 3
- 5. Eval 5
- 6. Apply (defn form-apply [proc args] (letfn [(primitive? [p] (= (first p) 'primitive)) (procedure? [p] (= (first p) 'procedure)) ;<-- from lambda (proc-params [p] (second p)) (proc-body [p] (nth p 2)) (proc-env [p] (nth p 3))] (cond (primitive? proc) (apply (second proc) args) ;<-- magic (procedure? proc) (eval-seq (proc-body proc) (extend-env (proc-env proc) (proc-params proc) args))))) 6
- 7. Primitive expressions true, 123, "words" nil var, my-fn (defn form-eval [exp env] (cond (self-evaluating? exp) exp (symbol? exp) (env-get exp env) (defn self-evaluating? [x] (or (number? x) (string? x) (nil? x) (boolean? x))) 7
- 8. Enviroment 8
- 9. Enviroment (defn env-find [var env action not-found] ...) (defn env-get [var env] ...) (defn env-set [var val env] ...) (defn extend-env [env] ...) 9
- 10. Initial Enviroment (defn setup-env [] (-> '() (extend-env (keys primitive-procs) (map #(list 'primitive %) (vals primitive-procs))) (extend-env) (built-in!) (extend-env))) (def primitive-procs {'true true '+ + 'car first ...}) primitive-procs 10
- 11. quote (quote 1) => 1 (quote a) => a (quote (+ 1 1)) => (+ 1 1) (defn form-eval [exp env] (cond (self-evaluating? exp) exp (symbol? exp) (env-get exp env) (= (first exp) 'quote) (second exp)) ;;<- here 11
- 12. if (if <cond-expr> expr else-expr) (defn form-eval [exp env] (let [exp (macroexpand exp env)] (cond (self-evaluating? exp) exp (symbol? exp) (env-get exp env) (= (first exp) 'quote) (second exp) (= (first exp) 'if) (eval-if exp env)))) ; <- here (defn eval-if [exp env] (let [[a0 a1 a2 a3] exp] (if (form-eval a1 env) (form-eval a2 env) (form-eval a3 env)))) 12
- 13. Why is "if" a special form? Can we just write a if function? (defn iif [condition stat else] (if (true? condition) expr else-expr)) (iif true (+ 1 2) (* 0 0)) ;=> 3 (iif false (+ 1 2) (* 0 0)) ;=> 0 (iif true (+ 1 2) (/ 0 0)) ;=> Error: ArithmeticException Divide by zero 13
- 14. begin (begin expr1 expr2 ...) like "do" in clojure (defn form-eval [exp env] (cond (self-evaluating? exp) exp (symbol? exp) (env-get exp env) (= (first exp) 'quote) (second exp) (= (first exp) 'if) (eval-if exp env) (= (first exp) 'begin) (eval-seq (rest exp) env))) ; <-- here (defn eval-seq [exp env] (reduce #(form-eval %2 env) nil exp)) 14
- 15. lambda (lambda (x y) (+ x y)) (lambda () 5) (defn form-eval [exp env] (cond (self-evaluating? exp) exp ; ... (= (first exp) 'lambda) (eval-lambda exp env)))) ;<- here (defn eval-lambda [exp env] (list 'procedure ;<-- this is for form-apply (second exp) (drop 2 exp) env)) 15
- 16. define (define x 1) (define (f x y) (+ x y)) (define f (lambda (x y) (+ x y))) (defn form-eval [exp env] (let [exp (macroexpand exp env)] (cond (self-evaluating? exp) exp ; ... (= (first exp) 'define) (eval-define exp env)))) ;<-- here 16
- 17. eval-define (defn define-var [exp] (if (seq? (second exp)) ;function? (first (second exp)) ;it's a function so the var is function name (second exp))) (defn define-val [exp env] (let [var (second exp) make-lambda #(cons 'lambda (cons %1 %2))] (if (seq? var) ;function? (form-eval (make-lambda (rest var) (drop 2 exp)) env) (form-eval (nth exp 2) env)))) (defn eval-define [exp env] (let [var (define-var exp) val (define-val exp env)] (swap! (first env) assoc var val))) 17
- 18. set! (define x 5) (set! x 10) (defn form-eval [exp env] (cond (self-evaluating? exp) exp ;... (= (first exp) 'set!) (eval-assignment exp env))) ;<-- here (defn eval-assignment [exp env] (let [[op var val] exp] (env-set var val env))) 18
- 19. let* (let* ((var val) ...) body) (defn form-eval [exp env] (cond (self-evaluating? exp) exp ;... (= (first exp) 'let*) (eval-let* exp env))) ;<--here (defn eval-let* [exp env] (let [eenv (extend-env env) [op vars body] exp] (doseq [[b e] vars] (swap! (first eenv) assoc b (form-eval e eenv))) (form-eval body eenv))) 19
- 20. defmacro (defmacro binding (lambda (args) body)) (defn form-eval [exp env] (cond (self-evaluating? exp) exp ;... (= (first exp) 'defmacro) (eval-defmacro exp env))); <-here (defn eval-defmacro [exp env] (let [[a0 a1 a2] exp mbody (with-meta (form-eval a2 env) {:ismacro true})] (swap! (first env) assoc a1 mbody) "ok")) 20
- 21. macroexpand (defn form-eval [exp env] (let [exp (macroexpand exp env)] ;<--here (cond (self-evaluating? exp) exp (= (first exp) 'macroexpand) (macroexpand (second exp) env)))) ;<-- here (defn macroexpand [exp env] (loop [exp exp] (if (is-macro-call exp env) (let [mac (env-get (first exp) env)] (recur (form-apply mac (rest exp)))) exp))) 21
- 22. macroexpand (cont.) (defn is-macro-call [exp env] (and (seq? exp) (symbol? (first exp)) (env-find (first exp) env #(:ismacro (meta (get @% (first exp)))) #(identity false)))) 22
- 23. apply else (defn form-eval [exp env] (let [exp (macroexpand exp env)] (cond (self-evaluating? exp) exp ;... :else (form-apply (form-eval (first exp) env) ;<-- here (map #(form-eval % env) (rest exp))))) 23
- 24. apply (defn form-apply [proc args] (letfn [(primitive? [p] (= (first p) 'primitive)) (procedure? [p] (= (first p) 'procedure)) ;;<-- from lambda (proc-params [p] (second p)) (proc-body [p] (nth p 2)) (proc-env [p] (nth p 3))] (cond (primitive? proc) (apply (second proc) args) ;;<-- magic (procedure? proc) (eval-seq (proc-body proc) (extend-env (proc-env proc) (proc-params proc) args))))) 24
- 25. Now you can write your own Lisp in Clojure 25
- 26. Try it (def env (setup-env)) (form-eval '(define (fact x) (if (eq? x 1) 1 (* x (fact (- x 1))))) env) ;=> ok (form-eval '(fact 6) env)) ;=> 720 More examples 26
- 27. Still some thing Add your built-in functions REPL 27
- 28. Question? 28