consequence 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6cdf2c9dad1c8995f8853db69da3d6804daf2029
-  data.tar.gz: bfc2e9093a371c54ee2c39c273c2c5ffea14ba18
+  metadata.gz: 5c2b7b3c259799b0b5a6c368a64a1f7bc0f12d6a
+  data.tar.gz: e441c9585001b3c347f74d129eeac6273e8e9ecd
 SHA512:
-  metadata.gz: 3066cbf8aa5a1415c37788e81f550c9ad96cc6b4a69604c26a2bc2ac8936e9ee610edc20b49bb694f37082b8cc8a084c0e9660f9e4bfb0085a00622550c0014b
-  data.tar.gz: 845c28a333e1ef7676cba5bbb6af7846eed3af5495e184b64a60f64adc7ebf3e128684886f59122d9bc804874f196154f77664cf5d0a1cc91622c3f56dbb6f71
+  metadata.gz: 645626fc457cec8d73894930e7f94df018f71874c9766d39d5420a134d8d47024697b91cf1373ea997c1b6eca8435f1a0d0292f8be32951ea19c9cfbd79bd579
+  data.tar.gz: 86b2c7ead5e669d41a84567799c313cfbe4892e9a868e826d31489bf238d3596ee5391ca767964f359decec147b6c77881ba54f8021018fb79cdaa47fe5d787d

data/README.md

@@ -2,110 +2,56 @@
 
 [![Gem Version](https://badge.fury.io/rb/consequence.svg)](http://badge.fury.io/rb/consequence)
 
-Monad implementation to be used with [contracts.ruby](https://github.com/egonSchiele/contracts.ruby)
+Simple monad implementation with clear and consistent syntax.
 
-## Example Usage
+## Usage
 
 ``` ruby
 require 'consequence'
 
-class HirePirate
-  include Consequence
-  alias_method :m, :method
+Foo = Class.new(Consequence::Monad)
+Bar = Class.new(Consequence::Monad)
 
-  def apply(applicant)
-    Success[applicant] >> m(:eye_patch_check) << m(:log) >> :sign_and_date
-  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 }
 
-  private
+react = ->(v, m) { @side_effect = v ** 2 if m.is_a?(Bar) }
+log   = ->(v) { @side_effect = @side_effect.to_s }
 
-  Contract Applicant => Monad
-  def eye_patch_check(applicant)
-    applicant.working_eyes > 1 ? Failure['Too many eyes'] : Success[Pirate.new(applicant)]
-  end
+result = Foo[0] >>
+         compare >>   # Foo[1]
+         transform >> # Foo[10]
+         validate >>  # Bar[10]
+         increment >> # Bar[11]
+         :next << react << log
 
-  def log(pirate)
-    puts "#{pirate.name} has joined the crew"
-  end
-end
+p result        # Bar[12]
+p @side_effect  # "144"
 ```
 
-## Monad Methods
+## Operations
 
-### >>
+* `>>` - Chains a proc with the result being passed along. If the result is not a `Monad`, it is wrapped up in one.
 
-Chains a method with the result being passed down the chain.
+* `<<` - The supplied proc is applied with the result being ignored and the unchanged `Monad` is passed down the chain.
 
-If the method has a contract that requires a Monad, then the method is passed the Monad, otherwise it is passed it's value.
+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 method has a contract that returns a Monad, then that Monad is passed down the chain, otherwise the result of the method is taken as the value for a new 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`.
 
-If called with a Symbol instead of a method, it is sent as a message to the value, and the result is taken as the value for a new Monad.
-
-### <<
-
-Method is applied with the result being ignored and the unchanged Monad is passed down the chain.
-
-If the method has a contract that requires a Monad, then the method is passed the Monad, otherwise it is passed it's value.
-
-If called with a Symbol instead of a method, it is sent as a message to the value.
-
-## Monad Types
+## Types
 
 ### Success & Failure
 
-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.
+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.
 
-### Option
-
-A Option Monad only applies a method if it's value is not nil, otherwise it ignores them. This prevents MissingMethod errors from methods trying to be applied to nil.
-
-## Example Implementation of Left and Right
-
-``` ruby
-require 'consequence'
+### Something & Nothing
 
-class Crab
-  include Consequence
-  alias_method :m, :method
+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`.
 
-  Contract Monad => Monad
-  def begin(direction = Left[0])
-    direction >> m(:turn) >> m(:move) << m(:log) >> m(:continue?)
-  end
-
-  private
-
-  Left = Class.new(Monad)
-  Right = Class.new(Monad)
-
-  Contract Left => Num
-  def move(monad)
-    monad.value + 5
-  end
-
-  Contract Right => Num
-  def move(monad)
-    monad.value - 5
-  end
-
-  Contract Num => Monad
-  def turn(value)
-    rand > 0.5 ? Left[value] : Right[value]
-  end
-
-  def log(value)
-    puts value
-  end
-
-  Contract Monad => Monad
-  def continue?(monad)
-    monad.value.abs > 25 ? monad : monad >> m(:begin)
-  end
-end
-
-Crab.new.begin
-```
+### More to come...
 
 ## Installation
 

data/lib/consequence/monad.rb

@@ -1,7 +1,5 @@
 module Consequence
   class Monad
-    include Contracts
-
     def self.[](value)
       new(value)
     end
@@ -12,58 +10,44 @@ module Consequence
 
     attr_reader :value
 
-    # >>
-    #########
-    Contract Symbol => Monad
-    define_method(:>>) { |symbol| wrap(vbind(symbol.to_proc)) }
-
-    Contract Func[Not[Monad] => Not[Monad]] => Monad
-    define_method(:>>) { |proc| wrap(vbind(proc)) }
-
-    Contract Func[Not[Monad] => Monad] => Monad
-    define_method(:>>) { |proc| vbind(proc) }
-
-    Contract Func[Monad => Monad] => Monad
-    define_method(:>>) { |proc| bind(proc) }
-
-    Contract Func[Monad => Not[Monad]] => Monad
-    define_method(:>>) { |proc| wrap(bind(proc)) }
-
-    # <<
-    #########
-    Contract Symbol => Monad
-    define_method(:<<) { |symbol| vbind(symbol.to_proc); self }
-
-    Contract Func[Not[Monad] => Any] => Monad
-    define_method(:<<) { |proc| vbind(proc); self }
+    def >>(proc)
+      wrap(bind(proc.to_proc))
+    end
 
-    Contract Func[Monad => Any] => Monad
-    define_method(:<<) { |proc| bind(proc); self }
+    def <<(proc)
+      bind(proc.to_proc)
+      self
+    end
 
     def ==(other)
       self.class == other.class && value == other.value
     end
 
     def to_s
-      "#{self.class}[#{value}]"
+      value.to_s
     end
 
     def inspect
-        to_s
+      "#{self.class}[#{value}]"
     end
 
     private
 
     def bind(proc)
-      proc.call(self)
+      proc.call(*args_for(proc))
     end
 
-    def vbind(proc)
-      proc.call(value)
+    def args_for(proc)
+      proc.arity.abs == 1 ? [value] : [value, self]
     end
 
     def wrap(value)
-      self.class[value]
+      value.is_a?(Monad) ? value : self.class[value]
     end
   end
+
+  class NullMonad < Monad
+    def >>(_); self end
+    def <<(_); self end
+  end
 end

data/lib/consequence/something.rb

@@ -0,0 +1,12 @@
+module Consequence
+  class Something < Monad
+    def >>(proc)
+      result = super
+      result.value.nil? ? Nothing[nil] : result
+    end
+  end
+
+  class Nothing < NullMonad
+    def nil?; true end
+  end
+end

data/lib/consequence/success.rb

@@ -15,4 +15,9 @@ module Consequence
     def succeeded?; true end
     def failed?; false end
   end
+
+  class Failure < NullMonad
+    def succeeded?; false end
+    def failed?; true end
+  end
 end

data/lib/consequence/utils.rb

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

data/lib/consequence.rb

@@ -1,12 +1,6 @@
-require 'contracts'
-
 module Consequence
-  def self.included(base)
-    base.include(Contracts)
-  end
 end
 
 require 'consequence/monad'
-require 'consequence/failure'
 require 'consequence/success'
-require 'consequence/option'
+require 'consequence/something'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: consequence
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Max White
@@ -10,26 +10,6 @@ bindir: bin
 cert_chain: []
 date: 2015-01-14 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: contracts
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.4'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.4.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.4'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.4.0
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -59,10 +39,10 @@ files:
 - LICENSE.txt
 - README.md
 - lib/consequence.rb
-- lib/consequence/failure.rb
 - lib/consequence/monad.rb
-- lib/consequence/option.rb
+- lib/consequence/something.rb
 - lib/consequence/success.rb
+- lib/consequence/utils.rb
 homepage: 
 licenses:
 - MIT
@@ -86,5 +66,5 @@ rubyforge_project:
 rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
-summary: Monad implementation to used in with contracts.ruby
+summary: Simple monad implementation with clear and consistent syntax.
 test_files: []

data/lib/consequence/failure.rb

@@ -1,8 +0,0 @@
-module Consequence
-  class Failure < Monad
-    def >>(_); self end
-    def <<(_); self end
-    def succeeded?; false end
-    def failed?; true end
-  end
-end

data/lib/consequence/option.rb

@@ -1,13 +0,0 @@
-module Consequence
-  class Option < Monad
-    def >>(proc)
-      value ? super : self
-    end
-
-    def <<(proc)
-      super if value
-    end
-
-    def nil?; value.nil? end
-  end
-end