;;; -*- scheme -*- ;;; \$Id: test.l,v 1.2 2001-05-31 14:27:21-05 annis Exp annis \$ ;;; Testing of some basic lisp code. ;;; Does the read() method work? (def foo (lambda (x y) (* x y))) (print (foo 12 55)) (def square (lambda (x) (* x x))) ;;; recursion tests (def map (lambda (fn args) (if (null? args) '() (cons (fn (first args)) (map fn (rest args)))))) (print (map square '(2 4 5 7))) (def member (lambda (elt lst) (cond ((null? lst) *false*) ((== elt (first lst)) elt) (*true* (member elt (rest lst)))))) (print (member 'c '(a b c d))) (print (member 'd '(a b c d))) (print (member 'e '(a b c d))) ;;; If you like a more common-lisp flavor for functions: ;;; (defun square (x) (* x x)) (def defun (macro (name args body) `(def ,name (lambda ,args ,body)))) ;;; Perhaps you like an official scheme version of define which can do ;;; two things? (def define (macro (head tail) (if (list? head) ; (define (square x) (* x x)) `(def ,(car head) (lambda ,(rest head) (begin ,tail))) ; (define foo 12) `(def ,head ,tail)))) ;;; Let's see what this does... (print (macro-expand (define foo 12))) (print (macro-expand (define (square x) (* x x)))) ;;; Redefine the list function with &rest arguments: (def list (lambda (&rest l) l)) ;;; Maybe you want to write your own interpreter: (def eval (macro (code) `(begin ,@code))) ;;; This could be: ;;; (macro (code) `,code) but that exercises a parsing buglet right now. ;;; A trivial apply: (apply + (2 5)). Works with macros, too, which is odd. (def apply (macro (fn args) `(,fn ,@args))) (def incf (macro (x) `(setq ,x (+ ,x 1)))) (def bob 33) (print 'bob bob) (apply incf (bob)) (print 'bob bob) (print (apply square (bob))) ;;; Various bits of scoping cleverness are also possible: (def make-value (lambda (value) (let ((dispatch (lambda (message) (cond ((== message 'get) (lambda () value)) ((== message 'set) (lambda (new-value) (setq value new-value))) (*true* 'unknown-message!))))) dispatch))) (def bob (make-value 14)) ((bob 'get)) ((bob 'set) 42) ((bob 'get)) ;;; Always fun: Fibonacci sequence: (def fib (lambda (x) (if (< x 2) x (+ (fib (- x 1)) (fib (- x 2)))))) (print "doing (fib 15) - this will be slow...") (print "The answer should be 610. It is:" (fib 15))