diff --git a/arr.sml b/arr.sml
index 61a9079ed21fb51737d0efe201399b8db7686d8d..964175648688783ef44ca9ff00300922ed44b9ef 100644
--- a/arr.sml
+++ b/arr.sml
@@ -5,10 +5,10 @@ abstype atom = N of Word8.word
              | FN of unit -> arr
              | FM of arr -> arr
              | FD of (arr * arr) -> arr
-             | STOP
 and     arr  = Lf of atom (* arrays as binary trees - SML doesn't allow arbitrarily nested lists *)
              | Nd of arr * arr (* (val, next) *)
              | Bx of arr * arr (* (shape, arr) *)
+             | Zl (* Zilde *)
 with
 exception Domain;
 exception Index;
@@ -18,56 +18,59 @@ fun Word(x) = Lf(N(x));
 fun Fun0(f) = Lf(FN(f));
 fun Fun1(f) = Lf(FM(f));
 fun Fun2(f) = Lf(FD(f));
-fun Stop() = Lf(STOP);
-fun Array([]) = Stop()
+fun Array([]) = Zl
+  | Array([x]) = x
   | Array(x::xs) = Nd(x,Array(xs)); (* TODO: automatically box? *)
 fun unbox(Bx(s,a)) = a
   | unbox(x) = x;
-fun tally(Lf(STOP)) = 0w0
+fun tally(Zl) = 0w0
   | tally(Lf(a:atom)) = 0w1
   | tally(Nd(x,y)) = 0w1 + tally y
   | tally(Bx(s,a)) = tally (unbox a);
 fun Box(a:arr) = Bx(Array([Word(tally a)]),a);
 fun shape(Bx(s,a)) = Box(s)
   | shape(Nd(x,y)) = Box(Array([Word(tally(Nd(x,y)))])); (* TODO: Do we want a boxed array to be length 1 of the length of the contents? *)
-fun str(Lf(STOP)) = "" (* TODO: box-drawing characters might be nice in the future *)
+fun str(Zl) = "(Zilde)" (* TODO: box-drawing characters might be nice in the future *)
   | str(Lf(N(x))) = Word8.fmt StringCvt.HEX x
   | str(Lf(FN(x))) = "(Nilad)" (* TODO: would be nice to get actual function names *)
   | str(Lf(FM(x))) = "(Monad)"
   | str(Lf(FD(x))) = "(Dyad)"
   | str(Nd(x,y)) = str(x) ^ " " ^ str(y)
-  | str(Bx(s,a)) = "[ " ^ str(a) ^ "]";
+  | str(Bx(s,a)) = "[" ^ str(a) ^ "]";
 (* TODO: higher-order functions *)
 fun apply0(f) = raise NYI; (* TODO - what if it generates a whole array? *)
-fun apply1(f,Lf(STOP)) = Lf(STOP) (* traverse the array tree, applying f to each leaf in turn *)
+fun apply1(f,Zl) = raise Domain  (* traverse the array tree, applying f to each leaf in turn *)
   | apply1(f,Lf(N(x))) = Lf(N(f(x)))
   | apply1(f,Nd(x,y)) = Nd(apply1(f,x),apply1(f,y));
 fun apply2(f,x,y) = raise NYI; (* TODO *)
 fun append(x,a) = Nd(x,a);
-fun index _ (Lf(STOP)) = raise Index
+fun index _ Zl = Zl (* TODO: Is this the behaviour that we want?  Or should it raise an exception? *)
   | index 0w0 (Lf(x)) = Lf(x)
   | index _ (Lf(x)) = raise Index
   | index 0w0 (Nd(x,y)) = x
   | index i (Nd(x,y)) = index (i-0w1) y
   | index i (Bx(s,a)) = index i a;
-fun take _ (Lf(STOP)) = raise Index
+fun take _ Zl = Zl
   | take 0w0 a = raise Index
   | take 0w1 (Lf(x)) = Lf(x)
   | take 0w1 (Bx(s,a)) = raise NYI (* TODO: implement taking from first axis like dyalog? *)
   | take 0w1 (Nd(x,y)) = x
   | take n (Nd(x,y)) = Nd(x,(take (n-0w1) y))
   | take n (Bx(x,y)) = raise NYI; (* TODO: see above *)
-fun drop _ (Lf(STOP)) = raise Index
+fun drop _ Zl = Zl
   | drop 0w0 a = a
   | drop 0w1 (Nd(x,y)) = y
   | drop n (Nd(x,y)) = drop (n-0w1) y
   | drop _ (Bx(s,a)) = raise NYI; (* TODO: see notes on boxes on take above *)
-fun reverse (Lf(x)) = Lf(x)
+fun reverse (Lf(x)) = Lf(x) (* FIXME: thsi doesn't behave properly, see str(take 0w4 (reverse (iota 0w8))); *)
   | reverse (Bx(s,a)) = Bx(s,a) (* TODO: boxing behaviour might be inconsistent across functions; check/correct asap before you get too deep into it *)
-  | reverse (Nd(x,y)) = Nd((reverse y),x); (* FIXME: this won't work due to the STOP elements - they need to be removed from the implementation if possible, or this needs to be reworked *)
-fun iota 0w0 = raise Index
-  | iota 0w1 = Word(0w0)
-  | iota n = Nd(Word(n-0w1),(iota (n-0w1))); (* TODO: need to reverse at the end; this probably needs to go into a let and then reverse the output at the end *)
+  | reverse (Nd(x,y)) = Nd((reverse y),x);
+fun iota n =
+  let fun i 0w0 = raise Index (* TODO: is this the right exception? *)
+        | i 0w1 = Word(0w0)
+        | i n = Nd(Word(n-0w1),(iota (n-0w1)))
+  in reverse (i n)
+  end;
 (* fun addD(x,Lf(STOP)) = x (* dyadic add *)
   | addD(Lf(N(x)),Lf(N(y))) = Lf(N(x+y))
   | addD(Nd(x,xs),Lf(N(y))) = Nd(Lf(N(x+y)),add(xs,Lf(N(y)))) (* FIXME: doesn't