consequence 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5c2b7b3c259799b0b5a6c368a64a1f7bc0f12d6a
-  data.tar.gz: e441c9585001b3c347f74d129eeac6273e8e9ecd
+  metadata.gz: 3038f8d2f6c5083a3e945054dd080b655507ae47
+  data.tar.gz: 16ec4fc46d518cadd43564e87acb3bca08e4c8c6
 SHA512:
-  metadata.gz: 645626fc457cec8d73894930e7f94df018f71874c9766d39d5420a134d8d47024697b91cf1373ea997c1b6eca8435f1a0d0292f8be32951ea19c9cfbd79bd579
-  data.tar.gz: 86b2c7ead5e669d41a84567799c313cfbe4892e9a868e826d31489bf238d3596ee5391ca767964f359decec147b6c77881ba54f8021018fb79cdaa47fe5d787d
+  metadata.gz: fdf17369f753147abb4d225f9690e6206235f506d82a346987aee3c8b89f97084592a524d6a9ef6f2d9506936553793707987104d6d1f6b1df4df543483530d6
+  data.tar.gz: f79925766a50f40b0d63e62cc5dc5f39e4d53d48ea60a85161dabc292f247562eecb682a483cb0a39e1479f0fcf6aa3ad139d0698ac7f00bef03a188549d64dd

data/README.md

@@ -9,37 +9,38 @@ Simple monad implementation with clear and consistent syntax.
 ``` ruby
 require 'consequence'
 
-Foo = Class.new(Consequence::Monad)
-Bar = Class.new(Consequence::Monad)
+def process(i)
+  Foo[i] >> :next << log >> validate
+end
 
-compare   = ->(v, m) { m == Foo[0] ? Foo[1] : Bar[v] }
-transform = ->(v, m) { m == Foo[1] ? 10 : 3 }
-validate  = ->(v) { v > 4 ? Bar[v] : Foo[v] }
-increment = ->(v) { v + 1 }
+def log
+  ->(v) { puts v }
+end
 
-react = ->(v, m) { @side_effect = v ** 2 if m.is_a?(Bar) }
-log   = ->(v) { @side_effect = @side_effect.to_s }
+def validate
+  ->(v, m) { m == Foo[5] ? m : Bar['Fail'] }
+end
 
-result = Foo[0] >>
-         compare >>   # Foo[1]
-         transform >> # Foo[10]
-         validate >>  # Bar[10]
-         increment >> # Bar[11]
-         :next << react << log
+Foo = Class.new(Consequence::Monad)
+Bar = Class.new(Consequence::Monad)
 
-p result        # Bar[12]
-p @side_effect  # "144"
+p process(0) # Bar['Fail']
+p process(4) # Foo[5]
 ```
 
 ## Operations
 
-* `>>` - Chains a proc with the result being passed along. If the result is not a `Monad`, it is wrapped up in one.
+<dl>
+  <dt> &gt;&gt; Right Shift </dt>
+  <dd>Chains a proc with the result being passed along. If the result is not a monad, it is wrapped up in one.</dd>
 
-* `<<` - The supplied proc is applied with the result being ignored and the unchanged `Monad` is passed down the chain.
+  <dt> &lt;&lt; Left Shift </dt>
+  <dd>The supplied proc is applied with the result being ignored and the unchanged monad is passed down the chain.</dd>
+</dl>
 
-If the proc accepts one argument, it is passed only the `value` of the `Monad`. If it accepts two values, it is passed both the `value` and the `Monad`.
+If the proc accepts one argument, it is passed only the `value` of the monad. If it accepts two arguments, it is passed both the `value` and the monad.
 
-Before being called, the proc have their `#to_proc` method called. This allows a `Symbol` to be passed in, whose `#to_proc` method sends the symbol as a message to the `value` of the `Monad`.
+Before being called, the proc have their `#to_proc` method called. This allows a `Symbol` to be passed in, whose `#to_proc` method sends the symbol as a message to the `value` of the monad.
 
 ## Types
 
@@ -47,11 +48,79 @@ Before being called, the proc have their `#to_proc` method called. This allows a
 
 A `Success` monad wraps up all exceptions in a `Failed` monad and a `Failed` monad ignores all chained methods. This allows all possible failures in a long process to be dealt with at the end.
 
+``` ruby
+require 'consequence'
+
+module CreateUser
+  class << self
+    include Consequence
+    alias_method :m, :method
+
+    def create(attributes)
+      Success[attributes] >> m(:build) >> m(:validate) >> m(:persist)
+    end
+
+    private
+
+    def build(attributes)
+      User.new(attributes)
+    end
+
+    def validate(user)
+      validator = UserValidator.new(user)
+      validator.valid? ? Success[user] : Failure[validator.errors]
+    end
+
+    def persist(user)
+      user.save
+    end
+  end
+end
+```
+
+If the `User#new` raises an exception, the `validate` and `persist` methods won't be called, and a `Failure` monad will be returned with the exception as it's `value`.
+
+If the `validator` finds the new user to be invalid, the `persist` method will not be called and a `Failure` monad will be returned with the errors as it's `value`.
+
 ### Something & Nothing
 
 A `Something` monad wraps up a nil result in a `Nothing` monad and a `Nothing` monad ignores all chained methods. This prevents `MissingMethod` errors from trying to be call a method on `nil`.
 
-### More to come...
+## Utils
+
+### `send_to_value` and `send_to_monad`
+
+`send_to_value` and `send_to_monad` are utility methods that can be included from `Consequence::Utils`. They create procs that pass their arguments to the send method on the value and monad respectively.
+
+``` ruby
+include Consequence::Utils
+
+Monad[2] << send_to_value(:**, 3) # Monad[8]
+```
+
+To include into Object to be available within all objects:
+
+``` ruby
+require 'consequence/core_ext/utils'
+```
+
+### `Object#m`
+
+As a shorthand for the `Object#method` method, it can be useful to alias this to m, such as in the Success/Failure example. To do this for all objects:
+
+``` ruby
+require 'consequence/core_ext/m_alias'
+```
+
+### `Symbol#to_proc`
+
+`Symbol#to_proc` can't be used to call private methods. This is inconvenient if you want an object to wrap itself up and call it's oen private methods with symbols. To use that style of notation, you can add this:
+
+``` ruby
+require 'consequence/core_ext/private_symbol_proc'
+```
+
+Alternatively, you can use `object#method`.
 
 ## Installation
 

data/lib/consequence.rb

@@ -2,5 +2,6 @@ module Consequence
 end
 
 require 'consequence/monad'
+require 'consequence/utils'
 require 'consequence/success'
 require 'consequence/something'

data/lib/consequence/core_ext/m_alias.rb

@@ -0,0 +1,3 @@
+class Object
+  alias_method :m, :method
+end

data/lib/consequence/core_ext/private_symbol_proc.rb

@@ -0,0 +1,9 @@
+# This allows symbol#to_proc method to call private functions.
+# Which can be useful if you want to have a class wrap itself in
+# a Monad and call it private methods.
+
+class Symbol
+  def to_proc
+    ->(v) { v.send(self) }
+  end
+end

data/lib/consequence/core_ext/utils.rb

@@ -0,0 +1,5 @@
+require 'consequence/utils'
+
+class Object
+  include Consequence::Utils
+end

data/lib/consequence/monad.rb

@@ -28,7 +28,7 @@ module Consequence
     end
 
     def inspect
-      "#{self.class}[#{value}]"
+      "#{self.class}[#{value.inspect}]"
     end
 
     private
@@ -38,7 +38,7 @@ module Consequence
     end
 
     def args_for(proc)
-      proc.arity.abs == 1 ? [value] : [value, self]
+      [value, self][0, proc.arity.abs]
     end
 
     def wrap(value)

data/lib/consequence/something.rb

@@ -1,3 +1,5 @@
+require 'consequence/monad'
+
 module Consequence
   class Something < Monad
     def >>(proc)

data/lib/consequence/success.rb

@@ -1,3 +1,5 @@
+require 'consequence/monad'
+
 module Consequence
   class Success < Monad
     def >>(proc)

data/lib/consequence/utils.rb

@@ -1,11 +1,11 @@
 module Consequence
-	module Utils
-		def send_to_value(*args)
-			->(v) { v.send(*args) }
-		end
+  module Utils
+    def send_to_value(*args)
+      ->(v) { v.send(*args) }
+    end
 
-		def send_to_monad(*args)
-			->(v, m) { m.send(*args) }
-		end
-	end
+    def send_to_monad(*args)
+      ->(v, m) { m.send(*args) }
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: consequence
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Max White
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-14 00:00:00.000000000 Z
+date: 2015-01-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -39,6 +39,9 @@ files:
 - LICENSE.txt
 - README.md
 - lib/consequence.rb
+- lib/consequence/core_ext/m_alias.rb
+- lib/consequence/core_ext/private_symbol_proc.rb
+- lib/consequence/core_ext/utils.rb
 - lib/consequence/monad.rb
 - lib/consequence/something.rb
 - lib/consequence/success.rb