Remove 'constructors' keyword

As standardized in dhall-lang/dhall-lang#385

src/dhall_clj/alpha_normalize.clj

@@ -304,10 +304,6 @@
        (update :b alpha-normalize)
        (assoc :type? (when type? (alpha-normalize type?)))))
 
-  dhall_clj.ast.Constructors
-  (alpha-normalize [this]
-    (update this :e alpha-normalize))
-
   dhall_clj.ast.Field
   (alpha-normalize [this]
     (update this :e alpha-normalize))

src/dhall_clj/ast.clj

@@ -83,7 +83,6 @@
 (defrecord CombineTypes [a b])
 (defrecord Prefer [a b])
 (defrecord Merge [a b type?])
-(defrecord Constructors [e])
 (defrecord Field [e k])
 (defrecord Project [e ks])
 (defrecord ImportAlt [a b])
@@ -396,10 +395,6 @@
        (update :a shift diff var)
        (update :b shift diff var)))
 
-  Constructors
-  (shift [this diff var]
-    (update this :e shift diff var))
-
   Merge
   (shift [this diff var]
     (let [type?  (:type? this)
@@ -710,10 +705,6 @@
        (update :b subst var e)
        (assoc :type? (when type? (subst type? var e)))))
 
-  Constructors
-  (subst [this var e]
-    (update this :e subst var e))
-
   Field
   (subst [this var e]
     (update this :e subst var e))

src/dhall_clj/beta_normalize.clj

@@ -645,13 +645,6 @@
                  (:v b')))
         (->Merge a' b' type?'))))
 
-  dhall_clj.ast.Constructors
-  (beta-normalize [this]
-    (let [e' (beta-normalize (:e this))]
-      (if (instance? UnionT e')
-        e'
-        (->Constructors e'))))
-
   dhall_clj.ast.Field
   (beta-normalize [{:keys [e k] :as this}]
     (let [e' (beta-normalize e)]

src/dhall_clj/binary.clj

@@ -170,7 +170,6 @@
           12 (let [[k v kvs] (rest e)]
                (assert-len! e 4)
                (->UnionLit k (decbor v) (map-vals decbor kvs)))
-          13 (->Constructors (decbor (second e)))
           14 (let [[test then else] (rest e)]
                (assert-len! e 4)
                (->BoolIf (decbor test) (decbor then) (decbor else)))
@@ -489,10 +488,6 @@
       [6 (cbor a) (cbor b) (cbor type?)]
       [6 (cbor a) (cbor b)]))
 
-  dhall_clj.ast.Constructors
-  (cbor [{:keys [e]}]
-    [13 (cbor e)])
-
   dhall_clj.ast.Field
   (cbor [{:keys [e k]}]
     [9 (cbor e) k])

src/dhall_clj/emit.clj

@@ -278,10 +278,6 @@
   (emit [{:keys [a b type?]}]
     "Merge") ;; TODO
 
-  dhall_clj.ast.Constructors
-  (emit [{:keys [e]}]
-    "Constructors") ;; TODO
-
   dhall_clj.ast.Field
   (emit [{:keys [e k]}]
     `(get ~(emit e) ~k))

src/dhall_clj/fail.clj

@@ -187,7 +187,6 @@
 (typecheck-ex cant-project)
 (typecheck-ex cant-text-append)
 (typecheck-ex combine-records-requires-record-type)
-(typecheck-ex constructors-require-a-union-type)
 (typecheck-ex duplicate-alternative)
 (typecheck-ex field-annotation-mismatch)
 (typecheck-ex field-collision)

src/dhall_clj/import.clj

@@ -493,10 +493,6 @@
        (update :a resolve-imports state)
        (update :b resolve-imports state)))
 
-  dhall_clj.ast.Constructors
-  (resolve-imports [this state]
-    (update this :e resolve-imports state))
-
   dhall_clj.ast.Merge
   (resolve-imports [{:keys [type?] :as this} state]
     (-> this

src/dhall_clj/parse.clj

@@ -54,7 +54,6 @@
    "as"
    "using"
    "merge"
-   "constructors"
    "Some"])
 
 (defn patch-grammar [grammar]
@@ -424,13 +423,9 @@
 (defmethod expr :application-expression [{:keys [c t]}]
   (if (> (count c) 1)
     (let [exprs (remove #(= :whitespace-chunk (:t %)) c)
-          constructors? (= :constructors (-> c first :t))
           some? (= :Some (-> c first :t))]
       (loop [more (nnext exprs)
              app (cond
-                   constructors?
-                   (->Constructors (expr (second exprs)))
-
                    some?
                    (->Some (expr (second exprs)))
 

src/dhall_clj/typecheck.clj

@@ -753,17 +753,6 @@
         ktsB)
       t))
 
-  dhall_clj.ast.Constructors
-  (typecheck [{:keys [e] :as this} ctx]
-    (typecheck e ctx)
-    (let [e' (beta-normalize e)]
-      (if (instance? UnionT e')
-        (typecheck e' ctx)
-        (fail/constructors-require-a-union-type!
-          ctx
-          this
-          {:type e :type-normal e'}))))
-
   dhall_clj.ast.Field
   (typecheck [{:keys [e k] :as this} ctx]
     (let [eT (-> e (typecheck ctx) beta-normalize)]

test/dhall_clj/binary_test.clj

@@ -88,7 +88,6 @@
 (defn union-type   [a] (gen/fmap ->UnionT (kvs a)))
 (defn union        [a b] (gen/fmap (partial apply ->UnionLit) (gen/tuple label a (kvs b))))
 (defn merge'       [a b] (gen/fmap (partial apply ->Merge) (gen/tuple a b (maybe b))))
-(defn constructors [a] (gen/fmap ->Constructors a))
 (defn field        [a] (gen/fmap (partial apply ->Field) (gen/tuple a label)))
 (defn project      [a] (gen/fmap (partial apply ->Project) (gen/tuple a (gen/not-empty (gen/vector label)))))
 
@@ -144,7 +143,6 @@
            (union-type a)
            (union a b)
            (merge' a b)
-           (constructors a)
            (field a)
            (project a)
            (app a b)

test/dhall_clj/parser_test.clj

@@ -172,12 +172,6 @@
    ["Natural/even 3"
     (->App (->NaturalEven) (->NaturalLit 3))]
 
-   ["constructors < A : Bool >"
-    (->Constructors (->UnionT {"A" (->BoolT)}))]
-
-   ["constructors < A : Bool > 2"
-    (->App (->Constructors (->UnionT {"A" (->BoolT)})) (->NaturalLit 2))]
-
    ["foo.a"
     (->Field (->Var "foo" 0) "a")]