monad-maybe 0.9.8 → 0.9.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fef7ce0402b5feff827312b8645dbd2eab91f53d
-  data.tar.gz: 36151eaf207a65bd4381fb5f5cb688fb4583c5f0
+  metadata.gz: b4b9973bafaf3d9e728106f0ca22fcd9e1c6cc25
+  data.tar.gz: 30d80d184fe6500b0a428a00ebd1766cf59e7824
 SHA512:
-  metadata.gz: 1177314d02a6e6fa0a7378c526324fcc98e8108321d651e3b2c45325803f2b8c04cb17328811cfaa39ac430d609028297406bfa2e186e7c42b81ac7518d45164
-  data.tar.gz: d388ce7399eb3e078406559c891976b63cdcf31e573834c795bf037e6ee4e635fda292aa10422e0b65f3004788a58a4790778a35e36ae19912cd6d0de7e7b419
+  metadata.gz: 3a217e29d79862e5a2966c60ff653e12aafee6d6b96ac508b92f7eeec2cb6d617a5843f998f21b45966e9dee70d412ca0616591f7cc5eaf5ec028230e02797b2
+  data.tar.gz: 0976f7d7acb1d70d91a98034422d99fd00a6abb5159de54733e2cd1a5a58094c7721cd9f15114a464e7b7f66cbf7e2f92a98317c507d1564071a32b9b397a841

data/Gemfile

@@ -1,7 +1,7 @@
-source "http://rubygems.org"
-
-group :development do
-  gem 'jeweler'
-  gem 'yard'
-  gem 'test-unit'
-end
+source "http://rubygems.org"
+
+group :development do
+  gem 'jeweler'
+  gem 'yard'
+  gem 'test-unit'
+end

data/Gemfile.lock

@@ -1,24 +1,24 @@
-GEM
-  remote: http://rubygems.org/
-  specs:
-    git (1.2.5)
-    jeweler (1.8.4)
-      bundler (~> 1.0)
-      git (>= 1.2.5)
-      rake
-      rdoc
-    json (1.8.0)
-    rake (10.0.4)
-    rdoc (4.0.1)
-      json (~> 1.4)
-    test-unit (2.5.5)
-    yard (0.8.6.1)
-
-PLATFORMS
-  ruby
-  x86-mingw32
-
-DEPENDENCIES
-  jeweler
-  test-unit
-  yard
+GEM
+  remote: http://rubygems.org/
+  specs:
+    git (1.2.5)
+    jeweler (1.8.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+      rdoc
+    json (1.8.0)
+    rake (10.0.4)
+    rdoc (4.0.1)
+      json (~> 1.4)
+    test-unit (2.5.5)
+    yard (0.8.6.1)
+
+PLATFORMS
+  ruby
+  x86-mingw32
+
+DEPENDENCIES
+  jeweler
+  test-unit
+  yard

data/README.md

@@ -1,12 +1,12 @@
-`monad-maybe`
-=============
-
-An Implementation of Haskell's Maybe Mondad
--------------------------------------------
-
-This is an attempt to implement Haskell's Maybe monad in a Ruby-ish way with as little monkey patching as possible. 
-
-SEE ALSO
-========
-[andand](http://)
-[Haskell's Maybe Monad](http://)
+`monad-maybe`
+=============
+
+An Implementation of Haskell's Maybe Mondad
+-------------------------------------------
+
+This is an attempt to implement Haskell's Maybe monad in a Ruby-ish way with as little monkey patching as possible. 
+
+SEE ALSO
+========
+[andand](http://)
+[Haskell's Maybe Monad](http://)

data/Rakefile

@@ -1,24 +1,25 @@
-require 'rake/testtask'
-require 'jeweler'
-Jeweler::Tasks.new do |gem|
-  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
-  gem.name = "monad-maybe"
-  gem.summary = %Q{A Ruby implementation of Haskell's Maybe Monad}
-  gem.description = %Q{This is an attempt to implement Haskell's Maybe monad in a Ruby-ish way.}
-  gem.email = "delon.newman@gmail.com"
-  gem.homepage = "https://github.com/delonnewman/monad-maybe"
-  gem.authors = ["Delon Newman"]
-end
-Jeweler::RubygemsDotOrgTasks.new
-
-desc "Run tests in ./test"
-task :test do
-  Dir['test/*.rb'].each do |test|
-    sh "ruby #{test}"
-  end
-end
-
-desc "Setup for development"
-task :setup do
-  sh "bundle"
-end
+require 'rake/testtask'
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "monad-maybe"
+  gem.summary = %Q{A Ruby implementation of Haskell's Maybe Monad}
+  gem.description = %Q{This is an attempt to implement Haskell's Maybe monad in a Ruby-ish way.}
+  gem.email = "delon.newman@gmail.com"
+  gem.homepage = "https://github.com/delonnewman/monad-maybe"
+  gem.authors = ["Delon Newman"]
+  gem.license = 'MIT'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+desc "Run tests in ./test"
+task :test do
+  Dir['test/*.rb'].each do |test|
+    sh "ruby #{test}"
+  end
+end
+
+desc "Setup for development"
+task :setup do
+  sh "bundle"
+end

data/VERSION

@@ -1 +1 @@
-0.9.8
+0.9.9

data/lib/monad/maybe.rb

@@ -1,59 +1,59 @@
-require_relative 'maybe/base'
-require_relative 'maybe/just'
-require_relative 'maybe/nothing'
-require_relative 'maybe/list'
-
-#
-# Some monkey patching and constructor methods.
-#
-module Enumerable
-  def maybe_map
-    Monad::Maybe::List.new(map{ |x| yield(x) })
-  end
-end
-  
-class Object
-  def to_maybe(&blk)
-    j = Monad::Maybe::Just.new(self)
-    blk ? j.maybe(&blk) : j
-  end
-  
-  def maybe?
-    false
-  end
-  
-  def just?
-    false
-  end
-  
-  def nothing?
-    false
-  end
-end
-
-class NilClass
-  def to_maybe(&blk)
-    Monad::Maybe::Nothing.instance
-  end
-end
-
-module Monad
-  module Maybe
-    def self.return(obj)
-      obj.to_maybe
-    end
-  end
-end
-
-def maybe(obj, &blk)
-  m = Monad::Maybe.return(obj)
-  blk ? m.maybe(&blk) : m
-end
-
-def just(o)
-  Monad::Maybe::Just.new(o)
-end
-
-def nothing
-  Monad::Maybe::Nothing.instance
-end
+require_relative 'maybe/base'
+require_relative 'maybe/just'
+require_relative 'maybe/nothing'
+require_relative 'maybe/list'
+
+#
+# Some monkey patching and constructor methods.
+#
+module Enumerable
+  def maybe_map
+    Monad::Maybe::List.new(map{ |x| yield(x) })
+  end
+end
+  
+class Object
+  def to_maybe(&blk)
+    j = Monad::Maybe::Just.new(self)
+    blk ? j.maybe(&blk) : j
+  end
+  
+  def maybe?
+    false
+  end
+  
+  def just?
+    false
+  end
+  
+  def nothing?
+    false
+  end
+end
+
+class NilClass
+  def to_maybe(&blk)
+    Monad::Maybe::Nothing.instance
+  end
+end
+
+module Monad
+  module Maybe
+    def self.return(obj)
+      obj.to_maybe
+    end
+  end
+end
+
+def maybe(obj, &blk)
+  m = Monad::Maybe.return(obj)
+  blk ? m.maybe(&blk) : m
+end
+
+def just(o)
+  Monad::Maybe::Just.new(o)
+end
+
+def nothing
+  Monad::Maybe::Nothing.instance
+end

data/lib/monad/maybe/base.rb

@@ -1,39 +1,39 @@
-module Monad
-  module Maybe
-    class Base
-      attr_reader :value
-
-      def <<(obj)
-        to_list << obj
-      end
-  
-      def maybe?
-        true
-      end
-  
-      def to_list
-        List.new(to_a)
-      end
-
-      def to_maybe
-        self
-      end
-
-      def maybe(&blk)
-        bind(blk)
-      end
-
-      def then(fn)
-        bind(->(x){ fn && fn.call })
-        self
-      end
-
-      def and(&blk)
-        self.then(blk)
-      end
-  
-      private
-      def initialize; end
-    end
-  end
-end
+module Monad
+  module Maybe
+    class Base
+      attr_reader :value
+
+      def <<(obj)
+        to_list << obj
+      end
+  
+      def maybe?
+        true
+      end
+  
+      def to_list
+        List.new(to_a)
+      end
+
+      def to_maybe
+        self
+      end
+
+      def maybe(&blk)
+        bind(blk)
+      end
+
+      def then(fn)
+        bind(->(x){ fn && fn.call })
+        self
+      end
+
+      def and(&blk)
+        self.then(blk)
+      end
+  
+      private
+      def initialize; end
+    end
+  end
+end

data/lib/monad/maybe/json.rb

@@ -1,26 +1,26 @@
-require 'json'
-
-#
-# Adds JSON conversions to Just, Nothing, and List
-#
-module Monad
-  module Maybe
-    class Just
-      def to_json(*args)
-        value.to_json(*args)
-      end
-    end
-
-    class Nothing
-      def to_json(*args)
-        'null'
-      end
-    end
-
-    class List
-      def to_json(*args)
-        to_a.to_json(*args)
-      end
-    end
-  end
-end
+require 'json'
+
+#
+# Adds JSON conversions to Just, Nothing, and List
+#
+module Monad
+  module Maybe
+    class Just
+      def to_json(*args)
+        value.to_json(*args)
+      end
+    end
+
+    class Nothing
+      def to_json(*args)
+        'null'
+      end
+    end
+
+    class List
+      def to_json(*args)
+        to_a.to_json(*args)
+      end
+    end
+  end
+end

data/lib/monad/maybe/just.rb

@@ -1,62 +1,62 @@
-module Monad
-  module Maybe
-    class Just < Base
-      def initialize(value)
-        @value = value
-      end
-  
-      def method_missing(method, *args)
-        value.send(method, *args).to_maybe
-      end
-  
-      def unwrap(val)
-        value
-      end
-  
-      def nothing?
-        false
-      end
-
-      def something?
-        true
-      end
-  
-      def just?
-        true
-      end
-
-      def bind(fn)
-        fn[@value].to_maybe
-      end
-  
-      def nil?
-        false
-      end
-  
-      def ==(other)
-        self === other || self.value == other
-      end
-  
-      def ===(other)
-        other.just? && self.value == other.value
-      end
-  
-      def equal?(other)
-        other.__id__ == self.__id__
-      end
-  
-      def inspect
-        "just(#{value.inspect})"
-      end
-
-      def to_s
-        value.to_s
-      end
-      alias to_str to_s
-  
-      def to_a
-        [self]
-      end
-    end
-  end
-end
+module Monad
+  module Maybe
+    class Just < Base
+      def initialize(value)
+        @value = value
+      end
+  
+      def method_missing(method, *args)
+        value.send(method, *args).to_maybe
+      end
+  
+      def unwrap(val)
+        value
+      end
+  
+      def nothing?
+        false
+      end
+
+      def something?
+        true
+      end
+  
+      def just?
+        true
+      end
+
+      def bind(fn)
+        fn[@value].to_maybe
+      end
+  
+      def nil?
+        false
+      end
+  
+      def ==(other)
+        self === other || self.value == other
+      end
+  
+      def ===(other)
+        other.just? && self.value == other.value
+      end
+  
+      def equal?(other)
+        other.__id__ == self.__id__
+      end
+  
+      def inspect
+        "just(#{value.inspect})"
+      end
+
+      def to_s
+        value.to_s
+      end
+      alias to_str to_s
+  
+      def to_a
+        [self]
+      end
+    end
+  end
+end

data/lib/monad/maybe/list.rb

@@ -1,72 +1,72 @@
-module Monad
-  module Maybe
-    class List
-      include Enumerable
-  
-      def initialize(enum)
-        @enum = enum.map { |v| v.maybe? ? v : v.to_maybe }
-      end
-  
-      def inspect
-        "#{to_a}"
-      end
-  
-      def maybe?
-        true
-      end
-
-      def <<(obj)
-        @enum << obj if obj.just?
-        self
-      end
-  
-      def to_a
-        @enum.to_a
-      end
-  
-      def to_maybe
-        first.to_maybe
-      end
-  
-      def each
-        @enum.each do |x|
-          yield(x)
-        end
-      end
-  
-      def map
-        e = []
-        each do |x|
-          e << yield(x)
-        end
-        List.new(e)
-      end
-      alias maybe_map map
-  
-      def select
-        e = []
-        each do |x|
-          is_true = yield(x)
-          e << x if is_true  
-        end
-        List.new(e)
-      end
-  
-      def reject
-        select { |x| !yield(x) }
-      end
-  
-      def select_just
-        select { |x| x.just? }
-      end
-  
-      def unwrap_map(default, &blk)
-        to_a.map { |x| blk ? blk.call(x.unwrap(default)) : x.unwrap(default) }
-      end
-  
-      def value_map(&blk)
-        to_a.map { |x| blk ? blk.call(x.value) : x.value }
-      end
-    end
-  end
-end
+module Monad
+  module Maybe
+    class List
+      include Enumerable
+  
+      def initialize(enum)
+        @enum = enum.map { |v| v.maybe? ? v : v.to_maybe }
+      end
+  
+      def inspect
+        "#{to_a}"
+      end
+  
+      def maybe?
+        true
+      end
+
+      def <<(obj)
+        @enum << obj if obj.just?
+        self
+      end
+  
+      def to_a
+        @enum.to_a
+      end
+  
+      def to_maybe
+        first.to_maybe
+      end
+  
+      def each
+        @enum.each do |x|
+          yield(x)
+        end
+      end
+  
+      def map
+        e = []
+        each do |x|
+          e << yield(x)
+        end
+        List.new(e)
+      end
+      alias maybe_map map
+  
+      def select
+        e = []
+        each do |x|
+          is_true = yield(x)
+          e << x if is_true  
+        end
+        List.new(e)
+      end
+  
+      def reject
+        select { |x| !yield(x) }
+      end
+  
+      def select_just
+        select { |x| x.just? }
+      end
+  
+      def unwrap_map(default, &blk)
+        to_a.map { |x| blk ? blk.call(x.unwrap(default)) : x.unwrap(default) }
+      end
+  
+      def value_map(&blk)
+        to_a.map { |x| blk ? blk.call(x.value) : x.value }
+      end
+    end
+  end
+end

data/lib/monad/maybe/nothing.rb

@@ -1,58 +1,58 @@
-require 'singleton'
-
-module Monad
-  module Maybe
-    class Nothing < Base
-      include ::Singleton
-  
-      def method_missing(method, *args)
-        self
-      end
-  
-      def clone
-        self
-      end
-  
-      def inspect
-        'nothing'
-      end
-  
-      def nil?
-        true
-      end
-  
-      def nothing?
-        true
-      end
-  
-      def bind(fn)
-        self
-      end
-
-      def just?
-        false
-      end
-
-      def something?
-        false
-      end
-  
-      def unwrap(val)
-        val
-      end
-  
-      def value
-        nil
-      end
-  
-      def to_s
-        ''
-      end
-      alias to_str to_s
-
-      def to_a
-        []
-      end
-    end
-  end
-end
+require 'singleton'
+
+module Monad
+  module Maybe
+    class Nothing < Base
+      include ::Singleton
+  
+      def method_missing(method, *args)
+        self
+      end
+  
+      def clone
+        self
+      end
+  
+      def inspect
+        'nothing'
+      end
+  
+      def nil?
+        true
+      end
+  
+      def nothing?
+        true
+      end
+  
+      def bind(fn)
+        self
+      end
+
+      def just?
+        false
+      end
+
+      def something?
+        false
+      end
+  
+      def unwrap(val)
+        val
+      end
+  
+      def value
+        nil
+      end
+  
+      def to_s
+        ''
+      end
+      alias to_str to_s
+
+      def to_a
+        []
+      end
+    end
+  end
+end

data/monad-maybe.gemspec

@@ -1,56 +1,57 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in rakefile, and run 'rake gemspec'
-# -*- encoding: utf-8 -*-
-
-Gem::Specification.new do |s|
-  s.name = "monad-maybe"
-  s.version = "0.9.8"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Delon Newman"]
-  s.date = "2013-08-16"
-  s.description = "This is an attempt to implement Haskell's Maybe monad in a Ruby-ish way."
-  s.email = "delon.newman@gmail.com"
-  s.extra_rdoc_files = [
-    "README.md"
-  ]
-  s.files = [
-    "Gemfile",
-    "Gemfile.lock",
-    "README.md",
-    "Rakefile",
-    "VERSION",
-    "lib/monad/maybe.rb",
-    "lib/monad/maybe/base.rb",
-    "lib/monad/maybe/json.rb",
-    "lib/monad/maybe/just.rb",
-    "lib/monad/maybe/list.rb",
-    "lib/monad/maybe/nothing.rb",
-    "monad-maybe.gemspec",
-    "test/maybe.rb"
-  ]
-  s.homepage = "https://github.com/delonnewman/monad-maybe"
-  s.require_paths = ["lib"]
-  s.rubygems_version = "2.0.0"
-  s.summary = "A Ruby implementation of Haskell's Maybe Monad"
-
-  if s.respond_to? :specification_version then
-    s.specification_version = 4
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<jeweler>, [">= 0"])
-      s.add_development_dependency(%q<yard>, [">= 0"])
-      s.add_development_dependency(%q<test-unit>, [">= 0"])
-    else
-      s.add_dependency(%q<jeweler>, [">= 0"])
-      s.add_dependency(%q<yard>, [">= 0"])
-      s.add_dependency(%q<test-unit>, [">= 0"])
-    end
-  else
-    s.add_dependency(%q<jeweler>, [">= 0"])
-    s.add_dependency(%q<yard>, [">= 0"])
-    s.add_dependency(%q<test-unit>, [">= 0"])
-  end
-end
-
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "monad-maybe"
+  s.version = "0.9.9"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Delon Newman"]
+  s.date = "2013-08-18"
+  s.description = "This is an attempt to implement Haskell's Maybe monad in a Ruby-ish way."
+  s.email = "delon.newman@gmail.com"
+  s.extra_rdoc_files = [
+    "README.md"
+  ]
+  s.files = [
+    "Gemfile",
+    "Gemfile.lock",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "lib/monad/maybe.rb",
+    "lib/monad/maybe/base.rb",
+    "lib/monad/maybe/json.rb",
+    "lib/monad/maybe/just.rb",
+    "lib/monad/maybe/list.rb",
+    "lib/monad/maybe/nothing.rb",
+    "monad-maybe.gemspec",
+    "test/maybe.rb"
+  ]
+  s.homepage = "https://github.com/delonnewman/monad-maybe"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "2.0.0.rc.2"
+  s.summary = "A Ruby implementation of Haskell's Maybe Monad"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<jeweler>, [">= 0"])
+      s.add_development_dependency(%q<yard>, [">= 0"])
+      s.add_development_dependency(%q<test-unit>, [">= 0"])
+    else
+      s.add_dependency(%q<jeweler>, [">= 0"])
+      s.add_dependency(%q<yard>, [">= 0"])
+      s.add_dependency(%q<test-unit>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<jeweler>, [">= 0"])
+    s.add_dependency(%q<yard>, [">= 0"])
+    s.add_dependency(%q<test-unit>, [">= 0"])
+  end
+end
+

data/test/maybe.rb

@@ -1,158 +1,158 @@
-require 'test/unit'
-require_relative '../lib/monad/maybe'
-require_relative '../lib/monad/maybe/json'
-
-class MaybeTest < Test::Unit::TestCase
-  def test_nothing
-    assert nil.to_maybe.nothing?
-    assert nil.to_maybe.value.nil?
-    assert_equal 'test', nil.to_maybe.unwrap('test')
-    assert_equal '', nothing.to_s
-  end
-
-  def test_just
-    assert maybe(1).just?
-    assert_equal 1, 1.to_maybe.value
-    assert_equal 1, 1.to_maybe.unwrap('test')
-    assert_equal '1', just(1).to_s
-  end
-
-  def test_json
-    assert_equal 'null', nothing.to_json
-    assert_equal '1', just(1).to_json
-    assert_equal '{}', just({}).to_json
-    assert_equal '[]', just([]).to_json
-    assert_equal (0..10).to_a.to_json, (0..10).maybe_map { |n| n }.to_json
-  end
-
-  def test_to_a
-    assert_equal [1.to_maybe], 1.to_maybe.to_a
-    assert_equal [], nil.to_maybe.to_a
-  end
-
-  def test_false
-    assert_equal false, false.to_maybe.value
-  end
-
-  def test_nil_conversions
-    assert_equal nil.nil?, nil.to_maybe.nil?
-  end
-
-  def test_class
-    assert_equal Monad::Maybe::Nothing, maybe(nil).class
-    assert_equal Monad::Maybe::Just, maybe(1).class
-  end
-
-  def test_list
-    xs = true.to_maybe << nil.to_maybe << 1.to_maybe << 3.to_maybe
-    assert_equal 3, xs.count
-    xs.each { |x| assert x.just? }
-  end
-
-  def test_enumerable
-    assert_nothing_raised do
-      xs = (0..10).select { |n| n % 2 != 0 }
-      ys = (0..10).maybe_map { |n| n % 2 == 0 ? nil : n }.select_just.value_map
-      assert_equal xs.count, ys.count
-    end
-  end
-
-  def test_maybe_block
-    assert_nothing_raised do
-      nothing.maybe do
-        raise Exception, "This should not be called"
-      end
-    end
-
-    assert_nothing_raised do
-      maybe(nil) do
-        raise Exception, "This should not be called"
-      end
-    end
-
-    maybe(1) do |n|
-      assert_equal 1, n
-    end
-
-    just(1).maybe do |n|
-      assert_equal 1, n
-    end
-  end
-
-  def test_to_maybe_blocks
-    1.to_maybe { |v| assert_equal 1, v }
-
-    assert_nothing_raised do
-      nil.to_maybe { raise Exception, "This should not run" }
-    end
-  end
-
-
-  def test_maybe_block_return_value_and_type
-    m = maybe(1).maybe { |n| n + 1 }
-    assert_equal 2, m.value
-    assert m.maybe?
-    assert m.just?
-
-    o = maybe(2).maybe { nil }
-    assert_equal nil, o.value
-    assert o.maybe?
-    assert o.nothing?
-  end
-
-  def test_to_maybe
-    assert_equal just(1), 1.to_maybe
-    assert_equal just(1), just(1).to_maybe
-    assert_equal nothing, nil.to_maybe
-    assert_equal nothing, nothing.to_maybe
-    assert_equal 1.to_maybe, [1].to_maybe
-    assert_equal 0.to_maybe, (0..10).maybe_map { |n| n }.to_maybe
-  end
-
-  def test_then_and_and
-    just(1).and do
-      assert true
-    end
-
-    nothing.and do
-      assert true
-    end
-
-    just(1).and{ assert true }.and{ assert true }
-    maybe(1).then(->(){ assert true }).then(->(){ assert true })
-  end
-
-  #
-  # Monad laws
-  #
-
-  #
-  # Right Unit:
-  #   m >>= return = m
-  #
-  def test_right_unit
-    m = just(1)
-    assert_equal m, m.bind(->(x){ Monad::Maybe.return(x) })
-  end
-
-  #
-  # Left Unit:
-  #   return x >>= f = f x
-  #
-  def test_left_unit
-    x = 2
-    f = ->(x) { x + 1 }
-    assert_equal Monad::Maybe.return(x).bind(f), f[x]
-  end
-
-  #
-  # Associativity:
-  #   (m >>= f) >>= g = m >>= (\x -> f x >>= g)
-  #
-  def test_associativity
-    m = just(3.1459)
-    f = ->(x) { x ** 2 }
-    g = ->(x) { 2 *  x }
-    assert_equal m.bind(f).bind(g), m.bind(->(x) { f[x] }).bind(g)
-  end
-end
+require 'test/unit'
+require_relative '../lib/monad/maybe'
+require_relative '../lib/monad/maybe/json'
+
+class MaybeTest < Test::Unit::TestCase
+  def test_nothing
+    assert nil.to_maybe.nothing?
+    assert nil.to_maybe.value.nil?
+    assert_equal 'test', nil.to_maybe.unwrap('test')
+    assert_equal '', nothing.to_s
+  end
+
+  def test_just
+    assert maybe(1).just?
+    assert_equal 1, 1.to_maybe.value
+    assert_equal 1, 1.to_maybe.unwrap('test')
+    assert_equal '1', just(1).to_s
+  end
+
+  def test_json
+    assert_equal 'null', nothing.to_json
+    assert_equal '1', just(1).to_json
+    assert_equal '{}', just({}).to_json
+    assert_equal '[]', just([]).to_json
+    assert_equal (0..10).to_a.to_json, (0..10).maybe_map { |n| n }.to_json
+  end
+
+  def test_to_a
+    assert_equal [1.to_maybe], 1.to_maybe.to_a
+    assert_equal [], nil.to_maybe.to_a
+  end
+
+  def test_false
+    assert_equal false, false.to_maybe.value
+  end
+
+  def test_nil_conversions
+    assert_equal nil.nil?, nil.to_maybe.nil?
+  end
+
+  def test_class
+    assert_equal Monad::Maybe::Nothing, maybe(nil).class
+    assert_equal Monad::Maybe::Just, maybe(1).class
+  end
+
+  def test_list
+    xs = true.to_maybe << nil.to_maybe << 1.to_maybe << 3.to_maybe
+    assert_equal 3, xs.count
+    xs.each { |x| assert x.just? }
+  end
+
+  def test_enumerable
+    assert_nothing_raised do
+      xs = (0..10).select { |n| n % 2 != 0 }
+      ys = (0..10).maybe_map { |n| n % 2 == 0 ? nil : n }.select_just.value_map
+      assert_equal xs.count, ys.count
+    end
+  end
+
+  def test_maybe_block
+    assert_nothing_raised do
+      nothing.maybe do
+        raise Exception, "This should not be called"
+      end
+    end
+
+    assert_nothing_raised do
+      maybe(nil) do
+        raise Exception, "This should not be called"
+      end
+    end
+
+    maybe(1) do |n|
+      assert_equal 1, n
+    end
+
+    just(1).maybe do |n|
+      assert_equal 1, n
+    end
+  end
+
+  def test_to_maybe_blocks
+    1.to_maybe { |v| assert_equal 1, v }
+
+    assert_nothing_raised do
+      nil.to_maybe { raise Exception, "This should not run" }
+    end
+  end
+
+
+  def test_maybe_block_return_value_and_type
+    m = maybe(1).maybe { |n| n + 1 }
+    assert_equal 2, m.value
+    assert m.maybe?
+    assert m.just?
+
+    o = maybe(2).maybe { nil }
+    assert_equal nil, o.value
+    assert o.maybe?
+    assert o.nothing?
+  end
+
+  def test_to_maybe
+    assert_equal just(1), 1.to_maybe
+    assert_equal just(1), just(1).to_maybe
+    assert_equal nothing, nil.to_maybe
+    assert_equal nothing, nothing.to_maybe
+    assert_equal 1.to_maybe, [1].to_maybe
+    assert_equal 0.to_maybe, (0..10).maybe_map { |n| n }.to_maybe
+  end
+
+  def test_then_and_and
+    just(1).and do
+      assert true
+    end
+
+    nothing.and do
+      assert true
+    end
+
+    just(1).and{ assert true }.and{ assert true }
+    maybe(1).then(->(){ assert true }).then(->(){ assert true })
+  end
+
+  #
+  # Monad laws
+  #
+
+  #
+  # Right Unit:
+  #   m >>= return = m
+  #
+  def test_right_unit
+    m = just(1)
+    assert_equal m, m.bind(->(x){ Monad::Maybe.return(x) })
+  end
+
+  #
+  # Left Unit:
+  #   return x >>= f = f x
+  #
+  def test_left_unit
+    x = 2
+    f = ->(x) { x + 1 }
+    assert_equal Monad::Maybe.return(x).bind(f), f[x]
+  end
+
+  #
+  # Associativity:
+  #   (m >>= f) >>= g = m >>= (\x -> f x >>= g)
+  #
+  def test_associativity
+    m = just(3.1459)
+    f = ->(x) { x ** 2 }
+    g = ->(x) { 2 *  x }
+    assert_equal m.bind(f).bind(g), m.bind(->(x) { f[x] }).bind(g)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: monad-maybe
 version: !ruby/object:Gem::Version
-  version: 0.9.8
+  version: 0.9.9
 platform: ruby
 authors:
 - Delon Newman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-16 00:00:00.000000000 Z
+date: 2013-08-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jeweler
@@ -73,7 +73,8 @@ files:
 - monad-maybe.gemspec
 - test/maybe.rb
 homepage: https://github.com/delonnewman/monad-maybe
-licenses: []
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -91,9 +92,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.0
+rubygems_version: 2.0.0.rc.2
 signing_key: 
 specification_version: 4
 summary: A Ruby implementation of Haskell's Maybe Monad
 test_files: []
-has_rdoc: