    
     (def doubler-contract
        (contract doubler
-         [x]
-         :requires
-         (number? x)
-    
-         :ensures
-         (= (* 2 x) %)
-    
-         [x y]
-         :requires
-         (every? number? [x y])
-           
-         :ensures
-         (= (* 2 (+ x y)) %)))
+         [x] [number? => (= (* 2 x) %)]
+
+         [x y] [(every? number? [x y]) => (= (* 2 (+ x y)) %)]))
 
    You can then partially apply this contract with an existing function:
 


   Similar results would occur for the 2-arity versions of `doubler` and `bad-doubler`.

   While it's fine to use `partial` directly, it's better to use the `with-constraints` macro
   found in this same library.

   If you're so inclined, you can inspect the terms of the contract via its metadata, keyed on
   the keyword `:constraints`.
  "
  [& forms]
  (let [name (when (symbol? (first forms))
               (first forms))
        arity-maps (build-forms-map
                    (map #(mapcat identity %) 
                         (partition 2
                                    (partition-by
                                     vector?
                                     (if name
                                       (rest forms)
                                       forms)))))]
    (list `with-meta 
          (list* `fn (if name name (gensym))
                 (collect-bodies arity-maps))
          `{:constraints (into {} '~arity-maps)})))

(defmacro with-constraints
  "Takes a target function and a number of contracts and returns a function with the contracts

          pre-post-map
          (list* 'f args))))

(defmacro contract
  "The base contract form returning a higher-order function that can then be partially
   applied to an existing function to 'apply' a contract.  Take for example a simple
