monadist 0.1

data/.gitignore

@@ -0,0 +1,16 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+/.idea
+/.ruby-version

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.1.3

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in monadist.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Zoltan Ormandi
+
+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/README.md

@@ -0,0 +1,41 @@
+# Monadist
+
+A practical and useful Ruby implementation of a couple of popular monads.
+Method naming follows the Haskell convention so the gem can be used for trying to understand monads
+(mostly described in tutorials using Haskell).
+
+Monads implemented:
+
+* Identity (for educational purposes)
+* Maybe
+* List
+* Continuation
+* Meanwhile
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'monadist'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install monadist
+
+## Usage
+
+For examples on how to use these monads, please check out the [examples](https://github.com/zormandi/monadist/tree/master/examples) directory.
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/monadist/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,12 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+desc "Run RSpec code examples (options: RSPEC_SEED=seed)"
+RSpec::Core::RakeTask.new :spec do |task|
+  task.verbose = false
+  task.rspec_opts = "--format progress --order random"
+  task.rspec_opts << " --seed #{ENV['RSPEC_SEED']}" if ENV['RSPEC_SEED']
+end
+
+task :default => :spec
+

data/examples/continuation/github_fetch_original.rb

@@ -0,0 +1,48 @@
+require 'net/http'
+require 'json'
+require 'uri_template'
+
+
+
+def get_json(url, &success)
+  Thread.new do
+    puts "Reading from #{url}"
+    uri = URI url
+    json = Net::HTTP.start uri.host, uri.port, :use_ssl => uri.scheme == 'https' do |http|
+      http.request_get(uri.path).body
+    end
+    value = JSON.parse json
+    success.call value
+  end
+end
+
+
+
+get_json('https://api.github.com/') do |urls|
+  org_url_template = URITemplate.new(urls['organization_url'])
+  org_url = org_url_template.expand(org: 'ruby')
+
+  get_json(org_url) do |org|
+    repos_url = org['repos_url']
+
+    get_json(repos_url) do |repos|
+      most_popular_repo = repos.max_by { |repo| repo['watchers_count'] }
+      repo_url = most_popular_repo['url']
+
+      get_json(repo_url) do |repo|
+        contributors_url = repo['contributors_url']
+
+        get_json(contributors_url) do |users|
+          most_prolific_user = users.max_by { |user| user['contributions'] }
+          user_url = most_prolific_user['url']
+
+          get_json(user_url) do |user|
+            puts "The most influential Rubyist is #{user['name']} (#{user['login']})"
+          end
+        end
+      end
+    end
+  end
+end
+
+sleep(1) while Thread.list.count > 1

data/examples/continuation/github_fetch_refactored_continuation.rb

@@ -0,0 +1,124 @@
+require 'monadist'
+require 'net/http'
+require 'json'
+require 'uri_template'
+
+
+
+def get_json(url, &success)
+  Thread.new do
+    puts "Reading from #{url}"
+    uri = URI url
+    json = Net::HTTP.start uri.host, uri.port, :use_ssl => uri.scheme == 'https' do |http|
+      http.request_get(uri.path).body
+    end
+    value = JSON.parse json
+    success.call value
+  end
+end
+
+
+
+def get_github_api_urls
+  github_root_url = 'https://api.github.com/'
+
+  Monadist::Continuation.new { |success| get_json github_root_url, &success }
+end
+
+
+
+def get_org(urls, name)
+  org_url_template = URITemplate.new(urls['organization_url'])
+  org_url = org_url_template.expand(org: name)
+
+  Monadist::Continuation.new { |success| get_json org_url, &success }
+end
+
+
+
+def get_repos(org)
+  repos_url = org['repos_url']
+
+  Monadist::Continuation.new { |success| get_json repos_url, &success }
+end
+
+
+
+def get_most_popular_repo(repos)
+  most_popular_repo = repos.max_by { |repo| repo['watchers_count'] }
+  repo_url = most_popular_repo['url']
+
+  Monadist::Continuation.new { |success| get_json repo_url, &success }
+end
+
+
+
+def get_contributors(repo)
+  contributors_url = repo['contributors_url']
+
+  Monadist::Continuation.new { |success| get_json contributors_url, &success }
+end
+
+
+
+def get_most_prolific_user(contributors)
+  most_prolific_user = contributors.max_by { |user| user['contributions'] }
+  user_url = most_prolific_user['url']
+
+  Monadist::Continuation.new { |success| get_json user_url, &success }
+end
+
+
+
+Monadist::Continuation.new { |success| get_json 'https://api.github.com/', &success }.bind do |urls|
+  org_url_template = URITemplate.new(urls['organization_url'])
+  org_url = org_url_template.expand(org: 'ruby')
+
+  Monadist::Continuation.new { |success| get_json org_url, &success }.bind do |org|
+    repos_url = org['repos_url']
+
+    Monadist::Continuation.new { |success| get_json repos_url, &success }.bind do |repos|
+      most_popular_repo = repos.max_by { |repo| repo['watchers_count'] }
+      repo_url = most_popular_repo['url']
+
+      Monadist::Continuation.new { |success| get_json repo_url, &success }.bind do |repo|
+        contributors_url = repo['contributors_url']
+
+        Monadist::Continuation.new { |success| get_json contributors_url, &success }.bind do |users|
+          most_prolific_user = users.max_by { |user| user['contributions'] }
+          user_url = most_prolific_user['url']
+
+          Monadist::Continuation.new { |success| get_json user_url, &success }
+        end
+      end
+    end
+  end
+end.run do |user|
+  puts "The most influential Rubyist is #{user['name']} (#{user['login']})"
+end
+
+
+get_github_api_urls.bind do |urls|
+  get_org(urls, 'ruby').bind do |org|
+    get_repos(org).bind do |repos|
+      get_most_popular_repo(repos).bind do |repo|
+        get_contributors(repo).bind do |users|
+          get_most_prolific_user(users)
+        end
+      end
+    end
+  end
+end.run do |user|
+  puts "The most influential Rubyist is #{user['name']} (#{user['login']})"
+end
+
+
+get_github_api_urls.
+  bind { |urls| get_org urls, 'ruby' }.
+  bind { |org| get_repos org }.
+  bind { |repos| get_most_popular_repo repos }.
+  bind { |repo| get_contributors repo }.
+  bind { |contributors| get_most_prolific_user contributors }.
+  run { |user| puts "The most influential Rubyist is #{user['name']} (#{user['login']})" }
+
+sleep 0.1 while Thread.list.count > 1

data/examples/continuation/github_fetch_refactored_meanwhile.rb

@@ -0,0 +1,49 @@
+require 'monadist'
+require 'net/http'
+require 'json'
+require 'uri_template'
+
+
+
+def get_json(url)
+  puts "Reading from #{url}"
+  uri = URI url
+  json = Net::HTTP.start uri.host, uri.port, :use_ssl => uri.scheme == 'https' do |http|
+    http.request_get(uri.path).body
+  end
+  JSON.parse json
+end
+
+
+
+def get_org(urls, name)
+  org_url_template = URITemplate.new(urls['organization_url'])
+  get_json org_url_template.expand(org: name)
+end
+
+
+
+def get_most_popular_repo(repos)
+  most_popular_repo = repos.max_by { |repo| repo['watchers_count'] }
+  get_json most_popular_repo['url']
+end
+
+
+
+def get_most_prolific_user(contributors)
+  most_prolific_user = contributors.max_by { |user| user['contributions'] }
+  get_json most_prolific_user['url']
+end
+
+
+
+Monadist::Meanwhile.unit('https://api.github.com/').
+  fmap { |github_api_url| get_json github_api_url }.
+  fmap { |urls| get_org urls, 'ruby' }.
+  fmap { |org| get_json org['repos_url'] }.
+  fmap { |repos| get_most_popular_repo repos }.
+  fmap { |repo| get_json repo['contributors_url'] }.
+  fmap { |contributors| get_most_prolific_user contributors }.
+  run { |user| puts "The most influential Rubyist is #{user['name']} (#{user['login']})" }
+
+sleep 0.1 while Thread.list.count > 1

data/examples/general.rb

@@ -0,0 +1,27 @@
+require 'monadist'
+require 'monadist/shims'
+require 'json'
+
+nothing = possibly_nil nil
+maybe = possibly_nil '{"first_name":"Sam", "last_name":"Vimes"}'
+list = list '{"first_name":"Granny", "last_name":"Weatherwax"}', '{"first_name":"Nanny", "last_name":"Ogg"}'
+continuation = with '{"first_name":"Fred", "last_name":"Colon"}'
+meanwhile = meanwhile_with '{"first_name":"Nobby", "last_name":"Nobbs"}'
+
+
+
+def full_name(json_monad)
+  json_monad.
+    fmap { |json| JSON.parse json }.
+    fmap { |person| "#{person['first_name']} #{person['last_name']}" }
+end
+
+
+
+p full_name(nothing).value
+p full_name(maybe).value
+p full_name(list).values
+full_name(continuation).run { |full_name| p full_name }
+
+full_name(meanwhile).run { |full_name| p full_name }
+sleep 0.1 while Thread.list.count > 1

data/examples/identity.rb

@@ -0,0 +1,6 @@
+require 'monadist'
+
+puts Monadist::Identity.unit("Hello").
+  bind { |value| Monadist::Identity.unit value + " world!" }.
+  value
+

data/examples/list.rb

@@ -0,0 +1,65 @@
+require 'monadist'
+require 'monadist/shims'
+
+Blog = Struct.new :categories
+Category = Struct.new :posts
+Post = Struct.new :comments
+
+
+
+def words_in(blogs)
+  blogs.flat_map do |blog|
+    blog.categories.flat_map do |category|
+      category.posts.flat_map do |post|
+        post.comments.flat_map do |comment|
+          comment.split /\s+/
+        end
+      end
+    end
+  end
+end
+
+
+
+def words_in_list_bind(blogs)
+  Monadist::List.unit(blogs).
+    bind { |blog| Monadist::List.unit blog.categories }.
+    bind { |category| Monadist::List.unit category.posts }.
+    bind { |post| Monadist::List.unit post.comments }.
+    bind { |comment| Monadist::List.unit comment.split /\s+/ }.
+    values
+end
+
+
+
+def words_in_list_fmap(blogs)
+  Monadist::List.unit(blogs).
+    fmap { |blog| blog.categories }.
+    fmap { |category| category.posts }.
+    fmap { |post| post.comments }.
+    fmap { |comment| comment.split /\s+/ }.
+    values
+end
+
+
+
+def words_in_list_sugar(blogs)
+  list(blogs).categories.posts.comments.split(/\s+/).values
+end
+
+
+
+blogs = [
+  Blog.new([Category.new([Post.new(['I love cats', 'I love dogs']),
+                          Post.new(['I love mice', 'I love pigs'])]),
+            Category.new([Post.new(['I hate cats', 'I hate dogs']),
+                          Post.new(['I hate mice', 'I hate pigs'])])]),
+
+  Blog.new([Category.new([Post.new(['Red is better than blue'])]),
+            Category.new([Post.new(['Blue is better than red'])])])
+]
+
+p words_in(blogs)
+p words_in_list_bind(blogs)
+p words_in_list_fmap(blogs)
+p words_in_list_sugar(blogs)

data/examples/maybe.rb

@@ -0,0 +1,90 @@
+require 'monadist'
+require 'monadist/shims'
+require 'active_support/all'
+
+
+
+def lead_conversion_rate_history(customer_metrics)
+  customer_metrics[:lead][:conversion][:rate][:history]
+end
+
+
+
+def lead_conversion_rate_history_safe(customer_metrics)
+  unless customer_metrics.nil?
+    unless customer_metrics[:lead].nil?
+      unless customer_metrics[:lead][:conversion].nil?
+        unless customer_metrics[:lead][:conversion][:rate].nil?
+          unless customer_metrics[:lead][:conversion][:rate][:history].nil?
+            customer_metrics[:lead][:conversion][:rate][:history]
+          end
+        end
+      end
+    end
+  end
+end
+
+
+
+def lead_conversion_rate_history_fetch(customer_metrics)
+  customer_metrics ||= {}
+  customer_metrics.
+    fetch(:lead, {}).
+    fetch(:conversion, {}).
+    fetch(:rate, {}).
+    fetch(:history, nil)
+end
+
+
+
+def lead_conversion_rate_history_try(customer_metrics)
+  customer_metrics.
+    try { |metrics| metrics[:lead] }.
+    try { |lead_metrics| lead_metrics[:conversion] }.
+    try { |lead_conversion_metrics| lead_conversion_metrics[:rate] }.
+    try { |lead_conversion_rate_metrics| lead_conversion_rate_metrics[:history] }
+end
+
+
+
+def lead_conversion_rate_history_maybe_bind(customer_metrics)
+  Monadist::Maybe.unit(customer_metrics).
+    bind { |metrics| Monadist::Maybe.unit(metrics[:lead]) }.
+    bind { |lead_metrics| Monadist::Maybe.unit(lead_metrics[:conversion]) }.
+    bind { |lead_conversion_metrics| Monadist::Maybe.unit(lead_conversion_metrics[:rate]) }.
+    bind { |lead_conversion_rate_metrics| Monadist::Maybe.unit(lead_conversion_rate_metrics[:history]) }.
+    value
+end
+
+
+
+def lead_conversion_rate_history_maybe_fmap(customer_metrics)
+  Monadist::Maybe.unit(customer_metrics).
+    fmap { |metrics| metrics[:lead] }.
+    fmap { |lead_metrics| lead_metrics[:conversion] }.
+    fmap { |lead_conversion_metrics| lead_conversion_metrics[:rate] }.
+    fmap { |lead_conversion_rate_metrics| lead_conversion_rate_metrics[:history] }.
+    value
+end
+
+
+
+def lead_conversion_rate_history_maybe_sugar(customer_metrics)
+  possibly_nil(customer_metrics)[:lead][:conversion][:rate][:history].value
+end
+
+
+
+customer_metrics = {
+  lead: {
+    conversion: {}
+  }
+}
+
+# p lead_conversion_rate_history customer_metrics
+p lead_conversion_rate_history_safe customer_metrics
+p lead_conversion_rate_history_fetch customer_metrics
+p lead_conversion_rate_history_try customer_metrics
+p lead_conversion_rate_history_maybe_bind customer_metrics
+p lead_conversion_rate_history_maybe_fmap customer_metrics
+p lead_conversion_rate_history_maybe_sugar customer_metrics

data/lib/monadist/continuation.rb

@@ -0,0 +1,31 @@
+module Monadist
+  class Continuation < Monad
+
+    def initialize(&block)
+      @block = block
+    end
+
+
+
+    def bind(&block)
+      self.class.new do |next_block|
+        run do |value|
+          block.call(value).run(&next_block)
+        end
+      end
+    end
+
+
+
+    def run(&block)
+      @block.call(block || lambda { |value| value })
+    end
+
+
+
+    def self.unit(value)
+      new { |next_block| next_block.call value }
+    end
+
+  end
+end

data/lib/monadist/identity.rb

@@ -0,0 +1,25 @@
+module Monadist
+  class Identity < Monad
+
+    attr_reader :value
+
+
+
+    def initialize(value)
+      @value = value
+    end
+
+
+
+    def bind(&block)
+      block.call value
+    end
+
+
+
+    def self.unit(value)
+      new value
+    end
+
+  end
+end

data/lib/monadist/list.rb

@@ -0,0 +1,29 @@
+module Monadist
+  class List < Monad
+
+    attr_reader :values
+
+
+
+    def initialize(values)
+      @values = values
+    end
+
+
+
+    def bind(&block)
+      self.class.new values.map(&block).flat_map(&:values)
+    end
+
+
+
+    def self.unit(value)
+      if value.is_a? Array
+        new value
+      else
+        new [value]
+      end
+    end
+
+  end
+end

data/lib/monadist/maybe.rb

@@ -0,0 +1,27 @@
+module Monadist
+  class Maybe < Monad
+
+    attr_reader :value
+
+
+
+    def initialize(value)
+      @value = value
+    end
+
+
+
+    def bind(&block)
+      return self if value.nil?
+
+      block.call value
+    end
+
+
+
+    def self.unit(value)
+      new value
+    end
+
+  end
+end

data/lib/monadist/meanwhile.rb

@@ -0,0 +1,15 @@
+module Monadist
+  class Meanwhile < Continuation
+
+    def bind(&block)
+      self.class.new do |next_block|
+        Thread.new do
+          run do |value|
+            block.call(value).run(&next_block)
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/monadist/monad.rb

@@ -0,0 +1,24 @@
+module Monadist
+  class Monad
+
+    def join
+      bind do |value|
+        raise "Wrapped value not a monad of type #{self.class.name}" unless value.instance_of? self.class
+        value
+      end
+    end
+
+
+
+    def fmap(&block)
+      bind { |value| self.class.unit block.call value }
+    end
+
+
+
+    def method_missing(*args, &block)
+      fmap { |value| value.public_send *args, &block }
+    end
+
+  end
+end

data/lib/monadist/shims.rb

@@ -0,0 +1,21 @@
+def possibly_nil(value)
+  Monadist::Maybe.unit value
+end
+
+
+
+def list(*values)
+  Monadist::List.unit *values
+end
+
+
+
+def with(value)
+  Monadist::Continuation.unit value
+end
+
+
+
+def meanwhile_with(value)
+  Monadist::Meanwhile.unit value
+end

data/lib/monadist/version.rb

@@ -0,0 +1,3 @@
+module Monadist
+  VERSION = '0.1'
+end

data/lib/monadist.rb

@@ -0,0 +1,7 @@
+require 'monadist/version'
+require 'monadist/monad'
+require 'monadist/identity'
+require 'monadist/maybe'
+require 'monadist/list'
+require 'monadist/continuation'
+require 'monadist/meanwhile'

data/monadist.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'monadist/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "monadist"
+  spec.version       = Monadist::VERSION
+  spec.authors       = ["Zoltan Ormandi"]
+  spec.email         = ["zoltan.ormandi@gmail.com"]
+  spec.summary       = %q{Practical implementation of a couple of popular monads.}
+  spec.description   = %q{A practical and useful Ruby implementation of a couple of popular monads. Method naming follows the Haskell convention so the gem can be used for trying to understand monads (mostly described in tutorials using Haskell).}
+  spec.homepage      = "https://github.com/zormandi/monadist"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+end

data/spec/monadist/identity_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+module Monadist
+  describe Identity do
+
+    describe ".unit" do
+      it "returns a monad wrapping the specified value" do
+        result = Identity.unit "value"
+
+        expect(result).to be_an Identity
+        expect(result.value).to eq "value"
+      end
+    end
+
+
+    describe "#value" do
+      it "returns the value wrapped by the monad" do
+        expect(Identity.unit("value").value).to eq "value"
+      end
+    end
+
+
+    describe "#bind" do
+      it "calls the passed block with the value" do
+        expect { |block| Identity.unit("some value").bind &block }.to yield_with_args "some value"
+      end
+    end
+
+
+    it "allows sending messages directly to the wrapped value" do
+      result = Identity.unit("test").length
+
+      expect(result).to be_an Identity
+      expect(result.value).to eq 4
+    end
+
+  end
+end

data/spec/monadist/list_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+module Monadist
+  describe List do
+
+    describe ".unit" do
+      it "returns a monad wrapping the specified value" do
+        result = List.unit "value"
+
+        expect(result).to be_a List
+        expect(result.values).to eq ["value"]
+      end
+
+      it "treats arrays as a list of values (for convenience)" do
+        expect(List.unit(%w(value1 value2)).values).to eq %w[value1 value2]
+      end
+    end
+
+
+    describe "#values" do
+      it "returns the value(s) wrapped by the monad as an array" do
+        expect(List.unit("value").values).to eq %w[value]
+      end
+    end
+
+
+    describe "#bind" do
+      it "calls the passed block with each value wrapped by the monad and returns a monad wrapping the resulting values" do
+        subject = List.unit [1, 2, 3]
+
+        result = subject.bind { |value| List.unit(value * 10) }
+
+        expect(result).to be_a List
+        expect(result.values).to eq [10, 20, 30]
+      end
+
+      it "handles array values without flattening or nesting them" do
+        subject = List.unit [[1, 2], [3, 4]]
+
+        result = subject.bind { |value| List.unit [value] }
+
+        expect(result.values).to eq [[1, 2], [3, 4]]
+      end
+    end
+
+
+    it "forwards messages to all the values it contains" do
+      subject = List.unit %w[HTTP_HOST HTTP_CONTENT_TYPE HTTP_DATE]
+
+      expect(subject[5..-1].tr("_", "-").capitalize.values).to eq %w[Host Content-type Date]
+    end
+
+  end
+end

data/spec/monadist/maybe_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+module Monadist
+  describe Maybe do
+
+    describe ".unit" do
+      it "returns a monad wrapping the specified value" do
+        result = Maybe.unit "value"
+
+        expect(result).to be_a Maybe
+        expect(result.value).to eq "value"
+      end
+    end
+
+
+    describe "#value" do
+      it "returns the value wrapped by the monad" do
+        expect(Maybe.unit("value").value).to eq "value"
+      end
+    end
+
+
+    describe "#bind" do
+      context "when wrapping nil" do
+        subject { Maybe.unit nil }
+
+        it "doesn't execute the passed block" do
+          expect { |block| subject.bind &block }.not_to yield_control
+        end
+
+        it "returns a monad wrapping nil" do
+          result = subject.bind {}
+
+          expect(result).to be_a Maybe
+          expect(result.value).to be_nil
+        end
+      end
+
+      context "when wrapping a non-nil value" do
+        subject { Maybe.unit "some value" }
+
+        it "calls the passed block with the value" do
+          expect { |block| subject.bind &block }.to yield_with_args "some value"
+        end
+
+        it "returns the block's result" do
+          result = subject.bind { |_| Maybe.unit "new value" }
+
+          expect(result).to be_a Maybe
+          expect(result.value).to eq "new value"
+        end
+      end
+    end
+
+
+    context "when wrapping a non-nil value" do
+      it "forwards messages directly to the wrapped value and returns a monad wrapping the result" do
+        result = Maybe.unit("test").length
+
+        expect(result).to be_a Maybe
+        expect(result.value).to eq 4
+      end
+    end
+
+
+    context "when wrapping nil" do
+      it "disregards all messages and returns a monad wrapping nil" do
+        result = Maybe.unit(nil).concat('some')[:property] + 1
+
+        expect(result).to be_a Maybe
+        expect(result.value).to be_nil
+      end
+    end
+
+  end
+end

data/spec/monadist_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Monadist do
+  it 'should have a version number' do
+    expect(Monadist::VERSION).to eq '0.1'
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'monadist'

data/spec/support/shared_examples_for_monad.rb

@@ -0,0 +1,27 @@
+RSpec.shared_examples "a monad" do
+
+  let(:test_value) { "test value" }
+  let(:f) { ->(value) { described_class.unit "f#{value}" } }
+  let(:g) { ->(value) { described_class.unit "g#{value}" } }
+
+  subject { described_class.unit test_value }
+
+
+  it "should obey the 1st monad law" do
+    expect(subject.bind &f).to eq f.call(test_value)
+  end
+
+
+  it "should obey the 2nd monad law" do
+    expect(subject.bind { |value| described_class.unit value }).to eq subject
+  end
+
+
+  it "should obey the 3rd monad law" do
+    chained_result = subject.bind { |value| f.call value }.bind { |value| g.call value }
+    nested_result = subject.bind { |v1| f.call(v1).bind { |v2| g.call v2 } }
+
+    expect(nested_result).to eq chained_result
+  end
+
+end

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: monadist
+version: !ruby/object:Gem::Version
+  version: '0.1'
+  prerelease: 
+platform: ruby
+authors:
+- Zoltan Ormandi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A practical and useful Ruby implementation of a couple of popular monads.
+  Method naming follows the Haskell convention so the gem can be used for trying to
+  understand monads (mostly described in tutorials using Haskell).
+email:
+- zoltan.ormandi@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/continuation/github_fetch_original.rb
+- examples/continuation/github_fetch_refactored_continuation.rb
+- examples/continuation/github_fetch_refactored_meanwhile.rb
+- examples/general.rb
+- examples/identity.rb
+- examples/list.rb
+- examples/maybe.rb
+- lib/monadist.rb
+- lib/monadist/continuation.rb
+- lib/monadist/identity.rb
+- lib/monadist/list.rb
+- lib/monadist/maybe.rb
+- lib/monadist/meanwhile.rb
+- lib/monadist/monad.rb
+- lib/monadist/shims.rb
+- lib/monadist/version.rb
+- monadist.gemspec
+- spec/monadist/identity_spec.rb
+- spec/monadist/list_spec.rb
+- spec/monadist/maybe_spec.rb
+- spec/monadist_spec.rb
+- spec/spec_helper.rb
+- spec/support/shared_examples_for_monad.rb
+homepage: https://github.com/zormandi/monadist
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23.2
+signing_key: 
+specification_version: 3
+summary: Practical implementation of a couple of popular monads.
+test_files:
+- spec/monadist/identity_spec.rb
+- spec/monadist/list_spec.rb
+- spec/monadist/maybe_spec.rb
+- spec/monadist_spec.rb
+- spec/spec_helper.rb
+- spec/support/shared_examples_for_monad.rb