speculation 0.1.0 → 0.2.0

data/lib/speculation/spec_impl/hash_spec.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 module Speculation
-  using Speculation::NamespacedSymbols.refine(self)
-  using Conj
-
   # @private
   class HashSpec < SpecImpl
+    include NamespacedSymbols
     S = Speculation
 
     attr_reader :id
@@ -19,7 +17,8 @@ module Speculation
       req_keys     = req.flat_map(&method(:extract_keys))
       req_un_specs = req_un.flat_map(&method(:extract_keys))
 
-      unless (req_keys + req_un_specs + opt + opt_un).all? { |s| s.is_a?(Symbol) && s.namespace }
+      all_keys = req_keys + req_un_specs + opt + opt_un
+      unless all_keys.all? { |s| s.is_a?(Symbol) && NamespacedSymbols.namespace(s) }
         raise "all keys must be namespaced Symbols"
       end
 
@@ -27,8 +26,8 @@ module Speculation
       req_keys += req_un_specs.map(&method(:unqualify_key))
 
       pred_exprs = [Utils.method(:hash?)]
-      pred_exprs.push(->(v) { parse_req(req, v, :itself.to_proc) == true }) if req.any?
-      pred_exprs.push(->(v) { parse_req(req_un, v, method(:unqualify_key)) == true }) if req_un.any?
+      pred_exprs.push(->(v) { parse_req(req, v, Utils.method(:itself)).empty? }) if req.any?
+      pred_exprs.push(->(v) { parse_req(req_un, v, method(:unqualify_key)).empty? }) if req_un.any?
 
       @req_keys        = req_keys
       @req_specs       = req_specs
@@ -39,7 +38,7 @@ module Speculation
     end
 
     def conform(value)
-      return :invalid.ns unless @keys_pred.call(value)
+      return ns(S, :invalid) unless @keys_pred.call(value)
 
       reg = S.registry
       ret = value
@@ -53,7 +52,7 @@ module Speculation
         conformed_value = S.conform(spec, v)
 
         if S.invalid?(conformed_value)
-          return :invalid.ns
+          return ns(S, :invalid)
         else
           unless conformed_value.equal?(v)
             ret = ret.merge(key => conformed_value)
@@ -66,30 +65,27 @@ module Speculation
 
     def explain(path, via, inn, value)
       unless Utils.hash?(value)
-        return [{ :path => path, :pred => :hash?, :val => value, :via => via, :in => inn }]
+        return [{ :path => path, :pred => [Utils.method(:hash?), [value]], :val => value, :via => via, :in => inn }]
       end
 
       problems = []
 
       if @req.any?
-        valid_or_failure = parse_req(@req, value, :itself.to_proc)
+        failures = parse_req(@req, value, Utils.method(:itself))
 
-        unless valid_or_failure == true
-          valid_or_failure.each do |failure_sexp|
-            pred = sexp_to_rb(failure_sexp)
-            problems << { :path => path, :pred => pred, :val => value, :via => via, :in => inn }
-          end
+        failures.each do |failure_sexp|
+          # eww
+          pred = [Utils.method(:key?), [sexp_to_rb(failure_sexp)]]
+          problems << { :path => path, :pred => pred, :val => value, :via => via, :in => inn }
         end
       end
 
       if @req_un.any?
-        valid_or_failure = parse_req(@req_un, value, method(:unqualify_key))
+        failures = parse_req(@req_un, value, method(:unqualify_key))
 
-        unless valid_or_failure == true
-          valid_or_failure.each do |failure_sexp|
-            pred = sexp_to_rb(failure_sexp)
-            problems << { :path => path, :pred => pred, :val => value, :via => via, :in => inn }
-          end
+        failures.each do |failure_sexp|
+          pred = [Utils.method(:key?), [sexp_to_rb(failure_sexp)]]
+          problems << { :path => path, :pred => pred, :val => value, :via => via, :in => inn }
         end
       end
 
@@ -97,7 +93,7 @@ module Speculation
         next unless S.registry.key?(@key_to_spec_map[k])
 
         unless S.pvalid?(@key_to_spec_map.fetch(k), v)
-          S.explain1(@key_to_spec_map.fetch(k), path.conj(k), via, inn.conj(k), v)
+          S.explain1(@key_to_spec_map.fetch(k), Utils.conj(path, k), via, Utils.conj(inn, k), v)
         end
       }
 
@@ -115,7 +111,7 @@ module Speculation
 
       reqs = @req_keys.zip(@req_specs).
         reduce({}) { |m, (k, s)|
-          m.merge(k => S.gensub(s, overrides, path.conj(k), rmap))
+          m.merge(k => S.gensub(s, overrides, Utils.conj(path, k), rmap))
         }
 
       opts = @opt_keys.zip(@opt_specs).
@@ -123,13 +119,13 @@ module Speculation
           if S.recur_limit?(rmap, @id, path, k)
             m
           else
-            m.merge(k => Gen.delay { S.gensub(s, overrides, path.conj(k), rmap) })
+            m.merge(k => Gen.delay { S.gensub(s, overrides, Utils.conj(path, k), rmap) })
           end
         }
 
       ->(rantly) do
         count = rantly.range(0, opts.count)
-        opts = opts.to_a.shuffle.take(count).to_h
+        opts = Hash[opts.to_a.shuffle.take(count)]
 
         reqs.merge(opts).each_with_object({}) { |(k, spec_gen), h|
           h[k] = spec_gen.call(rantly)
@@ -148,17 +144,17 @@ module Speculation
 
         keys.each_with_index do |key, i|
           unless i.zero?
-            rb_string << " #{op.name} "
+            rb_string << " #{NamespacedSymbols.name(op)} "
           end
 
-          rb_string << sexp_to_rb(key, level + 1)
+          rb_string << sexp_to_rb(key, level + 1).to_s
         end
 
         rb_string << ")" unless level.zero?
 
         rb_string
       else
-        ":#{sexp}"
+        sexp
       end
     end
 
@@ -171,7 +167,7 @@ module Speculation
     end
 
     def unqualify_key(x)
-      x.name.to_sym
+      NamespacedSymbols.name(x).to_sym
     end
 
     def parse_req(ks, v, f)
@@ -180,15 +176,15 @@ module Speculation
       ret = if key.is_a?(Array)
               op, *kks = key
               case op
-              when :or.ns
-                if kks.one? { |k| parse_req([k], v, f) == true }
-                  true
+              when ns(S, :or)
+                if kks.one? { |k| parse_req([k], v, f).empty? }
+                  []
                 else
                   [key]
                 end
-              when :and.ns
-                if kks.all? { |k| parse_req([k], v, f) == true }
-                  true
+              when ns(S, :and)
+                if kks.all? { |k| parse_req([k], v, f).empty? }
+                  []
                 else
                   [key]
                 end
@@ -196,17 +192,13 @@ module Speculation
                 raise "Expected or, and, got #{op}"
               end
             elsif v.key?(f.call(key))
-              true
+              []
             else
               [key]
             end
 
       if ks.any?
-        if ret == true
-          parse_req(ks, v, f)
-        else
-          ret + parse_req(ks, v, f)
-        end
+        ret + parse_req(ks, v, f)
       else
         ret
       end

data/lib/speculation/spec_impl/merge_spec.rb

@@ -1,9 +1,8 @@
 # frozen_string_literal: true
 module Speculation
-  using NamespacedSymbols.refine(self)
-
   # @private
   class MergeSpec < SpecImpl
+    include NamespacedSymbols
     S = Speculation
 
     def initialize(preds)
@@ -14,7 +13,7 @@ module Speculation
       ms = @preds.map { |pred| S.dt(pred, x) }
 
       if ms.any?(&S.method(:invalid?))
-        :invalid.ns(S)
+        ns(S, :invalid)
       else
         ms.reduce(&:merge)
       end

data/lib/speculation/spec_impl/nilable_spec.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 module Speculation
-  using NamespacedSymbols.refine(self)
-  using Conj
-
   # @private
   class NilableSpec < SpecImpl
+    include NamespacedSymbols
     S = Speculation
 
     def initialize(pred)
@@ -13,15 +11,16 @@ module Speculation
     end
 
     def conform(value)
-      value.nil? ? value : @delayed_spec.value.conform(value)
+      value.nil? ? value : @delayed_spec.value!.conform(value)
     end
 
     def explain(path, via, inn, value)
-      return if S.pvalid?(@delayed_spec.value, value) || value.nil?
+      return if S.pvalid?(@delayed_spec.value!, value) || value.nil?
 
-      S.
-        explain1(@pred, path.conj(:pred.ns), via, inn, value).
-        conj(:path => path.conj(:nil.ns), :pred => NilClass, :val => value, :via => via, :in => inn)
+      Utils.conj(
+        S.explain1(@pred, Utils.conj(path, ns(S, :pred)), via, inn, value),
+        :path => Utils.conj(path, ns(S, :nil)), :pred => [NilClass, [value]], :val => value, :via => via, :in => inn
+      )
     end
 
     def gen(overrides, path, rmap)
@@ -29,7 +28,7 @@ module Speculation
 
       ->(rantly) do
         rantly.freq([1, Gen.delay { Utils.constantly(nil) }],
-                    [9, Gen.delay { S.gensub(@pred, overrides, path.conj(:pred.ns), rmap) }])
+                    [9, Gen.delay { S.gensub(@pred, overrides, Utils.conj(path, ns(S, :pred)), rmap) }])
       end
     end
   end

data/lib/speculation/spec_impl/or_spec.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 module Speculation
-  using NamespacedSymbols.refine(self)
-  using Conj
-
   # @private
   class OrSpec < SpecImpl
+    include NamespacedSymbols
     S = Speculation
 
     attr_reader :id
@@ -21,7 +19,7 @@ module Speculation
     end
 
     def conform(value)
-      @delayed_specs.value.each_with_index do |spec, index|
+      @delayed_specs.value!.each_with_index do |spec, index|
         conformed = spec.conform(value)
 
         unless S.invalid?(conformed)
@@ -29,7 +27,7 @@ module Speculation
         end
       end
 
-      :invalid.ns
+      ns(S, :invalid)
     end
 
     def explain(path, via, inn, value)
@@ -37,7 +35,7 @@ module Speculation
 
       @keys.zip(@preds).flat_map do |(key, pred)|
         next if S.pvalid?(pred, value)
-        S.explain1(pred, path.conj(key), via, inn, value)
+        S.explain1(pred, Utils.conj(path, key), via, inn, value)
       end
     end
 
@@ -49,7 +47,7 @@ module Speculation
           rmap = S.inck(rmap, @id)
 
           unless S.recur_limit?(rmap, @id, path, k)
-            Gen.delay { S.gensub(p, overrides, path.conj(k), rmap) }
+            Gen.delay { S.gensub(p, overrides, Utils.conj(path, k), rmap) }
           end
         }.
         compact

data/lib/speculation/spec_impl/regex_spec.rb

@@ -1,9 +1,8 @@
 # frozen_string_literal: true
 module Speculation
-  using NamespacedSymbols.refine(self)
-
   # @private
   class RegexSpec < SpecImpl
+    include NamespacedSymbols
     S = Speculation
 
     def initialize(regex)
@@ -14,7 +13,7 @@ module Speculation
       if value.nil? || Utils.collection?(value)
         S.re_conform(@regex, value)
       else
-        :invalid.ns
+        ns(S, :invalid)
       end
     end
 

data/lib/speculation/spec_impl/spec.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 module Speculation
-  using Speculation::NamespacedSymbols.refine(self)
-  using Conj
-
   # @private
   class Spec < SpecImpl
+    include NamespacedSymbols
     S = Speculation
 
     def initialize(predicate, should_conform)
@@ -22,13 +20,13 @@ module Speculation
       if @should_conform
         ret
       else
-        ret ? value : :invalid.ns
+        ret ? value : ns(S, :invalid)
       end
     end
 
     def explain(path, via, inn, value)
       if S.invalid?(S.dt(@predicate, value))
-        [{ :path => path, :val => value, :via => via, :in => inn, :pred => @predicate }]
+        [{ :path => path, :val => value, :via => via, :in => inn, :pred => [@predicate, [value]] }]
       end
     end
 

data/lib/speculation/spec_impl/tuple_spec.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 module Speculation
-  using Speculation::NamespacedSymbols.refine(self)
-  using Conj
-
   # @private
   class TupleSpec < SpecImpl
+    include NamespacedSymbols
     S = Speculation
 
     def initialize(preds)
@@ -16,10 +14,10 @@ module Speculation
     end
 
     def conform(collection)
-      specs = @delayed_specs.value
+      specs = @delayed_specs.value!
 
       unless Utils.array?(collection) && collection.count == specs.count
-        return :invalid.ns
+        return ns(S, :invalid)
       end
 
       return_value = collection.class.new
@@ -28,7 +26,7 @@ module Speculation
         conformed_value = spec.conform(value)
 
         if S.invalid?(conformed_value)
-          return :invalid.ns
+          return ns(S, :invalid)
         else
           return_value += [conformed_value]
         end
@@ -39,13 +37,13 @@ module Speculation
 
     def explain(path, via, inn, value)
       if !Utils.array?(value)
-        [{ :path => path, :val => value, :via => via, :in => inn, :pred => "array?" }]
+        [{ :path => path, :val => value, :via => via, :in => inn, :pred => [Utils.method(:array?), [value]] }]
       elsif @preds.count != value.count
-        [{ :path => path, :val => value, :via => via, :in => inn, :pred => "count == predicates.count" }]
+        [{ :path => path, :val => value, :via => via, :in => inn, :pred => [Utils.method(:count_eq), [@preds, value.count]] }]
       else
         probs = @preds.zip(value).each_with_index.flat_map { |(pred, x), index|
           unless S.pvalid?(pred, x)
-            S.explain1(pred, path.conj(index), via, inn.conj(index), x)
+            S.explain1(pred, Utils.conj(path, index), via, Utils.conj(inn, index), x)
           end
         }
 
@@ -57,7 +55,7 @@ module Speculation
       return @gen if @gen
 
       gens = @preds.each_with_index.
-        map { |p, i| S.gensub(p, overrides, path.conj(i), rmap) }
+        map { |p, i| S.gensub(p, overrides, Utils.conj(path, i), rmap) }
 
       ->(rantly) do
         gens.map { |g| g.call(rantly) }

data/lib/speculation/test.rb

@@ -2,11 +2,12 @@
 require "concurrent"
 require "pp"
 require "speculation/pmap"
+require "speculation/gen"
 
 module Speculation
   module Test
-    using NamespacedSymbols.refine(self)
-    using Pmap
+    extend NamespacedSymbols
+    extend Pmap
 
     # @private
     S = Speculation
@@ -27,8 +28,8 @@ module Speculation
       instrument_enabled.value = true
     end
 
-    # Given an opts hash as per instrument, returns the set of
-    # Speculation::Identifiers for methods that can be instrumented.
+    # Given an opts hash as per instrument, returns the set of methods that can
+    # be instrumented.
     # @param opts [Hash]
     # @return [Array<Identifier>]
     def self.instrumentable_methods(opts = {})
@@ -38,16 +39,16 @@ module Speculation
         end
       end
 
-      S.registry.keys.select(&method(:fn_spec_name?)).to_set.tap do |set|
+      S.registry.keys.select(&method(:fn_spec_name?)).to_set.tap { |set|
         set.merge(opts[:spec].keys)    if opts[:spec]
         set.merge(opts[:stub])         if opts[:stub]
         set.merge(opts[:replace].keys) if opts[:replace]
-      end
+      }.map(&method(:Method))
     end
 
-    # @param method_or_methods [Method, Identifier, Array<Method>, Array<Identifier>]
+    # @param method_or_methods [Method, Array<Method>]
     #   Instruments the methods named by method-or-methods, a method or collection
-    #   of methods, or all instrumentable methods if method-or-methods is not
+    #   of methods, or all instrumentable methods if method_or_methods is not
     #   specified.
     #   If a method has an :args fn-spec, replaces the method with a method that
     #   checks arg conformance (throwing an exception on failure) before
@@ -74,7 +75,7 @@ module Speculation
     #   then invokes the method/proc you provide, enabling arbitrary stubbing and
     #   mocking.
     #
-    # @return [Array<Identifier>] a collection of Identifiers naming the methods instrumented.
+    # @return [Array<Method>] a collection of methods instrumented.
     def self.instrument(method_or_methods = instrumentable_methods, opts = {})
       if opts[:gen]
         gens = opts[:gen].reduce({}) { |h, (k, v)| h.merge(S.Identifier(k) => v) }
@@ -85,24 +86,26 @@ module Speculation
         map { |method| S.Identifier(method) }.
         uniq.
         map { |ident| instrument1(ident, opts) }.
-        compact
+        compact.
+        map(&method(:Method))
     end
 
     # Undoes instrument on the method_or_methods, specified as in instrument.
     # With no args, unstruments all instrumented methods.
-    # @param method_or_methods [Method, Identifier, Array<Method>, Array<Identifier>]
-    # @return [Array<Identifier>] a collection of Identifiers naming the methods unstrumented
+    # @param method_or_methods [Method, Array<Method>]
+    # @return [Array<Method>] a collection of methods unstrumented
     def self.unstrument(method_or_methods = nil)
       method_or_methods ||= @instrumented_methods.value.keys
 
       Array(method_or_methods).
         map { |method| S.Identifier(method) }.
         map { |ident| unstrument1(ident) }.
-        compact
+        compact.
+        map(&method(:Method))
     end
 
     # Runs generative tests for method using spec and opts.
-    # @param method [Method, Identifier]
+    # @param method [Method]
     # @param spec [Spec]
     # @param opts [Hash]
     # @return [Hash]
@@ -113,17 +116,16 @@ module Speculation
     end
 
     # @param opts [Hash] an opts hash as per `check`
-    # @return [Array<Identifier>] the set of Identifiers that can be checked.
+    # @return [Array<Method>] the array of methods that can be checked.
     def self.checkable_methods(opts = {})
       validate_check_opts(opts)
 
       S.
         registry.
         keys.
-        select(&method(:fn_spec_name?)).
-        reject(&:instance_method?).
-        to_set.
-        tap { |set| set.merge(opts[:spec].keys) if opts[:spec] }
+        select { |k| fn_spec_name?(k) && !k.instance_method? }.
+        concat(Hash(opts[:spec]).keys).
+        map(&method(:Method))
     end
 
     # Run generative tests for spec conformance on method_or_methods. If
@@ -151,10 +153,15 @@ module Speculation
     def self.check(method_or_methods = nil, opts = {})
       method_or_methods ||= checkable_methods
 
-      Array(method_or_methods).
-        map { |method| S.Identifier(method) }.
-        select { |ident| checkable_methods(opts).include?(ident) }.
-        pmap { |ident| check1(ident, S.get_spec(ident), opts) }
+      checkable = Set(checkable_methods(opts))
+      checkable.map!(&S.method(:Identifier))
+
+      methods = Set(method_or_methods)
+      methods.map!(&S.method(:Identifier))
+
+      pmap(methods.intersection(checkable)) { |ident|
+        check1(ident, S.get_spec(ident), opts)
+      }
     end
 
     # Given a check result, returns an abbreviated version suitable for summary use.
@@ -162,11 +169,11 @@ module Speculation
     # @return [Hash]
     def self.abbrev_result(x)
       if x[:failure]
-        x.reject { |k, _| k == :ret.ns }.
+        x.reject { |k, _| k == ns(:ret) }.
           merge(:spec    => x[:spec].inspect,
                 :failure => unwrap_failure(x[:failure]))
       else
-        x.reject { |k, _| [:spec, :ret.ns].include?(k) }
+        x.reject { |k, _| [:spec, ns(:ret)].include?(k) }
       end
     end
 
@@ -194,6 +201,13 @@ module Speculation
       }
     end
 
+    # @param modules [Module, Class]
+    # @return [Array<Method>] an array of public and protected singleton
+    #   methods belonging to modules
+    def self.enumerate_methods(*modules)
+      modules.flat_map { |mod| mod.methods(false).map(&mod.method(:method)) } # method
+    end
+
     class << self
       private
 
@@ -201,27 +215,27 @@ module Speculation
         fspec = S.send(:maybe_spec, fspec)
 
         conform = ->(args, block) do
-          conformed_args = S.conform(fspec.argspec, args)
-          conformed_block = S.conform(fspec.blockspec, block) if fspec.blockspec
+          conformed_args = S.conform(fspec.args, args)
+          conformed_block = S.conform(fspec.block, block) if fspec.block
 
-          if conformed_args == :invalid.ns(S)
+          if conformed_args == ns(S, :invalid)
             backtrace = backtrace_relevant_to_instrument(caller)
 
             ed = S.
-              _explain_data(fspec.argspec, [:args], [], [], args).
-              merge(:args.ns(S) => args, :failure.ns(S) => :instrument, :caller.ns => backtrace)
+              _explain_data(fspec.args, [:args], [], [], args).
+              merge(ns(S, :args) => args, ns(S, :failure) => :instrument, ns(:caller) => backtrace.first)
 
             io = StringIO.new
             S.explain_out(ed, io)
             msg = io.string
 
             raise Speculation::Error.new("Call to '#{ident}' did not conform to spec:\n #{msg}", ed)
-          elsif conformed_block == :invalid.ns(S)
+          elsif conformed_block == ns(S, :invalid)
             backtrace = backtrace_relevant_to_instrument(caller)
 
             ed = S.
-              _explain_data(fspec.blockspec, [:block], [], [], block).
-              merge(:block.ns(S) => block, :failure.ns(S) => :instrument, :caller.ns => backtrace)
+              _explain_data(fspec.block, [:block], [], [], block).
+              merge(ns(S, :block) => block, ns(S, :failure) => :instrument, ns(:caller) => backtrace.first)
 
             io = StringIO.new
             S.explain_out(ed, io)
@@ -236,7 +250,7 @@ module Speculation
 
           if Test.instrument_enabled.value
             Test.with_instrument_disabled do
-              conform.call(args, block) if fspec.argspec
+              conform.call(args, block) if fspec.args
 
               begin
                 Test.instrument_enabled.value = true
@@ -252,7 +266,7 @@ module Speculation
       end
 
       def no_fspec(ident, spec)
-        S::Error.new("#{ident} not spec'ed", :method => ident, :spec => spec, :failure.ns(S) => :no_fspec)
+        S::Error.new("#{ident} not spec'ed", :method => ident, :spec => spec, ns(S, :failure) => :no_fspec)
       end
 
       def instrument1(ident, opts)
@@ -324,9 +338,9 @@ module Speculation
       def explain_check(args, spec, v, role)
         data = unless S.valid?(spec, v)
                  S._explain_data(spec, [role], [], [], v).
-                   merge(:args.ns       => args,
-                         :val.ns        => v,
-                         :failure.ns(S) => :check_failed)
+                   merge(ns(:args)       => args,
+                         ns(:val)        => v,
+                         ns(S, :failure) => :check_failed)
                end
 
         S::Error.new("Specification-based check failed", data).tap do |e|
@@ -338,32 +352,32 @@ module Speculation
       # :backtrace, :cause and :data keys. :data will have a
       # :"Speculation/failure" key.
       def check_call(method, spec, args, block)
-        conformed_args = S.conform(spec.argspec, args) if spec.argspec
+        conformed_args = S.conform(spec.args, args) if spec.args
 
-        if conformed_args == :invalid.ns(S)
-          return explain_check(args, spec.argspec, args, :args)
+        if conformed_args == ns(S, :invalid)
+          return explain_check(args, spec.args, args, :args)
         end
 
-        conformed_block = S.conform(spec.blockspec, block) if spec.blockspec
+        conformed_block = S.conform(spec.block, block) if spec.block
 
-        if conformed_block == :invalid.ns(S)
+        if conformed_block == ns(S, :invalid)
           return explain_check(block, spec.block, block, :block)
         end
 
         ret = method.call(*args, &block)
 
-        conformed_ret = S.conform(spec.retspec, ret) if spec.retspec
+        conformed_ret = S.conform(spec.ret, ret) if spec.ret
 
-        if conformed_ret == :invalid.ns(S)
-          return explain_check(args, spec.retspec, ret, :ret)
+        if conformed_ret == ns(S, :invalid)
+          return explain_check(args, spec.ret, ret, :ret)
         end
 
-        return true unless spec.argspec && spec.retspec && spec.fnspec
+        return true unless spec.args && spec.ret && spec.fn
 
-        if S.valid?(spec.fnspec, :args => conformed_args, :block => conformed_block, :ret => conformed_ret)
+        if S.valid?(spec.fn, :args => conformed_args, :block => conformed_block, :ret => conformed_ret)
           true
         else
-          explain_check(args, spec.fnspec, { :args => conformed_args, :block => conformed_block, :ret => conformed_ret }, :fn)
+          explain_check(args, spec.fn, { :args => conformed_args, :block => conformed_block, :ret => conformed_ret }, :fn)
         end
       end
 
@@ -372,14 +386,14 @@ module Speculation
         num_tests = opts.fetch(:num_tests, 1000)
 
         args_gen = begin
-                     S.gen(spec.argspec, gen)
+                     S.gen(spec.args, gen)
                    rescue => e
                      return { :result => e }
                    end
 
-        block_gen = if spec.blockspec
+        block_gen = if spec.block
                       begin
-                        S.gen(spec.blockspec, gen)
+                        S.gen(spec.block, gen)
                       rescue => e
                         return { :result => e }
                       end
@@ -387,15 +401,18 @@ module Speculation
                       Utils.constantly(nil)
                     end
 
-        combined_gen = ->(r) { [args_gen.call(r), block_gen.call(r)] }
+        arg_block_gen = ->(r) { [args_gen.call(r), block_gen.call(r)] }
 
-        rantly_quick_check(combined_gen, num_tests) { |(args, block)| check_call(method, spec, args, block) }
+        generator_guard = ->(genned_val) { S.valid?(spec.args, genned_val) }
+        rantly_quick_check(arg_block_gen, num_tests, generator_guard) do |(args, block)|
+          check_call(method, spec, args, block)
+        end
       end
 
       def make_check_result(method, spec, check_result)
-        result = { :spec   => spec,
-                   :ret.ns => check_result,
-                   :method => method }
+        result = { :spec    => spec,
+                   ns(:ret) => check_result,
+                   :method  => method }
 
         if check_result[:result] && check_result[:result] != true
           result[:failure] = check_result[:result]
@@ -414,12 +431,12 @@ module Speculation
         reinstrument = unstrument(ident).any?
         method = ident.get_method
 
-        if specd.argspec # or blockspec?
+        if specd.args
           check_result = quick_check(method, spec, opts)
           make_check_result(method, spec, check_result)
         else
-          failure = { :info         => "No :args spec",
-                      failure.ns(S) => :no_args_spec }
+          failure = { :info        => "No :args spec",
+                      ns(:failure) => :no_args_spec }
 
           { :failure => failure,
             :method  => method,
@@ -447,7 +464,7 @@ module Speculation
 
       # Reimplementation of Rantly's `check` since it does not provide direct access to results
       # (shrunk data etc.), instead printing them to STDOUT.
-      def rantly_quick_check(gen, num_tests)
+      def rantly_quick_check(gen, num_tests, generator_guard, &invariant)
         i = 0
         limit = 100
 
@@ -455,32 +472,19 @@ module Speculation
           args, blk = val
           i += 1
 
-          result = begin
-                     yield([args, blk])
-                   rescue => e
-                     e
-                   end
+          result = yield([args, blk]) rescue $!
 
           unless result == true
-            # This is a Rantly Tuple.
-            args = ::Tuple.new(args)
-
-            if args.respond_to?(:shrink)
-              shrunk = shrink(args, result, ->(v) { yield([v, blk]) })
-
-              shrunk[:smallest] = [shrunk[:smallest].array, blk]
-
-              return { :fail      => args.array,
-                       :block     => blk,
-                       :num_tests => i,
-                       :result    => result,
-                       :shrunk    => shrunk }
-            else
-              return { :fail      => args.array,
-                       :block     => blk,
-                       :num_tests => i,
-                       :result    => result }
-            end
+            args = ::Tuple.new(args) # This is a Rantly Tuple.
+
+            shrunk = shrink(generator_guard, args, result, ->(v) { invariant.call([v, blk]) })
+
+            shrunk[:smallest] = { :args => shrunk[:smallest].array, :block => blk }
+
+            return { :fail      => { :args => args.array, :block => blk },
+                     :num_tests => i,
+                     :result    => result,
+                     :shrunk    => shrunk }
           end
         end
 
@@ -489,32 +493,36 @@ module Speculation
       end
 
       # reimplementation of Rantly's shrinking.
-      def shrink(data, result, block, depth = 0, iteration = 0)
-        smallest = data
+      def shrink(generator_guard, value, result, invariant, depth = 0, iteration = 0)
+        smallest = value
         max_depth = depth
 
-        if data.shrinkable?
+        if value.shrinkable?
           while iteration < 1024
-            shrunk_data = data.shrink
-            result = begin
-                       block.call(shrunk_data.array)
-                     rescue => e
-                       e
-                     end
+            shrunk_value = value.shrink
+
+            unless generator_guard.call(shrunk_value.array)
+              iteration += 1
+              value = shrunk_value
+              value.shrinkable? ? next : break
+            end
 
-            unless result == true
-              shrunk = shrink(shrunk_data, result, block, depth + 1, iteration + 1)
+            res = invariant.call(shrunk_value.array) rescue $!
 
-              branch_smallest, branch_depth, iteration =
-                shrunk.values_at(:smallest, :depth, :iteration)
+            unless res == true
+              shrunk = shrink(generator_guard, shrunk_value, res, invariant, depth + 1, iteration + 1)
+
+              branch_smallest, branch_depth, iteration, branch_result =
+                shrunk.values_at(:smallest, :depth, :iteration, :result)
 
               if branch_depth > max_depth
-                smallest = branch_smallest
                 max_depth = branch_depth
+                smallest = branch_smallest
+                result = branch_result
               end
             end
 
-            break unless data.retry?
+            break unless value.retry?
           end
         end
 
@@ -527,7 +535,7 @@ module Speculation
       ### check reporting ###
 
       def failure_type(x)
-        x.data[:failure.ns(S)] if x.is_a?(S::Error)
+        x.data[ns(S, :failure)] if x.is_a?(S::Error)
       end
 
       def unwrap_failure(x)
@@ -548,6 +556,23 @@ module Speculation
           failure_type(failure) || :check_raised
         end
       end
+
+      # if x is an Identifier, return its method
+      def Method(x)
+        case x
+        when Identifier then x.get_method
+        when Method, UnboundMethod then x
+        else raise ArgumentError, "unexpected method-like object #{x}"
+        end
+      end
+
+      def Set(x)
+        case x
+        when Set then x
+        when Enumerable then Set.new(x)
+        else Set[x]
+        end
+      end
     end
   end
 end