totally_lazy 0.1.26 → 0.1.28

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MjAwMDFhNmJiNmFlNTZmMDA3ODg5ZTUxNGNjMDZhNzA1MmFkYTRmOA==
+    MWZkMGRlODJjYzAwMDBmMmFiMTE3NDk0N2QzNTA4NTJkMTgxZTNkMw==
   data.tar.gz: !binary |-
-    ZDgwNjk1NTU3NDk5ZDk1OThlMTVlYWRhYmY2ZGUzNDQxOTIzNDBmNw==
+    OWM4YjJjMmIxYmUxZjE1N2RiYTI1Mjg0ZThhZmU4MzhlNGM2MWYxOQ==
 SHA512:
   metadata.gz: !binary |-
-    ZTExNjEzN2FhOWJjN2MzMDI2N2RmOTZlZmZlYzUxY2U4Mzc1NGZiMmZjYzJh
-    ZjViMjdlYzQzMmRkNDdkZjhlNDAxYjYwZDczZDRlOTA0MTY4NWYzYjlmMWNj
-    ZjJiODM4MDY1OWZkNmJhNjA5NTc5NDZkOGVmNTFmYTkzZGQwNmQ=
+    Y2FiN2M4YzIzN2M5OGIzNWFjNmFiM2UyYmYxYTE0MmI4OTBiNDZiZjE3MTdj
+    ZTY0YTkwYTYzM2FiY2FlNWFkMzlhNzhhMGRjZmQzYmE1OWE4NjE0M2UzN2I2
+    ZDBiNTE4NzFlMTY5OWExMjE5YTNlZGVjNzMxZjNkYzZiOWExYjY=
   data.tar.gz: !binary |-
-    YWIxNzc0N2EwYTRkNDA1Y2RmM2Q0MGFkMTRlZjk4Njk5ODQ5YWQxMWM2OWNj
-    ZGM4ZTRiYWYwN2JlZGQ4MDNjZTQ1OGYyMDlhZWIyYTVjZmQxNzgyN2ViZDgw
-    ZjExODFmYzkwYjk3YTZlMGZjNWFjYmI0ODljMjhiMjJkY2JmMmI=
+    OTY2MDA1ZjI5MjAzOGIwOGI2NDJkZTQxNmZiZDk2MzJkODNlZTRjOWI1NWY5
+    MjU0YTAzZTYyMDdmYTdlYzY2ZDgzMDdiMjcwNTU1NzFjN2FiNzQ5NDUwMjk4
+    Yzk1MTJlNzk4MTgyYzg3OWFmODcyMTU5YTkwZTNjYmE0MTk2Yjk=

data/lib/totally_lazy/either.rb

@@ -1,3 +1,5 @@
+require_relative 'lambda_block'
+
 module Eithers
   private
   def left(value)
@@ -11,6 +13,7 @@ end
 
 class Either
   include Comparable
+  include LambdaBlock
 
   def self.left(value)
     Left.new(value)
@@ -19,7 +22,6 @@ class Either
   def self.right(value)
     Right.new(value)
   end
-
 end
 
 class Left < Either
@@ -35,16 +37,25 @@ class Left < Either
     false
   end
 
-  def left
+  def left_value
     @value
   end
 
-  def right
+  def right_value
     raise NoSuchElementException.new
   end
 
+  def map_lr(fn_left, fn_right)
+    fn_left.(@value)
+  end
+
+  def map_left(fn=nil, &block)
+    assert_funcs(fn, block_given?)
+    left(block_given? ? block.call(@value) : fn.(@value))
+  end
+
   def <=>(other)
-    @value <=> other.left
+    @value <=> other.left_value
   end
 end
 
@@ -61,15 +72,29 @@ class Right < Either
     true
   end
 
-  def left
+  def left_value
     raise NoSuchElementException.new
   end
 
-  def right
+  def right_value
     @value
   end
 
+  def map(fn=nil, &block)
+    assert_funcs(fn, block_given?)
+    right(block_given? ? block.call(@value) : fn.(@value))
+  end
+
+  def map_lr(fn_left, fn_right)
+    fn_right.(@value)
+  end
+
+  def map_left(fn=nil, &block)
+    assert_funcs(fn, block_given?)
+    self
+  end
+
   def <=>(other)
-    @value <=> other.right
+    @value <=> other.right_value
   end
 end

data/lib/totally_lazy/functions.rb

@@ -87,10 +87,10 @@ module Functions
   end
 
   def get_left
-    ->(either) { either.left }
+    ->(either) { either.left_value }
   end
 
   def get_right
-    ->(either) { either.right }
+    ->(either) { either.right_value }
   end
 end

data/lib/totally_lazy/numbers.rb

@@ -4,8 +4,8 @@ module Numbers
     monoid(->(a, b) { a + b }, 0)
   end
 
-  def add
-    sum
+  def add(increment)
+    -> (number) { number + increment }
   end
 
   def even

data/spec/totally_lazy/either_spec.rb

@@ -1,9 +1,29 @@
 require_relative '../spec_helper'
 
 describe 'Either' do
-  it 'should support filter and map' do
+  it 'can be used in filter and map' do
     eithers = sequence(left('error'), right(3))
     expect(eithers.filter(is_left?).map(get_left)).to eq(sequence('error'))
     expect(eithers.filter(is_right?).map(get_right)).to eq(sequence(3))
   end
+
+  it 'should support map' do
+    expect(right(3).map(add(2))).to eq(right(5))
+    expect(right(3).map { |a| a+2 }).to eq(right(5))
+    expect(left(3).map_lr(add(2), nil)).to eq(5)
+    expect(right(3).map_lr(nil, add(2))).to eq(5)
+  end
+
+  it 'should support map_left' do
+    expect(right(3).map_left(add(2))).to eq(right(3))
+    expect(right(3).map_left { |a| a+2 }).to eq(right(3))
+    expect(left(3).map_left(add(2))).to eq(left(5))
+    expect(left(3).map_left { |a| a+2 }).to eq(left(5))
+  end
+
+  it 'should raise exception if you try to use both lambda and block' do
+    expect { right(1).map(add(2)) { |a| a+2 } }.to raise_error(RuntimeError)
+    expect { right(1).map_left(add(2)) { |a| a+2 } }.to raise_error(RuntimeError)
+    expect { left(1).map_left(add(2)) { |a| a+2 } }.to raise_error(RuntimeError)
+  end
 end

data/spec/totally_lazy/option_spec.rb

@@ -29,11 +29,11 @@ describe 'Option' do
   end
 
   it 'should support fold (aka fold_left)' do
-    expect(option(1).fold(1, add)).to eq(2)
-    expect(option(1).fold_left(1, add)).to eq(2)
+    expect(option(1).fold(1, sum)).to eq(2)
+    expect(option(1).fold_left(1, sum)).to eq(2)
     expect(option(1).fold(1) { |a, b| a + b }).to eq(2)
-    expect(some(1).fold(1, add)).to eq(2)
-    expect(none.fold(1, add)).to eq(1)
+    expect(some(1).fold(1, sum)).to eq(2)
+    expect(none.fold(1, sum)).to eq(1)
   end
 
   it 'should support map' do

metadata

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