totally_lazy 0.0.20 → 0.1.0

data/lib/option.rb

@@ -1,304 +1,74 @@
 module Option
 
-  def option(thing)
-    validate = thing.respond_to?(:empty?) ? thing.empty? : !thing
-    validate ? none : some(thing)
+  def option(value)
+    value.nil? ? none : some(value)
   end
 
-  def some(thing)
-    Some.new(thing)
+  def some(value)
+    Some.new(value)
   end
 
-  def none(thing=nil)
-    None.new(thing)
+  def none
+    NONE
   end
 
-  class Some
-
-    include Comparable
-
-    def initialize(content)
-      @content = content
-      raise(Exception, 'some cannot be nil') if @content.nil?
-    end
-
-    def <=>(object)
-      self.state <=> object.state
-    end
-
-    def is_none?
-      self.is_a?(None)
-    end
-
-    def is_some?
-      self.is_a?(Some)
-    end
-
-    def get
-      @content
-    end
-
-    def head_option
-      as_option(sequence(@content))
-    end
-
-    def value
-      get
-    end
-
-    def empty?
-      blank?
-    end
-
-    def defined?
-      !blank?
-    end
-
-    def get_or_else(item)
-      blank? ? item : @content
-    end
-
-    def get_or_nil
-      blank? ? nil : @content
-    end
-
-    def get_or_throw(exception, message='')
-      blank? ? raise(exception, message) : @content
-    end
-
-    def to_seq
-      sequence(get)
-    end
-
-    def contains(item)
-      value == item
-    end
-
-    def exists?(predicate)
-      value
-    end
-
-    def join(target_sequence)
-      sequence(value) << target_sequence
-    end
-
-    def each(&block)
-      block.call(@content)
-    end
-
-    def map(predicate=nil, &block)
-      as_option(sequence(@content).map(predicate, &block))
-    end
-
-    alias collect map
-
-    def select(predicate=nil, &block)
-      as_option(sequence(@content).select(predicate, &block))
-    end
-
-    alias find_all select
-    alias filter select
-
-    def reject(predicate=nil, &block)
-      as_option(sequence(@content).reject(predicate, &block))
-    end
-
-    alias unfilter reject
-
-    def grep(pattern)
-      as_option(sequence(@content).grep(pattern))
-    end
-
-    def drop(n)
-      as_option(sequence(@content).drop(n))
-    end
-
-    def drop_while(&block)
-      as_option(@content.drop_while(&block))
-    end
-
-    def take(n)
-      as_option(sequence(@content).take(n))
-    end
-
-    def take_while(&block)
-      as_option(@content.take_while(&block))
-    end
-
-    def flatten
-      @content
-    end
-
-    def flat_map(&block)
-      some(block.call(@content)).flatten
-    end
-
-    alias collect_concat flat_map
-
-    # TODO - fix me
-    # def zip(*args, &block)
-    #   sequence(@content).zip(*args,&block).head_option
-    # end
-
-    alias + join
-    alias << join
-
-    protected
-    def state
-      @content
-    end
-
-    private
-
-    def blank?
-      @content.respond_to?(:empty?) ? @content.empty? : !@content
+  class Option
+    def is_defined?
+      !is_empty?
     end
-
-    def as_option(seq)
-      seq.count == 1 ? seq.head_option : option(seq.entries)
-    end
-
   end
 
-  class None
-
+  class Some < Option
     include Comparable
+    attr_reader :value
 
-    def initialize(content)
-      @content = content
+    def initialize(value)
+      @value = value
     end
 
-    # def entries
-    #   []
-    # end
-    #
-    def <=>(object)
-      self.state <=> object.state
+    def map(fn)
+      some(fn.(value))
     end
 
-    def is_none?
-      self.is_a?(None)
+    def enumerator
+      Enumerator.new { |y|
+        y << @value
+        raise StopIteration.new
+      }
     end
 
-    def is_some?
-      self.is_a?(Some)
-    end
-
-    def get
-      raise NoSuchElementException.new, 'The option was empty'
-    end
-
-    def value
-      raise NoSuchElementException.new, 'The option was empty'
-    end
-
-    def empty?
-      true
-    end
-
-    def defined?
+    def is_empty?
       false
     end
 
-    def get_or_else(item)
-      item
-    end
-
-    def get_or_nil
-      nil
-    end
-
-    def get_or_throw(exception, message='')
-      raise(exception, message)
+    def <=>(other)
+      @value <=> other.value
     end
 
-    def to_seq
-      empty
-    end
-
-    def to_seq1
-      empty
-    end
-
-    def each(&block)
-      empty
-    end
-
-    def contains(item)
-      false
-    end
-
-    def exists?(predicate)
-      false
-    end
-
-    def join(target_sequence)
-      target_sequence.is_a?(Sequences::Sequence) ? target_sequence : sequence(target_sequence)
-    end
-
-    alias + join
-    alias << join
-
-    def map(predicate=nil, &block)
-      none
-    end
-
-    alias collect map
-
-    def select(predicate=nil, &block)
-      none
-    end
-
-    alias find_all select
-    alias filter select
-
-    def reject(predicate=nil, &block)
-      none
-    end
-
-    alias unfilter reject
-
-    def grep(pattern)
-      none
-    end
-
-    def drop(n)
-      none
-    end
-
-    def drop_while(&block)
-      none
-    end
-
-    def take(n)
-      none
-    end
-
-    def take_while(&block)
-      none
+    def to_s
+      "Some(#{value})"
     end
+  end
 
-    def flatten
-      none
+  class None < Option
+    def is_empty?
+      true
     end
 
-    def flat_map(&block)
+    def map(fn)
       none
     end
 
-    def head_option
-      none
+    def enumerator
+      Enumerator.new { |y|
+        raise StopIteration.new
+      }
     end
 
-    alias collect_concat flat_map
-
-    protected
-
-    def state
-      @content
+    def to_s
+      'None'
     end
-
   end
 
-
-end
+  NONE=None.new
+end

data/lib/pair.rb

@@ -4,11 +4,8 @@ module Pair
     Pair.new(first, second)
   end
 
-  def from_map(a_map)
-    Pair.from_map(a_map)
-  end
-
   class Pair
+    include Comparable
 
     def initialize(first, second)
       @first = -> { first }
@@ -16,63 +13,28 @@ module Pair
     end
 
     def first
-      @first.call
+      @first.()
     end
 
-    alias key first
-
     def second
-      @second.call
-    end
-
-    def first=(v)
-     @first = -> { v }
-    end
-    alias key= first=
-
-    def second=(v)
-      @second = -> { v }
-    end
-    alias value= second=
-
-    def each(&block)
-      [first,second].each do |i|
-        block.call(i)
-      end
+      @second.()
     end
 
-    alias value second
-
-    def to_map
-      {first => second}
+    def enumerator
+      Enumerator.new { |y|
+        y << first
+        y << second
+        raise StopIteration.new
+      }
     end
 
-    def self.from_map(a_map)
-      sequence(a_map.map{|k,v| Pair.new(k,v)}).flatten
-      # sequence(a_map).map{|k,v| Pair.new(k,v) }
-      # sequence(a_map).map { |k,v| Pair.new(k,v) }
+    def <=>(other)
+      (first <=> other.first) <=> (second <=> other.second)
     end
 
     def to_s
-      Type.responds_all(sequence(first, second), :to_s)
-      {first.to_s => second.to_s}
-    end
-
-    def to_i
-      Type.responds_all(sequence(first, second), :to_i)
-      {first.to_i => second.to_i}
-    end
-
-    def to_f
-      Type.responds_all(sequence(first, second), :to_f)
-      {first.to_f => second.to_f}
+      "(#{first}, #{second})"
     end
-
-    def values
-      sequence(first, second)
-    end
-
   end
 
-
-end
+end

data/lib/predicates.rb

@@ -0,0 +1,5 @@
+module Predicates
+  def not(pred)
+    -> (bool) { !pred.(bool) }
+  end
+end