  (concat [1 2 3] [4 5 6]) => [1 2 3 4 5 6])
 
 (defn parse-binder-term [def-env binder t bound]
-  (if (not= (count t) 3)
-    [:ko {:msg (str "Wrong " binder " form (expecting 3 arguments)") :term t :nb-args (count t)}]
+  (if (< (count t) 3)
+    [:ko {:msg (str "Wrong " binder " form (expecting at least 3 arguments)") :term t :nb-args (count t)}]
     (let [[status bindings] (parse-binding def-env (second t) bound)]
       (if (= status :ko)
         [:ko {:msg (str "Wrong bindings in " binder " form") :term t :from bindings}]
         (let [bound' (reduce (fn [res [x _]]
                                (conj res x)) #{} bindings)]
-          (let [[status body] (parse-term def-env (nth t 2) bound')]
-            (if (= status :ko)
-              [:ko {:msg (str "Wrong body in " binder " form") :term t :from body}]
-              (loop [i (dec (count bindings)), res body]
-                (if (>= i 0)
-                  (recur (dec i) (list binder (bindings i) res))
-                  [:ok res])))))))))
+          (let [body (if (= (count t) 3)
+                       (nth t 2)
+                       (rest (rest t)))]
+            (let [[status body] (parse-term def-env body bound')]
+              (if (= status :ko)
+                [:ko {:msg (str "Wrong body in " binder " form") :term t :from body}]
+                (loop [i (dec (count bindings)), res body]
+                  (if (>= i 0)
+                    (recur (dec i) (list binder (bindings i) res))
+                    [:ok res]))))))))))
 
 (defn parse-lambda-term [def-env t bound]
   (parse-binder-term def-env 'lambda t bound))

    (let [sdef (get def-env sym)]
      (if (not= (:arity sdef) 0)
        [:ko {:msg "Definition is not a constant (arity>0)" :term sym :def sdef}]
        [:ok (list ::stx/ref sym)]))
    :else [:ko {:msg "Variable out of scope" :term sym}]))

(example

              (not (symbol? (first s)))
              [:ko {:msg "Binding variable is not a symbol" :term v :var (first s)}]
              (reserved-symbol? (first s))
              [:ko {:msg "Wrong binding variable: symbol is reserved" :term v :symbol (first s)}]
              (contains? vars (first s))
              [:ko {:msg "Duplicate binding variable" :term v :var (first s)}]
              :else (recur (rest s) (conj vars (first s)) (conj res [(first s) ty'])))
