monads 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 992bed3108c9bd2b84cef78ba21bd99f56f52b88
-  data.tar.gz: 58c6f72fcf8c4c29caf1311462bc448c84f510aa
+  metadata.gz: 87404c6f7a69fed0181330dcaefafe2760574f36
+  data.tar.gz: 210ed8c40e603d2e0e9d13151170c37ab83443c2
 SHA512:
-  metadata.gz: 784a2a5bf9c923501d4f20c41c955ebd6d0b0252574c02714e1c0811d197a5fc0d51d87bef0e731982a56c26277eb7f180230714e8779164162b93b2922b477c
-  data.tar.gz: 83c250b59b392cb1f13613cac33dd4a80a5307a65be72f0251ed021c3b7205f8b6f81f3cb9d816ec300dff60c68df0b60af91e506a77f388df22b13cdcefa289
+  metadata.gz: 42898713212d672e5a774693ea259b1a62c2a274442cf141ab8bc1c97a85a7d8892589e62a480d5d437b7e6f78bfe22f60bceaa5bc50ff1b67ecc2bc9ce4989f
+  data.tar.gz: 43306a7166f3a1a653d2dfb8461bde9d8b4583a0c6ce08bba3b506147e5ebeecac4e5a41868a6d201e101fea4d21cab2ff9b679983cd6a50e23b80688bfef07c

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+rvm:
+  - 1.9.2
+  - 1.9.3
+  - 2.0.0
+  - 2.1.8
+  - 2.2.4
+  - 2.3.0
+script: bundle exec rspec
+before_install:
+  - gem install bundler

data/README.md

@@ -0,0 +1,98 @@
+# Monads
+
+[![Build Status](https://travis-ci.org/tomstuart/monads.svg?branch=master)](https://travis-ci.org/tomstuart/monads)
+
+This library provides simple Ruby implementations of some common [monads](http://en.wikipedia.org/wiki/Monad_(functional_programming)).
+
+The most important method of each implementation is `#and_then` (a.k.a. `bind` or `>>=`), which is used to connect together a sequence of operations involving the value(s) inside the monad. Each monad also has a `.from_value` class method (a.k.a. `return` or `unit`) for constructing an instance of that monad from an arbitrary value.
+
+## `Optional`
+
+(a.k.a. the [maybe monad](http://en.wikipedia.org/wiki/Monad_%28functional_programming%29#The_Maybe_monad))
+
+An `Optional` object contains a value that might be `nil`.
+
+```irb
+>> require 'monads/optional'
+=> true
+
+>> include Monads
+=> Object
+
+>> optional_string = Optional.new('hello world')
+=> #<struct Monads::Optional value="hello world">
+
+>> optional_result = optional_string.and_then { |string| Optional.new(string.upcase) }
+=> #<struct Monads::Optional value="HELLO WORLD">
+
+>> optional_result.value
+=> "HELLO WORLD"
+
+>> optional_string = Optional.new(nil)
+=> #<struct Monads::Optional value=nil>
+
+>> optional_result = optional_string.and_then { |string| Optional.new(string.upcase) }
+=> #<struct Monads::Optional value=nil>
+
+>> optional_result.value
+=> nil
+```
+
+## `Many`
+
+(a.k.a. the [list monad](http://en.wikipedia.org/wiki/Monad_%28functional_programming%29#Collections))
+
+A `Many` object contains multiple values.
+
+```irb
+>> require 'monads/many'
+=> true
+
+>> include Monads
+=> Object
+
+>> many_strings = Many.new(['hello world', 'goodbye world'])
+=> #<struct Monads::Many values=["hello world", "goodbye world"]>
+
+>> many_results = many_strings.and_then { |string| Many.new(string.split(/ /)) }
+=> #<struct Monads::Many values=["hello", "world", "goodbye", "world"]>
+
+>> many_results.values
+=> ["hello", "world", "goodbye", "world"]
+```
+
+## `Eventually`
+
+(a.k.a. the [continuation monad](http://en.wikipedia.org/wiki/Monad_%28functional_programming%29#Continuation_monad))
+
+An `Eventually` object contains a value that will eventually be available, perhaps as the result of an asynchronous process (e.g. a network request).
+
+```irb
+>> require 'monads/eventually'
+=> true
+
+>> include Monads
+=> Object
+
+>> eventually_string = Eventually.new do |success|
+     Thread.new do
+       sleep 5
+       success.call('hello world')
+     end
+   end
+=> #<struct Monads::Eventually block=#<Proc>>
+
+>> eventually_result = eventually_string.and_then do |string|
+     Eventually.new do |success|
+       Thread.new do
+         sleep 5
+         success.call(string.upcase)
+       end
+     end
+   end
+=> #<struct Monads::Eventually block=#<Proc>>
+
+>> eventually_result.run { |string| puts string }
+=> #<Thread run>
+HELLO WORLD
+```

data/lib/monads/eventually.rb

@@ -1,11 +1,13 @@
 require 'monads/monad'
 
 module Monads
-  Eventually = Struct.new(:block) do
+  class Eventually
     include Monad
 
+    attr_reader :block
+
     def initialize(&block)
-      super(block)
+      @block = block
     end
 
     def run(&success)
@@ -22,6 +24,10 @@ module Monads
       end
     end
 
+    def respond_to_missing?(method_name, include_private = false)
+      super || run { |value| value.respond_to?(method_name, include_private) }
+    end
+
     def self.from_value(value)
       Eventually.new do |success|
         success.call(value)

data/lib/monads/many.rb

@@ -1,15 +1,25 @@
 require 'monads/monad'
 
 module Monads
-  Many = Struct.new(:values) do
+  class Many
     include Monad
 
+    attr_reader :values
+
+    def initialize(values)
+      @values = values
+    end
+
     def and_then(&block)
       block = ensure_monadic_result(&block)
 
       Many.new(values.map(&block).flat_map(&:values))
     end
 
+    def respond_to_missing?(method_name, include_private = false)
+      super || values.all? { |value| value.respond_to?(method_name, include_private) }
+    end
+
     def self.from_value(value)
       Many.new([value])
     end

data/lib/monads/monad.rb

@@ -17,7 +17,7 @@ module Monads
     def ensure_monadic_result(&block)
       acceptable_result_type = self.class
 
-      -> *a, &b do
+      ->(*a, &b) do
         block.call(*a, &b).tap do |result|
           unless result.is_a?(acceptable_result_type)
             raise TypeError, "block must return #{acceptable_result_type.name}"

data/lib/monads/optional.rb

@@ -1,9 +1,15 @@
 require 'monads/monad'
 
 module Monads
-  Optional = Struct.new(:value) do
+  class Optional
     include Monad
 
+    attr_reader :value
+
+    def initialize(value)
+      @value = value
+    end
+
     def and_then(&block)
       block = ensure_monadic_result(&block)
 
@@ -14,6 +20,10 @@ module Monads
       end
     end
 
+    def respond_to_missing?(method_name, include_private = false)
+      super || value.nil? || value.respond_to?(method_name, include_private)
+    end
+
     def self.from_value(value)
       Optional.new(value)
     end

data/lib/monads/version.rb

@@ -1,3 +1,3 @@
 module Monads
-  VERSION = '0.0.1'
+  VERSION = '0.1.0'
 end

data/spec/monads/eventually_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'monads/eventually'
 
 module Monads
@@ -107,6 +109,37 @@ module Monads
         Eventually.new { |success| success.call(value) }.challenge.run { |result| @result = result }
         expect(@result).to eq response
       end
+
+      context 'when the value responds to the message' do
+        it 'reports that the Eventually responds to the message' do
+          expect(Eventually.new { |success| success.call(value) }).to respond_to(:challenge)
+        end
+
+        it 'allows a Method object to be retrieved' do
+          expect(Eventually.new { |success| success.call(value) }.method(:challenge)).to be_a(Method)
+        end
+      end
+
+      context 'when the value doesn’t respond to the message' do
+        it 'reports that the Eventually doesn’t respond to the message' do
+          expect(Eventually.new { |success| success.call(double) }).not_to respond_to(:challenge)
+        end
+
+        it 'doesn’t allow a Method object to be retrieved' do
+          expect { Eventually.new { |success| success.call(double) }.method(:challenge) }.to raise_error(NameError)
+        end
+      end
+
+      context 'when value is Enumerable' do
+        let(:value) { [1, 2, 3] }
+
+        it 'forwards any unrecognised message to the value' do
+          expect(Eventually.new { |success| success.call(value) }.first).to be_a(Eventually)
+          expect(Eventually.new { |success| success.call(value) }.first.run { |value| value }).to eq 1
+          expect(Eventually.new { |success| success.call(value) }.last).to be_a(Eventually)
+          expect(Eventually.new { |success| success.call(value) }.last.run { |value| value }).to eq 3
+        end
+      end
     end
   end
 end

data/spec/monads/many_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'monads/many'
 
 module Monads
@@ -90,6 +92,39 @@ module Monads
       it 'returns the messages’ results wrapped in a Many' do
         expect(many.challenge.values).to eq responses
       end
+
+      context 'when all of the values respond to the message' do
+        it 'reports that the Many responds to the message' do
+          expect(many).to respond_to(:challenge)
+        end
+
+        it 'allows a Method object to be retrieved' do
+          expect(many.method(:challenge)).to be_a(Method)
+        end
+      end
+
+      context 'when any of the values don’t respond to the message' do
+        let(:many) { Many.new(values + [double]) }
+
+        it 'reports that the Many doesn’t respond to the message' do
+          expect(many).not_to respond_to(:challenge)
+        end
+
+        it 'doesn’t allow a Method object to be retrieved' do
+          expect { many.method(:challenge) }.to raise_error(NameError)
+        end
+      end
+
+      context 'when values are Enumerable' do
+        let(:values) { [[1, 2], [3, 5]] }
+
+        it 'forwards any unrecognised message to the value' do
+          expect(many.first).to be_a(Many)
+          expect(many.first.values).to eq [1, 3]
+          expect(many.last).to be_a(Many)
+          expect(many.last.values).to eq [2, 5]
+        end
+      end
     end
   end
 end

data/spec/monads/optional_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'monads/optional'
 
 module Monads
@@ -92,6 +94,39 @@ module Monads
       it 'returns the message’s result wrapped in an Optional' do
         expect(optional.challenge.value).to eq response
       end
+
+      context 'when the value responds to the message' do
+        it 'reports that the Optional responds to the message' do
+          expect(optional).to respond_to(:challenge)
+        end
+
+        it 'allows a Method object to be retrieved' do
+          expect(optional.method(:challenge)).to be_a(Method)
+        end
+      end
+
+      context 'when the value doesn’t respond to the message' do
+        let(:optional) { Optional.new(double) }
+
+        it 'reports that the Optional doesn’t respond to the message' do
+          expect(optional).not_to respond_to(:challenge)
+        end
+
+        it 'doesn’t allow a Method object to be retrieved' do
+          expect { optional.method(:challenge) }.to raise_error(NameError)
+        end
+      end
+
+      context 'when value is Enumerable' do
+        let(:value) { [1, 2, 3] }
+
+        it 'forwards any unrecognised message to the value' do
+          expect(optional.first).to be_a(Optional)
+          expect(optional.first.value).to eq 1
+          expect(optional.last).to be_a(Optional)
+          expect(optional.last.value).to eq 3
+        end
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: monads
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Tom Stuart
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-02 00:00:00.000000000 Z
+date: 2016-02-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -38,8 +38,10 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
+- README.md
 - lib/monads.rb
 - lib/monads/eventually.rb
 - lib/monads/many.rb
@@ -71,7 +73,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Simple Ruby implementations of some common monads.