indubitably 0.3.0

data/lib/indubitably.rb

@@ -0,0 +1,129 @@
+class Maybe
+  ([:each] + Enumerable.instance_methods).each do |enumerable_method|
+    define_method(enumerable_method) do |*args, &block|
+      res = __enumerable_value.send(enumerable_method, *args, &block)
+      res.respond_to?(:each) ? Maybe(res.first) : res
+    end
+  end
+
+  def to_ary
+    __enumerable_value
+  end
+  alias_method :to_a, :to_ary
+
+  def ==(other)
+    other.class == self.class
+  end
+  alias_method :eql?, :==
+
+  def self.empty_value?(value)
+    value.nil? || (value.respond_to?(:length) && value.length == 0)
+  end
+end
+
+# Represents a non-empty value
+class Some < Maybe
+  def initialize(value)
+    @value = value
+  end
+
+  def get
+    @value
+  end
+
+  def or_else(*)
+    @value
+  end
+
+  # rubocop:disable PredicateName
+  def is_some?
+    true
+  end
+
+  def is_none?
+    false
+  end
+  # rubocop:enable PredicateName
+
+  def join
+    @value.is_a?(Maybe) ? @value : self
+  end
+
+  def join!
+    if @value.is_a?(Some)
+      @value.join!
+    elsif @value.is_a?(None)
+      @value
+    else
+      self
+    end
+  end
+
+  def ==(other)
+    super && get == other.get
+  end
+  alias_method :eql?, :==
+
+  def ===(other)
+    other && other.class == self.class && @value === other.get
+  end
+
+  def method_missing(method_sym, *args, &block)
+    if method_sym[0] == '_'
+      method_sym = method_sym.slice(1, method_sym.length)
+    end
+
+    map { |value| value.send(method_sym, *args, &block) }
+  end
+
+  private
+
+  def __enumerable_value
+    [@value]
+  end
+end
+
+# Represents an empty value
+class None < Maybe
+  def get
+    fail 'No such element'
+  end
+
+  def or_else(els = nil)
+    block_given? ? yield : els
+  end
+
+  # rubocop:disable PredicateName
+  def is_some?
+    false
+  end
+
+  def is_none?
+    true
+  end
+  # rubocop:enable PredicateName
+
+  def method_missing(*)
+    self
+  end
+
+  private
+
+  def __enumerable_value
+    []
+  end
+end
+
+# rubocop:disable MethodName
+def Maybe(value)
+  Maybe.empty_value?(value) ? None() : Some.new(value)
+end
+
+def Some(value)
+  Maybe(value)
+end
+
+def None
+  None.new
+end
+# rubocop:enable MethodName

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification
+name: indubitably
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+  prerelease: 
+platform: ruby
+authors:
+- Blake Hyde
+- Mikko Koski
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-30 00:00:00.000000000 Z
+dependencies: []
+description: Maybe monad implementation for Ruby (some might call it Option pattern
+  or Null pattern)
+email: syrion@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/indubitably.rb
+homepage: https://github.com/asthasr/ruby-indubitably
+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
+signing_key: 
+specification_version: 3
+summary: Maybe monad
+test_files: []