totally_lazy 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d2bd08beb128d57daef7cb8259b9dd391d77d3f6
-  data.tar.gz: 0436a18ccd3dc6f192af42e80fbfd8467e0c068b
+  metadata.gz: 580d257ae0a5c6db629420f25fc435870cbd09d7
+  data.tar.gz: 428a631231457eb51abd105a07a91b8ad5517b26
 SHA512:
-  metadata.gz: 562656c8ed06737fedb4dd348d788e484786873855c0ecd5fb951c651ed2383a90a738c2cd64f444155589b07df9c08881964e0fafbaeebdffd11d4200d47bce
-  data.tar.gz: 3c77e9a13c67a68b76797583a83179259ffca73e5a754902b31e99c51c8c2874711d07a3943836669dea4e7025d2147090e0f69672dc3f46d8589850f339ad4b
+  metadata.gz: 831ab147b15383e7fc2ff86c4d85636cc3a93ae14c64efa2b0a4a2cf06c0cb89ff6f43ffe747273252f595213f4c0e13c5943646e4b2e786c2095272a428de4d
+  data.tar.gz: aeff00bdcac329c9554adca869f9c022d7c9e11eef72958ae61e434a0a590dcff45b14a9aad03ce0af3ed15d685b2718c0ce10b992420e9886ed747a6e0bc6d5

data/Gemfile

@@ -6,4 +6,5 @@ group :development do
   gem 'bundler', '~> 1.0'
   gem 'jeweler', '~> 2.0.1'
   gem 'rspec_html_formatter', '~> 0.3.0'
+  gem 'rake', '~> 10.3.2'
 end

data/README.md

@@ -13,7 +13,7 @@ This is a port of the java functional library [Totally Lazy](https://code.google
 In your bundler Gemfile
 
 ```ruby
- gem totally_lazy, '~>0.0.2' 
+ gem totally_lazy, '~>0.0.3' 
 ```
 
 Or with rubygems
@@ -27,8 +27,10 @@ Or with rubygems
 The following are some simple examples of the currently implemented functionality.
 
 ```ruby
-sequence(1,2,3,4).filter{|i| i.even? } # lazily returns 2,4
-sequence(1,2).map{|i| i.to_s} # lazily returns "1","2"
+require 'totally_lazy'
+
+sequence(1,2,3,4).filter(even) # lazily returns 2,4
+sequence(1,2).map(to_string) # lazily returns "1","2"
 sequence(1,2,3).take(2) # lazily returns 1,2
 sequence(1,2,3).drop(2) # lazily returns 3
 sequence(1,2,3).tail # lazily returns 2,3

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.0.3

data/lib/functor.rb

@@ -0,0 +1,92 @@
+# Functor is Ruby's implementation of a Higher-Order-Message. Essentally,
+# a Functor can vary its behavior accorrding to the operation applied to it.
+#
+# Example
+#
+#   f = Functor.new { |op, x| x.send(op, x) }
+#   (f + 1)  #=> 2
+#   (f + 2)  #=> 4
+#   (f + 3)  #=> 6
+#   (f * 1)  #=> 1
+#   (f * 2)  #=> 4
+#   (f * 3)  #=> 9
+#
+class Functor #< BasicObject
+
+  # Functors can be somewhat inefficient if a new Functor
+  # is frequently recreated for the same use. So this cache
+  # can be used to speed things up.
+  #
+  # The +key+ will always be an array, wich makes it easier
+  # to cache Functor for multiple factors.
+  #
+  def self.cache(*key, &function)
+    @cache ||= {}
+    if function
+      @cache[key] = new(&function)
+    else
+      @cache[key]
+    end
+  end
+
+  EXCEPTIONS = [:binding, :inspect, :object_id]
+  if defined?(::BasicObject)
+    EXCEPTIONS.concat(::BasicObject.instance_methods)
+    EXCEPTIONS.uniq!
+    EXCEPTIONS.map!{ |m| m.to_sym }
+  end
+
+  #
+  alias :__class__ :class
+
+  ## If Functor were built-in to Ruby this would not be
+  ## needed since exceptions could just be added directly.
+  ##$FUNCTOR_EXCEPTIONS ||= [:binding, :undefine_method]
+
+  ## TODO: This will not work when BasicObject is utilized. How to fix?
+  ##def self.honor_exceptions
+  ##  $FUNCTOR_EXCEPTIONS.each{ |name|
+  ##    next if method_defined?(name)
+  ##    eval %{
+  ##      def #{name}(*a,&b)
+  ##        super(*a, &b)
+  ##      end
+  ##    }
+  ##  }
+  ##end
+
+  # Privatize all methods except vital methods and #binding.
+  instance_methods(true).each do |m|
+    next if m.to_s =~ /^__/
+    next if EXCEPTIONS.include?(m.to_sym)
+    undef_method(m)
+  end
+
+  #
+  def initialize(&function)
+    @function = function
+  end
+
+  #
+  def to_proc
+    @function
+  end
+
+  ##def inspect
+  ##  #"#<#{__class__}:#{object_id} #{method_missing(:inspect)}>"    # hex id ?
+  ##  "#{method_missing(:inspect)}"
+  ##end
+
+  ## Needed?
+  ##def send(op, *a, &b)
+  ##  method_missing(op, *a, &b)
+  ##end
+
+  private
+
+  # Any action against the Functor is processesd by the function.
+  def method_missing(op, *args, &blk)
+    @function.call(op, *args, &blk)
+  end
+
+end

data/lib/predicates.rb

@@ -0,0 +1,35 @@
+module Predicates
+
+  module Numbers
+
+    def even
+      -> (v) { Type.responds(v, :even?); v if v.even? }
+    end
+
+    def odd
+      -> (v) { Type.responds(v, :odd?); v if v.odd? }
+    end
+
+  end
+
+  module Conversions
+
+    def to_string
+      -> (v) { v.to_s }
+    end
+
+    def to_int
+      -> (v) { Type.responds(v, :to_i); v.to_i }
+    end
+
+    def to_float
+      -> (v) { Type.responds(v, :to_i); v.to_f }
+    end
+
+    def to_array
+      -> (v) { [v] }
+    end
+
+  end
+
+end

data/lib/sequence.rb

@@ -1,22 +1,17 @@
 class NoSuchElementException < RuntimeError
 end
 
-class Empty
-
-  def each
-    yield self
-  end
-
+class UnsupportedTypeException < RuntimeError
 end
 
 module Sequences
 
   def sequence(*items)
     if items.size == 1
-      if items.first.kind_of?(Range)
-        Sequence.new(items.first)
-      elsif items.first.kind_of?(Hash)
+      if [Range, Hash].include?(items.first.class)
         Sequence.new(items.first)
+      elsif items.first.nil?
+        empty
       else
         Sequence.new(items)
       end
@@ -26,7 +21,7 @@ module Sequences
   end
 
   def empty
-    sequence(Empty.new)
+    Empty.new
   end
 
   class Sequence < Enumerator
@@ -49,23 +44,37 @@ module Sequences
     end
 
     def <=>(object)
-      self.class <=> object.class
+      self.entries <=> object.entries
     end
 
-    def map(&block)
-      Sequence.new(self) { |yielder, val|
-        yielder << block.call(val)
-      }
+    def map(predicate=nil, &block)
+      if predicate
+        Sequence.new(self) { |yielder, val|
+          v = predicate.call(val)
+          yielder << v unless v.nil?
+        }
+      else
+        Sequence.new(self) { |yielder, val|
+          yielder << block.call(val)
+        }
+      end
     end
 
     alias collect map
 
-    def select(&block)
-      Sequence.new(self) { |yielder, val|
-        if block.call(val)
-          yielder << val
-        end
-      }
+    def select(predicate=nil, &block)
+      if predicate
+        Sequence.new(self) { |yielder, val|
+          v = predicate.call(val)
+          yielder << v unless v.nil?
+        }
+      else
+        Sequence.new(self) { |yielder, val|
+          if block.call(val)
+            yielder << val
+          end
+        }
+      end
     end
 
     alias find_all select
@@ -165,7 +174,11 @@ module Sequences
     alias get []
 
     def empty?
-      sequence.next.kind_of?(Empty)
+      begin
+        sequence.peek_values.empty?
+      rescue StopIteration
+        true
+      end
     end
 
     def head
@@ -206,30 +219,115 @@ module Sequences
     def transpose
       Sequence.new(Sequence::Generator.new do |g|
         result = []
-        max_size = self.entries.max { |a, b| a.size <=> b.size }.size
+        max_size = self.to_a.max { |a, b| a.size <=> b.size }.size
         max_size.times do |i|
-          result[i] = [self.entries.first.size]
-          self.entries.each_with_index { |r, j| result[i][j] = r[i] }
+          result[i] = [self.to_a.first.size]
+          self.to_a.each_with_index { |r, j| result[i][j] = r[i] }
         end
         result
-        self.empty? ? raise(NoSuchElementException.new, 'The sequence was empty') : result.each { |i| g.yield i }
+        if self.empty?
+          raise(NoSuchElementException.new, 'The sequence was empty')
+        else
+          raise(Exception.new, 'The subject of transposition must be multidimensional') unless self.to_a.first.is_a?(Array)
+        end
+        result.each { |i| g.yield i }
       end)
     end
 
     def join(target_sequence)
       Sequence.new(Sequence::Generator.new do |g|
         raise(Exception.new, 'The target (right side) must be a sequence') unless target_sequence.kind_of?(Sequences::Sequence)
-        (self.entries << target_sequence.entries).flatten.each{|i| g.yield i}
+        elements = self.entries
+        elements = elements.reject { |i| i.is_a?(Empty) }
+        (elements << target_sequence.entries).flatten.each { |i| g.yield i }
       end)
     end
-    alias + join
+
     alias << join
 
+    def add(target_sequence)
+      Sequence.new(Sequence::Generator.new do |g|
+        (self.entries + target_sequence.entries).each { |i| g.yield i }
+      end)
+    end
+
+    alias + add
+
+    def append(item)
+      Sequence.new(Sequence::Generator.new do |g|
+        elements = self.entries
+        elements = elements.reject { |i| i.is_a?(Empty) }
+        (elements << item).each { |i| g.yield i }
+      end)
+    end
+
+    def to_seq
+      Sequence.new(Sequence::Generator.new do |g|
+        self.entries.map { |e| Type.check(e, Sequences::Sequence); e.entries }.flatten.each { |i| g.yield i }
+      end)
+    end
+
+    def from_pairs
+      Sequence.new(Sequence::Generator.new do |g|
+        self.entries.map { |e| Type.check(e, Pair::Pair); [e.key, e.value] }.flatten.each { |i| g.yield i }
+      end)
+    end
+
+    def to_a
+      execution = {
+          Sequences::Sequence => -> { self.entries.map { |s| s.entries } },
+          Pair::Pair => -> { self.entries.map { |pair| pair.to_map } }
+      }
+      if self.empty?
+        self.entries
+      else
+
+        first_item = self.peek_values.first.class
+        execution[first_item].nil? ? self.entries : execution[first_item].call
+      end
+    end
+
+    def all
+      to_a.flatten
+    end
+
+    def get_or_else(index, or_else)
+      blank?(sequence[index]) ? or_else : sequence[index]
+    end
+
+    def get_option(index)
+      blank?(sequence[index]) ? none : some(sequence[index])
+    end
+
+
     private
     def sequence
       Sequence.new(self)
     end
 
+    def blank?(item)
+      item.respond_to?(:empty?) ? item.empty? : !item
+    end
+
+  end
+
+  class Empty < Sequence
+
+    def initialize(obj=[], &block)
+      super(obj) { |yielder|
+        begin
+          obj.each { |x|
+            if block
+              block.call(yielder, x)
+            else
+              yielder << x
+            end
+          }
+        rescue StopIteration
+        end
+      }
+    end
+
   end
 
 end
@@ -246,3 +344,5 @@ end
 
 
 
+
+

data/lib/totally_lazy.rb

@@ -1,8 +1,13 @@
+require_relative 'type_check'
 require_relative 'sequence'
 require_relative 'pair'
 require_relative 'option'
+require_relative 'functor'
+require_relative 'predicates'
 
 include Sequences
 include Option
 include Pair
+include Predicates::Numbers
+include Predicates::Conversions
 

data/lib/type_check.rb

@@ -0,0 +1,11 @@
+class Type
+
+  def self.check(actual, expected)
+    raise(UnsupportedTypeException.new, "Target must be of type: #{expected} but was: #{actual.class}") unless actual.kind_of?(expected)
+  end
+
+  def self.responds(value,meth)
+    raise(UnsupportedTypeException.new, "Target must respond to: #{meth} - but did not with: #{value.class} of: #{value}") unless value.respond_to?(meth)
+  end
+
+end

data/spec/option_spec.rb

@@ -4,7 +4,7 @@ require_relative '../lib/totally_lazy'
 describe 'Option' do
 
   it 'should support contains' do
-    expect(option(1).contains(1)).to be(true)
+    expect(option(1).contains(1)).to eq(true)
   end
 
   it 'should support is alias' do
@@ -26,7 +26,8 @@ describe 'Option' do
   end
 
   it 'should not get value of none' do
-
+    pending('not get none')
+    pass
   end
 
   it 'should get or else' do

data/spec/pair_spec.rb

@@ -22,7 +22,7 @@ describe 'Pair' do
   end
 
   it 'should convert to a sequence of pairs from a map' do
-    expect(Pair.from_map({apples:'10'})).to eq(sequence(pair(:apples,'10')))
+    expect(Pair.from_map({apples:'10'}).to_a).to eq(sequence(pair(:apples,'10')).to_a)
   end
 
   it 'should convert a pair to a map' do

data/spec/sequence_spec.rb

@@ -8,7 +8,7 @@ describe 'Sequence' do
   end
 
   it 'should support transpose' do
-    expect(sequence(sequence(1, 2), sequence(3, 4), sequence(5, 6))).to include(sequence(1, 3, 5), sequence(2, 4, 6))
+    expect(sequence(sequence(1, 2), sequence(3, 4), sequence(5, 6)).transpose).to include(sequence(1, 3, 5), sequence(2, 4, 6))
   end
 
   it 'should eagerly return the first element of a sequence, returns NoSuchElementException if empty' do
@@ -46,5 +46,10 @@ describe 'Sequence' do
     expect { empty.shuffle.first }.to raise_error(NoSuchElementException)
   end
 
+  it 'should lazily join sequences together' do
+    expect(sequence(1,2,3).join(sequence(4,5,6))).to eq(sequence(1,2,3,4,5,6))
+    expect(empty.join(sequence(1,2))).to eq(sequence(1,2))
+  end
+
 
 end

data/totally_lazy.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: totally_lazy 0.0.2 ruby lib
+# stub: totally_lazy 0.0.3 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "totally_lazy"
-  s.version = "0.0.2"
+  s.version = "0.0.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]
   s.authors = ["Kingsley Hendrickse"]
-  s.date = "2014-08-15"
+  s.date = "2014-08-16"
   s.description = "Port of java functional library totally lazy to ruby"
   s.email = "kingsleyhendrickse@me.com"
   s.extra_rdoc_files = [
@@ -26,11 +26,14 @@ Gem::Specification.new do |s|
     "README.md",
     "Rakefile",
     "VERSION",
+    "lib/functor.rb",
     "lib/option.rb",
     "lib/pair.rb",
+    "lib/predicates.rb",
     "lib/sequence.rb",
     "lib/totally_lazy.rb",
     "lib/tuple.rb",
+    "lib/type_check.rb",
     "spec/option_spec.rb",
     "spec/pair_spec.rb",
     "spec/sequence_spec.rb",
@@ -51,12 +54,14 @@ Gem::Specification.new do |s|
       s.add_development_dependency(%q<bundler>, ["~> 1.0"])
       s.add_development_dependency(%q<jeweler>, ["~> 2.0.1"])
       s.add_development_dependency(%q<rspec_html_formatter>, ["~> 0.3.0"])
+      s.add_development_dependency(%q<rake>, ["~> 10.3.2"])
     else
       s.add_dependency(%q<rspec>, ["~> 3.0.0"])
       s.add_dependency(%q<rdoc>, ["~> 3.12"])
       s.add_dependency(%q<bundler>, ["~> 1.0"])
       s.add_dependency(%q<jeweler>, ["~> 2.0.1"])
       s.add_dependency(%q<rspec_html_formatter>, ["~> 0.3.0"])
+      s.add_dependency(%q<rake>, ["~> 10.3.2"])
     end
   else
     s.add_dependency(%q<rspec>, ["~> 3.0.0"])
@@ -64,6 +69,7 @@ Gem::Specification.new do |s|
     s.add_dependency(%q<bundler>, ["~> 1.0"])
     s.add_dependency(%q<jeweler>, ["~> 2.0.1"])
     s.add_dependency(%q<rspec_html_formatter>, ["~> 0.3.0"])
+    s.add_dependency(%q<rake>, ["~> 10.3.2"])
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: totally_lazy
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Kingsley Hendrickse
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-15 00:00:00.000000000 Z
+date: 2014-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -80,6 +80,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.3.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 10.3.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 10.3.2
 description: Port of java functional library totally lazy to ruby
 email: kingsleyhendrickse@me.com
 executables: []
@@ -95,11 +109,14 @@ files:
 - README.md
 - Rakefile
 - VERSION
+- lib/functor.rb
 - lib/option.rb
 - lib/pair.rb
+- lib/predicates.rb
 - lib/sequence.rb
 - lib/totally_lazy.rb
 - lib/tuple.rb
+- lib/type_check.rb
 - spec/option_spec.rb
 - spec/pair_spec.rb
 - spec/sequence_spec.rb