monad-maybe 0.8.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1ce465e91a7fa1eaf0d0ab623ea89f2e94fb1a19
+  data.tar.gz: 2e99082f613f330a0f70ba2366ee197b13e9a85c
+SHA512:
+  metadata.gz: 4b9a853ff984432ca743f2855165b29945e7664231229fbfe9c21a4b98d63c91b86d1d209e4704f45d451b9f01eb50f4b114aacc65ba0edbd472cf1da8baa1fe
+  data.tar.gz: c8b2fe434cd8521497a3aa13138582d5c1a8363279a4346d0251f8a5be89eb5a0aa77a58791618710c282bd0842f2a5c4317a37855329aa45cfae155c63cd995

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,27 @@
+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)
+    mustache (0.99.4)
+    rake (10.0.4)
+    rdoc (4.0.1)
+      json (~> 1.4)
+    redcarpet (2.3.0)
+    rocco (0.8.2)
+      mustache
+      redcarpet
+    test-unit (2.5.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  jeweler
+  rocco
+  test-unit

data/README.md

@@ -0,0 +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://)

data/Rakefile

@@ -0,0 +1,23 @@
+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 with as little monkey patching as possible.}
+  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

data/VERSION

@@ -0,0 +1 @@
+0.8.0

data/lib/monad/maybe.rb

@@ -0,0 +1,59 @@
+require_relative 'maybe/base'
+require_relative 'maybe/just'
+require_relative 'maybe/nothing'
+require_relative 'maybe/list'
+
+module Monad
+  module Maybe
+    module Enumerable
+      def to_maybe
+        first.maybe
+      end
+  
+      def maybe_map
+        List.new(map{ |x| yield(x) })
+      end
+    end
+  
+    class ::Array; include Enumerable end
+    class ::Range; include Enumerable end
+  
+    class ::Object
+      def maybe
+        Just.new(self)
+      end
+  
+      def maybe?
+        false
+      end
+  
+      def just?
+        false
+      end
+  
+      def nothing?
+        false
+      end
+    end
+
+    class ::NilClass
+      def maybe
+        Nothing.instance.freeze
+      end
+    end
+
+    def maybe(o)
+      o.maybe
+    end
+
+    def just(o)
+      Just.new(o)
+    end
+
+    def nothing
+      Nothing.instance
+    end
+  end
+end
+
+include Monad::Maybe

data/lib/monad/maybe/base.rb

@@ -0,0 +1,26 @@
+module Monad
+  module Maybe
+    class Base
+      attr_reader :value
+
+      def <<(obj)
+        to_list << obj
+      end
+  
+      def maybe?
+        true
+      end
+  
+      def maybe
+        self
+      end
+  
+      def to_list
+        List.new(to_a)
+      end
+  
+      private
+      def initialize; end
+    end
+  end
+end

data/lib/monad/maybe/just.rb

@@ -0,0 +1,58 @@
+module Monad
+  module Maybe
+    #
+    # Wraps a non-nil object allows us to treat these
+    # objects as a Maybe while distinguishing them from
+    # a Nothing
+    #
+    class Just < Base
+      def initialize(value)
+        @value = value
+      end
+  
+      def method_missing(method, *args)
+        Just.new(value.send(method, *args))
+      end
+  
+      def unwrap(val)
+        value
+      end
+  
+      def nothing?
+        false
+      end
+  
+      def just?
+        true
+      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
+        Just.new(value.to_s)
+      end
+  
+      def to_a
+        [self]
+      end
+    end
+  end
+end

data/lib/monad/maybe/list.rb

@@ -0,0 +1,72 @@
+module Monad
+  module Maybe
+    class List
+      include Enumerable
+  
+      def initialize(enum)
+        @enum = enum.map { |v| v.maybe? ? v : v.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.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

@@ -0,0 +1,56 @@
+require 'singleton'
+
+module Monad
+  module Maybe
+    #
+    # A better nil
+    #
+    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 just?
+        false
+      end
+  
+      def unwrap(val)
+        val
+      end
+  
+      def value
+        nil
+      end
+  
+      def to_json(*args)
+        'null'
+      end
+
+      def to_s
+        self
+      end
+
+      def to_a
+        []
+      end
+    end
+  end
+end

data/monad-maybe.gemspec

@@ -0,0 +1,55 @@
+# 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.8.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Delon Newman"]
+  s.date = "2013-06-17"
+  s.description = "This is an attempt to implement Haskell's Maybe monad in a Ruby-ish way with as little monkey patching as possible."
+  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/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<rocco>, [">= 0"])
+      s.add_development_dependency(%q<test-unit>, [">= 0"])
+    else
+      s.add_dependency(%q<jeweler>, [">= 0"])
+      s.add_dependency(%q<rocco>, [">= 0"])
+      s.add_dependency(%q<test-unit>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<jeweler>, [">= 0"])
+    s.add_dependency(%q<rocco>, [">= 0"])
+    s.add_dependency(%q<test-unit>, [">= 0"])
+  end
+end
+

data/test/maybe.rb

@@ -0,0 +1,48 @@
+require 'test/unit'
+require_relative '../lib/monad/maybe'
+
+class MaybeTest < Test::Unit::TestCase
+  def test_nothing
+    assert nil.maybe.nothing?
+    assert nil.maybe.value.nil?
+    assert_equal 'test', nil.maybe.unwrap('test')
+  end
+
+  def test_just
+    assert 1.maybe.just?
+    assert_equal 1, 1.maybe.value
+    assert_equal 1, 1.maybe.unwrap('test')
+  end
+
+  def test_to_a
+    assert_equal [1.maybe], 1.maybe.to_a
+    assert_equal [], nil.maybe.to_a
+  end
+
+  def test_false
+    assert_equal false, false.maybe.value
+  end
+
+  def test_nil_conversions
+    assert_equal nil.nil?, nil.maybe.nil?
+  end
+
+  def test_class
+    assert_equal Nothing, nil.maybe.class
+    assert_equal Just, 1.maybe.class
+  end
+
+  def test_list
+    xs = true.maybe << nil.maybe << 1.maybe << 3.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
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: monad-maybe
+version: !ruby/object:Gem::Version
+  version: 0.8.0
+platform: ruby
+authors:
+- Delon Newman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rocco
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: This is an attempt to implement Haskell's Maybe monad in a Ruby-ish way
+  with as little monkey patching as possible.
+email: delon.newman@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- VERSION
+- lib/monad/maybe.rb
+- lib/monad/maybe/base.rb
+- lib/monad/maybe/just.rb
+- lib/monad/maybe/list.rb
+- lib/monad/maybe/nothing.rb
+- monad-maybe.gemspec
+- test/maybe.rb
+homepage: https://github.com/delonnewman/monad-maybe
+licenses: []
+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.0.0
+signing_key: 
+specification_version: 4
+summary: A Ruby implementation of Haskell's Maybe Monad
+test_files: []