;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;    
;; push2-examples.lisp
;;
;; Lee Spector, lspector@hampshire.edu
;;
;;
;; These are in the form of expressions to type to the Lisp prompt
;; after having loaded and configured the push2 interpreter. The
;; correct outputs are listed in push2-examples-output.

#|

;; dup
(runpush '(5 integer.dup))
(print-stacks)

(runpush '(TRUE FALSE boolean.dup))
(print-stacks)

;; pop
(runpush '(5 integer.pop))
(print-stacks)

;; swap
(runpush '(5 6 integer.swap))
(print-stacks)

;; =
(runpush '(5 6 integer.=))
(print-stacks)
(runpush '(5 5 integer.=))
(print-stacks)

;; set/get
(runpush '(5 x integer.set))
(print-stacks)
(runpush '(5 x integer.set x integer.get))
(print-stacks)

;; yank
(runpush '(1 2 3 4 5 1 integer.yank))
(print-stacks)
(runpush '(1 2 3 4 5 4 integer.yank))
(print-stacks)
(runpush '(1 2 3 4 5 -21 integer.yank))
(print-stacks)
(runpush '(1 2 3 4 5 21 integer.yank))
(print-stacks)
(runpush '(FALSE TRUE FALSE 1 boolean.yank))
(print-stacks)
(runpush '(FALSE TRUE FALSE 0 boolean.yank))
(print-stacks)
(runpush '(FALSE TRUE FALSE -120 boolean.yank))
(print-stacks)
(runpush '(FALSE TRUE FALSE 120 boolean.yank))
(print-stacks)

;; yankdup
(runpush '(1 2 3 4 5 1 integer.yankdup))
(print-stacks)
(runpush '(1 2 3 4 5 4 integer.yankdup))
(print-stacks)
(runpush '(1 2 3 4 5 -21 integer.yankdup))
(print-stacks)
(runpush '(1 2 3 4 5 21 integer.yankdup))
(print-stacks)
(runpush '(FALSE TRUE FALSE -120 boolean.yankdup))
(print-stacks)
(runpush '(FALSE TRUE FALSE 120 boolean.yankdup))
(print-stacks)
(runpush '(FALSE TRUE FALSE 1 boolean.yankdup))
(print-stacks)

;; shove
(runpush '(1 2 3 4 5 1 integer.shove))
(print-stacks)
(runpush '(1 2 3 4 5 -100 integer.shove))
(print-stacks)
(runpush '(1 2 3 4 5 100 integer.shove))
(print-stacks)
(runpush '(1 2 3 4 5 4 integer.shove))
(print-stacks)
(runpush '(TRUE FALSE TRUE 0 boolean.shove))
(print-stacks)
(runpush '(TRUE FALSE TRUE 1 boolean.shove))
(print-stacks)

;; rand
(runpush '(integer.rand))
(print-stacks)
(runpush '(boolean.rand))
(print-stacks)
(runpush '(name.rand))
(print-stacks)
(runpush '(10 code.rand))
(print-stacks)

;; stackdepth
(runpush '(TRUE TRUE TRUE TRUE TRUE boolean.stackdepth))
(print-stacks)
(runpush '(1 2 3 4 5 integer.stackdepth))
(print-stacks)

;; quote
(runpush '(code.quote (foo bar)))
(print-stacks)

;; atom
(runpush '(code.quote (foo bar) code.atom))
(print-stacks)
(runpush '(code.quote ( ) code.atom))
(print-stacks)
(runpush '(code.quote 22 code.atom))
(print-stacks)

;; null
(runpush '(code.quote (foo bar) code.null))
(print-stacks)
(runpush '(code.quote ( ) code.null))
(print-stacks)
(runpush '(code.quote 22 code.null))
(print-stacks)

;; car
(runpush '(code.quote (foo bar baz) code.car))
(print-stacks)

;; cdr
(runpush '(code.quote (foo bar baz) code.cdr))
(print-stacks)

;; cons
(runpush '(code.quote bonk code.quote (foo bar baz) code.cons))
(print-stacks)
(runpush '(code.quote bonk code.quote foo code.cons)) ;; cons onto atom
(print-stacks)

;; instructions
(runpush '(code.instructions))
(print-stacks)

;; do*
(runpush '(code.quote (code.quote (foo bar baz) code.car) code.do*))
(print-stacks)

;; if
(runpush '(code.quote name.rand code.quote integer.rand TRUE code.if))
(print-stacks)
(runpush '(code.quote name.rand code.quote integer.rand FALSE code.if))
(print-stacks)

;; noop
(runpush '(code.noop))
(print-stacks)

;; list
(runpush '(code.quote foo code.quote bar code.list))
(print-stacks)

;; append
(runpush '(code.quote (foo) code.quote (bar) code.append))
(print-stacks)
(runpush '(code.quote foo code.quote bar code.append))
(print-stacks)

;; nth
(runpush '(code.quote (a b c d) 2 code.nth))
(print-stacks)
(runpush '(code.quote (a b c d) 2000 code.nth))
(print-stacks)

;; nthcdr
(runpush '(code.quote (a b c d) 2 code.nthcdr))
(print-stacks)
(runpush '(code.quote (a b c d) 2000 code.nthcdr))
(print-stacks)

;; member
(runpush '(code.quote (a b) code.quote (x (a b) y) code.member))
(print-stacks)
(runpush '(code.quote (a b) code.quote (x (a x) y) code.member))
(print-stacks)

;; position
(runpush '(code.quote (a b) code.quote (x (a b) y) code.position))
(print-stacks)
(runpush '(code.quote (a b) code.quote (x (a x) y) code.position))
(print-stacks)

;; contains
(runpush '(code.quote (a) code.quote (x (b (a))) code.contains))
(print-stacks)
(runpush '(code.quote (a) code.quote (x (b (z))) code.contains))
(print-stacks)

;; insert
(runpush '(code.quote (x y z) code.quote a 0 code.insert))
(print-stacks)
(runpush '(code.quote (x y z) code.quote a 1 code.insert))
(print-stacks)
(runpush '(code.quote (x y z) code.quote a 3 code.insert))
(print-stacks)

;; extract
(runpush '(code.quote (x (y) z) 0 code.extract))
(print-stacks)
(runpush '(code.quote (x (y) z) 1 code.extract))
(print-stacks)
(runpush '(code.quote (x (y) z) 2 code.extract))
(print-stacks)
(runpush '(code.quote (x (y) z) 3 code.extract))
(print-stacks)
(runpush '(code.quote (x (y) z) 5 code.extract))
(print-stacks)

;; length
(runpush '(code.length))
(print-stacks)

;; size
(runpush '(code.quote (a b c) code.size))
(print-stacks)

;; do
(runpush '(code.quote (code.quote (foo bar baz) code.car) code.do))
(print-stacks)
(runpush '(code.quote (TRUE FALSE) code.do))
(print-stacks)

;; +
(runpush '(2 3 integer.+))
(print-stacks)

;; -
(runpush '(5 2 integer.-))
(print-stacks)

;; *
(runpush '(2 3 integer.*))
(print-stacks)

;; /
(runpush '(10 3 integer./))
(print-stacks)
(runpush '(10 0 integer./))
(print-stacks)

;; %
(runpush '(10 3 integer.%))
(print-stacks)
(runpush '(10 0 integer.%))
(print-stacks)

;; min
(runpush '(10 3 integer.min))
(print-stacks)

;; max
(runpush '(10 3 integer.max))
(print-stacks)

;; <
(runpush '(10 5 integer.<))
(print-stacks)
(runpush '(5 10 integer.<))
(print-stacks)

;; >
(runpush '(10 5 integer.>))
(print-stacks)
(runpush '(5 10 integer.>))
(print-stacks)

;; boolean tests
(runpush '(FALSE TRUE boolean.or FALSE boolean.not boolean.and))
(print-stacks)
(runpush '(FALSE TRUE  boolean.and FALSE boolean.not boolean.and))
(print-stacks)
(runpush '(FALSE TRUE boolean.or TRUE boolean.not boolean.and))
(print-stacks)

;; randboundname
(runpush '(foo 99 integer.set bar 33 integer.set name.randboundname))
(print-stacks)

;; subst
(runpush '(code.quote (foo) code.quote (bar) 
           code.quote (bing (bar) biz ((bar))) code.subst))
(print-stacks)

;; container
(runpush '(code.quote (baz) code.quote (foo (bar (baz))) code.container))
(print-stacks)
(runpush '(code.quote (a) code.quote (x (b (a))) code.container))
(print-stacks)
(runpush '(code.quote (a) code.quote (x (b (z))) code.container))
(print-stacks)

;; discrepancy
(runpush '(code.quote (foo (bar baz)) code.quote (foo (bar bing)) 
           code.discrepancy))
(print-stacks)

;; trig
(runpush '(1.2 float.sin 2.3 float.cos 4.5 float.tan float.+ float.*))
(print-stacks)

;; input + itself
(runpush '(integer.dup integer.+) '(5))
(print-stacks)

;; in a more complex way
(runpush '(code.quote (integer.dup integer.+) code.do)
         '(5))
(print-stacks)

;; factorial via stack manipulation
(runpush '(code.quote (code.quote (integer.pop 1) 
           code.quote (code.dup
                       integer.dup 1 integer.- 
                       code.do 
                       integer.*)
           integer.dup 2 integer.< 
           code.if)
           code.do)
         '(5))
(print-stacks)

;; a simpler factorial (thanks to Alan Robinson)
(runpush '(code.quote (integer.pop 1) 
           code.quote (code.dup
                       integer.dup 
                       1 integer.- code.do integer.*)
           integer.dup 2 integer.< code.if)
         '(5))
(print-stacks)

;; factorial with a named subroutine
(runpush '(factorial
           code.quote (code.quote (integer.pop 1) 
                       code.quote (integer.dup 1 integer.- 
                                   factorial code.get code.do 
                                   integer.*)
                       integer.dup 2 integer.< 
                       code.if)
           code.dup
           code.set
           code.do)
         '(5))
(print-stacks)

;; another named factorial, perhaps the nicest stylistically
(runpush '(code.quote (code.quote (integer.pop 1) 
                       code.quote (integer.dup 1 integer.- 
                                   factorial code.get code.do
                                   integer.*)
                       integer.dup 2 integer.< code.if)
           factorial code.set
           factorial code.get code.do)
         '(5))
(print-stacks)

;; factorial with a named subroutine and args passed via a single variable
;; also careful not to pass the code by stack ever
(runpush '(factorial
           code.quote (arg integer.get
                       code.quote (integer.pop 1) 
                       code.quote (integer.dup 1 integer.- 
                                   factorial code.get 
                                   arg integer.set
                                   code.do 
                                   integer.*)
                          integer.dup 2 integer.< 
                          code.if)
           code.set code.pop
           arg integer.set
           factorial code.get
           code.do)
         '(5))
(print-stacks)

;; mutating version (mutant left on code stack)
(runpush '(code.quote (code.quote (integer.pop 1) 
                       code.quote (code.dup
                                   integer.dup 1 integer.- 
                                   code.do 
                                   integer.*)
                       integer.dup 2 integer.< 
                       code.if)
           code.do
           integer.rand integer.rand code.rand code.insert
           )
         '(5))
(print-stacks)

;; float version
(runpush '(code.quote (code.quote (float.pop 1.0) 
                       code.quote (code.dup
                                   float.dup 1.0 float.- 
                                   code.do 
                                   float.*)
                       float.dup 2.0 float.< 
                       code.if)
           code.do)
         '(5.0))
(print-stacks)


|#