monads 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 992bed3108c9bd2b84cef78ba21bd99f56f52b88
+  data.tar.gz: 58c6f72fcf8c4c29caf1311462bc448c84f510aa
+SHA512:
+  metadata.gz: 784a2a5bf9c923501d4f20c41c955ebd6d0b0252574c02714e1c0811d197a5fc0d51d87bef0e731982a56c26277eb7f180230714e8779164162b93b2922b477c
+  data.tar.gz: 83c250b59b392cb1f13613cac33dd4a80a5307a65be72f0251ed021c3b7205f8b6f81f3cb9d816ec300dff60c68df0b60af91e506a77f388df22b13cdcefa289

data/.gitignore

@@ -0,0 +1 @@
+Gemfile.lock

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--warnings
+--require spec_helper

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org/'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Tom Stuart
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/monads.rb

@@ -0,0 +1,4 @@
+require 'monads/eventually'
+require 'monads/many'
+require 'monads/optional'
+require 'monads/version'

data/lib/monads/eventually.rb

@@ -0,0 +1,31 @@
+require 'monads/monad'
+
+module Monads
+  Eventually = Struct.new(:block) do
+    include Monad
+
+    def initialize(&block)
+      super(block)
+    end
+
+    def run(&success)
+      block.call(success)
+    end
+
+    def and_then(&block)
+      block = ensure_monadic_result(&block)
+
+      Eventually.new do |success|
+        run do |value|
+          block.call(value).run(&success)
+        end
+      end
+    end
+
+    def self.from_value(value)
+      Eventually.new do |success|
+        success.call(value)
+      end
+    end
+  end
+end

data/lib/monads/many.rb

@@ -0,0 +1,17 @@
+require 'monads/monad'
+
+module Monads
+  Many = Struct.new(:values) do
+    include Monad
+
+    def and_then(&block)
+      block = ensure_monadic_result(&block)
+
+      Many.new(values.map(&block).flat_map(&:values))
+    end
+
+    def self.from_value(value)
+      Many.new([value])
+    end
+  end
+end

data/lib/monads/monad.rb

@@ -0,0 +1,29 @@
+module Monads
+  module Monad
+    def within(&block)
+      and_then do |value|
+        self.class.from_value(block.call(value))
+      end
+    end
+
+    def method_missing(*args, &block)
+      within do |value|
+        value.public_send(*args, &block)
+      end
+    end
+
+    private
+
+    def ensure_monadic_result(&block)
+      acceptable_result_type = self.class
+
+      -> *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}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/monads/optional.rb

@@ -0,0 +1,21 @@
+require 'monads/monad'
+
+module Monads
+  Optional = Struct.new(:value) do
+    include Monad
+
+    def and_then(&block)
+      block = ensure_monadic_result(&block)
+
+      if value.nil?
+        self
+      else
+        block.call(value)
+      end
+    end
+
+    def self.from_value(value)
+      Optional.new(value)
+    end
+  end
+end

data/lib/monads/version.rb

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

data/monads.gemspec

@@ -0,0 +1,19 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'monads/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'monads'
+  spec.version       = Monads::VERSION
+  spec.author        = 'Tom Stuart'
+  spec.email         = 'tom@codon.com'
+  spec.summary       = 'Simple Ruby implementations of some common monads.'
+  spec.homepage      = 'https://github.com/tomstuart/monads'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'rspec', '~> 3.0', '>= 3.0.0'
+end

data/spec/monads/eventually_spec.rb

@@ -0,0 +1,112 @@
+require 'monads/eventually'
+
+module Monads
+  RSpec.describe 'the Eventually monad' do
+    describe '#run' do
+      it 'runs the block from an Eventually' do
+        expect { |block| Eventually.new(&block).run }.to yield_control
+      end
+
+      it 'uses its block argument as a success callback' do
+        @result, result = nil, double
+        Eventually.new { |success| success.call(result) }.run { |value| @result = value }
+        expect(@result).to eq result
+      end
+    end
+
+    describe '#and_then' do
+      context 'when the Eventually succeeds synchronously' do
+        it 'arranges for the block to run when the Eventually succeeds' do
+          @result, intermediate_result, final_result = nil, double, double
+          Eventually.new { |success| success.call(intermediate_result) }.
+            and_then do |value|
+              if value == intermediate_result
+                Eventually.new { |success| success.call(final_result) }
+              end
+            end.
+            run { |value| @result = value }
+          expect(@result).to eq final_result
+        end
+
+        it 'raises an error if the block doesn’t return another Eventually' do
+          expect { Eventually.new { |success| success.call }.and_then { double }.run }.to raise_error(TypeError)
+        end
+      end
+
+      context 'when the Eventually succeds asynchronously' do
+        it 'arranges for the block to run when the Eventually succeeds' do
+          @result, intermediate_result, final_result = nil, double, double
+          Eventually.new { |success| @job = -> { success.call(intermediate_result) } }.
+            and_then do |value|
+              if value == intermediate_result
+                Eventually.new { |success| success.call(final_result) }
+              end
+            end.
+            run { |value| @result = value }
+          @job.call
+          expect(@result).to eq final_result
+        end
+
+        it 'raises an error if the block doesn’t return another Eventually' do
+          expect {
+            Eventually.new { |success| @job = -> { success.call } }.and_then { double }.run
+            @job.call
+          }.to raise_error(TypeError)
+        end
+      end
+    end
+
+    describe '.from_value' do
+      let(:value) { double }
+
+      it 'wraps a value in an Eventually' do
+        @result = nil
+        Eventually.from_value(value).run { |value| @result = value }
+        expect(@result).to eq value
+      end
+    end
+
+    describe '#within' do
+      context 'when the Eventually succeeds synchronously' do
+        it 'arranges for the block to run when the Eventually succeeds' do
+          @result, intermediate_result, final_result = nil, double, double
+          Eventually.new { |success| success.call(intermediate_result) }.
+            within { |value| final_result if value == intermediate_result }.
+            run { |value| @result = value }
+          expect(@result).to eq final_result
+        end
+      end
+
+      context 'when the Eventually succeds asynchronously' do
+        it 'arranges for the block to run when the Eventually succeeds' do
+          @result, intermediate_result, final_result = nil, double, double
+          Eventually.new { |success| @job = -> { success.call(intermediate_result) } }.
+            within { |value| final_result if value == intermediate_result }.
+            run { |value| @result = value }
+          @job.call
+          expect(@result).to eq final_result
+        end
+      end
+    end
+
+    describe 'handling unrecognised messages' do
+      let(:value) { double }
+      let(:response) { double }
+
+      before(:example) do
+        allow(value).to receive(:challenge).and_return(response)
+      end
+
+      it 'forwards any unrecognised message to the block’s value' do
+        expect(value).to receive(:challenge)
+        Eventually.new { |success| success.call(value) }.challenge.run {}
+      end
+
+      it 'returns the message’s result wrapped in an Eventually' do
+        @result = nil
+        Eventually.new { |success| success.call(value) }.challenge.run { |result| @result = result }
+        expect(@result).to eq response
+      end
+    end
+  end
+end

data/spec/monads/many_spec.rb

@@ -0,0 +1,95 @@
+require 'monads/many'
+
+module Monads
+  RSpec.describe 'the Many monad' do
+    let(:many) { Many.new(values) }
+
+    describe '#values' do
+      let(:values) { double }
+
+      it 'retrieves the values from a Many' do
+        expect(many.values).to eq values
+      end
+    end
+
+    describe '#and_then' do
+      context 'when there aren’t any values' do
+        let(:values) { [] }
+
+        it 'doesn’t call the block' do
+          expect { |block| many.and_then(&block) }.not_to yield_control
+        end
+      end
+
+      context 'when there are values' do
+        let(:values) { [1, 2, 3] }
+
+        it 'calls the block with each value' do
+          @values = []
+          many.and_then { |value| @values << value; Many.new(double) }
+          expect(@values).to eq values
+        end
+
+        it 'returns a flattened version of the block’s results' do
+          expect(many.and_then { |value| Many.new(value * 2) }.values).to eq [2, 4, 6]
+        end
+
+        it 'raises an error if the block doesn’t return another Many' do
+          expect { many.and_then { double } }.to raise_error(TypeError)
+        end
+      end
+    end
+
+    describe '.from_value' do
+      let(:value) { double }
+
+      it 'wraps a value in a Many' do
+        expect(Many.from_value(value).values).to eq [value]
+      end
+    end
+
+    describe '#within' do
+      context 'when there aren’t any values' do
+        let(:values) { [] }
+
+        it 'doesn’t call the block' do
+          expect { |block| many.within(&block) }.not_to yield_control
+        end
+      end
+
+      context 'when there are values' do
+        let(:values) { [1, 2, 3] }
+
+        it 'calls the block with each value' do
+          expect { |block| many.within(&block) }.to yield_successive_args(*values)
+        end
+
+        it 'returns a flattened version of the block’s results wrapped in a Many' do
+          expect(many.within { |value| value * 2 }.values).to eq [2, 4, 6]
+        end
+      end
+    end
+
+    describe 'handling unrecognised messages' do
+      let(:values) { [double, double, double] }
+      let(:responses) { [double, double, double] }
+
+      before(:example) do
+        values.zip(responses) do |value, response|
+          allow(value).to receive(:challenge).and_return(response)
+        end
+      end
+
+      it 'forwards any unrecognised message to each value' do
+        values.each do |value|
+          expect(value).to receive(:challenge)
+        end
+        many.challenge
+      end
+
+      it 'returns the messages’ results wrapped in a Many' do
+        expect(many.challenge.values).to eq responses
+      end
+    end
+  end
+end

data/spec/monads/optional_spec.rb

@@ -0,0 +1,97 @@
+require 'monads/optional'
+
+module Monads
+  RSpec.describe 'the Optional monad' do
+    let(:value) { double }
+    let(:optional) { Optional.new(value) }
+
+    describe '#value' do
+      it 'retrieves the value from an Optional' do
+        expect(optional.value).to eq value
+      end
+    end
+
+    describe '#and_then' do
+      context 'when the value is nil' do
+        before(:example) do
+          allow(value).to receive(:nil?).and_return(true)
+        end
+
+        it 'doesn’t call the block' do
+          expect { |block| optional.and_then(&block) }.not_to yield_control
+        end
+      end
+
+      context 'when the value isn’t nil' do
+        before(:example) do
+          allow(value).to receive(:nil?).and_return(false)
+        end
+
+        it 'calls the block with the value' do
+          @value = nil
+          optional.and_then { |value| @value = value; Optional.new(double) }
+          expect(@value).to eq value
+        end
+
+        it 'returns the block’s result' do
+          result = double
+          expect(optional.and_then { |value| Optional.new(result) }.value).to eq result
+        end
+
+        it 'raises an error if the block doesn’t return another Optional' do
+          expect { optional.and_then { double } }.to raise_error(TypeError)
+        end
+      end
+    end
+
+    describe '.from_value' do
+      it 'wraps a value in an Optional' do
+        expect(Optional.from_value(value).value).to eq value
+      end
+    end
+
+    describe '#within' do
+      context 'when the value is nil' do
+        before(:example) do
+          allow(value).to receive(:nil?).and_return(true)
+        end
+
+        it 'doesn’t call the block' do
+          expect { |block| optional.within(&block) }.not_to yield_control
+        end
+      end
+
+      context 'when the value isn’t nil' do
+        before(:example) do
+          allow(value).to receive(:nil?).and_return(false)
+        end
+
+        it 'calls the block with the value' do
+          expect { |block| optional.within(&block) }.to yield_with_args(value)
+        end
+
+        it 'returns the block’s result wrapped in an Optional' do
+          result = double
+          expect(optional.within { result }.value).to eq result
+        end
+      end
+    end
+
+    describe 'handling unrecognised messages' do
+      let(:response) { double }
+
+      before(:example) do
+        allow(value).to receive(:challenge).and_return(response)
+      end
+
+      it 'forwards any unrecognised message to the value' do
+        expect(value).to receive(:challenge)
+        optional.challenge
+      end
+
+      it 'returns the message’s result wrapped in an Optional' do
+        expect(optional.challenge.value).to eq response
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+RSpec.configure do |config|
+  config.disable_monkey_patching!
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: monads
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Tom Stuart
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+description: 
+email: tom@codon.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- lib/monads.rb
+- lib/monads/eventually.rb
+- lib/monads/many.rb
+- lib/monads/monad.rb
+- lib/monads/optional.rb
+- lib/monads/version.rb
+- monads.gemspec
+- spec/monads/eventually_spec.rb
+- spec/monads/many_spec.rb
+- spec/monads/optional_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/tomstuart/monads
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Simple Ruby implementations of some common monads.
+test_files:
+- spec/monads/eventually_spec.rb
+- spec/monads/many_spec.rb
+- spec/monads/optional_spec.rb
+- spec/spec_helper.rb