(require 'stdlib)

;; structure
;; (cons 'stack (cons top (cons 2nd (cons 3rd nil))))

(define-structure stack
  (export make-stack
          initialize
          stackp
          emptyp
          push
          pop
          top
          size
          to-list
          from-list
          unit-test)

  (open rep)

  (define (make-stack)
    (cons 'stack nil))

  (define (initialize stack)
    (setcdr stack nil))

  (define (stackp stack)
    (eq 'stack (car stack)))

  (define (emptyp stack)
    (eq (top stack) nil))

  (define (push stack item)
    (setcdr stack (cons item (cdr stack))))

  (define (pop stack)
    (prog1
        (top stack)
      (setcdr stack (cddr stack))))

  (define (top stack)
    (car (cdr stack)))

  (define (size stack)
    (length (cdr stack)))

  (define (to-list stack)
    (cdr stack))

  (define (from-list stack lst)
    (setcdr stack lst))

  (define (unit-test)
    (require 'rep.test.framework)
    (let ((s (make-stack))
          lst)
      (assert (stackp s))
      (assert (= 0 (size s)))
      (assert (emptyp s))
      (push s 42)
      (initialize s)
      (assert (emptyp s))      
      (push s 42)
      (assert (= '(stack 42) s))
      (assert (= 1 (size s)))
      (push s 38)
      (assert (= '(38 42) (to-list s)))
      (assert (= '(stack 38 42) s))
      (assert (= 2 (size s)))
      (assert (= 38 (top s)))
      (assert (= 38 (pop s)))
      (assert (= '(42) (to-list s)))
      (assert (= 42 (pop s)))
      (assert (= '() (to-list s)))
      (assert (= 0 (size s)))
      (assert (= nil (pop s)))
      (assert (= nil (pop s)))
      (push s 4)
      (assert (= '(4) (to-list s)))
      (assert (= 4 (pop s)))
      (assert (= '() (to-list s)))
      (setq lst '(1 2 3 4 5))
      (from-list s lst)
      (assert (stackp s))
      (assert (= lst (to-list s))))))

(require 'stack)
(unit-test)