speculation 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 11bb7e3c5871a34e1419aa9b02bfce56bdc334a2
-  data.tar.gz: b4d3470f9bb704a94b61f333a632f193a8baa21d
+  metadata.gz: 21bae113d98b1aae417ce30534a9488f34ddbaa0
+  data.tar.gz: aa53139eed9b655d4ce4a1ff9984881e94f4e954
 SHA512:
-  metadata.gz: 1db14032f7e8755385fcd56346c8d04e712b3faf496caa9ecd77784f2ae7442edd0addea2d757d19e418970cbf7a408e82cef6291436f20dc18420312c893092
-  data.tar.gz: '096a7f073629269c834a691a2ad370b9e8722ffdc97fd8885a60b2ec299c29cfb3ce90be6d43b8414a5669afe31468cd6f3a8b3fa2f588a2991a7272cbc7fe22'
+  metadata.gz: 23a0f3f05968623d4cc91d34f7929fc2e76c42679930e9abb35e6f7e9fadfc7648d48a18c4b80452ec6871832ab1c16d4880f735dc1c6033649560fa12e1eaa7
+  data.tar.gz: 525d9d6479c8accd5b9347b7f8f97568ca708213c82db5538a731e072ba8b31e31df20e79ee5247b787611c8d16db8b22858a101419c5dbdff180447f6329e9f

data/.rubocop.yml

@@ -4,7 +4,7 @@ AllCops:
     - '*.*'
     - 'vendor/**/*'
     - 'examples/**/*'
-  TargetRubyVersion: 2.4
+  TargetRubyVersion: 2.0
 
 Metrics/ClassLength:
   Enabled: false
@@ -98,3 +98,12 @@ Performance/RedundantBlockCall:
 
 Style/MethodName:
   Enabled: false
+
+Style/SymbolArray:
+  Enabled: false
+
+Style/IndentHeredoc:
+  Enabled: false
+
+Style/EmptyLiteral:
+  Enabled: false

data/Gemfile

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 source "https://rubygems.org"
 
 gemspec

data/README.md

@@ -11,10 +11,13 @@ The goal of this project is to match clojure.spec as closely as possible, from d
 - [sinatra-web-app](examples/sinatra-web-app): A small sinatra web application demonstrating model validation and API error message generation.
 - [spec_guide.rb](examples/spec_guide.rb): Speculation port of Clojure's [spec guide](https://clojure.org/guides/spec)
 - [codebreaker.rb](examples/codebreaker.rb): Speculation port of the 'codebreaker' game described in [Interactive development with clojure.spec](http://blog.cognitect.com/blog/2016/10/5/interactive-development-with-clojurespec)
+- [json_parser.rb](examples/json_parser.rb): JSON parser using Speculation.
 
 ## Usage
 
-The API is more-or-less the same as `clojure.spec`. If you're already familiar clojure.spec with then you should feel at home with Speculation. Clojure and Ruby and quite different languages, so naturally there are some differences:
+Documentation is available at [RubyDoc](http://www.rubydoc.info/github/english/speculation). The API is more-or-less the same as `clojure.spec`. If you're already familiar clojure.spec with then you should feel at home with Speculation. Most guides, talks and discussion around clojure.spec should apply equally well to Speculation. Clojure and Ruby and quite different languages, so naturally there are some differences:
+
+## Differences with clojure.spec
 
 ### Built in predicates
 

data/Rakefile

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
+
 require "bundler/gem_tasks"
 require "rubocop"
 require "yard"
 
 task :rubocop do
-  status = RuboCop::CLI.new.run([])
+  status = RuboCop::CLI.new.run(["--display-cop-names"])
   raise "failed with status #{status}" unless status.zero?
 end
 

data/examples/json_parser.rb

@@ -0,0 +1,328 @@
+# Exercise from Ruby Quiz: http://rubyquiz.com/quiz155.html
+# Borrowed heavily from TreeTop parser used in http://learnruby.com/examples/ruby-quiz-155.shtml
+
+require "bundler/setup"
+require "minitest/autorun"
+require "speculation"
+require "speculation/gen"
+require "speculation/test"
+
+S = Speculation
+Gen = S::Gen
+STest = S::Test
+
+module JSONParser
+  extend S::NamespacedSymbols
+
+  def self.re_literal(string, conformed)
+    kvs = string.each_char.each_with_index.reduce({}) { |h, (v, i)| h.merge(i => Set[v]) }
+    S.cat(kvs)
+  end
+
+  S.def ns(:maybe_spaces), S.zero_or_more(Set[" "])
+
+  S.def ns(:null), re_literal("null", nil)
+  S.def ns(:true), re_literal("true", true)
+  S.def ns(:false), re_literal("false", false)
+
+  S.def ns(:boolean), S.alt(:true  => ns(:true),
+                            :false => ns(:false))
+
+  S.def ns(:number), S.alt(:integer => ns(:integer),
+                           :float   => ns(:float))
+
+  S.def ns(:digit), /\A[[:digit:]]\z/
+  S.def ns(:digits), S.one_or_more(ns(:digit))
+  S.def ns(:exp), Set["e", "E"]
+  S.def ns(:maybe_sign), S.zero_or_one(Set["-", "+"])
+  S.def ns(:exponent), S.cat(:pre    => ns(:exp),
+                             :sign   => ns(:maybe_sign),
+                             :digits => ns(:digits))
+  S.def ns(:maybe_exponent), S.zero_or_one(ns(:exponent))
+
+  S.def ns(:integer), S.cat(:neg      => S.zero_or_one(Set["-"]),
+                            :digits   => ns(:digits),
+                            :exponent => ns(:maybe_exponent))
+
+  S.def ns(:maybe_neg), S.zero_or_one(Set["-"])
+  S.def ns(:float), S.cat(:neg         => ns(:maybe_neg),
+                          :digits      => ns(:digits),
+                          :dot         => Set["."],
+                          :more_digits => ns(:digits),
+                          :exponent    => ns(:maybe_exponent))
+
+  S.def ns(:quote), Set['"']
+  S.def ns(:maybe_characters), S.zero_or_more(ns(:character))
+  S.def ns(:string), S.cat(:open     => ns(:quote),
+                           :contents => ns(:maybe_characters),
+                           :close    => ns(:quote))
+
+
+  S.def ns(:character), S.alt(:escaped => ns(:escaped_character),
+                              :special => ns(:special_character),
+                              :unicode => ns(:unicode_character),
+                              :regular => ns(:regular_character))
+
+  S.def ns(:unicode_character), S.cat(:escape => Set['\\'],
+                                      :u      => Set['u'],
+                                      :digits => S.constrained(S.one_or_more(ns(:hex_digit)), ->(digits) { digits.count == 4 }))
+
+  S.def ns(:hex_digit), /[0-9a-fA-F]/
+
+  S.def ns(:escaped_character), S.cat(:escape => Set['\\'],
+                                      :val    => Set['\\', '"'])
+
+  special_character_map = {
+    "b" => "\b",
+    "f" => "\f",
+    "n" => "\n",
+    "r" => "\r",
+    "t" => "\t",
+  }
+
+  S.def ns(:special_character), S.cat(:escape => Set['\\'],
+                                      :val    => Set['b', 'f', 'n', 'r', 't'])
+
+  S.def ns(:regular_character), ->(s) { !['\\', '"'].include?(s) }
+
+  S.def ns(:open_square_bracket), Set["["]
+  S.def ns(:close_square_bracket), Set["]"]
+  S.def ns(:empty_array), S.cat(:open   => ns(:open_square_bracket),
+                                :spaces => ns(:maybe_spaces),
+                                :close  => ns(:close_square_bracket))
+
+  S.def ns(:non_empty_array), S.cat(:open       => ns(:open_square_bracket),
+                                    :space      => ns(:maybe_spaces),
+                                    :value_list => ns(:value_list),
+                                    :more_space => ns(:maybe_spaces),
+                                    :close      => ns(:close_square_bracket))
+
+  S.def ns(:array), S.alt(:non_empty => ns(:non_empty_array),
+                          :empty     => ns(:empty_array))
+
+  S.def ns(:value_list), S.alt(:val  => ns(:json),
+                               :rest => S.cat(:val   => ns(:json),
+                                              :comma => Set[","],
+                                              :space => ns(:maybe_spaces),
+                                              :tail  => ns(:value_list)))
+
+  S.def ns(:open_brace), Set["{"]
+  S.def ns(:close_brace), Set["}"]
+  S.def ns(:empty_object), S.cat(:open   => ns(:open_brace),
+                                 :spaces => ns(:maybe_spaces),
+                                 :close  => ns(:close_brace))
+
+  S.def ns(:non_empty_object), S.cat(:open        => ns(:open_brace),
+                                     :spaces      => ns(:maybe_spaces),
+                                     :contents    => ns(:object_contents),
+                                     :more_spaces => ns(:maybe_spaces),
+                                     :close       => ns(:close_brace))
+
+  S.def ns(:object), S.alt(:empty_object     => ns(:empty_object),
+                           :non_empty_object => ns(:non_empty_object))
+
+  S.def ns(:kv), S.cat(:before => ns(:maybe_spaces),
+                       :key    => ns(:string),
+                       :colon  => Set[":"],
+                       :after  => ns(:maybe_spaces),
+                       :val    => ns(:json))
+
+  S.def ns(:object_contents), S.alt(:kv   => ns(:kv),
+                                    :rest => S.cat(:kv    => ns(:kv),
+                                                   :comma => Set[","],
+                                                   :space => ns(:maybe_spaces),
+                                                   :tail  => ns(:object_contents)))
+
+  S.def ns(:json), S.cat(:pre => ns(:maybe_spaces),
+                         :val => S.alt(:null    => ns(:null),
+                                       :boolean => ns(:boolean),
+                                       :number  => ns(:number),
+                                       :string  => ns(:string),
+                                       :array   => ns(:array),
+                                       :object  => ns(:object)),
+                         :post => ns(:maybe_spaces))
+
+  def self.parse(s)
+    chars = s.split("")
+    json_data = S.conform(ns(:json), chars)
+
+    if S.invalid?(json_data)
+      fail S.explain_str(ns(:json), chars)
+    else
+      transform_json(json_data)
+    end
+  end
+
+  def self.transform_json(data)
+    tag, val = data[:val]
+
+    case tag
+    when :boolean then transform_boolean(val)
+    when :null    then nil
+    when :number  then transform_number(val)
+    when :string  then transform_string(val)
+    when :array   then transform_array(val)
+    when :object  then transform_object(val)
+    end
+  end
+
+  def self.transform_boolean(tagged_val)
+    tag, val = tagged_val
+
+    case tag
+    when :true  then true
+    when :false then false
+    end
+  end
+
+  def self.transform_number(tagged_val)
+    tag, val = tagged_val
+
+    case tag
+    when :integer
+      Integer(val.values_at(:neg, :digits, :exponent).join)
+    when :float
+      exp = Hash(val[:exponent]).values_at(:pre, :sign, :digits).join
+      val = val.merge(:exp => exp)
+      Float(val.values_at(:neg, :digits, :dot, :more_digits, :exp).join)
+    end
+  end
+
+  SPECIAL_CHARACTER_MAP = {
+    "b" => "\b",
+    "f" => "\f",
+    "n" => "\n",
+    "r" => "\r",
+    "t" => "\t",
+  }
+
+  def self.transform_string(val)
+    Array(val[:contents]).map { |(tag, char)|
+      case tag
+      when :regular then char
+      when :special then SPECIAL_CHARACTER_MAP.fetch(char[:val])
+      when :escaped then char[:val]
+      when :unicode then [char[:digits].join.hex].pack("U")
+      end
+    }.join
+  end
+
+  def self.transform_array(tagged_val)
+    tag, val = tagged_val
+
+    case tag
+    when :empty     then []
+    when :non_empty then transform_value_list(val[:value_list])
+    end
+  end
+
+  def self.transform_value_list(tagged_val)
+    tag, val = tagged_val
+
+    case tag
+    when :rest
+      head = [transform_json(val[:val])]
+      tail = transform_value_list(val[:tail])
+      head + tail
+    when :val
+      [transform_json(val)]
+    end
+  end
+
+  def self.transform_object(tagged_val)
+    tag, val = tagged_val
+
+    case tag
+    when :empty_object     then {}
+    when :non_empty_object then transform_object_contents(val[:contents])
+    end
+  end
+
+  def self.transform_object_contents(tagged_val)
+    tag, val = tagged_val
+
+    case tag
+    when :kv
+      { transform_string(val[:key]) => transform_json(val[:val]) }
+    when :rest
+      transform_object_contents([:kv, val[:kv]]).
+        merge(transform_object_contents(val[:tail]))
+    end
+  end
+end
+
+class TestJSONParser < Minitest::Test
+  def test_keyword_parsing
+    assert_parses true,  "true"
+    assert_parses false, "false"
+    assert_parses nil,   "null"
+  end
+
+  def test_number_parsing
+    assert_parses 42,     "42"
+    assert_parses -13,    "-13"
+    assert_parses 3.1415, "3.1415"
+    assert_parses -0.01,  "-0.01"
+
+    assert_parses 0.2e1,  "0.2e1"
+    assert_parses 0.2e+1, "0.2e+1"
+    assert_parses 0.2e-1, "0.2e-1"
+    assert_parses 0.2E1,  "0.2e1"
+  end
+
+  def test_string_parsing
+    assert_parses String.new, '""'
+    assert_parses "JSON",     '"JSON"'
+
+    assert_parses 'nested "quotes"', '"nested \"quotes\""'
+    assert_parses "\n",                '"\\n"'
+
+    assert_parses "µ", '"\\u00b5"'
+  end
+
+  def test_array_parsing
+    assert_parses [], '[]'
+
+    assert_parses ["foo", "bar", "baz"],  '["foo", "bar", "baz"]'
+    assert_parses ["JSON", 3.1415, true], '["JSON", 3.1415, true]'
+    assert_parses [1, [2, [3]]],          '[1, [2, [3]]]'
+  end
+
+  def test_object_parsing
+    assert_parses Hash[], '{}'
+    assert_parses Hash["foo" => "bar"], '{"foo": "bar"}'
+    assert_parses Hash["foo" => "bar", "baz" => "qux"], '{"foo": "bar", "baz": "qux"}'
+    assert_parses Hash["JSON" => 3.1415, "data" => true], '{"JSON": 3.1415, "data": true}'
+
+    assert_parses Hash["Array" => [1, 2, 3], "Object" => {"nested" => "objects"}],
+      '{"Array": [1, 2, 3], "Object": {"nested": "objects"}}'
+  end
+
+  def test_parse_errors
+    assert_invalid "{"
+    assert_invalid %q{{"key": true false}}
+
+    assert_invalid "["
+    assert_invalid "[1,,2]" 
+    assert_invalid '"'
+    assert_invalid '"\\i"'
+
+    assert_invalid "$1,000"
+    assert_invalid "1_000"
+    assert_invalid "1K"
+
+    assert_invalid "unknown"
+  end
+
+  def assert_invalid(json_string)
+    assert_raises(RuntimeError) { JSONParser.parse(json_string) }
+  end
+
+  def assert_parses(expected_val, json_string)
+    if expected_val.nil?
+      assert_nil(JSONParser.parse(json_string))
+    else
+      assert_equal(expected_val, JSONParser.parse(json_string))
+    end
+  end
+end

data/lib/speculation/error.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "pp"
 
 module Speculation

data/lib/speculation/gen.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "set"
 require "rantly"
 require "rantly/property"

data/lib/speculation/pmap.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "concurrent"
 
 module Speculation

data/lib/speculation/spec/every_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Speculation
   # @private
   class EverySpec < Spec

data/lib/speculation/spec/hash_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Speculation
   # @private
   class HashSpec < Spec

data/lib/speculation/spec/merge_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Speculation
   # @private
   class MergeSpec < Spec

data/lib/speculation/spec/nilable_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Speculation
   # @private
   class NilableSpec < Spec

data/lib/speculation/spec/or_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Speculation
   # @private
   class OrSpec < Spec

data/lib/speculation/spec/predicate_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Speculation
   # @private
   class PredicateSpec < Spec

data/lib/speculation/spec/regex_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Speculation
   # @private
   class RegexSpec < Spec

data/lib/speculation/spec/tuple_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Speculation
   # @private
   class TupleSpec < Spec

data/lib/speculation/test.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "concurrent"
 require "pp"
 require "speculation/pmap"

data/lib/speculation/utils.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "set"
 
 module Speculation

data/lib/speculation/version.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Speculation
-  VERSION = "0.3.0"
+  VERSION = "0.3.1".freeze
 end

data/lib/speculation.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "concurrent"
 require "set"
 require "securerandom"
@@ -44,6 +45,27 @@ module Speculation
 
   INVALID = ns(:invalid)
 
+  # @private
+  OP = ns(:op)
+  # @private
+  ALT = ns(:alt)
+  # @private
+  AMP = ns(:amp)
+  # @private
+  PCAT = ns(:pcat)
+  # @private
+  REP = ns(:rep)
+  # @private
+  ACCEPT = ns(:accept)
+  # @private
+  NIL = ns(:nil)
+  # @private
+  RECURSION_LIMIT = ns(:recursion_limit)
+  # @private
+  GEN = ns(:gen)
+  # @private
+  NAME = ns(:name)
+
   # Can be enabled or disabled at runtime:
   # - enabled/disabled by setting `check_asserts`.
   # - enabled by setting environment variable SPECULATION_CHECK_ASSERTS to the
@@ -71,10 +93,11 @@ module Speculation
   # @return [Spec] that validates floats
   def self.float_in(min: nil, max: nil, infinite: true, nan: true)
     preds = [Float]
-    preds << ->(x) { !x.nan? } unless nan
-    preds << ->(x) { !x.infinite? } unless infinite
-    preds << ->(x) { x <= max } if max
-    preds << ->(x) { x >= min } if min
+
+    preds.push(->(x) { !x.nan? })      unless nan
+    preds.push(->(x) { !x.infinite? }) unless infinite
+    preds.push(->(x) { x <= max })     if max
+    preds.push(->(x) { x >= min })     if min
 
     min ||= Float::MIN
     max ||= Float::MAX
@@ -116,7 +139,7 @@ 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[ns(:op)] && x
+    Utils.hash?(x) && x[OP] && x
   end
 
   # @param value return value of a `conform` call
@@ -250,7 +273,7 @@ module Speculation
   # @return [Proc]
   def self.gen(spec, overrides = nil)
     spec = Identifier(spec)
-    gensub(spec, overrides, [], ns(:recursion_limit) => recursion_limit)
+    gensub(spec, overrides, [], RECURSION_LIMIT => recursion_limit)
   end
 
   # @private
@@ -500,7 +523,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(ns(:nil))], nil)
+    _alt([pred, accept(NIL)], nil)
   end
 
   # @param kv_specs [Hash] key+pred pairs
@@ -531,7 +554,7 @@ module Speculation
   #   resulting value to the conjunction of the predicates, and any conforming
   #   they might perform.
   def self.constrained(re, *preds)
-    { ns(:op) => ns(:amp), :p1 => re, :predicates => preds }
+    { OP => AMP, :p1 => re, :predicates => preds }
   end
 
   # @yield [value] predicate function with the semantics of conform i.e. it should
@@ -555,7 +578,8 @@ module Speculation
   # @param gen [Proc] generator proc, which must be a proc of one arg (Rantly
   #   instance) that generates a valid value.
   # @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
+  # @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(:args => spec(args), :ret => spec(ret), :fn => spec(fn), :block => spec(block)).tap do |spec|
       spec.gen = gen
@@ -645,7 +669,7 @@ module Speculation
 
   # @private
   def self.recur_limit?(rmap, id, path, k)
-    rmap[id] > rmap[ns(:recursion_limit)] &&
+    rmap[id] > rmap[RECURSION_LIMIT] &&
       path.include?(k)
   end
 
@@ -731,7 +755,7 @@ module Speculation
     p = reg_resolve!(p)
 
     id, op, ps, ks, p1, p2, ret, id, gen = p.values_at(
-      :id, ns(:op), :predicates, :keys, :p1, :p2, :return_value, :id, ns(:gen)
+      :id, OP, :predicates, :keys, :p1, :p2, :return_value, :id, GEN
     ) if regex?(p)
 
     id = p.id if spec?(p)
@@ -767,8 +791,8 @@ module Speculation
 
     if p
       case op
-      when ns(:accept)
-        if ret == ns(:nil)
+      when ACCEPT
+        if ret == NIL
           ->(_rantly) { [] }
         else
           ->(_rantly) { [ret] }
@@ -777,9 +801,9 @@ module Speculation
         g = gensub(p, overrides, path, rmap)
 
         ->(rantly) { [g.call(rantly)] }
-      when ns(:amp)
+      when AMP
         re_gen(p1, overrides, path, rmap)
-      when ns(:pcat)
+      when PCAT
         gens = ggens.call(ps, ks)
 
         if gens.all?
@@ -787,11 +811,11 @@ module Speculation
             gens.flat_map { |gg| gg.call(rantly) }
           end
         end
-      when ns(:alt)
+      when ALT
         gens = ggens.call(ps, ks).compact
 
         ->(rantly) { rantly.branch(*gens) } unless gens.empty?
-      when ns(:rep)
+      when REP
         if recur_limit?(rmap, id, [id], id)
           ->(_rantly) { [] }
         else
@@ -809,26 +833,17 @@ module Speculation
 
   # @private
   def self.re_conform(regex, data)
-    x, *xs = data
-
-    if data.empty?
-      return INVALID unless accept_nil?(regex)
+    data.each do |x|
+      regex = deriv(regex, x)
+      return INVALID unless regex
+    end
 
+    if accept_nil?(regex)
       return_value = preturn(regex)
 
-      if return_value == ns(:nil)
-        nil
-      else
-        return_value
-      end
+      return_value == NIL ? nil : return_value
     else
-      dp = deriv(regex, x)
-
-      if dp
-        re_conform(dp, xs)
-      else
-        INVALID
-      end
+      INVALID
     end
   end
 
@@ -845,7 +860,7 @@ module Speculation
       end
 
       if accept?(p)
-        if p[ns(:op)] == ns(:pcat)
+        if p[OP] == PCAT
           return op_explain(p, path, via, Utils.conj(inn, index), input[index..-1])
         else
           return [{ :path   => path,
@@ -908,7 +923,7 @@ module Speculation
       if Utils.ident?(spec)
         spec
       elsif regex?(spec)
-        spec.merge(ns(:name) => name)
+        spec.merge(NAME => name)
       else
         spec.tap { |s| s.name = name }
       end
@@ -918,7 +933,7 @@ module Speculation
       if Utils.ident?(spec)
         spec
       elsif regex?(spec)
-        spec[ns(:name)]
+        spec[NAME]
       elsif spec.respond_to?(:name)
         spec.name
       end
@@ -950,17 +965,12 @@ module Speculation
     end
 
     def and_preds(x, preds)
-      pred, *preds = preds
-
-      x = dt(pred, x)
-
-      if invalid?(x)
-        INVALID
-      elsif preds.empty?
-        x
-      else
-        and_preds(x, preds)
+      preds.each do |pred|
+        x = dt(pred, x)
+        return INVALID if invalid?(x)
       end
+
+      x
     end
 
     def specize(spec)
@@ -979,12 +989,12 @@ module Speculation
     ### regex ###
 
     def accept(x)
-      { ns(:op) => ns(:accept), :return_value => x }
+      { OP => ACCEPT, :return_value => x }
     end
 
     def accept?(hash)
       if hash.is_a?(Hash)
-        hash[ns(:op)] == ns(:accept)
+        hash[OP] == ACCEPT
       end
     end
 
@@ -997,7 +1007,7 @@ module Speculation
       return unless regex[:predicates].all?
 
       unless accept?(predicate)
-        return { ns(:op)       => ns(:pcat),
+        return { OP            => PCAT,
                  :predicates   => regex[:predicates],
                  :keys         => keys,
                  :return_value => regex[:return_value] }
@@ -1006,7 +1016,7 @@ module Speculation
       val = keys ? { key => predicate[:return_value] } : predicate[:return_value]
       return_value = Utils.conj(regex[:return_value], val)
 
-      if rest_predicates
+      if rest_predicates.any?
         pcat(:predicates   => rest_predicates,
              :keys         => rest_keys,
              :return_value => return_value)
@@ -1018,7 +1028,7 @@ module Speculation
     def rep(p1, p2, return_value, splice)
       return unless p1
 
-      regex = { ns(:op) => ns(:rep), :p2 => p2, :splice => splice, :id => SecureRandom.uuid }
+      regex = { OP => REP, :p2 => p2, :splice => splice, :id => SecureRandom.uuid }
 
       if accept?(p1)
         regex.merge(:p1 => p2, :return_value => Utils.conj(return_value, p1[:return_value]))
@@ -1027,23 +1037,23 @@ module Speculation
       end
     end
 
-    def filter_alt(ps, ks, &block)
+    def filter_alt(ps, ks)
       if ks
-        pks = ps.zip(ks).select { |xs| yield(xs.first) }
+        pks = ps.zip(ks).select { |(p, _k)| yield(p) }
         [pks.map(&:first), pks.map(&:last)]
       else
-        [ps.select(&block), ks]
+        [ps.select { |p| yield(p) }, ks]
       end
     end
 
     def _alt(predicates, keys)
-      predicates, keys = filter_alt(predicates, keys, &Utils.method(:itself))
-      return unless predicates
+      predicates, keys = filter_alt(predicates, keys) { |p| p }
+      return if predicates.empty?
 
       predicate, *rest_predicates = predicates
       key, *_rest_keys = keys
 
-      return_value = { ns(:op) => ns(:alt), :predicates => predicates, :keys => keys }
+      return_value = { OP => ALT, :predicates => predicates, :keys => keys }
       return return_value unless rest_predicates.empty?
 
       return predicate unless key
@@ -1061,24 +1071,24 @@ module Speculation
     end
 
     def no_ret?(p1, pret)
-      return true if pret == ns(:nil)
+      return true if pret == NIL
 
       regex = reg_resolve!(p1)
-      op = regex[ns(:op)]
+      op = regex[OP]
 
-      [ns(:rep), ns(:pcat)].include?(op) && pret.empty? || nil
+      [REP, PCAT].include?(op) && pret.empty? || nil
     end
 
     def accept_nil?(regex)
       regex = reg_resolve!(regex)
       return unless regex?(regex)
 
-      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)
+      case regex[OP]
+      when ACCEPT then true
+      when PCAT   then regex[:predicates].all? { |p| accept_nil?(p) }
+      when ALT    then regex[:predicates].any? { |p| accept_nil?(p) }
+      when REP    then (regex[:p1] == regex[:p2]) || accept_nil?(regex[:p1])
+      when AMP
         p1 = regex[:p1]
 
         return false unless accept_nil?(p1)
@@ -1086,7 +1096,7 @@ module Speculation
         no_ret?(p1, preturn(p1)) ||
           !invalid?(and_preds(preturn(p1), regex[:predicates]))
       else
-        raise "Unexpected #{ns(:op)} #{regex[ns(:op)]}"
+        raise "Unexpected #{OP} #{regex[OP]}"
       end
     end
 
@@ -1095,36 +1105,32 @@ module Speculation
       return unless regex?(regex)
 
       p0, *_pr = regex[:predicates]
-      k, *ks = regex[:keys]
+      k, *_ks = regex[:keys]
 
-      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)
+      case regex[OP]
+      when ACCEPT then regex[:return_value]
+      when PCAT   then add_ret(p0, regex[:return_value], k)
+      when REP    then add_ret(regex[:p1], regex[:return_value], k)
+      when AMP
         pret = preturn(regex[:p1])
 
         if no_ret?(regex[:p1], pret)
-          ns(:nil)
+          NIL
         else
           and_preds(pret, regex[:predicates])
         end
-      when ns(:alt)
-        ps, ks = filter_alt(regex[:predicates], regex[:keys], &method(:accept_nil?))
+      when ALT
+        pred, key = regex[:predicates].zip(Array(regex[:keys])).find { |(p, _k)| accept_nil?(p) }
 
-        r = if ps.first.nil?
-              ns(:nil)
+        r = if pred.nil?
+              NIL
             else
-              preturn(ps.first)
+              preturn(pred)
             end
 
-        if ks && ks.first
-          [ks.first, r]
-        else
-          r
-        end
+        key ? [key, r] : r
       else
-        raise "Unexpected #{ns(:op)} #{regex[ns(:op)]}"
+        raise "Unexpected #{OP} #{regex[OP]}"
       end
     end
 
@@ -1132,30 +1138,27 @@ module Speculation
       regex = reg_resolve!(regex)
       return r unless regex?(regex)
 
-      prop = -> do
+      case regex[OP]
+      when ACCEPT, ALT, AMP
         return_value = preturn(regex)
 
-        if return_value.empty?
+        if return_value == NIL
           r
         else
-          val = key ? { key => return_value } : return_value
-
-          regex[:splice] ? Utils.into(r, val) : Utils.conj(r, val)
+          Utils.conj(r, key ? { key => return_value } : return_value)
         end
-      end
-
-      case regex[ns(:op)]
-      when ns(:accept), ns(:alt), ns(:amp)
+      when PCAT, REP
         return_value = preturn(regex)
 
-        if return_value == ns(:nil)
+        if return_value.empty?
           r
         else
-          Utils.conj(r, key ? { key => return_value } : return_value)
+          val = key ? { key => return_value } : return_value
+
+          regex[:splice] ? Utils.into(r, val) : Utils.conj(r, val)
         end
-      when ns(:pcat), ns(:rep) then prop.call
       else
-        raise "Unexpected #{ns(:op)} #{regex[ns(:op)]}"
+        raise "Unexpected #{OP} #{regex[OP]}"
       end
     end
 
@@ -1178,9 +1181,9 @@ module Speculation
       pred, *rest_preds = predicates
       key, *rest_keys = keys
 
-      case regex[ns(:op)]
-      when ns(:accept) then nil
-      when ns(:pcat)
+      case regex[OP]
+      when ACCEPT then nil
+      when PCAT
         regex1 = pcat(:predicates => [deriv(pred, value), *rest_preds], :keys => keys, :return_value => return_value)
         regex2 = nil
 
@@ -1192,9 +1195,9 @@ module Speculation
         end
 
         alt2(regex1, regex2)
-      when ns(:alt)
+      when ALT
         _alt(predicates.map { |p| deriv(p, value) }, keys)
-      when ns(:rep)
+      when REP
         regex1 = rep(deriv(p1, value), p2, return_value, splice)
         regex2 = nil
 
@@ -1203,18 +1206,18 @@ module Speculation
         end
 
         alt2(regex1, regex2)
-      when ns(:amp)
+      when AMP
         p1 = deriv(p1, value)
         return unless p1
 
-        if p1[ns(:op)] == ns(:accept)
+        if p1[OP] == ACCEPT
           ret = and_preds(preturn(p1), predicates)
           accept(ret) unless invalid?(ret)
         else
           constrained(p1, *predicates)
         end
       else
-        raise "Unexpected #{ns(:op)} #{regex[ns(:op)]}"
+        raise "Unexpected #{OP} #{regex[OP]}"
       end
     end
 
@@ -1242,9 +1245,9 @@ module Speculation
         end
       end
 
-      case p[ns(:op)]
-      when ns(:accept) then nil
-      when ns(:amp)
+      case p[OP]
+      when ACCEPT then nil
+      when AMP
         if input.empty?
           if accept_nil?(p[:p1])
             explain_pred_list(p[:predicates], path, via, inn, preturn(p[:p1]))
@@ -1260,13 +1263,14 @@ module Speculation
             op_explain(p[:p1], path, via, inn, input)
           end
         end
-      when ns(:pcat)
-        pks = p[:predicates].zip(p[:keys] || [])
+      when PCAT
+        pks = p[:predicates].zip(Array(p[:keys]))
         pred, k = if pks.count == 1
                     pks.first
                   else
-                    pks.lazy.reject { |(predicate, _)| accept_nil?(predicate) }.first
+                    pks.find { |(predicate, _)| !accept_nil?(predicate) }
                   end
+
         path = Utils.conj(path, k) if k
 
         if input.empty? && !pred
@@ -1274,18 +1278,18 @@ module Speculation
         else
           op_explain(pred, path, via, inn, input)
         end
-      when ns(:alt)
+      when ALT
         return insufficient(p, path, via, inn) if input.empty?
 
-        probs = p[:predicates].zip(p[:keys]).flat_map { |(predicate, key)|
+        probs = p[:predicates].zip(Array(p[:keys])).flat_map { |(predicate, key)|
           op_explain(predicate, key ? Utils.conj(path, key) : path, via, inn, input)
         }
 
         probs.compact
-      when ns(:rep)
+      when REP
         op_explain(p[:p1], path, via, inn, input)
       else
-        raise "Unexpected #{ns(:op)} #{p[ns(:op)]}"
+        raise "Unexpected #{OP} #{p[OP]}"
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: speculation
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Jamie English
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-03-10 00:00:00.000000000 Z
+date: 2017-03-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -168,6 +168,7 @@ files:
 - bin/console
 - bin/setup
 - examples/codebreaker.rb
+- examples/json_parser.rb
 - examples/sinatra-web-app/Gemfile
 - examples/sinatra-web-app/Gemfile.lock
 - examples/sinatra-web-app/app.rb