lambda_driver 1.0.0 → 1.1.0

data/README.md

@@ -43,61 +43,79 @@ Or install it yourself as:
 #### alias :< to Proc#call
 
 ```ruby
-  f = lamdba{|x| x.to_s }
+  f = lambda{|x| x.to_s }
   f < :foo # => "foo"
 ```
 
+#### alias :+@ to Proc#to_proc
+
+```ruby
+  +:to_s           # => #<Proc:0x007ff78aadaa78>
+  +:to_s < :foo    # => "foo"
+```
+
+
 #### Proc#compose
 
 Returns new lambda which composed self and given function.
 A composed proc called with args, executes `self.(g(*args)).
 
 ```ruby
-  f = lamdba{|x| x.to_s }
+  f = lambda{|x| x.to_s * 2 }
   g = lambda{|y| y.length }
-  h = f compose g
-  h.(:hoge) # => 4
+
+  h = f.compose g  # => #<Proc:0x007ff78aa2ab2>
+  h.(:hoge)        # => "44" ( == f.call(g.call(:hoge)) )
 ```
 
 This method is aliased as `<<`.
 
 ```ruby
-  f << g # => f.compose(g)
+  f << g          # => f.compose(g)
+  f << g < :hoge  # => "44" ( == f.call(g.call(:hoge)) )
 ```
 
 #### Proc#with_args
 
-Returns partially applied function that has 2nd and more parameters
+Returns partially applied function that has 2nd and more parameters are
 fixed by given *args.
 
 ```ruby
-  f = lamdba{|x, y, z| [x, y, z]}
-  h = f.with_args(:a, :b)
-  h.(:c) # => [:c, :a, :b]
+  f = lambda{|x, y, z| [x, y, z]}
+
+  h = f.with_args(:a, :b)   # => #<Proc:0x007ff78a9c5ca0>
+  h.(:c)                    # => [:c, :a, :b] ( == f.call(:c, :a, :b) )
 ```
 
 This method is aliased as `*`.
 
 ```ruby
-  f * :foo  # => f.with_args(:foo)
+  f = lambda{|x, y| [x, y]}
+
+  f * :foo          # => #<Proc:0x007ff78a987540> (== f.with_args(:foo) )
+  f * :foo < :bar   # => [:bar,  :foo] ( == f.with_args(:foo).call(:bar) )
 ```
 
 
 #### Proc#flip
 
-Returns function whose parameter order spawed 1st for 2nd.
+Returns function whose parameter order swaped 1st for 2nd.
 A result of filped fuction is curried by Proc#curry.
 
 ```ruby
-  f = lamdba{|x, y, z| [x, y, z]}
-  h = f.flip
-  h.(:a).(:b).(:c) # => [:b, :a, :c]
+  f = lambda{|x, y, z| [x, y, z]}
+
+  h = f.flip                    # => #<Proc:0x007ff78a942fa>
+  h.call(:a).call(:b).call(:c)  # => [:b, :a, :c] (== f.curry.call(:b).call(:a).call(:b))
+  h < :a < :b < :c              # => [:b, :a, :c] (== f.curry.call(:b).call(:a).call(:b))
 ```
 
 If arguments is var-args, pass explicitly arity to curring.
 
 ```ruby
   p = Proc.new{|*args| args.inspect }
+
+  p.arity                           # => -1
   p.flip(3).call(:a).(:b).(:c)      # => "[:b, :a, :c]"
   p.flip(4).call(:a).(:b).(:c).(:d) # => "[:b, :a, :c, :d]"
 ```
@@ -107,11 +125,26 @@ If arity is 0 or 1, flip returns itself.
 This method is aliased as `~@`.
 
 ```ruby
-  ~f # => f.filp
+  ~f # =>             #<Proc:0x007ff78a8e22c> (== f.filp)
+  ~f < :a < :b < :c   # => [:b, :a, :c] (== f.filp.call(:b).call(:a).call(:b))
+
 ```
 
-<!-- Symbol extensions -->
-<!-- - to_method -->
+### Symbol extensions
+- to_method
+
+#### Symbol#to_method
+
+Symbol#to_method generates a function that extract Method object from given arguments.
+This method is aliased as `-@`.
+
+```ruby
+  (-:index).call("foobarbaz")             # => #<Method: String#index>
+  (-:index).call("foobarbaz").call("bar") # => 3 (== "foobarbaz".index(3) )
+
+  -:index < "foobarbaz"         # => #<Method: String#index>
+  -:index < "foobarbaz" < "bar" # => 3 (== "foobarbaz".index(3) )
+```
 
 ### Class extensions
 - alias instance_method, :/
@@ -134,32 +167,43 @@ This method is aliased as `~@`.
 - ski combinator
 
 ### Object extensions
-- ap(|>) :  obj.ap(f) => f.call(obj)
-- obj._.method : returns obj.method(method) or lamdba{|*args| obj.send(method, *args) }
-<!-- - obj.disjunction(f) : if f(self) is nil, return self else return f(self) -->
+- obj.ap(|>)
+- obj._
+- obj.disjunction(f)
 
-#### Object#ap
+#### Object#revapply
 
-`Object#ap` is applies self to given proc/block.
+`Object#revapply` is applies self to given proc/block.
 
 ```ruby
   f = lambda{|x| x * 2 }
-  "foo".ap(f) #  => "fooffoo"
+
+  "foo".revapply(f) #  => "fooffoo" (== f.call("foo") )
 ```
 
 #### Object#_
 
-Object#op is shortcut to quickly extract Method object.
+Object#_ is shortcut to quickly extract Method object.
 
 ```ruby
-"foobarbaz"._.index         #=> #<Method: String#index>
+"foobarbaz"._.index         # => #<Method: String#index>
 "foobarbaz"._.index < "bar" # => 3 (== "foobarbaz".index(3) )
 
-2._(:>=) # => #<Method: Fixnum#>=>
+2._(:>=)                    # => #<Method: Fixnum#>=>
 [1, 2, 3].select(&2._(:>=)) # => [1, 2]( = [1, 2].select{|n| 2 >= n})
 ```
 
+#### Object#disjunction
+
+`Object#disjunction` select self or result of applied self to given function.
+if f(self) is nil, returns self, otherwise return f(self).
 
+```ruby
+  f = lambda{|x| x % 2 == 0 ? nil : x * 2}
+
+  2.disjunction(f) # => 2 (disjunction returns reciever object)
+  3.disjunction(f) # => 6 (disjunction returns f(3) )
+```
 
 ## Contributing
 

data/lib/lambda_driver/core_ext/object.rb

@@ -1,4 +1,5 @@
 class Object
   include LambdaDriver::Op::Proxy
-  include LambdaDriver::Ap
+  include LambdaDriver::Revapply
+  include LambdaDriver::Disjunction
 end

data/lib/lambda_driver/core_ext/symbol.rb

@@ -1,4 +1,10 @@
 class Symbol
   include LambdaDriver::Callable
   include LambdaDriver::Currying if RUBY_VERSION < '1.9.0'
+
+  def to_method
+    lambda{|obj| obj._(self) }
+  end
+
+  alias_method :-@, :to_method
 end

data/lib/lambda_driver/disjunction.rb

@@ -0,0 +1,9 @@
+module LambdaDriver::Disjunction
+  def disjunction(f = nil, &block)
+    if f.nil? && (not block_given?)
+      return lambda{|g=nil,&inner_block| self.disjunction(g, &inner_block) }
+    end
+
+    (block_given? ?  (yield self) : f.call(self)) || self
+  end
+end

data/lib/lambda_driver/revapply.rb

@@ -0,0 +1,9 @@
+module LambdaDriver::Revapply
+  def revapply(f = nil, &block)
+    if f.nil? && (not block_given?)
+      return lambda{|g=nil,&inner_block| self.revapply(g, &inner_block) }
+    end
+
+    block_given? ?  (yield self) : f.call(self)
+  end
+end

data/lib/lambda_driver/version.rb

@@ -1,3 +1,3 @@
 module LambdaDriver
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

data/spec/disjunction_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe LambdaDriver::Disjunction do
+  let(:obj) { "foobarbaz" }
+  let(:f) { lambda{|x| x * 2 } }
+
+  describe '#disjunction'do
+    context 'f(obj) returns nil' do
+      context 'given none' do
+        subject { obj.disjunction }
+
+        it { should be_a_kind_of Proc }
+
+        it('obj.disjunction.call(f) should be obj'){
+          subject.call(lambda{|x| nil}).should == obj
+        }
+        it('obj.disjunction.call{block} should be obj'){
+          subject.call{nil}.should == obj
+        }
+        it('obj.disjunction.call(f){block} should obj'){
+          subject.call(f){nil}.should == obj
+        }
+      end
+
+      context 'block given' do
+        it('obj.disjunction{block} should be result of execute block with obj'){
+          obj.disjunction{nil}.should == obj
+        }
+      end
+
+      context 'proc object given' do
+        it('obj.ap(f) should be f.call(obj)'){
+          obj.disjunction(lambda{|x| nil}).should == obj
+        }
+      end
+
+      context 'block given and proc object given' do
+        it('obj.ap.call(f){block} should be result of execute block with obj'){
+          obj.disjunction(f){nil}.should == obj
+        }
+      end
+    end
+
+    context 'f(obj) does not returns nil' do
+      context 'given none' do
+        subject { obj.disjunction }
+
+        it { should be_a_kind_of Proc }
+
+        it('obj.disjunction.call(f) should be obj'){
+          subject.call(f).should == f.call(obj)
+        }
+        it('obj.disjunction.call{block} should be result of execute block with obj'){
+          subject.call{|x| x * 3 }.should == obj * 3
+        }
+        it('obj.disjunction.call(f){block} should be result of execute block with obj'){
+          subject.call(f){|x| x * 3 }.should == obj * 3
+        }
+      end
+
+      context 'block given' do
+        it('obj.disjunction{block} should be result of execute block with obj'){
+          obj.disjunction{|x| x * 3 }.should == (obj * 3)
+        }
+      end
+
+      context 'proc object given' do
+        it('obj.ap(f) should be f.call(obj)'){
+          obj.disjunction(f).should == f.call(obj)
+        }
+      end
+
+      context 'block given and proc object given' do
+        it('obj.ap.call(f){block} should be result of execute block with obj'){
+          obj.disjunction(f){|x| x * 3 }.should == (obj * 3)
+        }
+      end
+    end
+  end
+end

data/spec/revapply_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe LambdaDriver::Revapply do
+  let(:object) { "foobarbaz" }
+  let(:f) { lambda{|x| x * 2 } }
+
+  describe '#revapply'do
+    context 'given none' do
+      subject { object.revapply }
+
+      it { should be_a_kind_of Proc }
+      it('obj.revapply.call(f) should be f.call(obj)'){
+        subject.call(f).should == f.call(object)
+      }
+      it('obj.revapply.call{block} should be result of execute block with obj'){
+        subject.call{|x| x * 3 }.should == (object * 3)
+      }
+      it('obj.revapply.call(f){block} should be result of execute block with obj'){
+        subject.call(f){|x| x * 3 }.should == (object * 3)
+      }
+    end
+
+    context 'block given' do
+      it('obj.revapply{block} should be result of execute block with obj'){
+        object.revapply{|x| x * 3 }.should == (object * 3)
+      }
+    end
+
+    context 'proc object given' do
+      it('obj.revapply(f) should be f.call(obj)'){
+        object.revapply(f).should == f.call(object)
+      }
+    end
+
+    context 'block given and proc object given' do
+      it('obj.revapply.call(f){block} should be result of execute block with obj'){
+        object.revapply(f){|x| x * 3 }.should == (object * 3)
+      }
+    end
+  end
+end

data/spec/symbol_spec.rb

@@ -55,9 +55,32 @@ describe Symbol do
     it_should_behave_like 'aliases'
 
     it_should_behave_like 'aliases(varargs)' do
-      subject { :product }
-      let(:x) { [:bar] }
-      let(:y) { [:foo] }
+      subject { :delete}
+      let(:x) { :bar }
+      let(:y) { 'a' }
     end
   end
+
+  describe '#to_method' do
+    subject { :index.to_method }
+
+    let(:obj) { "foobarbaz" }
+
+    it { should be_a_kind_of Proc }
+    it('symbol.to_method.call(obj) should returns Method'){
+      subject.call(obj).should be_a_kind_of Method
+    }
+
+    it('symbol.to_method.call(obj).call(x) should be obj.method(symbol).call(x)'){
+      subject.call(obj).call("bar").should == obj.method(:index).call("bar")
+    }
+
+    it('-:symbol.to_method.call(obj) should returns Method'){
+      (-:index).call(obj).should be_a_kind_of Method
+    }
+
+    it('-:symbol.to_method.call(obj).call(x) should be obj.method(symbol).call(x)'){
+      (-:index).call(obj).call("bar").should == obj.method(:index).call("bar")
+    }
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lambda_driver
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-26 00:00:00.000000000Z
+date: 2013-03-27 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70364479275960 !ruby/object:Gem::Requirement
+  requirement: &70294430507480 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +21,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70364479275960
+  version_requirements: *70294430507480
 description: Drives your code more functioal!
 email:
 - ozaki@yuroyoro.com
@@ -37,7 +37,6 @@ files:
 - Rakefile
 - lambda_driver.gemspec
 - lib/lambda_driver.rb
-- lib/lambda_driver/ap.rb
 - lib/lambda_driver/callable.rb
 - lib/lambda_driver/core_ext.rb
 - lib/lambda_driver/core_ext/class.rb
@@ -47,14 +46,17 @@ files:
 - lib/lambda_driver/core_ext/symbol.rb
 - lib/lambda_driver/core_ext/unbound_method.rb
 - lib/lambda_driver/currying.rb
+- lib/lambda_driver/disjunction.rb
 - lib/lambda_driver/op.rb
+- lib/lambda_driver/revapply.rb
 - lib/lambda_driver/version.rb
-- spec/ap_spec.rb
 - spec/class_spec.rb
+- spec/disjunction_spec.rb
 - spec/lambda_spec.rb
 - spec/method_spec.rb
 - spec/op_spec.rb
 - spec/proc_spec.rb
+- spec/revapply_spec.rb
 - spec/shared/composable_spec.rb
 - spec/spec_helper.rb
 - spec/symbol_spec.rb
@@ -84,12 +86,13 @@ signing_key:
 specification_version: 3
 summary: Drives your code more functioal!
 test_files:
-- spec/ap_spec.rb
 - spec/class_spec.rb
+- spec/disjunction_spec.rb
 - spec/lambda_spec.rb
 - spec/method_spec.rb
 - spec/op_spec.rb
 - spec/proc_spec.rb
+- spec/revapply_spec.rb
 - spec/shared/composable_spec.rb
 - spec/spec_helper.rb
 - spec/symbol_spec.rb

data/lib/lambda_driver/ap.rb

@@ -1,13 +0,0 @@
-module LambdaDriver::Ap
-  def ap(f = nil, &block)
-    if f.nil? && (not block_given?)
-      return lambda{|g=nil,&inner_block| self.ap(g, &inner_block) }
-    end
-
-    if block_given?
-      yield self
-    else
-      f.call(self)
-    end
-  end
-end

data/spec/ap_spec.rb

@@ -1,41 +0,0 @@
-require 'spec_helper'
-
-describe LambdaDriver::Ap do
-  let(:object) { "foobarbaz" }
-  let(:f) { lambda{|x| x * 2 } }
-
-  describe '#ap'do
-    context 'given none' do
-      subject { object.ap }
-
-      it { should be_a_kind_of Proc }
-      it('obj.ap.call(f) should be f.call(obj)'){
-        subject.call(f).should == f.call(object)
-      }
-      it('obj.ap.call{block} should be result of execute block with obj'){
-        subject.call{|x| x * 3 }.should == (object * 3)
-      }
-      it('obj.ap.call(f){block} should be result of execute block with obj'){
-        subject.call(f){|x| x * 3 }.should == (object * 3)
-      }
-    end
-
-    context 'block given' do
-      it('obj.ap{block} should be result of execute block with obj'){
-        object.ap{|x| x * 3 }.should == (object * 3)
-      }
-    end
-
-    context 'proc object given' do
-      it('obj.ap(f) should be f.call(obj)'){
-        object.ap(f).should == f.call(object)
-      }
-    end
-
-    context 'block given and proc object given' do
-      it('obj.ap.call(f){block} should be result of execute block with obj'){
-        object.ap(f){|x| x * 3 }.should == (object * 3)
-      }
-    end
-  end
-end