Make empty list a literal instead of disjoint AST node.

Author: dvanhorn

ziggy/src/ast.rkt

@@ -1,8 +1,9 @@
 #lang crook
-{:= A B C D0 D0.A D1 E0 E1 F H0 H1 I J K L}
+{:= A B C D0 D0.A D1 E0 E1 F F.A H0 H1 I J K L}
 (provide {:> A} Lit {:> E0} Prim0 {:> B} Prim1 {:> F} Prim2 {:> H1} Prim3
-         {:> C D0} IfZero {:> D0} If {:> E0} Eof {:> E0} Begin {:> F} Let
-         {:> F} Var {:> H0} Empty {:> I} Prog {:> I} Defn {:> I} App
+         {:> C D0} IfZero {:> D0} If {:> E0} Eof {:> E0} Begin
+         {:> F} Let {:> F} Var {:> I} Prog {:> I} Defn {:> I} App
+         {:> F.A H} Cond {:> F.A H} Case
          {:> K} Match {:> K} Box {:> K} Cons {:> K} Conj {:> L} Lam)
 
 {:> I} ;; type Prog = (Prog (Listof Defn) Expr)
@@ -14,7 +15,6 @@
 {:> A D0} ;; type Expr = (Lit Integer)
 {:> D0}   ;; type Expr = (Lit Datum)
 {:> E0}   ;;           | (Eof)
-{:> H0}   ;;           | (Empty)
 {:> E0}   ;;           | (Prim0 Op0)
 {:> B}    ;;           | (Prim1 Op1 Expr)
 {:> F}    ;;           | (Prim2 Op2 Expr Expr)
@@ -23,10 +23,18 @@
 {:> D0}   ;;           | (If Expr Expr Expr)
 {:> D0.A D1}
           ;;           | (Cond [Listof CondClause] Expr)
+{:> F.A H0}
+          ;;           | (Cond [Listof CondClause] Expr)
 {:> D0.A D1}
           ;;           | (Case Expr [Listof CaseClause] Expr)
+{:> F.A H0}
+          ;;           | (Case Expr [Listof CaseClause] Expr)
 {:> E0}   ;;           | (Begin Expr Expr)
-{:> F}    ;;           | (Let Id Expr Expr)
+{:> F F.A}
+          ;;           | (Let Id Expr Expr)
+{:> F.A H0}
+          ;;           | (Let (Listof Id) (Listof Expr) Expr)
+{:> H0}   ;;           | (Let Id Expr Expr)
 {:> F}    ;;           | (Var Id)
 {:> I L}  ;;           | (App Id (Listof Expr))
 {:> L}    ;;           | (App Expr (Listof Expr))
@@ -37,6 +45,10 @@
 ;; type CondClause = (Clause Expr Expr)
 {:> D0.A D1}
 ;; type CaseClause = (Clause [Listof Datum] Expr)
+{:> F.A H0}
+;; type CondClause = (Clause Expr Expr)
+{:> F.A H0}
+;; type CaseClause = (Clause [Listof Datum] Expr)
 
 {:> F}    ;; type Id  = Symbol
 {:> D0}   ;; type Datum = Integer
@@ -66,7 +78,6 @@
 {:> K}    ;;           | (Conj Pat Pat)
 
 {:> E0}   (struct Eof () #:prefab)
-{:> H0}   (struct Empty () #:prefab)
 {:> A D0} (struct Lit (i) #:prefab)
 {:> D0}   (struct Lit (d) #:prefab)
 {:> E0}   (struct Prim0 (p) #:prefab)
@@ -77,6 +88,8 @@
 {:> D0}   (struct If (e1 e2 e3) #:prefab)
 {:> E0}   (struct Begin (e1 e2) #:prefab)
 {:> F}    (struct Let (x e1 e2) #:prefab)
+{:> F.A H} (struct Cond (cs es el) #:prefab)
+{:> F.A H} (struct Case (e ds es el) #:prefab)
 {:> F}    (struct Var (x) #:prefab)
 {:> I}    (struct App (f es) #:prefab)
 {:> L}    (struct Lam (f xs e) #:prefab)

ziggy/src/compile.rkt

@@ -157,8 +157,6 @@
     [(Lit d) (compile-value d)]
     {:> E0}
     [(Eof) (compile-value eof)]
-    {:> H0}
-    [(Empty) (compile-value '())]
     {:> F}
     [(Var x) (compile-variable x c)]
     {:> E0}

ziggy/src/interp.rkt

@@ -84,8 +84,6 @@
   (match e
     [(Lit d) d]
     [(Eof)   eof]
-    {:> H0}
-    [(Empty) '()]
     {:> F L}
     [(Var x) (lookup r x)]
     {:> L}

ziggy/src/parse.rkt

@@ -16,7 +16,7 @@
     {:> F}
     [(? symbol?)         (Var s)]
     {:> H0}
-    [(list 'quote (list)) (Empty)]
+    [(list 'quote (list)) (Lit '())]
     {:> E0}
     [(list (? op0? o))   (Prim0 o)]
     {:> B}
@@ -66,7 +66,7 @@
     [(? datum?)               (Lit s)]
     ['eof                     (Eof)]
     [(? symbol?)              (Var s)]
-    [(list 'quote (list))     (Empty)]
+    [(list 'quote (list))     (Lit '())]
     [(list (? op0? p0))       (Prim0 p0)]
     [(list (? op1? p1) e)     (Prim1 p1 (parse-e e))]
     [(list (? op2? p2) e1 e2) (Prim2 p2 (parse-e e1) (parse-e e2))]