anchor.diff:  
   [source,clojure]
   ----
  -(stest/check-var #'ranged-rand)
  -;;{:result {:clojure.spec/problems {[] {:pred (>= (:ret %) (-> % :args :start)),
  -;;                                      :val {:args {:start -1, :end 3}, :ret -3},
  -;;                                      :via [],
  -;;                                      :in []}},
  -;;          :failed-on :fn},
  -;; :seed 1466023411366,
  -;; :failing-size 0,
  -;; :num-tests 1,
  -;; :fail [(-1 3)],
  -;; :shrunk {:total-nodes-visited 2,
  -;;          :depth 1,
  -;;          :result {:clojure.spec/problems {[] {:pred (>= (:ret %) (-> % :args :start)),
  -;;                                               :val {:args {:start 0, :end 3}, :ret -2},
  -;;                                               :via [],
  -;;                                               :in []}},
  -;;                   :failed-on :fn},
  -;;          :smallest [(0 3)]}}
  -----
  -
  -`test` has reported an error in the `:fn` spec. We can see the arguments passed were -1 and 3 and the return value was -3, which is out of the expected range. At the bottom, test.check takes one step further though and "shrinks" the invalid inputs to find simpler/smaller inputs that yield the same error. Here the "simpler" inputs were 0 and 3, which is not much different, but on complicated data, shrinking is a killer feature for finding failing examples.
  +(stest/abbrev-result (first (stest/test `ranged-rand)))
  +;;=> ({:spec (fspec
  +;;            :args (and (cat :start int? :end int?) (fn* [p1__3468#] (< (:start p1__3468#) (:end p1__3468#))))
  +;;            :ret int?
  +;;            :fn (and
  +;;                  (fn* [p1__3469#] (>= (:ret p1__3469#) (-> p1__3469# :args :start)))
  +;;                  (fn* [p1__3470#] (< (:ret p1__3470#) (-> p1__3470# :args :end))))),
  +;;     :sym spec.examples.guide/ranged-rand,
  +;;     :result {:clojure.spec/problems [{:path [:fn],
  +;;                                       :pred (>= (:ret %) (-> % :args :start)),
  +;;                                       :val {:args {:start -3, :end 0}, :ret -5},
  +;;                                       :via [],
  +;;                                      :in []}],
  +;;              :clojure.spec.test/args (-3 0),
  +;;              :clojure.spec.test/val {:args {:start -3, :end 0}, :ret -5},
  +;;              :clojure.spec/failure :test-failed}}
  +----
  +
  +`test` has reported an error in the `:fn` spec. We can see the arguments passed were -3 and 0 and the return value was -5, which is out of the expected range.
   
   == Wrapping Up
   
  
positive.code: (s/def ::scores (s/map-of string? int?))
  (s/conform ::scores {"Sally" 1000, "Joe" 500})
  ;=> {"Sally" 1000, "Joe" 500}
  ----
  
  == Using spec for validation
  
negative.code: 
  A few helpers are provided for other special collection cases - http://clojure.github.io/clojure/branch-master/clojure.spec-api.html#clojure.spec/coll-of[`coll-of`], http://clojure.github.io/clojure/branch-master/clojure.spec-api.html#clojure.spec/tuple[`tuple`], and  http://clojure.github.io/clojure/branch-master/clojure.spec-api.html#clojure.spec/map-of[`map-of`].
  
  For the special case of a homogenous collection of arbitrary size, you can use `coll-of` to specify a collection of elements satisfying a predicate.
  
  [source,clojure]
  ----
  (s/conform (s/coll-of keyword?) [:a :b :c])
  ;;=> [:a :b :c]
  (s/conform (s/coll-of number?) #{5 10 2})
  ;;=> #{2 5 10}
  ----
  
  Additionally, `coll-of` can be passed a number of keyword arg options:
  
  * `:kind` - one of [], (), {}, or #{} to check that the incoming collection is of this type
  * `:count` - specifies exact expected count
  * `:min-count`, `:max-count` - checks that collection has `(<= min-count count max-count)`
  * `:distinct` - checks that all elements are distinct
  * `:into` - one of [], (), {}, or #{} for output conformed value. If `:into` is not specified, the input collection type will be used.
  
  Following is an example utilizing some of these options to spec a vector containing three distinct numbers conformed as a set and some of the errors for different kinds of invalid values:
  
  [source,clojure]
  ----
  (s/def ::vnum3 (s/coll-of number? :kind [] :count 3 :distinct true :into #{}))
  (s/conform ::vnum3 [1 2 3])
  ;;=> #{1 2 3}
  (s/explain ::vnum3 #{1 2 3})   ;; not a vector
  ;; val: #{1 3 2} fails spec: ::vnum3 predicate: clojure.core/vector?
  (s/explain ::vnum3 [1 1 1])    ;; not distinct
  ;; val: [1 1 1] fails spec: ::vnum3 predicate: distinct?
  (s/explain ::vnum3 [1 2 :a])   ;; not a number
  ;; In: [2] val: :a fails spec: ::vnum3 predicate: number?
  ----
  
  [NOTE]
  ====
  Both `coll-of` and `map-of` will conform all of their elements, which may make them unsuitable for large collections. In that case, consisder http://clojure.github.io/clojure/branch-master/clojure.spec-api.html#clojure.spec/every[`every`] or for maps  http://clojure.github.io/clojure/branch-master/clojure.spec-api.html#clojure.spec/every-kv[`every-kv`].
  ====
  
  While `coll-of` is good for homogenous collections of any size, another case is a fixed-size positional collection with fields of known type at different positions. For that we have `tuple`.
  