lambda_driver 1.2.2 → 1.2.3

data/README.md

@@ -96,6 +96,21 @@ The context-funciton should recieve 2 arguments.
 - second arg is a result of g(x)
   - g is a function passed to `compose_with_lifting`
 
+If given arguments is Symbol, find context-function from
+default context-functions.
+
+- :identify
+  - this context nothing to do
+- :maybe
+  - computations which may not return a result
+- :list
+  - computations which can return multiple possible results
+- :reader
+  - computations which read from a shared environment
+- :writer
+  - computations which write data in addition to computing values
+
+see -> LambdaDriver::Context
 
 #### Proc#compose_with_lifting
 

data/lib/lambda_driver/context.rb

@@ -0,0 +1,59 @@
+# -*- encoding : utf-8 -*-
+module LambdaDriver::Context
+
+  Identify = lambda{|f, x| f.call(x) }
+
+  Maybe = lambda{|f, x|
+    mzero_method = x.respond_to?(:mzero?) ? :mzero? : :nil?
+    x.send(mzero_method) ? x : f.call(x)
+  }
+
+  List = lambda{|f, x| x.map(&f) }
+
+  Reader = lambda{|f, (r, x)|
+    # set reader env to thread local
+    Thread.current[:lambda_driver_reader_ctx_ask] = r
+    # define ask method to access context of reader
+    f.binding.eval(<<-CODE)
+      def ask
+        Thread.current[:lambda_driver_reader_ctx_ask]
+      end
+    CODE
+
+    begin
+      [r, f.call(x)]
+    ensure
+      # tear down reader context
+      Thread.current[:lambda_driver_reader_ctx_ask] = nil
+      f.binding.eval("undef ask")
+    end
+  }
+
+  Writer = lambda{|f, (x, w)|
+    pool = w || []
+
+    # set writer pool to thread local
+    Thread.current[:lambda_driver_writer_ctx_pool] = pool
+    # define tell method to write log to context
+    f.binding.eval(<<-CODE)
+      def tell(s)
+        pool = Thread.current[:lambda_driver_writer_ctx_pool]
+        pool <<  s
+      end
+    CODE
+
+    begin
+      [f.call(x), pool]
+    ensure
+      # tear down reader context
+      Thread.current[:lambda_driver_writer_ctx_pool] = nil
+      f.binding.eval("undef tell")
+    end
+  }
+
+  def self.[](name)
+    name = name.to_s.capitalize
+    const_defined?(name) && const_get(name)
+  end
+
+end

data/lib/lambda_driver/liftable.rb

@@ -6,7 +6,7 @@ module LambdaDriver::Liftable
   #
   # This method returns composed funciton like bellow.
   #
-  #  lambda{|args|  context(self, g(*args)) }
+  #  lambda{|args|  context.call(self, context.call(g,*args) }
   #
   # For example, set context-function that logging the result.
   #
@@ -15,18 +15,17 @@ module LambdaDriver::Liftable
   #   g = lambda{|y| hash[y]}
   #
   #   ctx = lambda{|f,x|
-  #     puts "g(x)    -> #{x}"
-  #     y = f.call(x)
-  #     puts "f(g(x)) -> #{y}"
-  #     y
+  #     res = f.call(x)
+  #     puts "result -> #{res}"
+  #     res
   #   }
   #
   #   lifted = f.lift(ctx)
   #   h = lifted.compose_with_lifting g
   #
   #   h.(:a)
-  #   #=>  g(x)    -> foo
-  #   #=>  f(g(x)) -> 3
+  #   #=> result -> foo
+  #   #=> result -> 3
   #   #=> 3
   #
   # if context-function does not given,
@@ -49,9 +48,17 @@ module LambdaDriver::Liftable
   #   f <= g # => f.compose_with_lifting(g)
   #
   def compose_with_lifting(g)
-    context = lambda_driver_liftable_context
-
-    lambda{|*args| context.call(self.to_proc, g.to_proc.call(*args)) }.lift(context)
+    if @lambda_driver_lifted
+      ctx = @lambda_driver_liftable_context
+      self.compose(g).tap{|f|
+        f.instance_eval do
+          @lambda_driver_lifted = true
+          @lambda_driver_liftable_context = ctx
+        end
+      }
+    else
+      self.lift(DEFAULT_CONTEXT).compose_with_lifting(g)
+    end
   end
 
   # This is a default context-function.
@@ -69,10 +76,7 @@ module LambdaDriver::Liftable
   #   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)
-  }
+  DEFAULT_CONTEXT = LambdaDriver::Context[:maybe]
 
   # Lift this function to the given context-function.
   # The lifted fucntion can compose other function with context-fucntion.
@@ -85,9 +89,26 @@ module LambdaDriver::Liftable
   #  - 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
+  def lift(ctx = DEFAULT_CONTEXT, &block)
+    ctx = block_given? ? block : ctx
+    ctx = case ctx
+      when String, Symbol then LambdaDriver::Context[ctx]
+      else ctx
+    end
+
+    # do not lift same context again
+    return self if lambda_driver_lifted? && (ctx == lambda_driver_liftable_context)
+
+    lambda{|*args| ctx.call(self, *args) }.tap{|f|
+      f.instance_eval do
+        @lambda_driver_lifted = true
+        @lambda_driver_liftable_context = ctx
+      end
+    }
+  end
+
+  def lambda_driver_lifted?
+    @lambda_driver_lifted
   end
 
   def lambda_driver_liftable_context
@@ -95,7 +116,7 @@ module LambdaDriver::Liftable
   end
 
   def >=(g)
-    g.to_proc.lift(lambda_driver_liftable_context) <= self
+    g.to_proc.lift(lambda_driver_liftable_context).compose_with_lifting(self)
   end
 
   def self.included(klass)

data/lib/lambda_driver/version.rb

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

data/spec/context_spec.rb

@@ -0,0 +1,93 @@
+# -*- encoding : utf-8 -*-
+require 'spec_helper'
+
+describe LambdaDriver::Context do
+
+  let(:f){ lambda{|x| x.to_s} }
+  let(:g){ lambda{|x| x * 2} }
+
+  describe LambdaDriver::Context::Identify do
+    let(:ctx) { :identify }
+    let(:x){ :foo }
+    it("f.lift(:identify).call(x).should == f(x)"){
+      f.lift(:identify).call(x).should == f.call(x)
+    }
+
+    it("(f.lift(:identify) >= g).call(x).should == g(f(x))"){
+      (f.lift(:identify) >= g).call(x).should == g.call(f.call(x))
+    }
+  end
+
+  describe LambdaDriver::Context::Maybe do
+    let(:x){ :foo }
+
+    it("f.lift(:maybe).call(nil).should be_nil"){
+      f.lift(:maybe).call(nil).should be_nil
+    }
+
+    it("f.lift(:maybe).call(x).should f(x)"){
+      f.lift(:maybe).call(x).should == f.call(x)
+    }
+
+    it("(f.lift(:maybe) >= g).call(nil).should be_nil "){
+      (f.lift(:maybe) >= g).call(nil).should be_nil
+    }
+
+    it("(f.lift(:maybe) >= g).call(x).should == g(f(x))"){
+      (f.lift(:maybe) >= g).call(x).should == g.call(f.call(x))
+    }
+  end
+
+  describe LambdaDriver::Context::List do
+    let(:x){ [:foo, :bar] }
+
+    it("f.lift(:list).call([]).should == []"){
+      f.lift(:list).call([]).should == []
+    }
+
+    it("f.lift(:list).call(x).should == x.map(&f)"){
+      f.lift(:list).call(x).should == x.map(&f)
+    }
+
+    it("(f.lift(:list) >= g).call([]).should == (x.map(&f)).map(&g)"){
+      (f.lift(:list) >= g).call([]).should == []
+    }
+
+    it("(f.lift(:list) >= g).call(x).should == (x.map(&f)).map(&g)"){
+      (f.lift(:list) >= g).call(x).should == (x.map(&f)).map(&g)
+    }
+  end
+
+  describe LambdaDriver::Context::Reader do
+    let(:x){ 2 }
+    let(:r){ 3 }
+
+    let(:f){ lambda{|x| (ask + x).to_s} }
+    let(:g){ lambda{|x| x * (ask)} }
+
+    it("f.lift(:reader).call([r, x]).should == [r, f(x)]"){
+      f.lift(:reader).call([r, x]).should == [r, (r + x).to_s]
+    }
+
+    it("(f.lift(:reader) >= g).call([r, x]).should == [r, g(f(x))]"){
+      (f.lift(:reader) >= g).call([r, x]).should == [r, ((r + x).to_s) * r]
+    }
+  end
+
+  describe LambdaDriver::Context::Writer do
+    let(:w) { [:hoge] }
+    let(:x) { :foo }
+    let(:f){ lambda{|x| tell("bar_" + x.to_s); x.to_s } }
+    let(:g){ lambda{|x| tell("baz_" + x); x * 2 } }
+
+    it("f.lift(:writer).call([x, w]).should == [f(x), w]"){
+      f.lift(:writer).call([x, w]).should == [x.to_s, w]
+      w.should == [:hoge, "bar_foo"]
+    }
+
+    it("(f.lift(:writer) >= g).call([r, x]).should == [r, g(f(x))]"){
+      (f.lift(:writer) >= g).call([x, w]).should == [(x.to_s) * 2, w]
+      w.should == [:hoge, "bar_foo", "baz_foo"]
+    }
+  end
+end

data/spec/shared/liftable.rb

@@ -50,11 +50,11 @@ shared_examples_for 'liftable' do
     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.lift(ctx) >= g).call(x) should be ctx(g, ctx(f, x))'){
+      (subject.lift(ctx) >= g).call(x).should == ctx.call(g, ctx.call(subject.to_proc,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)))
+    it('"(f.lift(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, ctx.call(subject.to_proc, x)))
     }
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lambda_driver
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 1.2.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-30 00:00:00.000000000 Z
+date: 2014-02-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -45,6 +45,7 @@ files:
 - lib/lambda_driver.rb
 - lib/lambda_driver/callable.rb
 - lib/lambda_driver/composable.rb
+- lib/lambda_driver/context.rb
 - lib/lambda_driver/core_ext.rb
 - lib/lambda_driver/core_ext/class.rb
 - lib/lambda_driver/core_ext/method.rb
@@ -64,6 +65,7 @@ files:
 - lib/lambda_driver/version.rb
 - lib/lambda_driver/with_args.rb
 - spec/class_spec.rb
+- spec/context_spec.rb
 - spec/disjunction_spec.rb
 - spec/lambda_spec.rb
 - spec/method_spec.rb
@@ -89,7 +91,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -4555734478937324057
+      hash: -2789820637790150552
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -98,7 +100,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -4555734478937324057
+      hash: -2789820637790150552
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
@@ -107,6 +109,7 @@ specification_version: 3
 summary: Drives your code more functioal!
 test_files:
 - spec/class_spec.rb
+- spec/context_spec.rb
 - spec/disjunction_spec.rb
 - spec/lambda_spec.rb
 - spec/method_spec.rb