title Twerp -- LTwerp -- a minimalistish Pure Lisp interpreter, in C++
user strick
ip 216.239.45.4
vol 1
lock ********

/section NEW LOCATION:

/big(
The code is now in a
/link http://www.google.com/search?q=darcs   darcs
repository at
/tt  http://albus.yak.net/repos/ltwerp/
or you can get a snapshot with
/tt  wget -m -nv -np http://albus.yak.net/repos/ltwerp/
/big)

/box(
/tt  ./a.out [012]*.l  "(list (let chr (lambda (n) (if (null n) '@ (succ (chr (sub1 n))))) (implode (mapcar (mapcar '(XVIIII XX XVIII VIIII III XI) peano) chr))))" 2>&1 | tail -1
/box)
or, with the Y combinator:
/box(
/tt  ./a.out [0123]*.l "(list (run  (implode (mapcar (mapcar '(XVIIII XX XVIII VIIII III XI) peano) (Y (lambda (self) (lambda (n) (if (null n) '@ (succ (self (sub1 n))))))) )) ))" 2>&1 | tail -1
/box)

/section THE FOLLOWING HAS NOT BEEN UPDATED and is probably somewhat obsolete.

 /file lterp-2009-01-19.cc
/list(
* Single C++ module
* Stackless execution (so we can have call-cc)
* Pure functional model, no mutable variables.
* No numbers, just symbols.
* The basics:  CAR, CDR, CONS, NULL, ATOMP, EQ, LIST, IF, DEFUN.
* More: EXPLODE (into single-char symbols), IMPLODE (construct new symbols), CMP (like strcmp).
* Special Forms: QUOTE, IF, LAMBDA, LET, DEFUN, CALL-CC, JUMP (a continuation by call-cc).
* Tests 11 & 12 demonstrate APPEND and REVERSE from user code.
/list)

/tt Usage:  a.out lib1.lt lib2.lt ... "(call-some-function)"
-- Command line arguments are either lisp source files or,
if an argument starts with "(", an expressionn to eval.
In the latter case, if the result is an atom, its print value is
sent to stdout, raw; but if the result is a list, it is printed
to stdout with normal formatting and escaping.  Compile with -D"NDEBUG"
to supress lots of debugging output to stderr.


/tt (let atom1 expr1 atom2 expr2... resultExpr)
-- evals expr1 and binds to atom1; then expr2 to atom2, etc.; finally evals resultExpr and returns it.  (We omit 2 layers of parentheses around the atom/expr pairs, from the normal LET syntax).

/tt (defun name (arg1 arg2...) expr)
-- defines the name as global variable to have lambda expression

/tt (call-cc f)
-- calls f, passing it the Current Continuation, such that when the continuation is used later as a function, passing it some value x, the flow of control jumps back to the invokation of call-cc, which then returns x.  See
/file return.lt
for an example.

/b TODO
/list(
* S-Expression Parser
/b --done.
* STRCMP
/b --done.
* Library of useful functions
/b  --started
* input & output.  Write a Wiki!
* Monads WTF.
* EXPLODE & IMPLODE
/b  --done.
* call-cc:
/b --done.
* Error Handling, debugging output
/b --getting better
* Lexical Binding, defun
/b --done
* Demonstrate Y Combinator
/b --done
* Peano Numbers
/b --done;
Church Integers
/b --done;
Roman Numerals?
* Garbage Collector
/list)

/b INTERNALS
/list(
* The function
/b LTerp Step(Lterp)
executes one step, given an LTerp state with some work to do, returning the next LTerp state with one step finished.
*
/b struct LTerp { sn env, sn work, sn stk; }
defines interpreter state with 3 lists.  (sn is a pointer to a Cons Node or a Symbol).
* env holds local variable bindings.  Every other element is key (var name) or value.
* work is a list of things to do; each entry uses two elements.  Currently supported are EVAL, APPLY, BIND, UNBIND, and IF.
* stk is a data stack for work items to communicate with.
* Also there are Global Variable bindings.  Assume these are immutable.
* All values are either Symbols (atoms) or Cons Nodes (pairs).
* To eval something, set the work to "EVAL x", for your expression x.  Then iterate Step() until work is empty.  The result is on the stack.
* The Little Lisper's 5 Laws are enforced.  The CDR must be a list.  NULL must take a list; NOT takes anything.  Only NIL is false.
/list)

Updates
/list(
* /file lterp-2009-01-21.cc
* /file lterp-2009-01-22.cc
* /file lib.lt
* /file lib2.lt
* /file return.lt
* /file mk
* /file lterp.cc
* /file lib.lt
* /file mk
* /file lterp-2009-01-24.cc
/list)

/pre(
strick@retro:~/lterp$ ./lterp   lib.lt    macro.lt  "(incr-fn '5)"
      [12] eval:
        == x<139386416>
      [11] eval:
        == +
      [10] apply:
        ++ +  ==>  <EVAL#11>  <==
        ++ x<139386416>  ==>  <EVAL#12>  <==
        ++ n<139264920>  ==>  5  <==
      [9] unbind:
        -- n<139264920>  ==>  5  <==
      [8] unbind:
        -- ___FRAME___  ==>  ( lambda ( n<139264920> ) ( + x<139386416> n<139264920> ) )  <==
      [7] eval:
        == ( x<139386416> )
      [6] eval:
        == lambda
      [5] eval:
        == list
      [4] apply:
        ++ list  ==>  <EVAL#5>  <==
        ++ lambda  ==>  <EVAL#6>  <==
        ++ ( x<139386416> )  ==>  <EVAL#7>  <==
        ++ ( ( lambda ( n<139264920> ) ( + x<139386416> n<139264920> ) ) n<139264920> )  ==>  <APPLY#10>  <==
      [3] unbind:
        -- n<139264920>  ==>  5  <==
      [2] unbind:
        -- ___FRAME___  ==>  ( lambda ( n<139264920> ) ( list lambda ( x<139386416> ) ( ( lambda ( n<139264920> ) ( + x<139386416> n<139264920> ) ) n<139264920> ) ) )  <==
      [1] unbind:
        -- ___FRAME___  ==>  ( incr-fn '5 )  <==
      [0] Result: <APPLY#4>
LOOKUP NOT FOUND: x<139386416>

/pre)
* /file lterp-2009-01-27.cc

/section Demonstrating Church Integers
(based on test code in ParentheTcl -> http://albus.yak.net/repos/parenthetcl/tests/church.p7 )
/pre(
strick@retro:~/lterp$ cat church.lt

(fn  '0
     '(f)
     (lambda (x) x))

(fn  '1
     '(f)
     (lambda (x) (f x)))


(fn  '2
     '(f)
     (lambda (x) (f (f x))))

(fn  '++
     '(n)
     (lambda (f) (lambda (x) (f ((n f) x)))))

(def '3 (++ 2))
(def '4 (++ 3))
(def '5 (++ 4))

(fn  'tick
     '(s)
     '(implode (list 'I s)))

(say (list '0-> ((0 tick) '.)))
(say (list '1-> ((1 tick) '.)))
(say (list '2-> ((2 tick) '.)))
(say (list '3-> ((3 tick) '.)))
(say (list '4-> ((4 tick) '.)))
(say (list '5-> ((5 tick) '.)))


; composition is multiplication

(fn 'compose/curry
    '(f)
    (lambda (g) (lambda (x) (f (g x)))))

(fn 'times '(a b) '((compose/curry a) b))

(def '12 (times 3 4))

(say (list '12-> ((12 tick) '.)))

strick@retro:~/lterp$ ./lterp lib.lt macro.lt  church.lt
## ( 0-> . )
## ( 1-> I. )
## ( 2-> II. )
## ( 3-> III. )
## ( 4-> IIII. )
## ( 5-> IIIII. )
## ( 12-> IIIIIIIIIIII. )
strick@retro:~/lterp$
/pre)
/list(
* /file lterp.cc
* /file lib.lt
* /file macro.lt
* /file ycomb.lt
* /file church.lt
* /file return.lt
* /file lterp-2009-02-05.cc
/list)
* /file church.lt
* /file twerp.h
* /file t