(define stack '())
(define set-stack
(lambda ()
(set! stack '())
'done))
(define push
(lambda (x)
(cond ((null? stack) (set! stack (list x)))
(else (set! stack (cons x stack))))
stack))
(define pop
(lambda ()
(let ((tmp '()))
(cond ((null? stack) '())
(else (set! tmp (car stack))
(set! stack (cdr stack))
tmp) ))))
(set-stack)
(push 'a)
(push 'b)
(push 'c)
(pop)
(pop)
(pop)
(pop)
done
(a)
(b a)
(c b a)
c
b
a
()
- First In First Out (FIFO)
(define queue '())
(define tail '())
(define set-queue
(lambda ()
(set! queue '())
(set! tail '())
'done))
(define enqueue
(lambda (x)
(cond ((null? queue)
(set! queue (list x))
(set! tail queue))
(else (set-cdr! tail (list x))
(set! tail (cdr tail))))
queue))
(define dequeue
(lambda ()
(let ((tmp '()))
(cond ((null? queue) '())
(else (set! tmp (car queue))
(set! queue (cdr queue))
tmp) ))))
> (set-queue)
done
> (enqueue 'a)
(a)
> (enqueue 'b)
(a b)
> (enqueue 'c)
(a b c)
> (dequeue)
a
> (dequeue)
b
> (dequeue)
c
> (dequeue)
()
(define dfs-w (lambda (tree)
(define chk (lambda (tree)
(cond ((null? tree) (reverse stack))
((nonpair? tree) (push tree))
(else (chk (car tree))
(chk (cdr tree))))))
(set-stack) (chk tree)))
(define data '((a1 (b1)(b2)) (a2 (b3))))
(dfs-w data)
(define fail '())
(call/cc (lambda (f-cc)
(set! fail
(lambda () (if (null? stack)
(f-cc 'empty)
( ((pop)) ))))))
(define choose
(lambda x
(if (null? x)
(fail)
(call/cc (lambda (c-cc)
(push (lambda () (c-cc (apply choose (cdr x)))))
(car x))) )))
(set-stack)
(choose)
(choose 'test)
(define odd-killer
(lambda ()
(let ((x (choose 1 2)))
(if (odd? x)
(fail)
x) )))
(define two-nums
(lambda ()
(list (choose 2 3)
(choose 5 7) )))
(two-nums)
(fail)
(fail)
(fail)
(fail)
(2 5)
(2 7)
(3 5)
(3 7)
empty
