     `(defn ~name
        ~(if (:doc mdata) (:doc mdata) "")
        ~@body)))
+
+(comment
+  (defn foo [a b]
+    ((contract blah [a_ b_] [=> pos?])
+     (fn [a b] (+ a b))
+     a
+     b))
+
+  (let [con (contract blah [a_ b_] [=> pos?])]
+    (defn foo
+      "blah"
+      ([a]
+         (con ()))))
+  )
 
 (defmacro provide-contracts [& contracts]
   (let [fn-names  (map first contracts)

  (defconstrainedtype Bar [a 4 b 8] [(every? pos? [a b])])
  (Bar? (new-Bar))

(defn sqr [n]
  (* n n))

(provide-contracts
 [sqr "The constraining of sqr" [n] [number? (not= 0 n) => pos? number?]])

(sqr 0)

 (positive-nums -1)

  (type (new-Bar))
  

    ([f x] {:pre [(foo x)] :post [(bar %)]} (f x))
  "
  [cnstr]
  (let [[args pre-post-map] cnstr]
    `(~(into '[f] args)
      (let [ret# (try
                   ((fn []
                      ~(select-keys pre-post-map [:pre])
                      ~(list* 'f (mapcat (fn [item]
                                           (cond (symbol? item) [item]
                                                 (map? item) [(:as item)]
                                                 :else [item]))
                                         args))))
                   (catch AssertionError pre#
                     (throw (AssertionError. (str "Pre-condition failure! " (.getMessage pre#))))))]
        (try
          ((fn []
             ~(select-keys pre-post-map [:post])
             ret#))
          (catch AssertionError post#
            (throw (AssertionError. (str "Post-condition failure! " (.getMessage post#))))))))))

(defmacro contract
  "The base contract form returning a higher-order function that can then be partially
