deterministic 0.15.3 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 70b4013b20820efd41949d10c8bcb0706b514d12
-  data.tar.gz: cdb7071c05a8001af91c10212a67eceede5106cb
+  metadata.gz: 7120823c22300ba01fd44a7a3d18aae96f7357ba
+  data.tar.gz: 8cd374ad1eed4bba6aae559d96730954d76b15bd
 SHA512:
-  metadata.gz: 30b231a3e818e90d9f49fc5b9932adafe969ccfe8e645cabda707f2e5a13b50efd0e2f07916accb82c53f64e5dd592d85aa2075d21b1859a598c56a7ed9ba91b
-  data.tar.gz: b81e77b351c2fb48c5debfc979db451e5f021bd7cf3d240d101e867e0ae6e9c65ceeb3dd285f88f7332fce58c68db8d0c906dd1734c16c229ba80964c6336de2
+  metadata.gz: 0a15bd39adfa6dd90d2a9f5f395aba58881bab0380b743770a5dc6d09bf87d4681b7ae7493f344a66ae771a4f084e898d853c3f9745c9b165df27d9a7b928c49
+  data.tar.gz: d0df2e74a8a941216a1a58b836916dd55e5ed15d90c3e93dcd22d611e20a3b041dbf7ed4c767ad47c08c38eab7e2ccc60c76c10a9290c7125bb32c5321a1dd71

data/README.md

@@ -5,7 +5,7 @@
 
 Deterministic is to help your code to be more confident, by utilizing functional programming patterns.
 
-This is a spiritual successor of the [Monadic gem](http://github.com/pzol/monadic). The goal of the rewrite is to get away from a bit to forceful aproach I took in Monadic, especially when it comes to coercing monads, but also a more practical but at the same time more strict adherence to monad laws.
+This is a spiritual successor of the [Monadic gem](http://github.com/pzol/monadic). The goal of the rewrite is to get away from a bit too forceful aproach I took in Monadic, especially when it comes to coercing monads, but also a more practical but at the same time more strict adherence to monad laws.
 
 ## Patterns
 
@@ -213,29 +213,35 @@ Now that you have some result, you want to control flow by providing patterns.
 
 ```ruby
 Success(1).match do
-  Success(s) { |v| "success #{s}"}
-  Failure(f) { |v| "failure #{f}"}
+  Success() { |s| "success #{s}"}
+  Failure() { |f| "failure #{f}"}
 end # => "success 1"
 ```
-Note1: the inner value has been unwrapped! 
+Note1: the variant's inner value(s) have been unwrapped, and passed to the block.
 
 Note2: only the __first__ matching pattern block will be executed, so order __can__ be important.
 
+Note3: you can omit block parameters if you don't use them, or you can use `_` to signify that you don't care about their values. If you specify parameters, their number must match the number of values in the variant.
+
 The result returned will be the result of the __first__ `#try` or `#let`. As a side note, `#try` is a monad, `#let` is a functor.
 
 Guards
 
 ```ruby
 Success(1).match do
-  Success(s, where { s == 1 }) { "Success #{s}" }
+  Success(where { s == 1 }) { |s| "Success #{s}" }
 end # => "Success 1"
 ```
 
+Note1: the guard has access to variable names defined by the block arguments.
+
+Note2: the guard is not evaluated using the enclosing context's `self`; if you need to call methods on the enclosing scope, you must specify a receiver.
+
 Also you can match the result class
 
 ```ruby
 Success([1, 2, 3]).match do
-  Success(s, where { s.is_a?(Array)} ) { s.first }
+  Success(where { s.is_a?(Array) }) { |s| s.first }
 end # => 1
 ```
 
@@ -243,7 +249,7 @@ If no match was found a `NoMatchError` is raised, so make sure you always cover
 
 ```ruby
 Success(1).match do
-  Failure(f) { "you'll never get me" }
+  Failure() { |f| "you'll never get me" }
 end # => NoMatchError
 ```
 
@@ -323,9 +329,9 @@ Option.try! { raise "error"}           # => None
 ### Pattern Matching
 ```ruby
 Some(1).match {
-  Some(s, where { s == 1 }) { s + 1 }
-  Some(s)                   { 1 }
-  None()                    { 0 }
+  Some(where { s == 1 }) { |s| s + 1 }
+  Some()                 { |s| 1 }
+  None()                 { 0 }
 }                                      # => 2
 ```
 
@@ -361,28 +367,28 @@ Pattern matching
 
 ```ruby
 Threenum::Unary(5).match {
-  Nullary()     { 0 }
-  Unary(u)      { u }
-  Binary(a, b)  { a + b }
+  Nullary() {        0 }
+  Unary()   { |u|    u }
+  Binary()  { |a, b| a + b }
 }                                      # => 5
 
 # or
 t = Threenum::Unary(5)
 Threenum.match(t) {
-  Nullary()     { 0 }
-  Unary(u)      { u }
-  Binary(a, b)  { a + b }
+  Nullary() {        0 }
+  Unary()   { |u|    u }
+  Binary()  { |a, b| a + b }
 }                                      # => 5
 ```
 
-If you want the whole thing use the arg passed to the block (second case)
+If you want to return the whole matched object, you'll need to pass a reference to the object (second case). Note that `self` refers to the scope enclosing the `match` call.
 
 ```ruby
 def drop(n)
   match {
-    Cons(h, t, where { n > 0 }) { t.drop(n - 1) }
-    Cons(_, _) { |c| c }
-    Nil() { raise EmptyListError}
+    Cons(where { n > 0 }) { |h, t| t.drop(n - 1) }
+    Cons()                { |_, _| self }
+    Nil() { raise EmptyListError }
   }
 end
 ```
@@ -393,10 +399,10 @@ With guard clauses
 
 ```ruby
 Threenum::Unary(5).match {
-  Nullary()     { 0 }
-  Unary(u)      { u }
-  Binary(a, b, where { a.is_a?(Fixnum) && b.is_a?(Fixnum)})  { a + b }
-  Binary(a, b)  { raise "Expected a, b to be numbers" }
+  Nullary() {     0 }
+  Unary()   { |u| u }
+  Binary(where { a.is_a?(Fixnum) && b.is_a?(Fixnum) }) { |a, b| a + b }
+  Binary()  { |a, b| raise "Expected a, b to be numbers" }
 }                                      # => 5
 ```
 
@@ -406,17 +412,17 @@ Implementing methods for enums
 Deterministic::impl(Threenum) {
   def sum
     match {
-      Nullary()    { 0 }
-      Unary(u)     { u }
-      Binary(a, b) { a + b }
+      Nullary() {        0 }
+      Unary()   { |u|    u }
+      Binary()  { |a, b| a + b }
     }
   end
 
   def +(other)
     match {
-      Nullary()    { other.sum }
-      Unary(a)     { |this| this.sum + other.sum }
-      Binary(a, b) { |this| this.sum + other.sum }
+      Nullary() {        other.sum }
+      Unary()   { |a|    self.sum + other.sum }
+      Binary()  { |a, b| self.sum + other.sum }
     }
   end
 }

data/lib/deterministic/enum.rb

@@ -23,6 +23,16 @@ module Deterministic
         def name
           self.class.name.split("::")[-1]
         end
+
+        # Returns array. Will fail on Nullary objects.
+        # TODO: define a Unary module so we can define this method differently on Unary vs Binary
+        def wrapped_values
+          if self.is_a?(Deterministic::EnumBuilder::DataType::Binary)
+            value.values
+          else
+            [value]
+          end
+        end
       end
 
       module Nullary
@@ -35,6 +45,7 @@ module Deterministic
         end
       end
 
+      # TODO: this should probably be named Multary
       module Binary
         def initialize(*init)
           raise ArgumentError, "Expected arguments for #{args}, got #{init}" unless (init.count == 1 && init[0].is_a?(Hash)) || init.count == args.count
@@ -103,6 +114,8 @@ module_function
       class << self; private :new; end
 
       def self.match(obj, &block)
+        caller_ctx = block.binding.eval 'self'
+
         matcher = self::Matcher.new(obj)
         matcher.instance_eval(&block)
 
@@ -116,17 +129,19 @@ module_function
           obj, type, block, args, guard = match
 
           if args.count == 0
-            return instance_exec(obj, &block)
+            return caller_ctx.instance_eval(&block)
           else
-            raise Enum::MatchError, "Pattern (#{args.join(', ')}) must match (#{obj.args.join(', ')})" if args.count != obj.args.count
-            context = exec_context(obj, args)
+            if args.count != obj.args.count
+              raise Enum::MatchError, "Pattern (#{args.join(', ')}) must match (#{obj.args.join(', ')})"
+            end
+            guard_ctx = guard_context(obj, args)
 
             if guard
-              if context.instance_exec(obj, &guard)
-                return context.instance_exec(obj, &block)
+              if guard_ctx.instance_exec(obj, &guard)
+                return caller_ctx.instance_exec(* obj.wrapped_values, &block)
               end
             else
-              return context.instance_exec(obj, &block)
+              return caller_ctx.instance_exec(* obj.wrapped_values, &block)
             end
           end
         }
@@ -137,7 +152,7 @@ module_function
       def self.variants; constants - [:Matcher, :MatchError]; end
 
       private
-      def self.exec_context(obj, args)
+      def self.guard_context(obj, args)
         if obj.is_a?(Deterministic::EnumBuilder::DataType::Binary)
           Struct.new(*(args)).new(*(obj.value.values))
         else
@@ -163,17 +178,22 @@ module_function
         guard
       end
 
-      def method_missing(m)
-        m
-      end
-
       type_variants.each { |m|
-        define_method(m) { |*args, &block|
+        define_method(m) { |guard = nil, &block|
           raise ArgumentError, "No block given to `#{m}`" if block.nil?
+          params_spec = block.parameters
+          if params_spec.any? {|spec| spec.size < 2 }
+            raise ArgumentError, "Unnamed param found in block parameters: #{params_spec.inspect}"
+          end
+          if params_spec.any? {|spec| spec[0] != :req && spec[0] != :opt }
+            raise ArgumentError, "Only :req & :opt params allowed; parameters=#{params_spec.inspect}"
+          end
+          args = params_spec.map {|spec| spec[1] }
+
           type = Kernel.eval("#{mod.name}::#{m}")
 
-          if args.count > 0 && args[-1].is_a?(Proc)
-            guard = args.delete_at(-1)
+          if guard && !guard.is_a?(Proc)
+            guard = nil
           end
 
           @matches << [@obj, type, block, args, guard]

data/lib/deterministic/match.rb

@@ -1,3 +1,4 @@
+# TODO: remove dead code
 module Deterministic
   module PatternMatching
 

data/lib/deterministic/option.rb

@@ -29,15 +29,15 @@ module Deterministic
 
     def fmap(&fn)
       match {
-        Some(s) { |m| m.class.new(fn.(s)) }
-        None()  { |n| n }
+        Some() {|s| self.class.new(fn.(s)) }
+        None() {    self }
       }
     end
 
     def map(&fn)
       match {
-        Some(s) { |m| m.bind(&fn) }
-        None()  { |n| n }
+        Some() {|s| self.bind(&fn) }
+        None() {    self }
       }
     end
 
@@ -53,8 +53,8 @@ module Deterministic
 
     def value_or(n)
       match {
-        Some(s) { s }
-        None()  { n }
+        Some() {|s| s }
+        None() {    n }
       }
     end
 
@@ -65,9 +65,9 @@ module Deterministic
     def +(other)
       match {
         None() { other }
-        Some(_, where { !other.is_a?(Option)}) { raise TypeError, "Other must be an #{Option}"}
-        Some(s, where { other.some? }) { Option::Some.new(s + other.value) }
-        Some(_) { |s| s }
+        Some(where { !other.is_a?(Option) }) {|_| raise TypeError, "Other must be an #{Option}"}
+        Some(where { other.some? }) {|s| Option::Some.new(s + other.value) }
+        Some() {|_| self }
       }
     end
   }

data/lib/deterministic/result.rb

@@ -19,8 +19,8 @@ module Deterministic
   Deterministic::impl(Result) {
     def map(proc=nil, &block)
       match {
-        Success(_) { |s| s.bind(proc || block) }
-        Failure(_) { |f| f }
+        Success() {|_| self.bind(proc || block) }
+        Failure() {|_| self }
       }
     end
 
@@ -29,8 +29,8 @@ module Deterministic
 
     def map_err(proc=nil, &block)
       match {
-        Success(_) { |s| s }
-        Failure(_) { |f| f.bind(proc|| block) }
+        Success() {|_| self }
+        Failure() {|_| self.bind(proc|| block) }
       }
     end
 
@@ -54,26 +54,26 @@ module Deterministic
     def or(other)
       raise Deterministic::Monad::NotMonadError, "Expected #{other.inspect} to be a Result" unless other.is_a? Result
       match {
-        Success(_) { |s| s }
-        Failure(_) { other}
+        Success() {|_| self }
+        Failure() {|_| other }
       }
     end
 
     def and(other)
       raise Deterministic::Monad::NotMonadError, "Expected #{other.inspect} to be a Result" unless other.is_a? Result
       match {
-        Success(_) { other }
-        Failure(_) { |f| f }
+        Success() {|_| other }
+        Failure() {|_| self }
       }
     end
 
     def +(other)
       raise Deterministic::Monad::NotMonadError, "Expected #{other.inspect} to be a Result" unless other.is_a? Result
       match {
-        Success(s, where { other.success?} ) { Result::Success.new(s + other.value) }
-        Failure(f, where { other.failure?} ) { Result::Failure.new(f + other.value) }
-        Success(_) { other } # implied other.failure?
-        Failure(_) { |f| f } # implied other.success?
+        Success(where { other.success? } ) {|s| Result::Success.new(s + other.value) }
+        Failure(where { other.failure? } ) {|f| Result::Failure.new(f + other.value) }
+        Success() {|_| other } # implied other.failure?
+        Failure() {|_| self } # implied other.success?
       }
     end
 

data/lib/deterministic/version.rb

@@ -1,3 +1,3 @@
 module Deterministic
-  VERSION = "0.15.3"
+  VERSION = "0.16.0"
 end

data/spec/examples/amount_spec.rb

@@ -16,17 +16,17 @@ end
 Deterministic::impl(Amount) {
   def to_s
     match {
-      Due(a)  { "%0.2f" % [a] }
-      Paid(a) { "-%0.2f" % [a] }
-      Info(a) { "(%0.2f)" % [a] }
+      Due()  {|a| "%0.2f" % [a] }
+      Paid() {|a| "-%0.2f" % [a] }
+      Info() {|a| "(%0.2f)" % [a] }
     }
   end
 
   def to_f
     match {
-      Info(a) { 0 }
-      Due(a)  { a }
-      Paid(a) { -1 * a }
+      Info() {|a| 0 }
+      Due()  {|a| a }
+      Paid() {|a| -1 * a }
     }
   end
 

data/spec/examples/config_spec.rb

@@ -11,8 +11,8 @@ class ElasticSearchConfig
 
   def hosts
     Option.any?(proc_env["RESFINITY_LOG_CLIENT_ES_HOST"]).match {
-      Some(s) { { hosts: s.split(/, */) } }
-      None() { default_hosts }
+      Some() {|s| { hosts: s.split(/, */) } }
+      None() { default_hosts }  # calls ElasticSearchConfig instance's method
     }
   end
 
@@ -31,7 +31,7 @@ private
 end
 
 describe ElasticSearchConfig do
-  pending("match exec context must have access to parents block binding context") {
+  # NOTE: the "empty" cases also verify that the variant matchers use the enclosing context as self
 
   let(:cfg) { ElasticSearchConfig.new(environment, env) }
   context "test" do
@@ -72,5 +72,4 @@ describe ElasticSearchConfig do
       specify { expect(cfg.hosts).to eq({ hosts: ["acc.resfinity.net:9200"] }) }
     end
   end
-}
 end

data/spec/examples/list.rb

@@ -28,46 +28,46 @@ Deterministic::impl(List) {
 
   def first
     match {
-      Cons(_, _) { |c| c }
-      Nil() { |n| n }
+      Cons() {|_, _| self }
+      Nil() {  self }
     }
   end
 
   def last
     match {
-      Cons(h, t, where { t.null? }) { |c| return c }
-      Cons(_, t) { t.last }
-      Nil() { |n| n }
+      Cons(where { t.null? }) {|h, t| return self }
+      Cons() {|_, t| t.last }
+      Nil() { self }
     }
   end
 
   def head
     match {
-      Cons(h, _) { h }
-      Nil() { |n| n }
+      Cons() {|h, _| h }
+      Nil() { self }
     }
   end
 
   def tail
     match {
-      Cons(_, t) { t }
-      Nil() { |n| raise EmptyListError }
+      Cons() { |_, t| t }
+      Nil() { raise EmptyListError }
     }
   end
 
   def init
     match {
-      Cons(h, t, where { |c| t.tail.null? } ) { |c| Cons.new(h, Nil.new) }
-      Cons(h, t) { |c| Cons.new(h, t.init) }
+      Cons(where { t.tail.null? } ) {|h, t| Cons.new(h, Nil.new) }
+      Cons() {|h, t| Cons.new(h, t.init) }
       Nil() { raise EmptyListError }
     }
   end
 
   def filter(&pred)
     match {
-      Cons(h, t, where { pred.(h) }) { |c| Cons.new(h, t.filter(&pred)) }
-      Cons(_, t) { t.filter(&pred) }
-      Nil() { |n| n }
+      Cons(where { pred.(h) }) {|h, t| Cons.new(h, t.filter(&pred)) }
+      Cons() {|_, t| t.filter(&pred) }
+      Nil() { self }
     }
   end
 
@@ -76,21 +76,21 @@ Deterministic::impl(List) {
   def find(&pred)
     match {
       Nil() { Deterministic::Option::None.new }
-      Cons(h, t) { if pred.(h) then Deterministic::Option::Some.new(h) else t.find(&pred) end }
+      Cons() {|h, t| pred.(h) ? Deterministic::Option::Some.new(h) : t.find(&pred) }
     }
   end
 
   def length
     match {
-      Cons(h, t) { 1 + t.length }
+      Cons() {|h, t| 1 + t.length }
       Nil() { 0 }
     }
   end
 
   def map(&fn)
     match {
-      Cons(h, t) { Cons.new(fn.(h), t.map(&fn)) }
-      Nil() { |n| n }
+      Cons() {|h, t| Cons.new(fn.(h), t.map(&fn)) }
+      Nil() { self }
     }
   end
 
@@ -102,14 +102,14 @@ Deterministic::impl(List) {
     match {
       Nil() { start }
       # foldl f z (x:xs) = foldl f (f z x) xs
-      Cons(h, t) { t.foldl(fn.(start, h), &fn) }
+      Cons() {|h, t| t.foldl(fn.(start, h), &fn) }
     }
   end
 
   def foldl1(&fn)
     match {
       Nil() { raise EmptyListError }
-      Cons(h, t) { t.foldl(h, &fn)}
+      Cons() {|h, t| t.foldl(h, &fn)}
     }
   end
 
@@ -117,32 +117,32 @@ Deterministic::impl(List) {
     match {
       Nil() { start }
       # foldr f z (x:xs) = f x (foldr f z xs)
-      Cons(h, t) { fn.(h, t.foldr(start, &fn)) }
+      Cons() {|h, t| fn.(h, t.foldr(start, &fn)) }
     }
   end
 
   def foldr1(&fn)
     match {
       Nil() { raise EmptyListError }
-      Cons(h, t, where { t.null? }) { h }
+      Cons(where { t.null? }) {|h, t| h }
       # foldr1 f (x:xs) =  f x (foldr1 f xs)
-      Cons(h, t) { fn.(h, t.foldr1(&fn)) }
+      Cons() {|h, t| fn.(h, t.foldr1(&fn)) }
     }
   end
 
   def take(n)
     match {
-      Cons(h, t, where { n > 0 }) { Cons.new(h, t.take(n - 1))}
-      Cons(_, _) { Nil.new }
-      Nil() { raise EmptyListError}
+      Cons(where { n > 0 }) {|h, t| Cons.new(h, t.take(n - 1)) }
+      Cons() {|_, _| Nil.new }
+      Nil() { raise EmptyListError }
     }
   end
 
   def drop(n)
     match {
-      Cons(h, t, where { n > 0 }) { t.drop(n - 1) }
-      Cons(_, _) { |c| c }
-      Nil() { raise EmptyListError}
+      Cons(where { n > 0 }) {|h, t| t.drop(n - 1) }
+      Cons() {|_, _| self }
+      Nil() { raise EmptyListError }
     }
   end
 
@@ -153,31 +153,31 @@ Deterministic::impl(List) {
   def any?(&pred)
     match {
       Nil() { false }
-      Cons(h, t, where { t.null? }) { pred.(h) }
-      Cons(h, t) { pred.(h) || t.any?(&pred) }
+      Cons(where { t.null? }) {|h, t| pred.(h) }
+      Cons() {|h, t| pred.(h) || t.any?(&pred) }
     }
   end
 
   def all?(&pred)
     match {
       Nil() { false }
-      Cons(h, t, where { t.null? }) { pred.(h) }
-      Cons(h, t)                    { pred.(h) && t.all?(&pred) }
+      Cons(where { t.null? }) {|h, t| pred.(h) }
+      Cons()                  {|h, t| pred.(h) && t.all?(&pred) }
     }
   end
 
   def reverse
     match {
-      Nil() { |n| n }
-      Cons(_, t, where { t.null? }) { |c| c }
-      Cons(h, t) { |c| Cons.new(c.last.head, c.init.reverse) }
+      Nil() { self }
+      Cons(where { t.null? }) {|_, t| self }
+      Cons() {|h, t| Cons.new(self.last.head, self.init.reverse) }
     }
   end
 
   def to_s(joiner = ", ")
     match {
       Nil() { "Nil" }
-      Cons(head, tail) { head.to_s + joiner + tail.to_s }
+      Cons() {|head, tail| head.to_s + joiner + tail.to_s }
     }
   end
 }

data/spec/examples/list_spec.rb

@@ -13,9 +13,9 @@ describe List do
     it "catches ignores guards with non-matching clauses" do
       expect(
         list.match {
-          Nil()       { self }
-          Cons(h, t, where { h == 0 })  { h }
-          Cons(h, t)  { h }
+          Nil()       { list }
+          Cons(where { h == 0 }) {|h,t| h }
+          Cons()  {|h, t| h }
         }).to eq 1
     end
 
@@ -23,15 +23,15 @@ describe List do
       expect( # guard catched
         list.match {
           Nil() { raise "unreachable" }
-          Cons(h, t, where { h == 1 })  { h + 1 }
-          Cons(h, t)  { h }
+          Cons(where { h == 1 }) {|h,t| h + 1 }
+          Cons() {|h| h }
         }).to eq 2
     end
 
     it "raises an error when no match was made" do
       expect {
         list.match {
-          Cons(_, _, where { true == false }) { 1 }
+          Cons(where { true == false }) {|_, _| 1 }
           Nil(where { true == false }) { 0 }
         }
       }.to raise_error(Deterministic::Enum::MatchError)
@@ -40,7 +40,7 @@ describe List do
     it "raises an error when the match is not exhaustive" do
       expect {
         list.match {
-          Cons(_, _) {}
+          Cons() {|_, _| }
         }
       }.to raise_error(Deterministic::Enum::MatchError)
     end

data/spec/examples/logger_spec.rb

@@ -1,5 +1,6 @@
 require 'spec_helper'
 
+# TODO: dead code?
 class Logger
     alias :m :method
 
@@ -14,6 +15,7 @@ class Logger
   private
     attr_reader :repository
 
+    # TODO: this is never called; the matcher syntax is old
     def validate(item)
       return Failure(["Item cannot be empty"]) if item.blank?
       return Failure(["Item must be a Hash"]) unless item.is_a?(Hash)

data/spec/lib/deterministic/option_spec.rb

@@ -75,8 +75,8 @@ describe Deterministic::Option do
   it "match" do
     expect(
       Some(0).match {
-        Some(s, where { s == 1 } ) { |n| 99 }
-        Some(s, where { s == 0 }) { |n| s + 1 }
+        Some(where { s == 1 }) {|s| 99 }
+        Some(where { s == 0 }) {|s| s + 1 }
         None() {}
       }
     ).to eq 1
@@ -84,14 +84,14 @@ describe Deterministic::Option do
     expect(
       Some(1).match {
         None() { 0 }
-        Some(s) { 1 }
+        Some() {|s| 1 }
       }
     ).to eq 1
 
     expect(
       Some(1).match {
         None() { 0 }
-        Some(s, where { s.is_a? Fixnum }) { 1 }
+        Some(where { s.is_a? Fixnum }) {|s| 1 }
       }
     ).to eq 1
 

data/spec/lib/enum_spec.rb

@@ -27,7 +27,7 @@ describe Deterministic::Enum  do
       expect(n).to be_a MyEnym
       expect(n).to be_a MyEnym::Nullary
       expect(n.name).to eq "Nullary"
-      expect { n.value }.to raise_error
+      expect { n.value }.to raise_error NoMethodError
       expect(n.inspect).to eq "Nullary"
       expect(n.to_s).to eq ""
       expect(n.fmap { }).to eq n
@@ -77,8 +77,8 @@ describe Deterministic::Enum  do
       res =
         MyEnym.match(b) {
           Nullary()  { 0 }
-          Unary(a) { [a, b] }
-          Binary(x, y) { [x, y]}
+          Unary() {|a| a }
+          Binary() {|x,y| [x, y] }
         }
 
       expect(res).to eq [1, 2]
@@ -86,8 +86,8 @@ describe Deterministic::Enum  do
       res =
         b.match {
           Nullary()  { 0 }
-          Unary(a) { [a, b] }
-          Binary(x, y) { [x, y]}
+          Unary() {|a| a }
+          Binary() {|x,y| [x, y] }
         }
 
       expect(res).to eq [1, 2]
@@ -98,10 +98,10 @@ describe Deterministic::Enum  do
       }.to raise_error(NameError)
 
       expect { b.match {
-        Nullary()
-        Unary()
-        Binary()
-      }
+                 Nullary()
+                 Unary()
+                 Binary()
+               }
       }.to raise_error ArgumentError, "No block given to `Nullary`"
     end
   end

data/spec/readme_spec.rb

@@ -20,19 +20,18 @@ Threenum = Deterministic::enum {
 
 Deterministic::impl(Threenum) {
   def sum
-
     match {
-      Nullary()    { 0 }
-      Unary(u)     { u }
-      Binary(a, b) { a + b }
+      Nullary() {        0 }
+      Unary()   { |u|    u }
+      Binary()  { |a, b| a + b }
     }
   end
 
   def +(other)
     match {
-      Nullary()    { other.sum }
-      Unary(a)     { |this| this.sum + other.sum }
-      Binary(a, b) { |this| this.sum + other.sum }
+      Nullary() {        other.sum }
+      Unary()   { |a|    self.sum + other.sum }
+      Binary()  { |a, b| self.sum + other.sum }
     }
   end
 }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: deterministic
 version: !ruby/object:Gem::Version
-  version: 0.15.3
+  version: 0.16.0
 platform: ruby
 authors:
 - Piotr Zolnierek
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-28 00:00:00.000000000 Z
+date: 2016-03-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler