lambda_driver 1.2.1 → 1.2.2

data/README.md

@@ -82,22 +82,70 @@ This method is aliased as `<<`.
   f << g < :hoge  # => "44" ( == f.call(g.call(:hoge)) )
 ```
 
+#### Proc#lift
+
+Lift this function to the given context-function.
+The lifted fucntion can compose other function with context-fucntion.
+
+The given context-fuction used by `compose_with_lifting`
+to compose other fucntion.
+
+The context-funciton should recieve 2 arguments.
+
+- first one is a function that reciver function of `compose_with_lifting` method.
+- second arg is a result of g(x)
+  - g is a function passed to `compose_with_lifting`
+
 
 #### Proc#compose_with_lifting
 
-compose self and give fuction with checking g(x) is mzero.
+Compose self and given function on the context-function.
+The context-funciton is passed by `lift` method.
+
+This method returns composed funciton like bellow.
+
+```ruby
+ lambda{|args|  context(self, g(*args)) }
+```
+
+For example, set context-function that logging the result.
+
+```ruby
+  hash = {:a => "foo"}
+  f = lambda{|x| x.length}
+  g = lambda{|y| hash[y]}
+
+  ctx = lambda{|f,x|
+    puts "g(x)    -> #{x}"
+    y = f.call(x)
+    puts "f(g(x)) -> #{y}"
+    y
+  }
+
+  lifted = f.lift(ctx)
+  h = lifted.compose_with_lifting g
+
+  h.(:a)
+  #=>  g(x)    -> foo # output by ctx
+  #=>  f(g(x)) -> 3   # output by ctx
+  #=> 3
+```
+
+if context-function does not given,
+default behaivior is compose function with checking g(x) is mzoro
+
 if g(x) is mzero, it does not call self and return g(x),
 otherwise returns f(g(x)).
 
 mzero means the object is nil or emtpy
 
 ```ruby
-   hash = {:a => "foo"}
-   f = lambda{|y| y.length }
-   g = lambda{|y| hash[y]}
-   h = f.compose_with_lifting g
-   h.(:a) # => 3
-   h.(:b) # => nil (it does not called f)
+  hash = {:a => "foo"}
+  f = lambda{|y| y.length }
+  g = lambda{|y| hash[y]}
+  h = f.compose_with_lifting g
+  h.(:a) # => 3
+  h.(:b) # => nil (it does not called f)
 ```
 
 This method is aliased as `<=`.
@@ -106,7 +154,6 @@ This method is aliased as `<=`.
   f <= g # => f.compose_with_lifting(g)
 ```
 
-
 #### Proc#with_args
 
 Returns partially applied function that has 2nd and more parameters are

data/lib/lambda_driver/liftable.rb

@@ -1,7 +1,37 @@
 # -*- encoding : utf-8 -*-
 module LambdaDriver::Liftable
 
-  # compose self and give fuction with checking g(x) is mzero.
+  # Compose self and given function on the context-function.
+  # The context-funciton is passed by `lift` method.
+  #
+  # This method returns composed funciton like bellow.
+  #
+  #  lambda{|args|  context(self, g(*args)) }
+  #
+  # For example, set context-function that logging the result.
+  #
+  #   hash = {:a => "foo"}
+  #   f = lambda{|x| x.length}
+  #   g = lambda{|y| hash[y]}
+  #
+  #   ctx = lambda{|f,x|
+  #     puts "g(x)    -> #{x}"
+  #     y = f.call(x)
+  #     puts "f(g(x)) -> #{y}"
+  #     y
+  #   }
+  #
+  #   lifted = f.lift(ctx)
+  #   h = lifted.compose_with_lifting g
+  #
+  #   h.(:a)
+  #   #=>  g(x)    -> foo
+  #   #=>  f(g(x)) -> 3
+  #   #=> 3
+  #
+  # if context-function does not given,
+  # default behaivior is compose function with checking g(x) is mzoro
+  #
   # if g(x) is mzero, it does not call self and return g(x),
   # otherwise returns f(g(x)).
   #
@@ -19,15 +49,53 @@ module LambdaDriver::Liftable
   #   f <= g # => f.compose_with_lifting(g)
   #
   def compose_with_lifting(g)
-    lambda{|*args|
-      result = g.to_proc.call(*args)
-      mzero_method = result.respond_to?(:mzero?) ? :mzero? : :nil?
-      result.send(mzero_method) ? result : self.to_proc.call(result)
-    }
+    context = lambda_driver_liftable_context
+
+    lambda{|*args| context.call(self.to_proc, g.to_proc.call(*args)) }.lift(context)
+  end
+
+  # This is a default context-function.
+  # default behaivior is compose function with checking g(x) is mzoro
+  #
+  # if g(x) is mzero, it does not call self and return g(x),
+  # otherwise returns f(g(x)).
+  #
+  # mzero means the object is nil or emtpy
+  #
+  #   hash = {:a => "foo"}
+  #   f = lambda{|y| y.length }
+  #   g = lambda{|y| hash[y]}
+  #   h = f.compose_with_lifting g
+  #   h.(:a) # => 3
+  #   h.(:b) # => nil (it does not called f)
+  #
+  DEFAULT_CONTEXT = lambda{|f, x|
+    mzero_method = x.respond_to?(:mzero?) ? :mzero? : :nil?
+    x.send(mzero_method) ? x : f.call(x)
+  }
+
+  # Lift this function to the given context-function.
+  # The lifted fucntion can compose other function with context-fucntion.
+  #
+  # The given context-fuction used by `compose_with_lifting`
+  # to compose other fucntion.
+  #
+  # The context-funciton should recieve 2 arguments.
+  #  - first one is a function that reciver function of `compose_with_lifting` method.
+  #  - second arg is a result of g(x)
+  #  -- g is a function passed to `compose_with_lifting`
+  #
+  def lift(g = DEFAULT_CONTEXT)
+    @lambda_driver_liftable_context = g
+    self
+  end
+
+  def lambda_driver_liftable_context
+    @lambda_driver_liftable_context || DEFAULT_CONTEXT
   end
 
   def >=(g)
-    g.to_proc <= self
+    g.to_proc.lift(lambda_driver_liftable_context) <= self
   end
 
   def self.included(klass)

data/lib/lambda_driver/version.rb

@@ -1,4 +1,4 @@
 # -*- encoding : utf-8 -*-
 module LambdaDriver
-  VERSION = "1.2.1"
+  VERSION = "1.2.2"
 end

data/spec/shared/liftable.rb

@@ -17,28 +17,44 @@ shared_examples_for 'liftable' do
     end
     }
   }
+  let(:h) { lambda{|x| (x.to_s * 3) + "_h" } }
 
-  it('" f >= g" returns function that does not call g if args is mzero'){
-    (subject >= g).should be_a_kind_of Proc
-  }
+  context 'lift on default-context' do
+    it('" f >= g" returns function that does not call g if args is mzero'){
+      (subject >= g).should be_a_kind_of Proc
+    }
 
-  it('"(f >= g).call(nil) returns nil and does not call g'){
-    (subject >= g).call(nil).should be_nil
-  }
-  it('"(f >= g).call(x) should be g(f(x))'){
-    (subject >= g).call(x).should == g.call(subject.to_proc.call(x))
-  }
-  it('"(f >= g).call([]) returns [] and does not call g'){
-    (subject >= g).call([]).should == []
-  }
-  it('"(f >= g).call([1,2]) should be g(f([1,2]))'){
-    (subject >= g).call(y).should == g.call(subject.to_proc.call(y))
-  }
-  it('"(f >= g).call({}) returns {} and does not call g'){
-    (subject >= g).call({}).should == {}
-  }
-  it('"(f >= g).call({:a => 1,:b => 2}) should be g(f({:a => 1,  :b => 2}))'){
-    (subject >= g).call(z).should == g.call(subject.to_proc.call(z))
-  }
+    it('"(f >= g).call(nil) returns nil and does not call g'){
+      (subject >= g).call(nil).should be_nil
+    }
+    it('"(f >= g).call(x) should be g(f(x))'){
+      (subject >= g).call(x).should == g.call(subject.to_proc.call(x))
+    }
+    it('"(f >= g).call([]) returns [] and does not call g'){
+      (subject >= g).call([]).should == []
+    }
+    it('"(f >= g).call([1,2]) should be g(f([1,2]))'){
+      (subject >= g).call(y).should == g.call(subject.to_proc.call(y))
+    }
+    it('"(f >= g).call({}) returns {} and does not call g'){
+      (subject >= g).call({}).should == {}
+    }
+    it('"(f >= g).call({:a => 1,:b => 2}) should be g(f({:a => 1,  :b => 2}))'){
+      (subject >= g).call(z).should == g.call(subject.to_proc.call(z))
+    }
+  end
 
+  context 'lift on given context' do
+    let(:ctx) { lambda{|f,x| f.call(x) + "_ctx_" }}
+
+    it(" f.lift(ctx) >= g returns funciton that compose with ctx"){
+      (subject.lift(ctx) >= g).should be_a_kind_of Proc
+    }
+    it('"(f.flit(ctx) >= g).call(x) should be ctx(g, f(x))'){
+      (subject.lift(ctx) >= g).call(x).should == ctx.call(g, subject.to_proc.call(x))
+    }
+    it('"(f.flit(ctx) >= g >= h).call(x) should be ctx(h, ctx(g, f(x)))'){
+      (subject.lift(ctx) >= g >= h).call(x).should == ctx.call(h, ctx.call(g, subject.to_proc.call(x)))
+    }
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lambda_driver
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.2.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-29 00:00:00.000000000 Z
+date: 2014-01-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -87,12 +87,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -4555734478937324057
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -4555734478937324057
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23