diff --git a/ast.sml b/ast.sml
index 720042cea596621de3fb85ff602bc0cfb6bc519c..0cf45dd61c48584b1c0b09e874508b976bebc69f 100644
--- a/ast.sml
+++ b/ast.sml
@@ -10,6 +10,9 @@               (* | Fun of func *) (* FIXME: we want functions as atoms! *)
 and      arr  = Scalar of atom
               | Array of arr list;
 
+datatype ''a arr = Scalar of ''a
+                 | Array of ''a list;
+
 datatype ast = Leaf of arr
              | Nilad of unit -> arr
              | Monad of (arr -> arr) * ast
@@ -19,24 +22,26 @@                 want to do an APL rather than a K? *)
 
 (* Test data *)
 fun dup(x) = Array([x]@[x]);
-val x = Leaf(Scalar(Num(0w2)));
+fun cat(x,y) = Array([x]@[y]);
+val x0 = Leaf(Scalar(Num(0w2)));
+val x1 = Leaf(Scalar(Num(0w3)));
 val y = Leaf(Array([Scalar(Num(0w3)),Scalar(Num(0w4))]));
-val m = Monad(dup,x);
-(* val n = Dyad(dup,x,y);
-val t0 = Dyad(dup,n,n);
-val t1 = Dyad(dup,t0,n}); *)
+val m = Monad(dup,x0);
+val d = Dyad(cat,x0,x1);
 
 fun eval_atom(a) = case a of
                         Num(x) => x;
                       (* | Fun(x) => 0wxff; (* FIXME *) *)
 
-fun eval_arr(a) = case a of
-                       Scalar(x) => eval_atom(x)
-                     | Array(x) => 0wxaa; (* FIXME *)
+fun listify(a) = case a of
+                       Scalar(x) => listify(Array([Scalar(x)])) (* FIXME *)
+                     | Array(x)  => x;
+
+fun eval_scalar(s) = case s of
+                          Scalar(Num(s)) => s;
 
 fun eval_ast(t) = case t of
-                       Leaf(a) => eval_arr(a)
-                     | Nilad(f) => eval_arr(f())
-                     | Monad(f,r) => Leaf(f(eval_ast(r)));
-                     (* | Dyad(f,l,r) => eval_arr(f(eval_ast(l),eval_ast(r)));
-                     * *)
+                       Leaf(a)     => a
+                     | Nilad(f)    => f()
+                     | Monad(f,r)  => f(eval_ast(r))
+                     | Dyad(f,l,r) => f(eval_ast(l),eval_ast(r));