   [f specs args]
   (let [cargs (when (:args specs) (s/conform (:args specs) args))]
     (if (= cargs ::s/invalid)
-      (explain-test args (:args specs) args :args)
+      (explain-check args (:args specs) args :args)
       (let [ret (apply f args)
             cret (when (:ret specs) (s/conform (:ret specs) ret))]
         (if (= cret ::s/invalid)
-          (explain-test args (:ret specs) ret :ret)
+          (explain-check args (:ret specs) ret :ret)
           (if (and (:args specs) (:ret specs) (:fn specs))
             (if (s/valid? (:fn specs) {:args cargs :ret cret})
               true
-              (explain-test args (:fn specs) {:args cargs :ret cret} :fn))
+              (explain-check args (:fn specs) {:args cargs :ret cret} :fn))
             true))))))
 
-(defn- check-fn
+(defn- quick-check
   [f specs {gen :gen opts ::stc/opts}]
   (let [{:keys [num-tests] :or {num-tests 1000}} opts
         g (try (s/gen (:args specs) gen) (catch Throwable t t))]

  [ret]
  (let [result (:result ret)]
    (cond
     (true? result) :test-passed
     (failure-type result) (failure-type result)
     :default :test-threw)))

(defn abbrev-result
  "Given a test result, returns an abbreviated version
suitable for summary use."
  [x]
  (if (true? (:result x))

      {::s/failure :no-fn :sym s :spec spec}
    
      (:args spec)
      (let [tcret (quick-check f spec opts)]
        (make-check-result s spec tcret))
    
      :default
      {::s/failure :no-args-spec :sym s :spec spec}))
   (finally
    (when v (instrument s)))))

(defn- sym->check-map
  [s]
  (let [v (resolve s)]
    {:s s
     :v v
     :spec (when v (s/get-spec v))}))

(defn- validate-check-opts
  [opts]
  (assert (every? ident? (keys (:gen opts))) "check :gen expects ident keys"))

(defn check-fn
  "Runs generative tests for fn f using spec and opts. See
'check' for options and return."
  ([f spec] (check-fn f spec nil))
  ([f spec opts]
     (validate-check-opts opts)
     (check-1 {:f f :spec spec} opts)))

(defn testable-syms
  "Given an opts map as per check, returns the set of syms that
can be tested."
  ([] (testable-syms nil))
  ([opts]
     (validate-check-opts opts)
     (reduce into #{} [(filter fn-spec-name? (keys (s/registry)))
                       (keys (:spec opts))])))

(defn check
  "Run generative tests for spec conformance on vars named by
sym-or-syms, a symbol or collection of symbols. If sym-or-syms
is not specified, check all testable vars.

The opts map includes the following optional keys, where stc
aliases clojure.spec.test.check: 
