Validation DSL comparison

validation.clj

(validation :postal_address
   :street_number [required :message "waaaah!"]
   :country [required]

(validation :record
   :email [
           v/required
           v/number
           v/email :message "naaah" :when green
           v/matches :expr /gmail[.]com$/ :message "woah!"]
   :address [v/like :postal_address]
   :pets [required
          each :item has_name
          v/count :min 1 max 5]
   :key  [ 
          (complement nil?) :message "message" :optional false
          required :message :locale-specific-key ]

(validate :record
          (required :email "message")
          (required [:address :street])          
          (number :email)
          (mk-validator #(not (nil? %)) :key "message" :optional false)
          (email :email "message")
  	  (every :pets has_name)
          (min   :pets 1))

(v/check {:email "jim@gmail.com"} {:as :record} )

(def person {:address {:past [{:country nil} {:country "Brazil"}]}})
(new-validate person
              :name required
              :age  [(required :message "custom")
                     number]
              [:passport :number] positive
              [:passport :number] [(positive :message) (number :message)]
              [:address :past]    [(every :pred #(not (nil? (:country %)))
                                                   :message "all past addresses must have a country")])

;without the anonymous function
(complement (comp nil? :country))

;using s-exp as the expression form
[:address]    [(custom #(not (nil? (:country %))) "all past addresses must have a country")
                    number]

;composable matchers...
(v/matcher :citizens-only
                       every_item {:satisfies #(not (nil? (:country %)) 
                                         :message "all past addresses must have a country"})
{
  :name required
  :age  [(required :message "custom")
               number
               (citizens-only :message "Oui monsieur")]
}

Got this form working:

(new-validate {}
              :name required
              :age  [(required :message "custom")
                       number]
              [:passport :number] positive
              [:address :past] [(every #(not (nil? (:country %)))
                                       :message "all past addresses must have a country")])

(def invalid-map {:name nil
                  :age ""
                  :passport {:number -7 :issued_by "Australia"}
                  :address {:current { :country "Australia"}
                            :past [{:country nil} {:country "Brasil"}]}})
(core/validate invalid-map
               :name core/required
               :age [core/required (core/number :message "NaN")]
               [:passport :number] core/positive 
               [:address :past] (core/every #(not (nil? (:country %)))))