虚弦斥力場生成システム
LambdaDriver drives your code more functional.
# [:foo, :bar, :baz].map{|s| s.to_s }.map{|s| s.upcase }
# [:foo, :bar, :baz].map(&:to_s).map(&:upcase)
[:foo, :bar, :baz].map(&:to_s >> :upcase ) # => ["FOO", "BAR", "BAZ"]# [:foo, :hoge, :bar, :fuga].select{|s| s.to_s.length > 3} # => [:hoge, :fuga]
[:foo, :hoge, :bar, :fuga].select(&:to_s >> :length >> 3._(:<)) # => [:hoge, :fuga]
Add this line to your application's Gemfile:
gem 'lambda_driver'
And then execute:
$ bundle
Or install it yourself as:
$ gem install lambda_driver
- call
- compose
- with_args
- flip
- curry
f = lambda{|x| x.to_s }
f < :foo # => "foo" +:to_s # => #<Proc:0x007ff78aadaa78>
+:to_s < :foo # => "foo"Returns new lambda which composed self and given function. A composed proc called with args, executes `self.(g(*args)).
f = lambda{|x| x.to_s * 2 }
g = lambda{|y| y.length }
h = f.compose g # => #<Proc:0x007ff78aa2ab2>
h.(:hoge) # => "44" ( == f.call(g.call(:hoge)) )This method is aliased as <<.
f << g # => f.compose(g)
f << g < :hoge # => "44" ( == f.call(g.call(:hoge)) )Lift this function to the given context-function. The lifted function can compose other function with context-function.
The given context-fuction used by compose_with_lifting
to compose other function.
The context-function should recieve 2 arguments.
- first one is a function that reciver function of
compose_with_liftingmethod. - second arg is a result of g(x)
- g is a function passed to
compose_with_lifting
- g is a function passed to
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
Compose self and given function on the context-function.
The context-function is passed by lift method.
This method returns composed function 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 # output by ctx
#=> f(g(x)) -> 3 # output by ctx
#=> 3if context-function does not given, default behaivior is compose function with checking g(x) is mzero
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)This method is aliased as <=.
f <= g # => f.compose_with_lifting(g)An annoying try chain like arr.try(:first).try(:upcase).try(:to_sym) is rewritten by following
arr = ["foo", "bar"]
arr.try(&:first >= :upcase >= :to_sym) # => :Foo
arr = [nil]
arr.try(&:first >= :upcase >= :to_sym) # => nilReturns partially applied function that has 2nd and more parameters are fixed by given *args.
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 *.
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) )Returns function whose parameter order swaped 1st for 2nd. A result of filped fuction is curried by Proc#curry.
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.
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]"If arity is 0 or 1, flip returns itself.
This method is aliased as ~@.
~f # => #<Proc:0x007ff78a8e22c> (== f.filp)
~f < :a < :b < :c # => [:b, :a, :c] (== f.filp.call(:b).call(:a).call(:b))- to_method
- to_method_with_args
Symbol#to_method generates a function that extract Method object from given argument.
This method is aliased as -@.
(-:index).call("foobarbaz") # => #<Method: String#index>
(-:index).call("foobarbaz").call("bar") # => 3 (== "foobarbaz".index("bar") )
-:index < "foobarbaz" # => #<Method: String#index>
-:index < "foobarbaz" < "bar" # => 3 (== "foobarbaz".index("bar") )Symbol#to_method_with_args generates a function that extract Method object from given object, and returns function is partially applied parameters by passed arguments. It is same as Symbol#to_method with Proc#with_args.
This method is aliased as &.
:index.to_method_with_args("bar") # => #<Proc:0x007ffef4886ff8
:index.to_method_with_args("bar").call("foobarbaz") # => 3 (== "foobarbaz".index("bar") )
:index & "bar" # => #<Proc:0x007ffef4886ff8
:index & "bar" < "foobarbaz" # => 3 (== "foobarbaz".index("bar") )- alias instance_method, :/
String / :index # => #<UnboundMethod: String#index>- alias bind, :<
String / :index # => #<UnboundMethod: String#index>
String / :index < "foobarbaz" # => #<Method: String#index>
String / :index < "foobarbaz" < 3 # => 3 (== "foobarbaz".index("bar") )- ski combinator
- obj.revapply(|>)
- obj._
- obj.disjunction(f)
Object#revapply is applies self to given proc/block.
f = lambda{|x| x * 2 }
"foo".revapply(f) # => "foofoo" (== f.call("foo") )Object#_ is shortcut to quickly extract Method object.
"foobarbaz"._.index # => #<Method: String#index>
"foobarbaz"._.index < "bar" # => 3 (== "foobarbaz".index("bar") )
2._(:>=) # => #<Method: Fixnum#>=>
[1, 2, 3].select(&2._(:>=)) # => [1, 2]( = [1, 2].select{|n| 2 >= n})Object#disjunction select self or result of applied self to given function.
if f(self) is nil, returns self, otherwise return f(self).
f = lambda{|x| x % 2 == 0 ? nil : x * 2}
2.disjunction(f) # => 2 (disjunction returns receiver object)
3.disjunction(f) # => 6 (disjunction returns f(3) )- Fork it
- Create your feature branch (
git checkout -b my-new-feature) - Commit your changes (
git commit -am 'Add some feature') - Push to the branch (
git push origin my-new-feature) - Create new Pull Request