speculation 0.1.0 → 0.2.0

data/lib/speculation.rb

@@ -5,15 +5,13 @@ require "securerandom"
 
 require "speculation/version"
 require "speculation/namespaced_symbols"
-require "speculation/conj"
 require "speculation/identifier"
 require "speculation/utils"
 require "speculation/spec_impl"
 require "speculation/error"
 
 module Speculation
-  using NamespacedSymbols.refine(self)
-  using Conj
+  extend NamespacedSymbols
 
   class << self
     # Enables or disables spec asserts. Defaults to false.
@@ -36,7 +34,7 @@ module Speculation
     attr_accessor :coll_error_limit
   end
 
-  @check_asserts    = false
+  @check_asserts    = ENV["SPECULATION_CHECK_ASSERTS"] == "true"
   @recursion_limit  = 4
   @fspec_iterations = 21
   @coll_check_limit = 101
@@ -44,20 +42,24 @@ module Speculation
 
   @registry_ref = Concurrent::Atom.new({})
 
-  # Can be enabled/disabled by setting check_asserts.
+  # Can be enabled or disabled at runtime:
+  # - enabled/disabled by setting `check_asserts`.
+  # - enabled by setting environment variable SPECULATION_CHECK_ASSERTS to the
+  #   string "true"
+  # Defaults to false if not set.
   # @param spec [Spec]
   # @param x value to validate
   # @return x if x is valid? according to spec
   # @raise [Error] with explain_data plus :Speculation/failure of :assertion_failed
   def self.assert(spec, x)
     return x unless check_asserts
-    return x unless valid?(spec, x)
+    return x if valid?(spec, x)
 
-    ed = S._explain_data(spec, [], [], [], x)
+    ed = _explain_data(spec, [], [], [], x).merge(ns(:failure) => :assertion_failed)
     out = StringIO.new
-    S.explain_out(ed, out)
+    explain_out(ed, out)
 
-    raise Speculation::Error.new("Spec assertion failed\n#{out.string}", :failure.ns => :assertion_failed)
+    raise Speculation::Error.new("Spec assertion failed\n#{out.string}", ed)
   end
 
   # @param infinite [Boolean] whether +/- infinity allowed (default true)
@@ -76,30 +78,30 @@ module Speculation
     max ||= Float::MAX
 
     gens = [[20, ->(_) { rand(min.to_f..max.to_f) }]]
-    gens << [1, ->(_) { Float::INFINITY }] if infinite
+    gens << [1, ->(r) { r.choose(Float::INFINITY, -Float::INFINITY) }] if infinite
     gens << [1, ->(_) { Float::NAN }] if nan
 
-    spec(S.and(*preds), :gen => ->(rantly) { rantly.freq(*gens) })
+    spec(self.and(*preds), :gen => ->(rantly) { rantly.freq(*gens) })
   end
 
   # @param range [Range<Integer>]
   # @return Spec that validates ints in the given range
   def self.int_in(range)
-    spec(S.and(Integer, ->(x) { range.include?(x) }),
+    spec(self.and(Integer, ->(x) { range.include?(x) }),
          :gen => ->(_) { rand(range) })
   end
 
   # @param time_range [Range<Time>]
   # @return Spec that validates times in the given range
   def self.time_in(time_range)
-    spec(S.and(Time, ->(x) { time_range.cover?(x) }),
+    spec(self.and(Time, ->(x) { time_range.cover?(x) }),
          :gen => ->(_) { rand(time_range) })
   end
 
   # @param date_range [Range<Date>]
   # @return Spec that validates dates in the given range
   def self.date_in(date_range)
-    spec(S.and(Date, ->(x) { date_range.cover?(x) }),
+    spec(self.and(Date, ->(x) { date_range.cover?(x) }),
          :gen => ->(_) { rand(date_range) })
   end
 
@@ -112,13 +114,13 @@ module Speculation
   # @param x [Hash, Object]
   # @return [Hash, false] x if x is a (Speculation) regex op, else logical false
   def self.regex?(x)
-    Utils.hash?(x) && x[:op.ns] && x
+    Utils.hash?(x) && x[ns(:op)] && x
   end
 
   # @param value return value of a `conform` call
   # @return [Boolean] true if value is the result of an unsuccessful conform
   def self.invalid?(value)
-    value.equal?(:invalid.ns)
+    value.equal?(ns(:invalid))
   end
 
   # @param spec [Spec]
@@ -129,13 +131,13 @@ module Speculation
     specize(spec).conform(value)
   end
 
-  # Takes a spec and a one-arg generator block and returns a version of the spec that uses that generator
+  # Takes a spec and a one-arg generator function and returns a version of the spec that uses that generator
   # @param spec [Spec]
-  # @yield [Rantly] generator block
+  # @param gen [Proc] generator proc that receives a Rantly instance
   # @return [Spec]
-  def self.with_gen(spec, &gen)
+  def self.with_gen(spec, gen)
     if regex?(spec)
-      spec.merge(:gfn.ns => gen)
+      spec.merge(ns(:gfn) => gen)
     else
       specize(spec).tap { |s| s.gen = gen }
     end
@@ -146,7 +148,7 @@ module Speculation
     probs = specize(spec).explain(path, via, inn, value)
 
     if probs && probs.any?
-      { :problems.ns => probs }
+      { ns(:problems) => probs }
     end
   end
 
@@ -172,7 +174,7 @@ module Speculation
   def self.explain_out(ed, out = STDOUT)
     return out.puts("Success!") unless ed
 
-    ed.fetch(:problems.ns).each do |prob|
+    ed.fetch(ns(:problems)).each do |prob|
       path, pred, val, reason, via, inn = prob.values_at(:path, :pred, :val, :reason, :via, :in)
 
       out.print("In: ", inn.to_a.inspect, " ") unless inn.empty?
@@ -184,7 +186,7 @@ module Speculation
 
       prob.each do |k, v|
         unless [:path, :pred, :val, :reason, :via, :in].include?(k)
-          out.print("\n\t ", k.inspect, v.inspect)
+          out.print("\n\t ", k.inspect, PP.pp(v, String.new))
         end
       end
 
@@ -192,7 +194,7 @@ module Speculation
     end
 
     ed.each do |k, v|
-      out.puts(k, v) unless k == :problems.ns
+      out.puts("#{k} #{PP.pp(v, String.new)}") unless k == ns(:problems)
     end
 
     nil
@@ -226,7 +228,7 @@ module Speculation
       Gen.such_that(->(x) { valid?(spec, x) }, g)
     else
       raise Speculation::Error.new("unable to construct gen at: #{path.inspect} for: #{spec.inspect}",
-                                   :failure.ns => :no_gen, :path.ns => path)
+                                   ns(:failure) => :no_gen, ns(:path) => path)
     end
   end
 
@@ -246,10 +248,9 @@ module Speculation
   # @return [Proc]
   def self.gen(spec, overrides = nil)
     spec = Identifier(spec)
-    gensub(spec, overrides, [], :recursion_limit.ns => recursion_limit)
+    gensub(spec, overrides, [], ns(:recursion_limit) => recursion_limit)
   end
 
-  # rubocop:disable Style/MethodName
   # @private
   def self.Identifier(x)
     case x
@@ -258,19 +259,17 @@ module Speculation
     else x
     end
   end
-  # rubocop:enable Style/MethodName
 
   # Given a namespace-qualified symbol key, and a spec, spec name, predicate or
   # regex-op makes an entry in the registry mapping key to the spec
   # @param key [Symbol] namespace-qualified symbol
   # @param spec [Spec, Symbol, Proc, Hash] a spec, spec name, predicate or regex-op
-  # @return [Symbol, Identifier]
+  # @return [Symbol, Method]
   def self.def(key, spec)
     key = Identifier(key)
 
-    unless Utils.ident?(key) && key.namespace
-      raise ArgumentError,
-            "key must be a namespaced Symbol, e.g. #{:my_spec.ns}, given #{key}, or a Speculation::Identifier"
+    unless Utils.ident?(key) && (!key.is_a?(Symbol) || NamespacedSymbols.namespace(key))
+      raise ArgumentError, "key must be a namespaced Symbol, e.g. #{ns(:my_spec)}, or a Method"
     end
 
     spec = if spec?(spec) || regex?(spec) || registry[spec]
@@ -280,10 +279,10 @@ module Speculation
            end
 
     @registry_ref.swap do |reg|
-      reg.merge(key => with_name(spec, key))
+      reg.merge(key => with_name(spec, key)).freeze
     end
 
-    key
+    key.is_a?(Identifier) ? key.get_method : key
   end
 
   # @return [Hash] the registry hash
@@ -336,8 +335,8 @@ module Speculation
   #
   # The :req key array supports 'and_keys' and 'or_keys' for key groups:
   #
-  #     S.keys(req: [:x.ns, :y.ns, S.or_keys(:secret.ns, S.and_keys(:user.ns, :pwd.ns))],
-  #            opt: [:z.ns])
+  #     S.keys(req: [ns(:x), ns(:y), S.or_keys(ns(:secret), S.and_keys(ns(:user), ns(:pwd)))],
+  #            opt: [ns(:z)])
   #
   # There are also _un versions of :req and :opt. These allow you to connect
   # unqualified keys to specs. In each case, fully qualfied keywords are passed,
@@ -367,12 +366,12 @@ module Speculation
 
   # @see keys
   def self.or_keys(*ks)
-    [:or.ns, *ks]
+    [ns(:or), *ks]
   end
 
   # @see keys
   def self.and_keys(*ks)
-    [:and.ns, *ks]
+    [ns(:and), *ks]
   end
 
   # @param key_preds [Hash] Takes key+pred hash
@@ -442,8 +441,8 @@ module Speculation
   # @param options [Hash]
   # @return [Spec] spec that validates associative collections
   def self.every_kv(kpred, vpred, options)
-    every(tuple(kpred, vpred), :kfn.ns => ->(_i, v) { v.first },
-                               :into   => {},
+    every(tuple(kpred, vpred), ns(:kfn) => ->(_i, v) { v.first },
+                               :into    => {},
                                **options)
   end
 
@@ -459,7 +458,7 @@ module Speculation
   # @param opts [Hash]
   # @return [Spec]
   def self.coll_of(pred, opts = {})
-    every(pred, :conform_all.ns => true, **opts)
+    every(pred, ns(:conform_all) => true, **opts)
   end
 
   # Returns a spec for a hash whose keys satisfy kpred and vals satisfy vpred.
@@ -476,8 +475,8 @@ module Speculation
   # @param options [Hash]
   # @return [Spec]
   def self.hash_of(kpred, vpred, options = {})
-    every_kv(kpred, vpred, :kind           => Utils.method(:hash?).to_proc,
-                           :conform_all.ns => true,
+    every_kv(kpred, vpred, :kind            => Utils.method(:hash?),
+                           ns(:conform_all) => true,
                            **options)
   end
 
@@ -499,7 +498,7 @@ module Speculation
   # @return [Hash] regex op that matches zero or one value matching pred. Produces a
   # single value (not a collection) if matched.
   def self.zero_or_one(pred)
-    _alt([pred, accept(:nil.ns)], nil)
+    _alt([pred, accept(ns(:nil))], nil)
   end
 
   # @param kv_specs [Hash] key+pred pairs
@@ -530,14 +529,14 @@ module Speculation
   #   resulting value to the conjunction of the predicates, and any conforming
   #   they might perform.
   def self.constrained(re, *preds)
-    { :op.ns => :amp.ns, :p1 => re, :predicates => preds }
+    { ns(:op) => ns(:amp), :p1 => re, :predicates => preds }
   end
 
-  # @param f predicate function with the semantics of conform i.e. it should
+  # @yield [value] predicate function with the semantics of conform i.e. it should
   #   return either a (possibly converted) value or :"Speculation/invalid"
-  # @return [Spec] a spec that uses pred as a predicate/conformer.
-  def self.conformer(f)
-    spec_impl(f, true)
+  # @return [Spec] a spec that uses block as a predicate/conformer.
+  def self.conformer(&pred)
+    spec_impl(pred, true)
   end
 
   # Takes :args :ret and (optional) :block and :fn kwargs whose values are preds and returns a spec
@@ -556,7 +555,7 @@ module Speculation
   # @return [Spec]
   # @see fdef See 'fdef' for a single operation that creates an fspec and registers it, as well as a full description of :args, :block, :ret and :fn
   def self.fspec(args: nil, ret: nil, fn: nil, block: nil, gen: nil)
-    FSpec.new(:argspec => spec(args), :retspec => spec(ret), :fnspec => spec(fn), :blockspec => spec(block)).tap do |spec|
+    FSpec.new(:args => spec(args), :ret => spec(ret), :fn => spec(fn), :block => spec(block)).tap do |spec|
       spec.gen = gen
     end
   end
@@ -575,8 +574,8 @@ module Speculation
   #   S.fdef(Hash.method(:[]),
   #     args: S.alt(
   #       hash: Hash,
-  #       array_of_pairs: S.coll_of(S.tuple(:any.ns(S), :any.ns(S)), kind: Array),
-  #       kvs: S.constrained(S.one_or_more(:any.ns(S)), -> (kvs) { kvs.count.even? })
+  #       array_of_pairs: S.coll_of(S.tuple(ns(S, :any), ns(S, :any)), kind: Array),
+  #       kvs: S.constrained(S.one_or_more(ns(S, :any)), -> (kvs) { kvs.count.even? })
   #     ),
   #     ret: Hash
   #   )
@@ -589,13 +588,12 @@ module Speculation
   # @option spec :fn a spec of the relationship between args and ret - the value passed is
   #   { args: conformed_args, block: given_block, ret: conformed_ret } and is expected to contain
   #   predicates that relate those values
-  # @return [Identifier] the Speculation::Identifier object representing the method which is used as the spec's
-  #   key in the spec registry.
+  # @return [Method] the method spec'ed
   # @note Note that :fn specs require the presence of :args and :ret specs to conform values, and so :fn
   #   specs will be ignored if :args or :ret are missing.
   def self.fdef(method, spec)
-    ident = Identifier(method)
-    self.def(ident, fspec(spec))
+    self.def(Identifier(method), fspec(spec))
+    method
   end
 
   # @param spec
@@ -638,14 +636,14 @@ module Speculation
     fspec ||= get_spec(method)
     raise ArgumentError, "No fspec found for #{method}" unless fspec
 
-    Gen.sample(gen(fspec.argspec), n).map { |args| [args, method.call(*args)] }
+    Gen.sample(gen(fspec.args), n).map { |args| [args, method.call(*args)] }
   end
 
   ### impl ###
 
   # @private
   def self.recur_limit?(rmap, id, path, k)
-    rmap[id] > rmap[:recursion_limit.ns] &&
+    rmap[id] > rmap[ns(:recursion_limit)] &&
       path.include?(k)
   end
 
@@ -663,11 +661,11 @@ module Speculation
     if spec
       conform(spec, x)
     elsif pred.is_a?(Module) || pred.is_a?(::Regexp)
-      pred === x ? x : :invalid.ns
+      pred === x ? x : ns(:invalid)
     elsif pred.is_a?(Set)
-      pred.include?(x) ? x : :invalid.ns
+      pred.include?(x) ? x : ns(:invalid)
     elsif pred.respond_to?(:call)
-      pred.call(x) ? x : :invalid.ns
+      pred.call(x) ? x : ns(:invalid)
     else
       raise "#{pred} is not a class, proc, set or regexp"
     end
@@ -685,11 +683,11 @@ module Speculation
 
     if spec?(spec)
       name = spec_name(spec)
-      via = via.conj(name) if name
+      via = Utils.conj(via, name) if name
 
       spec.explain(path, via, inn, value)
     else
-      [{ :path => path, :val => value, :via => via, :in => inn, :pred => pred }]
+      [{ :path => path, :val => value, :via => via, :in => inn, :pred => [pred, [value]] }]
     end
   end
 
@@ -731,7 +729,7 @@ module Speculation
     p = reg_resolve!(p)
 
     id, op, ps, ks, p1, p2, ret, id, gen = p.values_at(
-      :id, :op.ns, :predicates, :keys, :p1, :p2, :return_value, :id, :gen.ns
+      :id, ns(:op), :predicates, :keys, :p1, :p2, :return_value, :id, ns(:gen)
     ) if regex?(p)
 
     id = p.id if spec?(p)
@@ -743,9 +741,9 @@ module Speculation
       preds.zip(keys).map do |pred, k|
         unless rmap && id && k && recur_limit?(rmap, id, path, k)
           if id
-            Gen.delay { Speculation.re_gen(pred, overrides, k ? path.conj(k) : path, rmap) }
+            Gen.delay { Speculation.re_gen(pred, overrides, k ? Utils.conj(path, k) : path, rmap) }
           else
-            re_gen(pred, overrides, k ? path.conj(k) : path, rmap)
+            re_gen(pred, overrides, k ? Utils.conj(path, k) : path, rmap)
           end
         end
       end
@@ -767,8 +765,8 @@ module Speculation
 
     if p
       case op
-      when :accept.ns
-        if ret == :nil.ns
+      when ns(:accept)
+        if ret == ns(:nil)
           ->(_rantly) { [] }
         else
           ->(_rantly) { [ret] }
@@ -777,9 +775,9 @@ module Speculation
         g = gensub(p, overrides, path, rmap)
 
         ->(rantly) { [g.call(rantly)] }
-      when :amp.ns
+      when ns(:amp)
         re_gen(p1, overrides, path, rmap)
-      when :pcat.ns
+      when ns(:pcat)
         gens = ggens.call(ps, ks)
 
         if gens.all?
@@ -787,11 +785,11 @@ module Speculation
             gens.flat_map { |gg| gg.call(rantly) }
           end
         end
-      when :alt.ns
+      when ns(:alt)
         gens = ggens.call(ps, ks).compact
 
         ->(rantly) { rantly.branch(*gens) } unless gens.empty?
-      when :rep.ns
+      when ns(:rep)
         if recur_limit?(rmap, id, [id], id)
           ->(_rantly) { [] }
         else
@@ -812,11 +810,11 @@ module Speculation
     x, *xs = data
 
     if data.empty?
-      return :invalid.ns unless accept_nil?(regex)
+      return ns(:invalid) unless accept_nil?(regex)
 
       return_value = preturn(regex)
 
-      if return_value == :nil.ns
+      if return_value == ns(:nil)
         nil
       else
         return_value
@@ -827,7 +825,7 @@ module Speculation
       if dp
         re_conform(dp, xs)
       else
-        :invalid.ns
+        ns(:invalid)
       end
     end
   end
@@ -845,22 +843,22 @@ module Speculation
       end
 
       if accept?(p)
-        if p[:op.ns] == :pcat.ns
-          return op_explain(p, path, via, inn.conj(index), input[index..-1])
+        if p[ns(:op)] == ns(:pcat)
+          return op_explain(p, path, via, Utils.conj(inn, index), input[index..-1])
         else
           return [{ :path   => path,
                     :reason => "Extra input",
                     :val    => input,
                     :via    => via,
-                    :in     => inn.conj(index) }]
+                    :in     => Utils.conj(inn, index) }]
         end
       else
-        return op_explain(p, path, via, inn.conj(index), input[index..-1]) ||
+        return op_explain(p, path, via, Utils.conj(inn, index), input[index..-1]) ||
             [{ :path   => path,
                :reason => "Extra input",
                :val    => input,
                :via    => via,
-               :in     => inn.conj(index) }]
+               :in     => Utils.conj(inn, index) }]
       end
     end
 
@@ -908,7 +906,7 @@ module Speculation
       if Utils.ident?(spec)
         spec
       elsif regex?(spec)
-        spec.merge(:name.ns => name)
+        spec.merge(ns(:name) => name)
       else
         spec.tap { |s| s.name = name }
       end
@@ -918,7 +916,7 @@ module Speculation
       if Utils.ident?(spec)
         spec
       elsif regex?(spec)
-        spec[:name.ns]
+        spec[ns(:name)]
       elsif spec.respond_to?(:name)
         spec.name
       end
@@ -955,7 +953,7 @@ module Speculation
       x = dt(pred, x)
 
       if invalid?(x)
-        :invalid.ns
+        ns(:invalid)
       elsif preds.empty?
         x
       else
@@ -979,12 +977,12 @@ module Speculation
     ### regex ###
 
     def accept(x)
-      { :op.ns => :accept.ns, :return_value => x }
+      { ns(:op) => ns(:accept), :return_value => x }
     end
 
     def accept?(hash)
       if hash.is_a?(Hash)
-        hash[:op.ns] == :accept.ns
+        hash[ns(:op)] == ns(:accept)
       end
     end
 
@@ -997,14 +995,14 @@ module Speculation
       return unless regex[:predicates].all?
 
       unless accept?(predicate)
-        return { :op.ns        => :pcat.ns,
+        return { ns(:op)       => ns(:pcat),
                  :predicates   => regex[:predicates],
                  :keys         => keys,
                  :return_value => regex[:return_value] }
       end
 
       val = keys ? { key => predicate[:return_value] } : predicate[:return_value]
-      return_value = regex[:return_value].conj(val)
+      return_value = Utils.conj(regex[:return_value], val)
 
       if rest_predicates
         pcat(:predicates   => rest_predicates,
@@ -1018,10 +1016,10 @@ module Speculation
     def rep(p1, p2, return_value, splice)
       return unless p1
 
-      regex = { :op.ns => :rep.ns, :p2 => p2, :splice => splice, :id => SecureRandom.uuid }
+      regex = { ns(:op) => ns(:rep), :p2 => p2, :splice => splice, :id => SecureRandom.uuid }
 
       if accept?(p1)
-        regex.merge(:p1 => p2, :return_value => return_value.conj(p1[:return_value]))
+        regex.merge(:p1 => p2, :return_value => Utils.conj(return_value, p1[:return_value]))
       else
         regex.merge(:p1 => p1, :return_value => return_value)
       end
@@ -1037,13 +1035,13 @@ module Speculation
     end
 
     def _alt(predicates, keys)
-      predicates, keys = filter_alt(predicates, keys, &:itself)
+      predicates, keys = filter_alt(predicates, keys, &Utils.method(:itself))
       return unless predicates
 
       predicate, *rest_predicates = predicates
       key, *_rest_keys = keys
 
-      return_value = { :op.ns => :alt.ns, :predicates => predicates, :keys => keys }
+      return_value = { ns(:op) => ns(:alt), :predicates => predicates, :keys => keys }
       return return_value unless rest_predicates.empty?
 
       return predicate unless key
@@ -1061,24 +1059,24 @@ module Speculation
     end
 
     def no_ret?(p1, pret)
-      return true if pret == :nil.ns
+      return true if pret == ns(:nil)
 
       regex = reg_resolve!(p1)
-      op = regex[:op.ns]
+      op = regex[ns(:op)]
 
-      [:rep.ns, :pcat.ns].include?(op) && pret.empty? || nil
+      [ns(:rep), ns(:pcat)].include?(op) && pret.empty? || nil
     end
 
     def accept_nil?(regex)
       regex = reg_resolve!(regex)
       return unless regex?(regex)
 
-      case regex[:op.ns]
-      when :accept.ns then true
-      when :pcat.ns   then regex[:predicates].all?(&method(:accept_nil?))
-      when :alt.ns    then regex[:predicates].any?(&method(:accept_nil?))
-      when :rep.ns    then (regex[:p1] == regex[:p2]) || accept_nil?(regex[:p1])
-      when :amp.ns
+      case regex[ns(:op)]
+      when ns(:accept) then true
+      when ns(:pcat)   then regex[:predicates].all?(&method(:accept_nil?))
+      when ns(:alt)    then regex[:predicates].any?(&method(:accept_nil?))
+      when ns(:rep)    then (regex[:p1] == regex[:p2]) || accept_nil?(regex[:p1])
+      when ns(:amp)
         p1 = regex[:p1]
 
         return false unless accept_nil?(p1)
@@ -1086,7 +1084,7 @@ module Speculation
         no_ret?(p1, preturn(p1)) ||
           !invalid?(and_preds(preturn(p1), regex[:predicates]))
       else
-        raise "Unexpected #{:op.ns} #{regex[:op.ns]}"
+        raise "Unexpected #{ns(:op)} #{regex[ns(:op)]}"
       end
     end
 
@@ -1097,23 +1095,23 @@ module Speculation
       p0, *_pr = regex[:predicates]
       k, *ks = regex[:keys]
 
-      case regex[:op.ns]
-      when :accept.ns then regex[:return_value]
-      when :pcat.ns   then add_ret(p0, regex[:return_value], k)
-      when :rep.ns    then add_ret(regex[:p1], regex[:return_value], k)
-      when :amp.ns
+      case regex[ns(:op)]
+      when ns(:accept) then regex[:return_value]
+      when ns(:pcat)   then add_ret(p0, regex[:return_value], k)
+      when ns(:rep)    then add_ret(regex[:p1], regex[:return_value], k)
+      when ns(:amp)
         pret = preturn(regex[:p1])
 
         if no_ret?(regex[:p1], pret)
-          :nil.ns
+          ns(:nil)
         else
           and_preds(pret, regex[:predicates])
         end
-      when :alt.ns
+      when ns(:alt)
         ps, ks = filter_alt(regex[:predicates], regex[:keys], &method(:accept_nil?))
 
         r = if ps.first.nil?
-              :nil.ns
+              ns(:nil)
             else
               preturn(ps.first)
             end
@@ -1124,7 +1122,7 @@ module Speculation
           r
         end
       else
-        raise "Unexpected #{:op.ns} #{regex[:op.ns]}"
+        raise "Unexpected #{ns(:op)} #{regex[ns(:op)]}"
       end
     end
 
@@ -1140,22 +1138,22 @@ module Speculation
         else
           val = key ? { key => return_value } : return_value
 
-          regex[:splice] ? Utils.into(r, val) : r.conj(val)
+          regex[:splice] ? Utils.into(r, val) : Utils.conj(r, val)
         end
       end
 
-      case regex[:op.ns]
-      when :accept.ns, :alt.ns, :amp.ns
+      case regex[ns(:op)]
+      when ns(:accept), ns(:alt), ns(:amp)
         return_value = preturn(regex)
 
-        if return_value == :nil.ns
+        if return_value == ns(:nil)
           r
         else
-          r.conj(key ? { key => return_value } : return_value)
+          Utils.conj(r, key ? { key => return_value } : return_value)
         end
-      when :pcat.ns, :rep.ns then prop.call
+      when ns(:pcat), ns(:rep) then prop.call
       else
-        raise "Unexpected #{:op.ns} #{regex[:op.ns]}"
+        raise "Unexpected #{ns(:op)} #{regex[ns(:op)]}"
       end
     end
 
@@ -1178,9 +1176,9 @@ module Speculation
       pred, *rest_preds = predicates
       key, *rest_keys = keys
 
-      case regex[:op.ns]
-      when :accept.ns then nil
-      when :pcat.ns
+      case regex[ns(:op)]
+      when ns(:accept) then nil
+      when ns(:pcat)
         regex1 = pcat(:predicates => [deriv(pred, value), *rest_preds], :keys => keys, :return_value => return_value)
         regex2 = nil
 
@@ -1192,9 +1190,9 @@ module Speculation
         end
 
         alt2(regex1, regex2)
-      when :alt.ns
+      when ns(:alt)
         _alt(predicates.map { |p| deriv(p, value) }, keys)
-      when :rep.ns
+      when ns(:rep)
         regex1 = rep(deriv(p1, value), p2, return_value, splice)
         regex2 = nil
 
@@ -1203,24 +1201,25 @@ module Speculation
         end
 
         alt2(regex1, regex2)
-      when :amp.ns
+      when ns(:amp)
         p1 = deriv(p1, value)
         return unless p1
 
-        if p1[:op.ns] == :accept.ns
+        if p1[ns(:op)] == ns(:accept)
           ret = and_preds(preturn(p1), predicates)
           accept(ret) unless invalid?(ret)
         else
           constrained(p1, *predicates)
         end
       else
-        raise "Unexpected #{:op.ns} #{regex[:op.ns]}"
+        raise "Unexpected #{ns(:op)} #{regex[ns(:op)]}"
       end
     end
 
-    def insufficient(path, via, inn)
+    def insufficient(pred, path, via, inn)
       [{ :path   => path,
          :reason => "Insufficient input",
+         :pred   => [pred, []],
          :val    => [],
          :via    => via,
          :in     => inn }]
@@ -1235,20 +1234,20 @@ module Speculation
 
       unless regex?(p)
         if input.empty?
-          return insufficient(path, via, inn)
+          return insufficient(p, path, via, inn)
         else
           return explain1(p, path, via, inn, x)
         end
       end
 
-      case p[:op.ns]
-      when :accept.ns then nil
-      when :amp.ns
+      case p[ns(:op)]
+      when ns(:accept) then nil
+      when ns(:amp)
         if input.empty?
           if accept_nil?(p[:p1])
             explain_pred_list(p[:predicates], path, via, inn, preturn(p[:p1]))
           else
-            insufficient(path, via, inn)
+            insufficient(p, path, via, inn)
           end
         else
           p1 = deriv(p[:p1], x)
@@ -1259,46 +1258,46 @@ module Speculation
             op_explain(p[:p1], path, via, inn, input)
           end
         end
-      when :pcat.ns
+      when ns(:pcat)
         pks = p[:predicates].zip(p[:keys] || [])
         pred, k = if pks.count == 1
                     pks.first
                   else
                     pks.lazy.reject { |(predicate, _)| accept_nil?(predicate) }.first
                   end
-        path = path.conj(k) if k
+        path = Utils.conj(path, k) if k
 
         if input.empty? && !pred
-          insufficient(path, via, inn)
+          insufficient(pred, path, via, inn)
         else
           op_explain(pred, path, via, inn, input)
         end
-      when :alt.ns
-        return insufficient(path, via, inn) if input.empty?
+      when ns(:alt)
+        return insufficient(p, path, via, inn) if input.empty?
 
         probs = p[:predicates].zip(p[:keys]).flat_map { |(predicate, key)|
-          op_explain(predicate, key ? path.conj(key) : path, via, inn, input)
+          op_explain(predicate, key ? Utils.conj(path, key) : path, via, inn, input)
         }
 
         probs.compact
-      when :rep.ns
+      when ns(:rep)
         op_explain(p[:p1], path, via, inn, input)
       else
-        raise "Unexpected #{:op.ns} #{p[:op.ns]}"
+        raise "Unexpected #{ns(:op)} #{p[ns(:op)]}"
       end
     end
 
     # Resets the spec registry to only builtin specs
     def reset_registry!
       builtins = {
-        :any.ns              => with_gen(Utils.constantly(true)) { |r| r.branch(*Gen::GEN_BUILTINS.values) },
-        :boolean.ns          => Set[true, false],
-        :positive_integer.ns => with_gen(self.and(Integer, ->(x) { x > 0 })) { |r| r.range(1) },
+        ns(:any)              => with_gen(Utils.constantly(true), ->(r) { r.branch(*Gen::GEN_BUILTINS.values) }),
+        ns(:boolean)          => Set[true, false],
+        ns(:positive_integer) => with_gen(self.and(Integer, ->(x) { x > 0 }), ->(r) { r.range(1) }),
         # Rantly#positive_integer is actually a natural integer
-        :natural_integer.ns  => with_gen(self.and(Integer, ->(x) { x >= 0 }), &:positive_integer),
-        :negative_integer.ns => with_gen(self.and(Integer, ->(x) { x < 0 })) { |r| r.range(nil, -1) },
-        :empty.ns            => with_gen(:empty?.to_proc) { |_| [] }
-      }
+        ns(:natural_integer)  => with_gen(self.and(Integer, ->(x) { x >= 0 }), :positive_integer.to_proc),
+        ns(:negative_integer) => with_gen(self.and(Integer, ->(x) { x < 0 }), ->(r) { r.range(nil, -1) }),
+        ns(:empty)            => with_gen(Utils.method(:empty?), Utils.constantly([]))
+      }.freeze
 
       @registry_ref.reset(builtins)
     end