totally_lazy 0.1.53 → 0.1.54

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZTdhZDRmMzNkZmNiODRjYjcxMTFjM2Y1NDgwN2MxZWFiMjU1YzQ2MA==
+    ODE3OWEyZGRkZjQwZjQ5MjdjOTI5YmFkMjdiZDU1Y2FhMjc0MzAwYQ==
   data.tar.gz: !binary |-
-    NTllOGQ4MjEwY2UyZDNiMDI3YTAyNTgwY2UwNGU5NWRhYmFhOTY4ZA==
+    ZTEyZjkwNWU1ZmNjODA1NDFjOWVkOGEwNmQ4MmI3NmYyNzY5MWJmMg==
 SHA512:
   metadata.gz: !binary |-
-    Yjc5M2JmOTBmNWMyNWRiMmU3YzE5ZWE3OGMyYzM0MzM4OTQ5ZGExYjdjMjZm
-    NWM4YWQwNDJmZjQ1MjBlNzBjY2M2YjlmMTRhYTE1YjZiYmZjMjdhNzZjMTNj
-    ZTZiMTM2OWMwYmI3MDQ1ODhkNGYxMzcyN2RhZjI3N2ExNTgzNTM=
+    MmU3MDY1NDBkOTg4NGFmZGE5ZDFlNTZjMDhlNjdhMGIyNjI2YzE3MDMxNjMy
+    ZWRhNDAwNGQzMGE5ZmI2NjRlMTdkNjhhOTA1Y2M4MjYyYTZjOGNiOWYyNGI1
+    MzZjOWRiZDQxOWI0YzY4OGQ4NGVmOTlhNWEyY2FmNGU4OWYxNzk=
   data.tar.gz: !binary |-
-    NmZjYWIxMjM4MWMzNzE0MTlmMDg1Y2ZmOGNiYzgxZGFmYzNmNzljNDc0Mzk0
-    ODc4MmNhMDNmMWU3MmU5NGE5Y2VhODFjYjY1ZDdkMWFkYjA4MjI5NDg4MTU3
-    ZWMwMzEzMTRiM2QwMDllODBkMjA3ZDVmOTcwYmJiYjQwZjk3NzM=
+    YzM5MmRhZjQ4NTY3ZDAzMjQ0YzgyMjA2ZGQyMmJlNzBhNmI4N2FmZTdkMjA5
+    ZDg0ZjNkYzI2NDY1NGZiMGM1MTM5NjEwMzMwYjAwOGNjZjA2MWQ1M2RkODFk
+    NjVhNWZjMzIxY2JlMGNkOWIyZDJjMTkyYWJkODhmOTM1NjEyOTg=

data/lib/totally_lazy/either.rb

@@ -22,6 +22,14 @@ module Eithers
     Either.right(value)
   end
 
+  def is_left
+    predicate(-> (either) { either.is_left? })
+  end
+
+  def is_right
+    predicate(-> (either) { either.is_right? })
+  end
+
   def as_left
     ->(value) { left(value) }
   end

data/lib/totally_lazy/functions.rb

@@ -10,10 +10,9 @@ class Proc
     Proc.compose(self, g)
   end
 
-  def and(g)
+  def and_then(g)
     Proc.compose(g, self)
   end
-  alias and_then and
 end
 
 module Functions

data/lib/totally_lazy/numbers.rb

@@ -21,7 +21,7 @@ module Numbers
   end
 
   def remainder_is(divisor, remainder)
-    ->(dividend) { remainder(dividend, divisor) == remainder }
+    predicate(->(dividend) { remainder(dividend, divisor) == remainder })
   end
 
   def remainder(dividend, divisor)
@@ -45,6 +45,6 @@ module Numbers
   end
 
   def greater_than(right)
-    ->(left) { left > right }
+    predicate(->(left) { left > right })
   end
 end

data/lib/totally_lazy/predicates.rb

@@ -1,27 +1,39 @@
 module Predicates
   private
-  def is_not(pred)
-    -> (bool) { !pred.(bool) }
-  end
-
-  def is_left
-    -> (either) { either.is_left? }
+  def predicate(fn)
+    def fn.and(other)
+      -> (value) { self.(value) && other.(value) }
+    end
+    def fn.or(other)
+      -> (value) { self.(value) || other.(value) }
+    end
+    fn
   end
 
-  def is_right
-    -> (either) { either.is_right? }
+  def is_not(pred)
+    predicate(-> (bool) { !pred.(bool) })
   end
 
   def matches(regex)
-    ->(value) { !regex.match(value).nil? }
+    predicate(->(value) { !regex.match(value).nil? })
   end
 
   def equal_to?(that)
-    ->(this) { this == that }
+    predicate(->(this) { this == that })
   end
   alias is equal_to?
 
   def where(fn, predicate)
-    ->(value) { predicate.(fn.(value)) }
+    predicate(->(value) { predicate.(fn.(value)) })
+  end
+end
+
+class PredicateFunction < Proc
+  def and(other)
+    ->(value) { self.(value) && other.(value) }
+  end
+
+  def or(other)
+    ->(value) { self.(value) || other.(value) }
   end
 end

data/lib/totally_lazy/sequence.rb

@@ -319,6 +319,10 @@ class Sequence
     @enumerator.entries <=> other.enumerator.entries
   end
 
+  def inspect
+    to_s
+  end
+
   def to_s
     sample = take(100).to_a.to_seq
     "[#{sample.is_empty? ? '' : sample.reduce(join_with_sep(','))}]"

data/spec/totally_lazy/functions_spec.rb

@@ -5,6 +5,6 @@ describe 'Functions' do
     add_2 = ->(value) { value+2 }
     divide_by_2 = ->(value) { value/2 }
     expect(sequence(10).map(divide_by_2 * add_2)).to eq(sequence(6))
-    expect(sequence(10).map(divide_by_2.and(add_2))).to eq(sequence(7))
+    expect(sequence(10).map(divide_by_2.and_then(add_2))).to eq(sequence(7))
   end
 end

data/spec/totally_lazy/predicates_spec.rb

@@ -32,4 +32,9 @@ describe 'Predicates' do
   it 'should be able to negate other predicates using is_not' do
     expect(sequence(raymond).filter(where(age, is_not(greater_than(40))))).to eq(empty)
   end
+
+  it 'should allow predicates to be composed using logical operations (AND/OR)' do
+    expect(sequence(1,2,3,4,5).filter(greater_than(2).and(odd))).to eq(sequence(3,5))
+    expect(sequence(1,2,3,4,5).filter(greater_than(2).or(odd))).to eq(sequence(1,3,4,5))
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: totally_lazy
 version: !ruby/object:Gem::Version
-  version: 0.1.53
+  version: 0.1.54
 platform: ruby
 authors:
 - Raymond Barlow
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-02 00:00:00.000000000 Z
+date: 2016-03-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby-edge