aboutsummaryrefslogtreecommitdiffstats
path: root/simple.scm
diff options
context:
space:
mode:
Diffstat (limited to 'simple.scm')
-rw-r--r--simple.scm250
1 files changed, 250 insertions, 0 deletions
diff --git a/simple.scm b/simple.scm
new file mode 100644
index 0000000..6e4c3c4
--- /dev/null
+++ b/simple.scm
@@ -0,0 +1,250 @@
+
+; cyclic dependency graph (sigh)
+;
+; meaning
+; expression-to-action
+; list-to-action
+; *application
+; meaning
+;
+; actions
+
+; ### preliminaries, utilities, shorthand
+
+; check if something is an atom vs {null, collection}
+(define atom?
+ (lambda (x)
+ (and (not (pair? x)) (not (null? x)))))
+
+; need a list or tuple type; tuples prefered
+(define first
+ (lambda (p) (car p)))
+
+(define second
+ (lambda (p) (car (cdr p))))
+
+(define third
+ (lambda (p) (car (cdr (cdr p)))))
+
+(define build
+ (lambda (a b) (cons a (cons b (quote ())))))
+
+(define text-of second)
+
+; test functions
+(define add1 (lambda (x) (+ x 1)))
+(define sub1 (lambda (x) (- x 1)))
+
+; table operations
+(define new-entry build)
+
+(define lookup-in-entry
+ (lambda (name entry entry-f)
+ (lookup-in-entry-help name
+ (first entry)
+ (second entry)
+ entry-f)))
+
+(define lookup-in-entry-help
+ (lambda (name names values entry-f)
+ (cond
+ ((null? names) (entry-f name))
+ ((eq? (car names) name) (car values))
+ (else (lookup-in-entry-help name (cdr names) (cdr values) entry-f)))))
+
+(define extend-table cons)
+
+(define lookup-in-table
+ (lambda (name table table-f)
+ (cond
+ ((null? table) (table-f name))
+ (else (lookup-in-entry name
+ (car table)
+ (lambda (n)
+ (lookup-in-table n (cdr table) table-f)))))))
+
+(define initial-table
+ (lambda (name)
+ (car (quote ()))))
+
+;(lookup-in-entry 'fish
+; '((teach a man to fish)
+; (1 2 3 4 5))
+; (lambda (x) x))
+
+;(lookup-in-table 'fish
+; (extend-table '((teach a man to fish)
+; (1 2 3 4 5))
+; (quote ()))
+; (lambda (x) x))
+
+; ### specific types/helpers
+(define builtin?
+ (lambda (l)
+ (eq? (first l) (quote builtin))))
+
+(define non-builtin?
+ (lambda (l)
+ (eq? (first l) (quote non-builtin))))
+
+(define else?
+ (lambda (x)
+ (cond
+ ((atom? x) (eq? x (quote else)))
+ (else #f))))
+
+(define table-of first)
+(define formals-of second)
+(define body-of third)
+(define question-of first)
+(define answer-of second)
+(define cond-lines-of cdr)
+(define function-of car)
+(define arguments-of cdr)
+
+; need generic true/false booleans, a number type, and a symbol type
+; also need a mutable "table" collection
+(define *const
+ (lambda (e table)
+ (cond
+ ((number? e) e)
+ ((eq? e #t) #t)
+ ((eq? e #f) #f)
+ (else (build (quote builtin) e)))))
+;(*const 'asdf '()) ; (builtin asdf)
+
+(define *lambda
+ (lambda (e table)
+ (build (quote non-builtin) (cons table (cdr e)))))
+;(*lambda '(lambda (a b) (cond ((eq? a b) b) (else a))) '( ((1 2 3) (a b c))))
+; (non-builtin ((((1 2 3) (a b c))) (a b) (cond ((eq? a b) b) (else a))))
+
+(define *quote
+ (lambda (e table)
+ (text-of e)))
+;(*quote '(quote stuff) '()) ; stuff
+
+(define *identifier
+ (lambda (e table)
+ (lookup-in-table e table initial-table)))
+;(*identifier 'asdf '()) ; error
+;(*identifier 'a '( ((1 2 3 a b c) (first second third 1 2 3)))) ; 1
+
+(define *cond
+ (lambda (e table)
+ (evcon (cond-lines-of e) table)))
+
+(define :atom?
+ (lambda (x)
+ (cond
+ ((atom? x) #t)
+ ((null? x) #f)
+ ((eq? (car x) (quote builtin)) #t)
+ ((eq? (car x) (quote non-builtin)) #t)
+ (else #f))))
+
+; ### now we start the meat!
+
+(define atom-to-action
+ (lambda (e)
+ (cond
+ ((number? e) *const)
+ ((eq? e #t) *const)
+ ((eq? e #f) *const)
+ ((eq? e (quote cons)) *const)
+ ((eq? e (quote car)) *const)
+ ((eq? e (quote cdr)) *const)
+ ((eq? e (quote null?)) *const)
+ ((eq? e (quote eq?)) *const)
+ ((eq? e (quote atom?)) *const)
+ ((eq? e (quote zero?)) *const)
+ ((eq? e (quote add1)) *const)
+ ((eq? e (quote sub1)) *const)
+ ((eq? e (quote number?)) *const)
+ (else *identifier))))
+;(atom-to-action 'number?); *const
+
+(define list-to-action
+ (lambda (e)
+ (cond
+ ((atom? (car e)) (cond
+ ((eq? (car e) (quote quote)) *quote)
+ ((eq? (car e) (quote lambda)) *lambda)
+ ((eq? (car e) (quote cond)) *cond)
+ (else *application)))
+ (else *application))))
+;(list-to-action '(lambda (x) x)) ; *lambda
+;(list-to-action '(cond ((eq? 1 2) #f) (else #t))) ; *cond
+
+(define expression-to-action
+ (lambda (e)
+ (cond
+ ((atom? e) (atom-to-action e))
+ (else (list-to-action e)))))
+;(expression-to-action '#f) ; *const
+;(expression-to-action '(lambda (x) x)) ; *lambda
+
+(define evcon
+ (lambda (lines table)
+ (cond
+ ((else? (question-of (car lines)))
+ (meaning (answer-of (car lines)) table))
+ ((meaning (question-of (car lines)) table)
+ (meaning (answer-of (car lines)) table))
+ (else (evcon (cdr lines) table)))))
+
+(define evlis
+ (lambda (args table)
+ (cond
+ ((null? args) (quote ()))
+ (else (cons (meaning (car args) table)
+ (evlis (cdr args) table))))))
+;(evlis '(cons #f 4) '()) ; ((builtin cons) #f 4)
+
+(define *application
+ (lambda (e table)
+ (apply2
+ (meaning (function-of e) table)
+ (evlis (arguments-of e) table))))
+
+; basic, low-level, non-compound functions
+(define apply-builtin
+ (lambda (name vals)
+ (cond
+ ((eq? name (quote cons)) (cons (first vals) (second vals)))
+ ((eq? name (quote car)) (car (first vals)))
+ ((eq? name (quote cdr)) (cdr (first vals)))
+ ((eq? name (quote null?)) (null? (first vals)))
+ ((eq? name (quote eq?)) (eq? (first vals) (second vals)))
+ ((eq? name (quote atom?)) (:atom? (first vals)))
+ ((eq? name (quote zero?)) (zero? (first vals)))
+ ((eq? name (quote add1)) (add1 (first vals)))
+ ((eq? name (quote sub1)) (sub1 (first vals)))
+ ((eq? name (quote number?)) (number? (first vals))))))
+
+; for compound functions
+(define apply-closure
+ (lambda (closure vals)
+ (meaning (body-of closure)
+ (extend-table (new-entry (formals-of closure) vals)
+ (table-of closure)))))
+
+; this is "how apply would be implemented"; it isn't used in this file
+(define apply2
+ (lambda (fun vals)
+ (cond
+ ((builtin? fun) (apply-builtin (second fun) vals))
+ ((non-builtin? fun) (apply-closure (second fun) vals)))))
+
+; find the value of an s-expression in the context of an environment
+(define meaning
+ (lambda (e table)
+ ((expression-to-action e) e table)))
+;(meaning '(lambda (x) (cons x y)) '(((y z) ((8) 9))))
+; (non-primative ((((y z) ((8) 9)))) (x) (cons x y))
+
+; and finally, helper to find values in a starting environment
+(define value
+ (lambda (e)
+ (meaning e (quote ()))))
+;(value '((lambda (a b) (a (add1 b))) (lambda (c) (add1 c)) 4)) ; 6