(* CS320 Fall 2006 Assignment 7.
 * Likai Liu, Computer Science Department, Boston University.
 *
 * Distribution without permission is prohibited and is a violation of U.S.
 * Copyright Law. Submitting this solution as your own work whether in part
 * or as a whole also violates Academic Code of Conduct.
 *)

(* Problem 1 *)

exception UnequalLength

fun listAssign (rs, xs) =
    let
      fun checkLen ([], []) = ()
	| checkLen (x :: xs, y :: ys) = checkLen (xs, ys)
	| checkLen _ = raise UnequalLength
    in
      checkLen (rs, xs);
      ListPair.app (fn (r, x) => r := x) (rs, xs)
    end

(* Problem 2 *)

signature QUEUE = sig
  type 'a queue

  exception EmptyQueue

  val make_with_list : 'a list -> 'a queue

  val empty : 'a queue
  val is_empty : 'a queue -> bool

  val insert : 'a * 'a queue -> 'a queue
  val remove: 'a queue -> 'a * 'a queue

  val foreach : ('a -> unit) -> 'a queue -> unit

  val fprint :
      TextIO.outstream -> (TextIO.outstream -> 'a -> unit) -> 'a queue -> unit
end

structure Queue :> QUEUE = struct
  datatype 'a sllist = SLnil | SLcons of 'a * ('a sllist ref)

  type 'a queue = ('a sllist * 'a sllist) option (* SOME (enq, deq) *)

  exception EmptyQueue

  val empty: 'a queue = NONE

  fun is_empty (q: 'a queue) = case q of SOME _ => false | NONE => true

  fun make_with_list xs =
      let
	fun listToSL (xs, accu) =
	    case xs of
	      [] => accu
	    | x :: xs => listToSL (xs, SLcons (x, ref accu))
      in
	case List.rev xs of
	  [] => NONE
	| (last_x :: xs_rev) =>
	  let val enq = SLcons (last_x, ref SLnil) in
	    SOME (enq, listToSL (xs_rev, enq))
	  end
      end

  fun insert (x: 'a, q: 'a queue) =
      let val node = SLcons (x, ref SLnil) in
	case q of
	  NONE => SOME (node, node)
	| SOME (enq as SLcons (_, next), deq) =>
	  ( next := node; SOME (node, deq) )
      end

  fun remove (q: 'a queue): 'a * 'a queue =
      case q of
	NONE => raise EmptyQueue
      | SOME (enq, deq as SLcons (x, next)) =>
	case !next of
	  SLnil => (x, NONE)
	| node => ( x, SOME (enq, node) )

  fun foreach f (q: 'a queue) =
      let
	fun loop SLnil = ()
	  | loop (SLcons (x, next)) = (f x; loop (!next))
      in
	case q of
	  NONE => ()
	| SOME (_, deq) => loop deq
      end

  fun fprint ostrm p q =
      foreach (p ostrm) q
end