Rubyで関数合成とかしたいので lambda_driver.gem というのを作った

f:id:yuroyoro:20130327185507p:plain
LambdaDriver by yuroyoro

Rubyで、Procやlambdaで関数合成できるようにしたかったので、lambda_driver.gemというのを作った。
内容的にはこの辺で書いたヤツをgemにした感じ。

こんな風に、カッコよくコードが書ける。

require 'lambda_driver'

# [: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]

このgemは、個人的に「こういう風に書けたらいいな」という感覚に基づいているので、可読性とかは、アレだ、言わせんな。
演算子についても、すでに定義されているものは上書きしないようになってるので安全ですよ?

あと、名前の由来は≪虚弦斥力場生成システム≫です。

Proc/lambda/Symbol/Methodへの拡張

call
compose
with_args
flip
curry

Proc#

`Proc#<` は `Proc#call`へのaliasなので、Procの呼び出しは以下のように書ける。

  f = lambda{|x| x.to_s }
  f < :foo # => "foo"

Proc#+@

Proc/lambda/Symbol/Methodに単項演算子+を適用すると、to_procを呼び出す。

  +:to_s           # => #<Proc:0x007ff78aadaa78>
  +:to_s < :foo    # => "foo"

Proc#compose

関数合成は`Proc#compose`や`>>`, `<<` でできる。

`f.compose(g)`は、合成関数`lambda{|*args| f.call(g.call(*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)) )

`Proc#compose`は`<<` にaliasされている

  f << g          # => f.compose(g)
  f << g < :hoge  # => "44" ( == f.call(g.call(:hoge)) )

`>>`は、Proc#compseをレシーバーを入れ替えて呼び出す。結果的に、`g.call(f.call(x))`になる

f >> g          # => g.compose(f)
f >> g < :hoge  # => "8" ( == g.call(f.call(:hoge)) )

Proc#with_args

`Proc#with_args`は、2引数以降の引数を部分適用した関数を返す。

  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) )

`Proc#with_args`は`*`にaliasされている。

  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

第1引数と第2引数を入れかえた関数を返す。結果の関数はカリー化される。

  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))

`Proc#flip`を呼び出すProcが可変長引数の場合は、明示的にarityを指定してfilpを呼び出す必要がある。
arityが0または1ならば、何もせずに自身を返す。

  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]"

このメソッドは `~@` にaliaasされているので、Procに単項演算子`~`を適用することで呼び出すこともできる。
その際には、arityの指定はできない。

  ~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#to_method

`Symbol#to_method`は、引数のオブジェクトに対してObject#methodを自身を引数に呼び出す関数を生成して返す。
単項演算子`-`にaliasされている。

  (-: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

`Class#instance_method`を `/`演算子で呼び出すことができる。これは、少しclojureを意識した。

  String / :index # => #<UnboundMethod: String#index>

UnboundMethod extensions

`UnboundMethod#bind`を `<`演算子で呼び出すことができる。上記の`Class#/`と組み合わせるとカッコよく書ける。

  String / :index                    # => #<UnboundMethod: String#index>
  String / :index < "foobarbaz"      # => #<Method: String#index>
  String / :index < "foobarbaz" < "bar"  # => 3 (== "foobarbaz".index(3) )

Object extensions

obj.revapply(|>)
obj._
obj.disjunction(f)

Object#revapply

`Object#revapply` は、自身を渡された関数に適用する。Scalazの`|>`な。
revapplyという名前の由来はOCamlから。

  f = lambda{|x| x * 2 }

  "foo".revapply(f) #  => "fooffoo" (== f.call("foo") )

Object#_

`Object#_`は、オブジェクトからMethodオブジェクトを簡単に取り出すためのショートカット。

"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

`Object#disjunction`は、引数の関数に自身を適用した結果がnilでなければそれを返し、nilだったらレシーバーオブジェクト自身を返す。

  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) )

( ꒪⌓꒪) ゆるよろ日記

(　ﾟ∀ﾟ)o彡°ｵﾊﾟｰｲ!ｵﾊﾟｰｲ! ( ;ﾟ皿ﾟ)ﾉｼΣ ﾌｨﾝｷﾞｨｨｰｰｯ!!!