indubitably 0.3.0 → 0.4.0

data/lib/indubitably.rb

@@ -1,4 +1,8 @@
+# encoding: utf-8
+# base class for Some and None
 class Maybe
+  @@none = nil
+
   ([:each] + Enumerable.instance_methods).each do |enumerable_method|
     define_method(enumerable_method) do |*args, &block|
       res = __enumerable_value.send(enumerable_method, *args, &block)
@@ -16,9 +20,30 @@ class Maybe
   end
   alias_method :eql?, :==
 
+  def self.concat(list, default = none)
+    if default == none
+      list.select(&:is_some?).map(&:get)
+    else
+      list.map { |x| x.or_else(default) }
+    end
+  end
+
   def self.empty_value?(value)
     value.nil? || (value.respond_to?(:length) && value.length == 0)
   end
+
+  def self.join?(value)
+    return value if value.is_a?(Maybe)
+    Maybe(value)
+  end
+
+  def self.none
+    @@none ||= None.new
+  end
+
+  def self.seq(list, default = none)
+    Maybe(concat(list, default))
+  end
 end
 
 # Represents a non-empty value
@@ -31,6 +56,10 @@ class Some < Maybe
     @value
   end
 
+  def if(&blk)
+    blk.call(@value) ? self : Maybe.none
+  end
+
   def or_else(*)
     @value
   end
@@ -68,16 +97,21 @@ class Some < Maybe
     other && other.class == self.class && @value === other.get
   end
 
+  # This strips the leading underscore if the method is sent with that prefix;
+  # this allows us to force dispatch to the contained object. It is inline in
+  # two places because this avoids a function call performance hit.
   def method_missing(method_sym, *args, &block)
-    if method_sym[0] == '_'
-      method_sym = method_sym.slice(1, method_sym.length)
-    end
-
+    method_sym = method_sym.slice(1, method_sym.length) if method_sym[0] == "_"
     map { |value| value.send(method_sym, *args, &block) }
   end
 
   private
 
+  def respond_to_missing?(method_sym, include_private = false)
+    method_sym = method_sym.slice(1, method_sym.length) if method_sym[0] == "_"
+    @value.respond_to?(method_sym, include_private) || super
+  end
+
   def __enumerable_value
     [@value]
   end
@@ -86,7 +120,7 @@ end
 # Represents an empty value
 class None < Maybe
   def get
-    fail 'No such element'
+    fail "No such element"
   end
 
   def or_else(els = nil)
@@ -107,6 +141,10 @@ class None < Maybe
     self
   end
 
+  def respond_to_missing?(*)
+    true
+  end
+
   private
 
   def __enumerable_value
@@ -116,7 +154,7 @@ end
 
 # rubocop:disable MethodName
 def Maybe(value)
-  Maybe.empty_value?(value) ? None() : Some.new(value)
+  Maybe.empty_value?(value) ? Maybe.none : Some.new(value)
 end
 
 def Some(value)
@@ -124,6 +162,6 @@ def Some(value)
 end
 
 def None
-  None.new
+  Maybe.none
 end
 # rubocop:enable MethodName

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: indubitably
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,10 +10,9 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-30 00:00:00.000000000 Z
+date: 2015-02-13 00:00:00.000000000 Z
 dependencies: []
-description: Maybe monad implementation for Ruby (some might call it Option pattern
-  or Null pattern)
+description: An implementation of Maybe/Option for Ruby.
 email: syrion@gmail.com
 executables: []
 extensions: []