Note: There also is the [WWW] x-alice:/lib/data/Stack component in the Alice library, subsuming the module shown here.


Imperative stacks are a mutable data structure.
Every stack contains elements of some type 'a. 

  - Stack.push adds an element to some stack, while 
  - Stack.pop remove and returns the lastestly added 
    element from the stack.
  - Stack.new creates and returns a new empty stack.
  - Stack.toList returns the list of elements in the
    order in which they were added.
  - Stack.isEmpty test for emptyness of the stack

The stack implementation shown here is not thread-safe!
Please use the stacks from the library (lib/data/Stack)
for real work.


   The signature STACK defines the types of 
   the functions provided by all stacks. 

signature STACK =
        type 'a stack
        exception Empty
        val new     : unit -> 'a stack
        val isEmpty : 'a stack -> bool
        val pop     : 'a stack -> 'a 
        val push    : 'a stack -> 'a -> unit
        val toList  : 'a stack -> 'a list

   The structure Stack of signature STACK implements 
   the functions provided by stacks
structure Stack :> STACK =
        type 'a stack = 'a list ref
        exception Empty
        fun new () = ref []
        fun isEmpty s = null (!s)
        fun pop s =
            case !s of
               nil  => raise Empty
             | h::t => (s:=t ; h)
        fun push s x =
            s := x :: !s
        fun toList s = !s

   test stacks 


val stack1 = Stack.new ()
val _ = Stack.push (stack1, 1)
val content = Stack.toList stack1
val _ = Stack.pop stack1

val stack2 = Stack.new ()
val _ = Stack.push (stack2, "hello world")

(* raises an exeption

val _ = Stack.pop stack