speculation 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 21bae113d98b1aae417ce30534a9488f34ddbaa0
-  data.tar.gz: aa53139eed9b655d4ce4a1ff9984881e94f4e954
+  metadata.gz: 7aa989a5796d79c562dc7ade44fe3b9b146b208e
+  data.tar.gz: 4e3249fae769e64f274f040ad59ef012ed4e50f5
 SHA512:
-  metadata.gz: 23a0f3f05968623d4cc91d34f7929fc2e76c42679930e9abb35e6f7e9fadfc7648d48a18c4b80452ec6871832ab1c16d4880f735dc1c6033649560fa12e1eaa7
-  data.tar.gz: 525d9d6479c8accd5b9347b7f8f97568ca708213c82db5538a731e072ba8b31e31df20e79ee5247b787611c8d16db8b22858a101419c5dbdff180447f6329e9f
+  metadata.gz: bf7cb77e9f081fa6605a7676fd733c1ea5a2d3d8da9634bf529bdfd523e37cf54795e96dabdc84e039c920efbd2e1a620f7fcd3d7abbff16c5d8eed90ca0a28d
+  data.tar.gz: b997fa5b070e09ac6c146bb0587278351e03da7bb27ef12d650765484c66045e7f05576bbdea13ccfaf8f4b72e44d53e1ab54e52149eafff7e3b10f48ee78d54

data/README.md

@@ -1,17 +1,24 @@
 # Speculation [![Build Status](https://travis-ci.org/english/speculation.svg?branch=master)](https://travis-ci.org/english/speculation)
 
-A Ruby port of Clojure's `clojure.spec`. See [clojure.spec - Rationale and Overview](https://clojure.org/about/spec). All advantages/disadvantages for clojure.spec should apply to Speculation too. This library is largely a copy-and-paste from clojure.spec so all credit goes to the clojure.spec authors.
+A Ruby port of Clojure's `clojure.spec`. This library is largely a copy-and-paste from clojure.spec so all credit goes to Rich Hickey and contributors for their original work.
+
+See [clojure.spec - Rationale and Overview](https://clojure.org/about/spec) for a thorough outline of the problems clojure.spec (and thus Speculation) was built to address and how it addresses them. As a brief summary, Speculation allows you to write predicate specs (nothing to do with RSpec!) which enable:
+
+* declarative data validation and destructuring
+* error reporting
+* runtime method instrumentation, argument checking and stubbing
+* generative testing
 
 ## Project Goals
 
-The goal of this project is to match clojure.spec as closely as possible, from design to features to API. This decision comes with the trade-off that the library may not necessarily be idiomatic Ruby, however there's nothing stopping other libraries from being built on top of Speculation to bring a more Ruby-like feel. This library won't introduce features that do not exist in clojure.spec.
+The goal of this project is to match clojure.spec as closely as possible, from design to features to API. There aren't, and won't be any, significant departures from clojure.spec.
 
 ## Examples
 
-- [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.
+* [sinatra-web-app](examples/sinatra-web-app): A small Sinatra web application demonstrating parameter 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), demonstrating most features.
+* [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
 
@@ -21,7 +28,7 @@ Documentation is available at [RubyDoc](http://www.rubydoc.info/github/english/s
 
 ### Built in predicates
 
-clojure.spec leans on its macro system and rich standard library of predicate functions when writing specs. Ruby has neither of those, so we must be creative with what we define as a 'predicate' in Speculation. Each of the following are valid Speculation predicates:
+clojure.spec utilises its rich standard library of predicate functions and data structures when writing specs. Ruby has neither of those, so we must be creative with what we define as a 'predicate' in Speculation. Each of the following are valid Speculation predicates:
 
 ```rb
 S.valid?(->(x) { x > 0 }, 2)
@@ -80,30 +87,24 @@ S.fdef(method(:hello), :args => S.cat(:name => String),
 
 #### Generators and quick check
 
-Speculation uses [`Rantly`](https://github.com/abargnesi/rantly) for random data generation. Generator functions in Speculation are Procs that take one argument (Rantly instance) and return a random value. While clojure's test.check generators generate values that start small and continue to grow and get more complex as a property holds true, Rantly always generates random values.
+Speculation uses [`Rantly`](https://github.com/abargnesi/rantly) for random data generation. Generator functions in Speculation are Procs that take one argument (Rantly instance) and return a random value. While Clojure's test.check generators generate values that start small and continue to grow and get more complex as a property holds true, Rantly always generates random values.
 
 Rantly gives Speculation the ability to shrink a failing test case down to its smallest failing case, however in Speculation we limit this to Integers and Strings. This is an area where Speculation may currently be significantly weaker than clojure.spec.
 
-## Development
-
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake` to run rubocop and the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
-
-## Contributing
-
-Bug reports and pull requests are welcome on GitHub at https://github.com/english/speculation.
-
-## TODO
+## Project status
 
-- tidy up tests
+Speculation will mirror any changes made to clojure.spec. clojure.spec is still in alpha so breaking changes should be expected.
 
-### clojure.spec features
+While most of features of clojure.spec are implemented in Speculation, a few remain:
 
 - [`unform`](https://clojuredocs.org/clojure.spec/unform)
 - [`form`](https://clojuredocs.org/clojure.spec/form)
 - [`abbrev`](https://clojuredocs.org/clojure.spec/abbrev)
 - [`describe`](https://clojuredocs.org/clojure.spec/describe)
 
-### Improvements
+## Improvements
+
+Some things I hope to focus on in the near future:
 
 - Explore alternative generator library
   - Build up a library of generators around Rantly in the meantime?
@@ -111,6 +112,14 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/englis
   - perhaps integrating with [Pry's documentation browsing](https://github.com/pry/pry/wiki/Documentation-browsing)?
 - Profile and optimise
 
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake` to run rubocop and the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/english/speculation.
+
 ## License
 
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/bin/console

@@ -19,7 +19,7 @@ def reload!
 
   load "./lib/speculation/namespaced_symbols.rb"
   load "./lib/speculation/pmap.rb"
-  load "./lib/speculation/identifier.rb"
+  load "./lib/speculation/method_identifier.rb"
   load "./lib/speculation/utils.rb"
   load "./lib/speculation/error.rb"
 

data/examples/codebreaker.rb

@@ -1,14 +1,13 @@
 # frozen_string_literal: true
-# See http://blog.cognitect.com/blog/2016/10/5/interactive-development-with-clojurespec
 
-require "bundler/inline"
-require "set"
+# Speculation version of
+# http://blog.cognitect.com/blog/2016/10/5/interactive-development-with-clojurespec by David
+# Chelimsky.
 
-gemfile true do
-  gem "speculation",
-      :git     => "https://github.com/english/speculation.git",
-      :require => ["speculation", "speculation/test", "speculation/gen"]
-end
+require "bundler/setup"
+require "speculation"
+require "speculation/gen"
+require "speculation/test"
 
 S = Speculation
 Gen = S::Gen
@@ -103,10 +102,10 @@ end
 
 S.exercise_fn method(:score)
 
-# [[[[:c, :w, :r, :c, :c, :b], [:c, :y, :y, :r, :c, :b]], {:"main/exact_matches"=>3, :"main/loose_matches"=>0}],
-#  [[[:r, :g, :w, :c, :y], [:y, :w, :r, :w, :r]], {:"main/exact_matches"=>0, :"main/loose_matches"=>0}],
-#  [[[:b, :b, :r, :b, :r], [:b, :g, :c, :c, :g]], {:"main/exact_matches"=>1, :"main/loose_matches"=>0}],
-#  [[[:g, :r, :b, :y], [:g, :c, :r, :w]], {:"main/exact_matches"=>1, :"main/loose_matches"=>0}],
+# [[[[:y, :b, :b, :b, :b, :c], [:y, :y, :g, :r, :y, :b]], nil, {:"Object/exact_matches"=>1, :"Object/loose_matches"=>0}],
+#  [[[:b, :c, :w, :w, :w, :g], [:r, :w, :c, :c, :b, :w]], nil, {:"Object/exact_matches"=>0, :"Object/loose_matches"=>0}],
+#  [[[:c, :c, :g, :w, :r], [:g, :g, :g, :c, :w]], nil, {:"Object/exact_matches"=>1, :"Object/loose_matches"=>0}],
+#  [[[:b, :y, :g, :y, :b, :y], [:g, :w, :b, :y, :r, :c]], nil, {:"Object/exact_matches"=>1, :"Object/loose_matches"=>0}],
 
 STest.check method(:score)
 
@@ -139,10 +138,10 @@ S.fdef method(:exact_matches),
 
 S.exercise_fn method(:exact_matches)
 
-# [[[[:g, :b, :b, :b, :c], [:w, :y, :c, :y, :b]], 0],
-#  [[[:c, :w, :r, :c], [:y, :r, :y, :g]], 0],
-#  [[[:g, :c, :g, :g, :y], [:g, :g, :c, :c, :r]], 1],
-#  [[[:g, :r, :y, :g, :g], [:g, :y, :y, :r, :w]], 2],
+# [[[[:y, :y, :c, :g, :b], [:c, :w, :g, :b, :y]], nil, 0],
+#  [[[:y, :c, :w, :y, :b], [:y, :w, :c, :c, :r]], nil, 1],
+#  [[[:r, :g, :r, :y, :y], [:c, :r, :c, :c, :w]], nil, 0],
+#  [[[:r, :b, :r, :c], [:y, :r, :g, :b]], nil, 0],
 
 STest.check method(:exact_matches)
 # [{:spec=>Speculation::FSpec(main.exact_matches), :"Speculation::Test/ret"=>{:num_tests=>1000, :result=>true}, :method=>#<Method: main.exact_matches>}]
@@ -150,10 +149,11 @@ STest.check method(:exact_matches)
 STest.instrument method(:exact_matches)
 S.exercise_fn method(:score)
 
-# [[[[:y, :r, :y, :r], [:g, :w, :b, :g]], {:"main/exact_matches"=>0, :"main/loose_matches"=>0}],
-#  [[[:c, :g, :g, :y, :b, :c], [:w, :y, :g, :b, :y, :c]], {:"main/exact_matches"=>2, :"main/loose_matches"=>0}],
-#  [[[:r, :b, :r, :g, :w, :r], [:c, :w, :y, :g, :g, :y]], {:"main/exact_matches"=>1, :"main/loose_matches"=>0}],
-#  [[[:r, :y, :c, :y, :y, :b], [:g, :r, :b, :c, :r, :y]], {:"main/exact_matches"=>0, :"main/loose_matches"=>0}],
+# [[[[:b, :g, :w, :b, :r], [:b, :g, :y, :g, :g]], nil, {:"Object/exact_matches"=>2, :"Object/loose_matches"=>0}],
+#  [[[:c, :w, :g, :b, :y], [:g, :r, :g, :y, :c]], nil, {:"Object/exact_matches"=>1, :"Object/loose_matches"=>0}],
+#  [[[:c, :b, :c, :y, :r], [:r, :c, :y, :r, :b]], nil, {:"Object/exact_matches"=>0, :"Object/loose_matches"=>0}],
+#  [[[:y, :c, :y, :g, :c, :c], [:w, :r, :b, :w, :b, :w]], nil, {:"Object/exact_matches"=>0, :"Object/loose_matches"=>0}],
+#  [[[:b, :b, :w, :c, :g, :c], [:r, :b, :y, :r, :c, :r]], nil, {:"Object/exact_matches"=>1, :"Object/loose_matches"=>0}],
 
 def self.score(secret, guess)
   { ns(:exact_matches) => exact_matches(secret, guess.take(3)),
@@ -180,11 +180,12 @@ S.fdef method(:match_count),
        :ret  => ns(S, :natural_integer),
        :fn   => ->(fn) { fn[:ret].between?(0, fn[:args][:secret].count) }
 
-S.exercise_fn method(:exact_matches), :n => 10, :fspec => S.get_spec(method(:match_count))
+S.exercise_fn method(:exact_matches), 10, S.get_spec(method(:match_count))
 
-# [[[[:r, :b, :g, :w, :b], [:b, :c, :c, :r, :w]], 0],
-#  [[[:c, :r, :c, :g, :g, :y], [:y, :c, :b, :y, :y, :r]], 0],
-#  [[[:c, :g, :r, :y, :y], [:w, :y, :y, :c, :w]], 0],
+# [[[[:w, :c, :w, :b, :b], [:r, :r, :c, :c, :r]], nil, 0],
+#  [[[:y, :b, :g, :y, :y], [:w, :b, :g, :y, :w]], nil, 3],
+#  [[[:y, :r, :r, :r, :b], [:b, :w, :b, :c, :r]], nil, 0],
+#  [[[:w, :g, :r, :b, :b, :b], [:y, :c, :g, :b, :c, :b]], nil, 2],
 
 STest.check_method method(:exact_matches), S.get_spec(method(:match_count))
 
@@ -194,9 +195,10 @@ STest.instrument method(:exact_matches), :spec => { method(:exact_matches) => S.
 
 S.exercise_fn method(:score)
 
-# [[[[:y, :r, :y, :c, :y], [:b, :w, :c, :g, :b]], {:"main/exact_matches"=>0, :"main/loose_matches"=>0}],
-#  [[[:r, :b, :w, :c, :w, :y], [:w, :r, :w, :g, :b, :r]], {:"main/exact_matches"=>1, :"main/loose_matches"=>0}],
-#  [[[:c, :w, :r, :w, :g, :c], [:g, :g, :c, :c, :c, :b]], {:"main/exact_matches"=>0, :"main/loose_matches"=>0}],
+# [[[[:y, :y, :r, :b, :c, :c], [:b, :b, :b, :w, :w, :r]], nil, {:"Object/exact_matches"=>0, :"Object/loose_matches"=>0}],
+#  [[[:r, :b, :r, :b, :b], [:r, :y, :c, :y, :y]], nil, {:"Object/exact_matches"=>1, :"Object/loose_matches"=>0}],
+#  [[[:c, :y, :y, :w], [:y, :c, :y, :r]], nil, {:"Object/exact_matches"=>1, :"Object/loose_matches"=>0}],
+#  [[[:w, :g, :w, :g, :b, :g], [:r, :y, :r, :y, :c, :b]], nil, {:"Object/exact_matches"=>0, :"Object/loose_matches"=>0}],
 
 STest.check method(:score)
 
@@ -212,11 +214,12 @@ def self.all_matches(secret, guess)
     reduce(0, &:+)
 end
 
-S.exercise_fn method(:all_matches), :n => 10, :fspec => S.get_spec(method(:match_count))
+S.exercise_fn method(:all_matches), 10, S.get_spec(method(:match_count))
 
-# [[[[:c, :b, :w, :w], [:b, :c, :g, :y]], 2],
-#  [[[:y, :r, :g, :r, :b], [:r, :g, :w, :b, :r]], 4],
-#  [[[:r, :g, :r, :g, :g], [:r, :g, :g, :b, :c]], 3],
+# [[[[:b, :r, :c, :r, :y, :w], [:r, :r, :c, :w, :y, :w]], nil, 5],
+#  [[[:c, :y, :g, :c, :r, :c], [:b, :w, :b, :b, :w, :b]], nil, 0],
+#  [[[:w, :g, :y, :r, :y], [:g, :y, :w, :r, :w]], nil, 4],
+#  [[[:g, :c, :c, :g], [:w, :g, :y, :w]], nil, 1],
 
 def self.score(secret, guess)
   exact = exact_matches(secret, guess)
@@ -231,10 +234,10 @@ STest.instrument [method(:exact_matches), method(:all_matches)],
                             method(:all_matches)   => S.get_spec(method(:exact_matches)) }
 
 S.exercise_fn method(:score)
-# [[[[:w, :r, :w, :c, :c, :c], [:r, :y, :r, :w, :c, :b]], {:"main/exact_matches"=>1, :"main/loose_matches"=>2}],
-#  [[[:r, :c, :w, :y, :c], [:g, :c, :y, :y, :y]], {:"main/exact_matches"=>2, :"main/loose_matches"=>0}],
-#  [[[:y, :y, :b, :g, :b], [:g, :w, :b, :c, :g]], {:"main/exact_matches"=>1, :"main/loose_matches"=>1}],
-#  [[[:c, :b, :r, :y, :g], [:g, :w, :r, :y, :y]], {:"main/exact_matches"=>2, :"main/loose_matches"=>1}],
+# [[[[:w, :g, :y, :y], [:w, :c, :c, :r]], nil, {:"Object/exact_matches"=>1, :"Object/loose_matches"=>0}],
+#  [[[:y, :w, :g, :b, :b], [:y, :w, :g, :y, :b]], nil, {:"Object/exact_matches"=>4, :"Object/loose_matches"=>0}],
+#  [[[:b, :b, :c, :b], [:b, :y, :w, :y]], nil, {:"Object/exact_matches"=>1, :"Object/loose_matches"=>0}],
+#  [[[:y, :w, :c, :y, :c], [:y, :g, :w, :w, :r]], nil, {:"Object/exact_matches"=>1, :"Object/loose_matches"=>1}],
 
 STest.summarize_results STest.check method(:score)
 

data/examples/json_parser.rb

@@ -14,19 +14,15 @@ STest = S::Test
 module JSONParser
   extend S::NamespacedSymbols
 
-  def self.re_literal(string, conformed)
+  def self.re_literal(string)
     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(:boolean), S.alt(:true  => re_literal("true"),
+                            :false => re_literal("false"))
 
   S.def ns(:number), S.alt(:integer => ns(:integer),
                            :float   => ns(:float))
@@ -134,7 +130,7 @@ module JSONParser
                                                    :tail  => ns(:object_contents)))
 
   S.def ns(:json), S.cat(:pre => ns(:maybe_spaces),
-                         :val => S.alt(:null    => ns(:null),
+                         :val => S.alt(:null    => re_literal("null"),
                                        :boolean => ns(:boolean),
                                        :number  => ns(:number),
                                        :string  => ns(:string),

data/examples/spec_guide.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
-# See https://clojure.org/guides/spec (as of 2017-18-02)
+
+# Speculation version of the clojure.spec guide by Alex Miller: https://clojure.org/guides/spec
 # Output generated by https://github.com/JoshCheek/seeing_is_believing
 
+require "bundler/setup"
 require "set"
 require "date"
 require "speculation"
@@ -249,7 +251,7 @@ S.explain :"unq/person", :first_name => "Elon"
 # >> val: {:first_name=>"Elon"} fails spec: :"unq/person" predicate: [#<Method: Speculation::Utils.key?>, [:"Object/last_name"]]
 # >> val: {:first_name=>"Elon"} fails spec: :"unq/person" predicate: [#<Method: Speculation::Utils.key?>, [:"Object/email"]]
 
-# Unqualified keys can also be used to validate record attributes # TODO for objects/structs
+# Unqualified keys can also be used to validate record attributes - don't support
 # Keyword args keys* - don't support
 
 # Sometimes it will be convenient to declare entity maps in parts, either
@@ -905,16 +907,16 @@ S.exercise S.or(:k => Symbol, :s => String, :n => Numeric), :n => 5
 # invokes the spec’ed function and returns the args and the return value.
 
 S.exercise_fn(method(:ranged_rand))
-# => [[[-2128611012334186431, -1417738444057945122], -1635106169064592441],
-#     [[1514518280943101595, 1786254628919354373], 1739796291756227578],
-#     [[-46749061680797208, 822766248044755470], -7474228458851983],
-#     [[-649513218842008808, 1875894039691321060], -390581384114488816],
-#     [[858361555883341214, 1741658980258358628], 1374077212657449917],
-#     [[-1258388171360603963, -985723099401376708], -1123010455669592843],
-#     [[-1035489322616947034, 1688366643195138662], 441214083022620176],
-#     [[-2229284211372056198, -893085296484913242], -1161469637076511831],
-#     [[819684425123939548, 1044514159372510410], 971678102106589235],
-#     [[366502776249932529, 1318835861470496704], 377553467194155955]]
+# => [[[-700291252660959460, 1315380256022004247], nil, -169059138562218507],
+#     [[-574949810996775321, -378316617969347527], nil, -540044395410145946],
+#     [[-760338081857905380, 484821106293575090], nil, 34570709564512062],
+#     [[-992673786379804322, 1487953925990349054], nil, -422423278764959748],
+#     [[-247390476258570074, 772122472766305147], nil, 397399655705976787],
+#     [[-1690412389556301777, -759316596276798578], nil, -1369751846456512938],
+#     [[1784449723230598375, 2047557531834071249], nil, 1819590014631499324],
+#     [[1116688093572002660, 1455424852058678548], nil, 1197557588479387983],
+#     [[-355113538297959975, 665164320042412170], nil, 195897461527121732],
+#     [[-631825347800361288, 2171238312189431384], nil, 885825441795070534]]
 
 ## Using S.and Generators
 
@@ -1022,7 +1024,6 @@ Gen.sample S.gen(ns(:syms)), 5
 #     :"my.domain/occupation",
 #     :"my.domain/id"]
 
-# TODO: make gens no-arg functions???
 # Note that with_gen (and other places that take a custom generator) take a
 # one-arg function that returns the generator, allowing it to be lazily
 # realized.
@@ -1284,5 +1285,3 @@ STest.summarize_results STest.check(method(:run_query))
 # In this guide we have covered most of the features for designing and using
 # specs and generators. We expect to add some more advanced generator
 # techniques and help on testing in a future update.
-
-# Original author of clojure.spec guide: Alex Miller

data/lib/speculation/gen.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+# This is a Ruby translation of clojure.spec.gen:
+#   https://github.com/clojure/clojure/blob/master/src/clj/clojure/spec/gen.clj
+# All credit belongs with Rich Hickey and contributors for their original work.
+
 require "set"
 require "rantly"
 require "rantly/property"
@@ -13,14 +17,16 @@ require "time"
 
 module Speculation
   module Gen
-    # Adds `pred` as a Rantly `guard` to generator `gen`.
-    # @param pred
+    # Adds pred block as a Rantly `guard` to generator `gen`.
     # @param gen [Proc]
+    # @yield generated value
     # @return [Proc]
     # @see https://github.com/abargnesi/rantly Rantly
-    def self.such_that(pred, gen)
+    def self.such_that(gen)
+      raise ArgumentError, "block required" unless block_given?
+
       ->(rantly) do
-        gen.call(rantly).tap { |val| rantly.guard(pred.call(val)) }
+        gen.call(rantly).tap { |val| rantly.guard(yield(val)) }
       end
     end
 
@@ -63,6 +69,13 @@ module Speculation
       end
     end
 
+    # @private
+    def self.tuple(*generators)
+      ->(r) do
+        generators.map { |g| g.call(r) }
+      end
+    end
+
     # @private
     GEN_BUILTINS = {
       Integer    => ->(r) { r.integer },

data/lib/speculation/{identifier.rb → method_identifier.rb}

@@ -2,7 +2,7 @@
 
 module Speculation
   # @private
-  class Identifier
+  class MethodIdentifier
     attr_reader :namespace, :name
 
     def initialize(namespace, name, is_instance_method)

data/lib/speculation/spec/and_spec.rb

@@ -1,13 +1,18 @@
 # frozen_string_literal: true
 
+# This is a Ruby translation of clojure.spec:
+#   https://github.com/clojure/clojure/blob/master/src/clj/clojure/spec.clj
+# All credit belongs with Rich Hickey and contributors for their original work.
+
 module Speculation
   # @private
   class AndSpec < Spec
     include NamespacedSymbols
     S = Speculation
 
-    def initialize(preds)
+    def initialize(preds, gen = nil)
       @preds = preds
+      @gen   = gen
       @specs = Concurrent::Delay.new do
         preds.map { |pred| S.send(:specize, pred) }
       end
@@ -27,6 +32,10 @@ module Speculation
       S.explain_pred_list(@preds, path, via, inn, value)
     end
 
+    def with_gen(gen)
+      self.class.new(@preds, gen)
+    end
+
     def gen(overrides, path, rmap)
       if @gen
         @gen

data/lib/speculation/spec/every_spec.rb

@@ -1,14 +1,19 @@
 # frozen_string_literal: true
 
+# This is a Ruby translation of clojure.spec:
+#   https://github.com/clojure/clojure/blob/master/src/clj/clojure/spec.clj
+# All credit belongs with Rich Hickey and contributors for their original work.
+
 module Speculation
   # @private
   class EverySpec < Spec
     include NamespacedSymbols
     S = Speculation
 
-    def initialize(predicate, options)
+    def initialize(predicate, options, gen = nil)
       @predicate = predicate
       @options = options
+      @gen = gen
 
       collection_predicates = [options.fetch(:kind, Enumerable)]
 
@@ -107,6 +112,10 @@ module Speculation
       probs.compact
     end
 
+    def with_gen(gen)
+      self.class.new(@predicate, @options, gen)
+    end
+
     def gen(overrides, path, rmap)
       return @gen if @gen
 

data/lib/speculation/spec/f_spec.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+# This is a Ruby translation of clojure.spec:
+#   https://github.com/clojure/clojure/blob/master/src/clj/clojure/spec.clj
+# All credit belongs with Rich Hickey and contributors for their original work.
+
 module Speculation
   # @private
   class FSpec < Spec
@@ -8,11 +12,12 @@ module Speculation
 
     attr_reader :args, :ret, :fn, :block
 
-    def initialize(args: nil, ret: nil, fn: nil, block: nil)
-      @args = args
-      @ret = ret
-      @fn = fn
+    def initialize(args: nil, ret: nil, fn: nil, block: nil, gen: nil)
+      @args  = args
+      @ret   = ret
+      @fn    = fn
       @block = block
+      @gen   = gen
     end
 
     def conform(f)
@@ -56,6 +61,10 @@ module Speculation
       end
     end
 
+    def with_gen(gen)
+      self.class.new(:args => @args, :ret => @ret, :fn => @fn, :block => @block, :gen => gen)
+    end
+
     def gen(overrides, _path, _rmap)
       return @gen if @gen
 
@@ -77,18 +86,13 @@ module Speculation
     # @private
     # returns f if valid, else smallest
     def self.validate_fn(f, specs, iterations)
-      args_gen = S.gen(specs[:args])
-
-      block_gen = if specs[:block]
-                    S.gen(specs[:block])
-                  else
-                    Utils.constantly(nil)
-                  end
-
-      combined = ->(r) { [args_gen.call(r), block_gen.call(r)] }
+      args_gen      = S.gen(specs[:args])
+      block_gen     = specs[:block] ? S.gen(specs[:block]) : Utils.constantly(nil)
+      arg_block_gen = Gen.tuple(args_gen, block_gen)
 
       generator_guard = ->(genned_val) { S.valid?(specs[:args], genned_val) }
-      ret = S::Test.send(:rantly_quick_check, combined, iterations, generator_guard) { |(args, block)|
+
+      ret = S::Test.send(:rantly_quick_check, arg_block_gen, iterations, generator_guard) { |(args, block)|
         call_valid?(f, specs, args, block)
       }
 

data/lib/speculation/spec/hash_spec.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+# This is a Ruby translation of clojure.spec:
+#   https://github.com/clojure/clojure/blob/master/src/clj/clojure/spec.clj
+# All credit belongs with Rich Hickey and contributors for their original work.
+
 module Speculation
   # @private
   class HashSpec < Spec
@@ -8,12 +12,13 @@ module Speculation
 
     attr_reader :id
 
-    def initialize(req, opt, req_un, opt_un)
+    def initialize(req, opt, req_un, opt_un, gen = nil)
       @id = SecureRandom.uuid
       @req = req
       @opt = opt
       @req_un = req_un
       @opt_un = opt_un
+      @gen = gen
 
       req_keys     = req.flat_map(&method(:extract_keys))
       req_un_specs = req_un.flat_map(&method(:extract_keys))
@@ -100,8 +105,8 @@ module Speculation
       problems.compact
     end
 
-    def specize
-      self
+    def with_gen(gen)
+      self.class.new(@req, @opt, @req_un, @opt_un, gen)
     end
 
     def gen(overrides, path, rmap)

data/lib/speculation/spec/merge_spec.rb

@@ -1,13 +1,18 @@
 # frozen_string_literal: true
 
+# This is a Ruby translation of clojure.spec:
+#   https://github.com/clojure/clojure/blob/master/src/clj/clojure/spec.clj
+# All credit belongs with Rich Hickey and contributors for their original work.
+
 module Speculation
   # @private
   class MergeSpec < Spec
     include NamespacedSymbols
     S = Speculation
 
-    def initialize(preds)
+    def initialize(preds, gen = nil)
       @preds = preds
+      @gen   = gen
     end
 
     def conform(x)
@@ -26,6 +31,10 @@ module Speculation
         compact
     end
 
+    def with_gen(gen)
+      self.class.new(@preds, gen)
+    end
+
     def gen(overrides, path, rmap)
       return @gen if @gen
 

data/lib/speculation/spec/nilable_spec.rb

@@ -1,13 +1,18 @@
 # frozen_string_literal: true
 
+# This is a Ruby translation of clojure.spec:
+#   https://github.com/clojure/clojure/blob/master/src/clj/clojure/spec.clj
+# All credit belongs with Rich Hickey and contributors for their original work.
+
 module Speculation
   # @private
   class NilableSpec < Spec
     include NamespacedSymbols
     S = Speculation
 
-    def initialize(pred)
+    def initialize(pred, gen = nil)
       @pred = pred
+      @gen = gen
       @delayed_spec = Concurrent::Delay.new { S.send(:specize, pred) }
     end
 
@@ -24,6 +29,10 @@ module Speculation
       )
     end
 
+    def with_gen(gen)
+      self.class.new(@pred, gen)
+    end
+
     def gen(overrides, path, rmap)
       return @gen if @gen
 

data/lib/speculation/spec/nonconforming_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# This is a Ruby translation of clojure.spec:
+#   https://github.com/clojure/clojure/blob/master/src/clj/clojure/spec.clj
+# All credit belongs with Rich Hickey and contributors for their original work.
+
+module Speculation
+  # @private
+  class NonconformingSpec < Spec
+    include NamespacedSymbols
+    S = Speculation
+
+    def initialize(spec, gen = nil)
+      @spec = spec
+      @gen = gen
+      @delayed_spec = Concurrent::Delay.new { S.send(:specize, spec) }
+    end
+
+    def conform(value)
+      ret = @delayed_spec.value!.conform(value)
+
+      S.invalid?(ret) ? S::INVALID : value
+    end
+
+    def explain(path, via, inn, value)
+      @delayed_spec.value!.explain(path, via, inn, value)
+    end
+
+    def with_gen(gen)
+      self.class.new(@spec, gen)
+    end
+
+    def gen(overrides, path, rmap)
+      @delayed_spec.value!.gen(overrides, path, rmap)
+    end
+  end
+end

data/lib/speculation/spec/or_spec.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+# This is a Ruby translation of clojure.spec:
+#   https://github.com/clojure/clojure/blob/master/src/clj/clojure/spec.clj
+# All credit belongs with Rich Hickey and contributors for their original work.
+
 module Speculation
   # @private
   class OrSpec < Spec
@@ -8,11 +12,12 @@ module Speculation
 
     attr_reader :id
 
-    def initialize(named_specs)
+    def initialize(named_specs, gen = nil)
       @id = SecureRandom.uuid
       @named_specs = named_specs
       @keys = named_specs.keys
       @preds = preds = named_specs.values
+      @gen = gen
 
       @delayed_specs = Concurrent::Delay.new do
         preds.map { |spec| S.send(:specize, spec) }
@@ -40,8 +45,12 @@ module Speculation
       end
     end
 
+    def with_gen(gen)
+      self.class.new(@named_specs, gen)
+    end
+
     def gen(overrides, path, rmap)
-      return gen if @gen
+      return @gen if @gen
 
       gs = @keys.zip(@preds).
         map { |(k, p)|

data/lib/speculation/spec/predicate_spec.rb

@@ -1,14 +1,19 @@
 # frozen_string_literal: true
 
+# This is a Ruby translation of clojure.spec:
+#   https://github.com/clojure/clojure/blob/master/src/clj/clojure/spec.clj
+# All credit belongs with Rich Hickey and contributors for their original work.
+
 module Speculation
   # @private
   class PredicateSpec < Spec
     include NamespacedSymbols
     S = Speculation
 
-    def initialize(predicate, should_conform)
+    def initialize(predicate, should_conform, gen = nil)
       @predicate = predicate
       @should_conform = should_conform
+      @gen = gen
     end
 
     def conform(value)
@@ -31,6 +36,10 @@ module Speculation
       end
     end
 
+    def with_gen(gen)
+      self.class.new(@predicate, @should_conform, gen)
+    end
+
     def gen(_, _, _)
       if @gen
         @gen

data/lib/speculation/spec/regex_spec.rb

@@ -1,13 +1,18 @@
 # frozen_string_literal: true
 
+# This is a Ruby translation of clojure.spec:
+#   https://github.com/clojure/clojure/blob/master/src/clj/clojure/spec.clj
+# All credit belongs with Rich Hickey and contributors for their original work.
+
 module Speculation
   # @private
   class RegexSpec < Spec
     include NamespacedSymbols
     S = Speculation
 
-    def initialize(regex)
+    def initialize(regex, gen = nil)
       @regex = regex
+      @gen = gen
     end
 
     def conform(value)
@@ -26,6 +31,10 @@ module Speculation
       end
     end
 
+    def with_gen(gen)
+      self.class.new(@regex, gen)
+    end
+
     def gen(overrides, path, rmap)
       return @gen if @gen
 

data/lib/speculation/spec/tuple_spec.rb

@@ -1,13 +1,18 @@
 # frozen_string_literal: true
 
+# This is a Ruby translation of clojure.spec:
+#   https://github.com/clojure/clojure/blob/master/src/clj/clojure/spec.clj
+# All credit belongs with Rich Hickey and contributors for their original work.
+
 module Speculation
   # @private
   class TupleSpec < Spec
     include NamespacedSymbols
     S = Speculation
 
-    def initialize(preds)
+    def initialize(preds, gen = nil)
       @preds = preds
+      @gen = gen
 
       @delayed_specs = Concurrent::Delay.new do
         preds.map { |pred| S.send(:specize, pred) }
@@ -52,6 +57,10 @@ module Speculation
       end
     end
 
+    def with_gen(gen)
+      self.class.new(@preds, gen)
+    end
+
     def gen(overrides, path, rmap)
       return @gen if @gen
 

data/lib/speculation/spec.rb

@@ -3,7 +3,7 @@
 module Speculation
   # @private
   class Spec
-    attr_accessor :name, :gen
+    attr_accessor :name
     attr_reader :id
 
     def conform(_x)
@@ -34,3 +34,4 @@ require_relative "spec/every_spec"
 require_relative "spec/regex_spec"
 require_relative "spec/f_spec"
 require_relative "spec/nilable_spec"
+require_relative "spec/nonconforming_spec"

data/lib/speculation/test.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+# This is a Ruby translation of clojure.spec.test:
+#   https://github.com/clojure/clojure/blob/master/src/clj/clojure/spec/test.clj
+# All credit belongs with Rich Hickey and contributors for their original work.
+
 require "concurrent"
 require "pp"
 require "speculation/pmap"
@@ -32,7 +36,7 @@ module Speculation
     # Given an opts hash as per instrument, returns the set of methods that can
     # be instrumented.
     # @param opts [Hash]
-    # @return [Array<Identifier>]
+    # @return [Array<Method>]
     def self.instrumentable_methods(opts = {})
       if opts[:gen]
         unless opts[:gen].keys.all? { |k| k.is_a?(Method) || k.is_a?(Symbol) }
@@ -79,12 +83,12 @@ module Speculation
     # @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) }
+        gens = opts[:gen].reduce({}) { |h, (k, v)| h.merge(S.MethodIdentifier(k) => v) }
         opts = opts.merge(:gen => gens)
       end
 
       Array(method_or_methods).
-        map { |method| S.Identifier(method) }.
+        map { |method| S.MethodIdentifier(method) }.
         uniq.
         map { |ident| instrument1(ident, opts) }.
         compact.
@@ -99,7 +103,7 @@ module Speculation
       method_or_methods ||= @instrumented_methods.value.keys
 
       Array(method_or_methods).
-        map { |method| S.Identifier(method) }.
+        map { |method| S.MethodIdentifier(method) }.
         map { |ident| unstrument1(ident) }.
         compact.
         map(&method(:Method))
@@ -113,7 +117,7 @@ module Speculation
     # @see check see check for options and return
     def self.check_method(method, spec, opts = {})
       validate_check_opts(opts)
-      check1(S.Identifier(method), spec, opts)
+      check1(S.MethodIdentifier(method), spec, opts)
     end
 
     # @param opts [Hash] an opts hash as per `check`
@@ -137,7 +141,7 @@ module Speculation
     # @option opts :num_tests [Integer] (1000) number of times to generatively test each method
     # @option opts :gen [Hash] map from spec names to generator overrides.
     #   Generator overrides are passed to Speculation.gen when generating method args.
-    # @return [Array<Identifier>] an array of check result hashes with the following keys:
+    # @return [Array<Hash>] an array of check result hashes with the following keys:
     #   * :spec       the spec tested
     #   * :method     optional method tested
     #   * :failure    optional test failure
@@ -155,10 +159,10 @@ module Speculation
       method_or_methods ||= checkable_methods
 
       checkable = Set(checkable_methods(opts))
-      checkable.map!(&S.method(:Identifier))
+      checkable.map!(&S.method(:MethodIdentifier))
 
       methods = Set(method_or_methods)
-      methods.map!(&S.method(:Identifier))
+      methods.map!(&S.method(:MethodIdentifier))
 
       pmap(methods.intersection(checkable)) { |ident|
         check1(ident, S.get_spec(ident), opts)
@@ -300,9 +304,9 @@ module Speculation
       end
 
       def instrument_choose_fn(f, spec, ident, opts)
-        stubs   = (opts[:stub] || []).map(&S.method(:Identifier))
+        stubs   = (opts[:stub] || []).map(&S.method(:MethodIdentifier))
         over    = opts[:gen] || {}
-        replace = (opts[:replace] || {}).reduce({}) { |h, (k, v)| h.merge(S.Identifier(k) => v) }
+        replace = (opts[:replace] || {}).reduce({}) { |h, (k, v)| h.merge(S.MethodIdentifier(k) => v) }
 
         if stubs.include?(ident)
           Gen.generate(S.gen(spec, over))
@@ -313,7 +317,7 @@ module Speculation
 
       def instrument_choose_spec(spec, ident, overrides)
         (overrides || {}).
-          reduce({}) { |h, (k, v)| h.merge(S.Identifier(k) => v) }.
+          reduce({}) { |h, (k, v)| h.merge(S.MethodIdentifier(k) => v) }.
           fetch(ident, spec)
       end
 
@@ -402,7 +406,7 @@ module Speculation
                       Utils.constantly(nil)
                     end
 
-        arg_block_gen = ->(r) { [args_gen.call(r), block_gen.call(r)] }
+        arg_block_gen = Gen.tuple(args_gen, block_gen)
 
         generator_guard = ->(genned_val) { S.valid?(spec.args, genned_val) }
         rantly_quick_check(arg_block_gen, num_tests, generator_guard) do |(args, block)|
@@ -460,7 +464,7 @@ module Speculation
       end
 
       def fn_spec_name?(spec_name)
-        spec_name.is_a?(S::Identifier)
+        spec_name.is_a?(S::MethodIdentifier)
       end
 
       # Reimplementation of Rantly's `check` since it does not provide direct access to results
@@ -558,10 +562,10 @@ module Speculation
         end
       end
 
-      # if x is an Identifier, return its method
+      # if x is an MethodIdentifier, return its method
       def Method(x)
         case x
-        when Identifier then x.get_method
+        when MethodIdentifier      then x.get_method
         when Method, UnboundMethod then x
         else raise ArgumentError, "unexpected method-like object #{x}"
         end

data/lib/speculation/utils.rb

@@ -44,7 +44,7 @@ module Speculation
     end
 
     def self.ident?(x)
-      x.is_a?(Symbol) || x.is_a?(Identifier)
+      x.is_a?(Symbol) || x.is_a?(MethodIdentifier)
     end
 
     def self.method?(x)

data/lib/speculation/version.rb

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

data/lib/speculation.rb

@@ -1,12 +1,16 @@
 # frozen_string_literal: true
 
+# This is a Ruby translation of clojure.spec:
+#   https://github.com/clojure/clojure/blob/master/src/clj/clojure/spec.clj
+# All credit belongs with Rich Hickey and contributors for their original work.
+
 require "concurrent"
 require "set"
 require "securerandom"
 
 require "speculation/version"
 require "speculation/namespaced_symbols"
-require "speculation/identifier"
+require "speculation/method_identifier"
 require "speculation/utils"
 require "speculation/spec"
 require "speculation/error"
@@ -152,7 +156,7 @@ module Speculation
   # @param value value to conform
   # @return [Symbol, Object] :Speculation/invalid if value does not match spec, else the (possibly destructured) value
   def self.conform(spec, value)
-    spec = Identifier(spec)
+    spec = MethodIdentifier(spec)
     specize(spec).conform(value)
   end
 
@@ -164,7 +168,7 @@ module Speculation
     if regex?(spec)
       spec.merge(ns(:gfn) => gen)
     else
-      specize(spec).tap { |s| s.gen = gen }
+      specize(spec).with_gen(gen)
     end
   end
 
@@ -189,7 +193,7 @@ module Speculation
   #   where problem-hash has at least :path :pred and :val keys describing the
   #   predicate and the value that failed at that path.
   def self.explain_data(spec, x)
-    spec = Identifier(spec)
+    spec = MethodIdentifier(spec)
     name = spec_name(spec)
     _explain_data(spec, [], Array(name), [], x)
   end
@@ -250,7 +254,7 @@ module Speculation
     g = gfn || spec.gen(overrides, path, rmap)
 
     if g
-      Gen.such_that(->(x) { valid?(spec, x) }, g)
+      Gen.such_that(g) { |x| valid?(spec, x) }
     else
       raise Speculation::Error.new("unable to construct gen at: #{path.inspect} for: #{spec.inspect}",
                                    ns(:failure) => :no_gen, ns(:path) => path)
@@ -272,15 +276,15 @@ module Speculation
   # @param overrides <Hash>
   # @return [Proc]
   def self.gen(spec, overrides = nil)
-    spec = Identifier(spec)
+    spec = MethodIdentifier(spec)
     gensub(spec, overrides, [], RECURSION_LIMIT => recursion_limit)
   end
 
   # @private
-  def self.Identifier(x)
+  def self.MethodIdentifier(x)
     case x
-    when Method        then Identifier.new(x.receiver, x.name, false)
-    when UnboundMethod then Identifier.new(x.owner, x.name, true)
+    when Method        then MethodIdentifier.new(x.receiver, x.name, false)
+    when UnboundMethod then MethodIdentifier.new(x.owner, x.name, true)
     else x
     end
   end
@@ -291,7 +295,7 @@ module Speculation
   # @param spec [Spec, Symbol, Proc, Hash] a spec, spec name, predicate or regex-op
   # @return [Symbol, Method]
   def self.def(key, spec)
-    key = Identifier(key)
+    key = MethodIdentifier(key)
 
     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"
@@ -300,14 +304,14 @@ module Speculation
     spec = if spec?(spec) || regex?(spec) || registry[spec]
              spec
            else
-             spec_impl(spec, false)
+             spec_impl(spec, nil, false)
            end
 
     @registry_ref.swap do |reg|
       reg.merge(key => with_name(spec, key)).freeze
     end
 
-    key.is_a?(Identifier) ? key.get_method : key
+    key.is_a?(MethodIdentifier) ? key.get_method : key
   end
 
   # @return [Hash] the registry hash
@@ -319,7 +323,7 @@ module Speculation
   # @param key [Symbol, Method]
   # @return [Spec, nil] spec registered for key, or nil
   def self.get_spec(key)
-    registry[Identifier(key)]
+    registry[MethodIdentifier(key)]
   end
 
   # NOTE: it is not generally necessary to wrap predicates in spec when using
@@ -346,11 +350,7 @@ module Speculation
   #   arg (Rantly instance) that generates a valid value.
   # @return [Spec]
   def self.spec(pred, gen: nil)
-    if pred
-      spec_impl(pred, false).tap do |spec|
-        spec.gen = gen if gen
-      end
-    end
+    spec_impl(pred, gen, false) if pred
   end
 
   # Creates and returns a hash validating spec. :req and :opt are both arrays of
@@ -384,9 +384,7 @@ module Speculation
   # @param gen [Proc] generator function, which must be a proc of one arg
   #   (Rantly instance) that generates a valid value
   def self.keys(req: [], opt: [], req_un: [], opt_un: [], gen: nil)
-    HashSpec.new(req, opt, req_un, opt_un).tap do |spec|
-      spec.gen = gen
-    end
+    HashSpec.new(req, opt, req_un, opt_un, gen)
   end
 
   # @see keys
@@ -450,9 +448,7 @@ module Speculation
   def self.every(pred, opts = {})
     gen = opts.delete(:gen)
 
-    EverySpec.new(pred, opts).tap do |spec|
-      spec.gen = gen
-    end
+    EverySpec.new(pred, opts, gen)
   end
 
   # Like 'every' but takes separate key and val preds and works on associative collections.
@@ -557,11 +553,11 @@ module Speculation
     { OP => AMP, :p1 => re, :predicates => preds }
   end
 
-  # @yield [value] predicate function with the semantics of conform i.e. it should
+  # @param f 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 block as a predicate/conformer.
-  def self.conformer(&pred)
-    spec_impl(pred, true)
+  # @return [Spec] a spec that uses pred as a predicate/conformer.
+  def self.conformer(f)
+    spec_impl(f, nil, true)
   end
 
   # Takes :args :ret and (optional) :block and :fn kwargs whose values are preds and returns a spec
@@ -581,9 +577,7 @@ module Speculation
   # @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
-    end
+    FSpec.new(:args => spec(args), :ret => spec(ret), :fn => spec(fn), :block => spec(block), :gen => gen)
   end
 
   # @param preds [Array] one or more preds
@@ -618,7 +612,7 @@ module Speculation
   # @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)
-    self.def(Identifier(method), fspec(spec))
+    self.def(MethodIdentifier(method), fspec(spec))
     method
   end
 
@@ -626,7 +620,7 @@ module Speculation
   # @param x
   # @return [Boolean] true when x is valid for spec.
   def self.valid?(spec, x)
-    spec = Identifier(spec)
+    spec = MethodIdentifier(spec)
     spec = specize(spec)
 
     !invalid?(spec.conform(x))
@@ -638,6 +632,14 @@ module Speculation
     NilableSpec.new(pred)
   end
 
+  # @param spec
+  # @return [Spec] a spec that has the same properies as the given spec, except
+  #   `conform` will return the original (not the conformed) value. Note, will
+  #   specize regex ops.
+  def self.nonconforming(spec)
+    NonconformingSpec.new(spec)
+  end
+
   # Generates a number (default 10) of values compatible with spec and maps
   # conform over them, returning a sequence of [val conformed-val] tuples.
   # @param spec
@@ -657,12 +659,15 @@ module Speculation
   # @param method [Method]
   # @param n [Integer]
   # @param fspec [Spec]
-  # @return [Array] an arrray of tuples of [args, ret].
-  def self.exercise_fn(method, n: 10, fspec: nil)
+  # @return [Array] an array of triples of [args, block, ret].
+  def self.exercise_fn(method, n = 10, fspec = nil)
     fspec ||= get_spec(method)
     raise ArgumentError, "No fspec found for #{method}" unless fspec
 
-    Gen.sample(gen(fspec.args), n).map { |args| [args, method.call(*args)] }
+    block_gen = fspec.block ? gen(fspec.block) : Utils.constantly(nil)
+    gen = Gen.tuple(gen(fspec.args), block_gen)
+
+    Gen.sample(gen, n).map { |(args, block)| [args, block, method.call(*args, &block)] }
   end
 
   ### impl ###
@@ -718,15 +723,16 @@ module Speculation
   end
 
   # @private
-  def self.spec_impl(pred, should_conform)
+  def self.spec_impl(pred, gen, should_conform)
     if spec?(pred)
-      pred
+      with_gen(pred, gen)
     elsif regex?(pred)
-      RegexSpec.new(pred)
+      RegexSpec.new(pred, gen)
     elsif Utils.ident?(pred)
-      the_spec(pred)
+      spec = the_spec(pred)
+      gen ? with_gen(spec, gen) : spec
     else
-      PredicateSpec.new(pred, should_conform)
+      PredicateSpec.new(pred, should_conform, gen)
     end
   end
 
@@ -978,10 +984,10 @@ module Speculation
         spec
       else
         case spec
-        when Symbol, Identifier
+        when Symbol, MethodIdentifier
           specize(reg_resolve!(spec))
         else
-          spec_impl(spec, false)
+          spec_impl(spec, nil, false)
         end
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: speculation
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Jamie English
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-03-27 00:00:00.000000000 Z
+date: 2017-04-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -177,7 +177,7 @@ files:
 - lib/speculation.rb
 - lib/speculation/error.rb
 - lib/speculation/gen.rb
-- lib/speculation/identifier.rb
+- lib/speculation/method_identifier.rb
 - lib/speculation/namespaced_symbols.rb
 - lib/speculation/pmap.rb
 - lib/speculation/spec.rb
@@ -187,6 +187,7 @@ files:
 - lib/speculation/spec/hash_spec.rb
 - lib/speculation/spec/merge_spec.rb
 - lib/speculation/spec/nilable_spec.rb
+- lib/speculation/spec/nonconforming_spec.rb
 - lib/speculation/spec/or_spec.rb
 - lib/speculation/spec/predicate_spec.rb
 - lib/speculation/spec/regex_spec.rb