consequence 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 35e897cf0811f0e794d208bfcff9c243f86fd167
-  data.tar.gz: 4d71d729915727771f5ae6e9263bbf1a72fc0093
+  metadata.gz: 1d9f0c8c6460d68c6920b23b9d54b164d5e89d6e
+  data.tar.gz: 9b94446f09dbf982fb67043adc34dff1646b5043
 SHA512:
-  metadata.gz: 434bcae89a6fad08652e5d697a6f9a3ea3e2eadcf6393a68827b087680c1cfa7d49e14546373b45a3380dd1268d5383e647bfa196ddbd38bc1917c1130ef50bf
-  data.tar.gz: efd3cb4d3e8bd01b2d2fb99aae2a1ce69257baa7d7da55edb37428e58560b69d1860f2438bfe8cb7229321c62bbc2161da3714d1f2675f003872c743ef1c6980
+  metadata.gz: 52332a52917ef7cc1359d80e9a667cdaff60593a393d035d0f2091f03eb4ec01ec914ac68923bee4f687412349122aff6c7b6af02bc6fad5dde886fc29889dc6
+  data.tar.gz: 879ea1c9cdebb84d14e8f95e303f7f76bfcd6188fc820a6355092e5a396cddaa7da6dbd1761191d76b78f9f70293cb3b5e3b1329de346ac45ceac199ff8fae8e

data/README.md

@@ -1,5 +1,6 @@
 # Consequence
 
+[![Build Status](https://travis-ci.org/mushishi78/consequence.svg?branch=master)](https://travis-ci.org/mushishi78/consequence)
 [![Gem Version](https://badge.fury.io/rb/consequence.svg)](http://badge.fury.io/rb/consequence)
 
 Simple monad implementation with clear and consistent syntax.
@@ -41,7 +42,7 @@ Foo[0] == Foo[0] # true
 
 Monads have two main operations `>>` and `<<`.
 
-Both take a proc for their only argument. The supplied proc can take 0-2 arguments and the monad will match them, even if it's a lamda or method object with arity checking.
+Both take an object with a `#call` method, such as a proc, for their only argument. The `#call` method can take 0-2 arguments and the monad will match them, even if it's a lamda or method object with arity checking.
 
 It's first argument will be passed the monads value:
 
@@ -61,13 +62,13 @@ Foo[0] << ->(v, m) { puts v if m.is_a?(Foo) }
 
 The `>>` operation may be variously thought of as the 'map', 'bind' or 'join' operations, but has been left unnamed to avoid any specific connotations.
 
-It takes the result of the proc given to it and passes it on:
+It takes the result of the argument's `#call` method and passes it on:
 
 ``` ruby
 Foo[0] >> ->(v) { Bar[v] } # Bar[0]
 ```
 
-If it return's a result that is not a monad, it is wrapped up in one so the chain can continue:
+If the returned result that is not a monad, it is wrapped up in one so the chain can continue:
 
 ``` ruby
 Foo[0] >> ->(v) { v + 1 } # Foo[1]
@@ -77,7 +78,7 @@ Foo[0] >> ->(v) { v + 1 } # Foo[1]
 
 The `<<` operation may be thought of as the 'pipe' operation.
 
-It calls the proc given to it, but ignores it's return value:
+It calls the argument's `#call` method, but ignores the return value:
 
 ``` ruby
 Foo[0] << ->(v) { v + 1 } # Foo[0]
@@ -91,28 +92,6 @@ puts @side_effect
 # $ 1
 ```
 
-### `#to_proc`
-
-Before either operation calls a proc, the `#to_proc` method is called on it. This can be useful if the operation is given an object that is no a proc, but has a `#to_proc` method that returns one.
-
-A good example of this is the Symbol object, whose `#to_proc` method supplies a proc that sends the symbol as a message to its first argument. In this case this means calling that method on the value:
-
-``` ruby
-Foo[[1, 4, 7]] >> :pop # Foo[7]
-```
-
-This also can be used to make a composition syntax, by writing a `#to_proc` method for a monad:
-
-``` ruby
-class Add < Monad
-  def to_proc
-    ->(v) { v + value }
-  end
-end
-
-Add[1] >> Add[4] >> Add[6] # Add[11]
-```
-
 ## Built-In Types
 
 ### NullMonad
@@ -123,7 +102,7 @@ The `NullMonad` is a monad whose `>>` and `<<` operations have been overriden to
 NullMonad[0] >> ->(v) { v + 1 } # Consequence::NullMonad[0]
 ```
 
-This is different from the `<<` operation, because the proc isn't even run, so can cause no side effects:
+This is different from the `<<` operation, because the argument's `#call` method isn't even run, so can cause no side effects:
 
 ``` ruby
 NullMonad[0] << ->(v) { @side_effect = v + 1 }
@@ -155,7 +134,7 @@ Success[0] >> ->(v) { 5 / v }
 # Consequence::Failure[#<ZeroDivisionError: divided by 0>]
 ```
 
-A `Failure` monad is a subclass of the `NullMonad` so all successive chained procs are ignored.
+A `Failure` monad is a subclass of the `NullMonad` so all successive chained operations are ignored.
 
 Both `Success` and `Failure` respond to the `#succeeded?` and `#failed?` query methods in the way you'd expect:
 
@@ -176,7 +155,7 @@ A `Something` monad wraps up a nil result in a `Nothing` monad:
 Something[[1, 3, 5]] >> ->(v) { v[4] } # Consequence::Nothing[nil]
 ```
 
-A `Nothing` monad is also a subclass of the `NullMonad` so all successive chained procs are ignored. This prevents `MissingMethod` errors from trying to call a method on a `nil`.
+A `Nothing` monad is also a subclass of the `NullMonad` so all successive chained operations are ignored. This prevents `MissingMethod` errors from trying to call a method on a `nil`.
 
 A `Nothing` responds positively to the `#nil?` method:
 
@@ -208,6 +187,16 @@ Something[dangrous_hash][:user][:orders][1][:price] # Consequence::Something[3.9
 Something[dangrous_hash][:user][:orders][2][:price] # Consequence::Nothing[nil]
 ```
 
+## `#to_proc`
+
+Before either operation calls the argument's `#call` method, the `#to_proc` method is called on it if it has one. This can be useful if the operation is given an object that has no `#call` method, but has a `#to_proc`.
+
+A good example of this is the Symbol object, whose `#to_proc` method supplies a proc that sends the symbol as a message to its first argument. In this case this means calling that method on the value:
+
+``` ruby
+Foo[[1, 4, 7]] >> :pop # Foo[7]
+```
+
 ## Wiki
 
 To find some examples and information about utils, [check out the wiki](https://github.com/mushishi78/consequence/wiki) and feel free to contribute to it.
@@ -215,7 +204,6 @@ To find some examples and information about utils, [check out the wiki](https://
 ## Inspirations
 
 * [Deterministic](https://github.com/pzol/deterministic)
-* [Kleisli](https://github.com/txus/kleisli)
 * [Refactoring Ruby with Monads](https://www.youtube.com/watch?v=J1jYlPtkrqQ&feature=youtu.be&a)
 
 ## Installation

data/lib/consequence/eventually.rb

@@ -1,17 +1,17 @@
 require 'consequence/monad'
 
 module Consequence
-	class Eventually < Monad
-	  def execute(proc)
-	    value.(proc)
-	  end
+  class Eventually < Monad
+    def execute(proc)
+      value.(proc)
+    end
 
-	  def <<(_); self end
+    def <<(_); self end
 
-	  private
+    private
 
-	  def bind(proc)
-	    ->(callback) { execute(proc.(callback)) }
-	  end
-	end
+    def bind(proc)
+      ->(callback) { execute(proc.(callback)) }
+    end
+  end
 end

data/lib/consequence/monad.rb

@@ -10,12 +10,13 @@ module Consequence
 
     attr_reader :value
 
-    def >>(proc)
-      wrap(bind(proc.to_proc))
+    def >>(obj)
+      obj = obj.to_proc if obj.respond_to?(:to_proc)
+      wrap(bind(obj))
     end
 
-    def <<(proc)
-      bind(proc.to_proc)
+    def <<(obj)
+      bind(obj.to_proc)
       self
     end
 
@@ -33,12 +34,17 @@ module Consequence
 
     private
 
-    def bind(proc)
-      proc.call(*args_for(proc))
+    def bind(obj)
+      obj.call(*args_for(obj))
     end
 
-    def args_for(proc)
-      [value, self][0, proc.arity.abs]
+    def args_for(obj)
+      [value, self][0, arity(obj)]
+    end
+
+    def arity(obj)
+      method = obj.respond_to?(:arity) ? obj : obj.method(:call)
+      method.arity.abs
     end
 
     def wrap(value)

data/lib/consequence/something.rb

@@ -3,16 +3,16 @@ require 'consequence/delegates_to_value'
 
 module Consequence
   class Something < Monad
-  	include DelegatesToValue
+    include DelegatesToValue
 
-    def >>(proc)
+    def >>(obj)
       result = super
       result.value.nil? ? Nothing[nil] : result
     end
   end
 
   class Nothing < NullMonad
-  	include DelegatesToValue
+    include DelegatesToValue
 
     def nil?; true end
   end

data/lib/consequence/success.rb

@@ -2,13 +2,13 @@ require 'consequence/monad'
 
 module Consequence
   class Success < Monad
-    def >>(proc)
+    def >>(obj)
       super
     rescue => err
       Failure[err]
     end
 
-    def <<(proc)
+    def <<(obj)
       super
     rescue => err
       Failure[err]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: consequence
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors:
 - Max White
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-16 00:00:00.000000000 Z
+date: 2015-01-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec