Esm lt threading_macro

Clojureの
スレッディングマクロ
っぽいものをRubyで実装してみた話
について
esm LT

ClojureのスレッディングマクロっぽいものをRubyで実装してみた話につい
て
自己紹介
▸ 久納工
▸ 2006年入社
▸ ITサービス事業部

Clojure
▸Clojure (発音は/'klouʒər/[2], クロージャー)はプログラミング言
語であり、LISP系の言語の方言の一つである。関数型プログラ
ミングのプログラミングスタイルでのインタラクティブな開発
を支援し、マルチスレッドプログラムの開発を容易化する汎用
言語である。Clojure言語のプログラムはJava仮想マシンと
Microsoft .NET 共通言語ランタイムで動作する。Clojure言語は
「データとしてのプログラムコード」 (英語:「code as data」)
という思想で設計されており、洗練されたマクロ機構を持つ。
て
Wikipediaより

て
スレッディングマクロとは
ClojureのS式だと
(reduce + 100
(map #(* %1 2)
(filter even?
[1 2 3 4])))

て
(reduce + 100
(map #(* %1 2)
(filter even?
[1 2 3 4]))) こう実行されて

て
(reduce + 100
(map #(* %1 2)
(filter even?
[1 2 3 4])))
;;=> 112
こうなる

て
スレッディングマクロだと
(->>
[1 2 3 4]
(filter even?)
(map #(* %1 2))
(reduce + 100))

て
(->>
[1 2 3 4]
(filter even?)
(map #(* %1 2))
(reduce + 100))
こう実行されて

て
(->>
[1 2 3 4]
(filter even?)
(map #(* %1 2))
(reduce + 100))
;;=> 112
こうなる

て
スレッディングマクロの利点
(->>
[1 2 3 4]
(filter even?)
(map #(* %1 2))
(reduce + 100))
S式のみ
(reduce + 100
(map #(* %1 2)
(filter even?
[1 2 3 4])))

て
(->>
[1 2 3 4]
(filter even?)
(map #(* %1 2))
(reduce + 100))
S式のみ
(reduce + 100
(map #(* %1 2)
(filter even?
[1 2 3 4])))
スレッディングマクロを使うと
評価の時系列順に上から読むことが出来る

て
他にもあるスレッディングマクロの利点
(reduce + 100
(map #(* %1 2)
(filter even?
[1 2 3 4])))

て
(reduce + 100
..(map #(* %1 2)
....(filter even?
......[1 2 3 4])))
インデントはこうなる

て
(->>
[1 2 3 4]
(filter even?)
(map #(* %1 2))
(reduce + 100))

て
(->>
..[1 2 3 4]
..(filter even?)
..(map #(* %1 2))
..(reduce + 100))
インデントはこうなる

て
(->>
[1 2 3 4]
(filter even?)
(map #(* %1 2))
(reduce + 100))
S式のみ
(reduce + 100
(map #(* %1 2)
(filter even?
[1 2 3 4])))

て
(->>
..[1 2 3 4]
..(filter even?)
..(map #(* %1 2))
..(reduce + 100))
S式のみ
(reduce + 100
..(map #(* %1 2)
....(filter even?
......[1 2 3 4])))
コードのインデントが深くならない

て
他にも有るけど割愛

Clojureの
っぽいものをRubyで実装してみた話
について
第二部
esm LT

て
Rubyのラムダ式でS式相当の処理を書くと…

て
-> (collection) { collection.reduce(100, :+) }.
call(-> (collection) { collection.map {|e| e * 2 } }.
call(-> (collection) { collection.select(&:even?) }.
call([1, 2, 3, 4])))

て
call([1, 2, 3, 4])))
これをスレッディングマクロっぽく
書けるようにする

て
基本のアイディア
[
-> (collection) { collection.select(&:even?) },
-> (collection) {
collection.map {|e| e * 2 }
},
-> (collection) { collection.reduce(100, :+) }
].reduce([1, 2, 3, 4]) {
|acc, proc| proc.call(acc)
}

て
[
-> (collection) {
},
].reduce([1, 2, 3, 4]) {
}
Procの配列に対して

て
[
-> (collection) {
},
].reduce([1, 2, 3, 4]) {
}
reduceして、処理結果に順々に適用する

て
[
-> (collection) {
},
].reduce([1, 2, 3, 4]) {
}
=> 112
reduceして、処理結果に順々に適用する

て
とりあえずここまで実装してみる
def thread_last(*procs)
procs[1..-1].reduce(procs.first) {|acc, proc|
proc.call acc
}
end

て
proc.call acc
}
end
thread_last(
[1,2,3,4],
-> (collection) { collection.map {|e| e * 2 } },
)

て
proc.call acc
}
end
thread_last(
[1,2,3,4],
)
=> 112

て
proc.call acc
}
end
thread_last(
[1,2,3,4],
)
=> 112 出来た！

て
こんなときはどうする？
[
-> (n, collection) {
collection.map {|e| e * n }
},
].reduce([1, 2, 3, 4]) {
}

て
[
},
].reduce([1, 2, 3, 4]) {
} nを指定したい

て
[
},
].reduce([1, 2, 3, 4]) {
}
ArgumentError: wrong number of arguments (given 1,
expected 2)

て
[
},
].reduce([1, 2, 3, 4]) {
}
ArgumentError: wrong number of arguments (given 1,
expected 2)
一つの引数にだけ
Procを適用している

て
こんなときは
[
},
].reduce([1, 2, 3, 4]) {
}

て
こんなときはこうする！
[
}.curry[2],
].reduce([1, 2, 3, 4]) {
}

て
[
}.curry[2],
].reduce([1, 2, 3, 4]) {
}
=> 112

て
[
}.curry[2],
].reduce([1, 2, 3, 4]) {
}
curryとは？

60sec で分かる(と良いなと
思う)
カリー化と部分適用

60sec で分かる(と良いなと思う)カリー化と部分適用
カリー化とは
関数がただ一つの引数だけをとるようにすること
。この状態の関数をカリー化されていると呼ぶ。
２引数の関数はカリー化することで、引数の数が
一つである関数と、その関数を返す引数の数が一
つの関数に分けられる。

カリー化とは
Ruby で書くと…
->(x, y) { x + y }.call(2, 3)
=> 5

カリー化とは
->(x, y) { x + y }.call(2, 3)
=> 5
->(x) { -> (y) { x + y } }.call(2).call(3)
=> 5
カリー化(手動)

カリー化とは
->(x, y) { x + y }.call(2, 3)
=> 5
->(x, y) { x + y }.curry[2][3]
=> 5
カリー化

カリー化とは
->(x, y) { x + y }.call(2, 3)
->(x, y) { x + y }.curry[2][3]
``-> (y) { 2 + y }`` 相当のProcが返ってくる
カリー化

カリー化とは
任意の数の引数のProcをカリー化出来る
->(x, y, z) { x + y + z }.curry[2][3][4]
=> 9
->(x, y, z, xx, yy, zz) { x + y + z + xx + yy + zz
}.curry[2][3][4][5][6][7]
=> 27

カリー化とは
途中で変数に取ることも出来る
partialized_proc = ->(x, y) { x + y }.curry[2]
=> #<Proc:0x007feaa2f4c6f0 (lambda)>
partialized_proc[3]
=> 5

カリー化とは
途中で変数に取ることも出来る
partialized_proc[3]
=> 5
全ての引数が渡されると処理結果が返ってくる

部分適用とは
部分適用とは、関数に対して全ての引数を一度に
渡さず、一部の引数だけ渡すことができる仕組み
。

部分適用とは
partialized_proc[3]
=> 5

部分適用とは
partialized_proc[3]
=> 5
これが部分適用された状態のProc

て
⚠注意事項

て
⚠注意事項
Clojureではスレッディングマクロの実現に
Transducersという機構を使用しています。

て
⚠注意事項
Clojureではスレッディングマクロの実現に
Transducersという機構を使用しています。
が、ここではTransducersについては触れません。

て
この書き方を
[
}.curry[2],
].reduce([1, 2, 3, 4]) {
}

て
thread_last に適用すると…
thread_last(
[1,2,3,4],
-> (n, collection) { collection.map {|e| e * n }.curry[2] },
)

て
thread_last(
[1,2,3,4],
)
=> 112

て
thread_last(
[1,2,3,4],
)
=> 112
利用者がcurryしないといけない

て
いちいちcurryしたくない……

て
class Proc
def |(arg)
self.curry[arg]
end
end

て
class Proc
def |(arg)
self.curry[arg]
end
end
Procに | メソッドを生やす

て
class Proc
def |(arg)
self.curry[arg]
end
end
thread_last(
[1,2,3,4],
-> (n, collection) { collection.map {|e| e * n } } | 2,
)

て
class Proc
def |(arg)
self.curry[arg]
end
end
thread_last(
[1,2,3,4],
-> (n, collection) { collection.map {|e| e * n } } | 2,
)
=> 112

て
thread_last(->>) が出来た！

て
色々なスレッディングマクロ
‣ ->
‣ ->>
‣ as->
‣ some->
‣ some->>
‣ cond->
‣ cond->>

て
色々なスレッディングマクロ
‣ ->
‣ ->>
‣ as->
‣ some->
‣ some->>
‣ cond->
‣ cond->>
まだまだ戦いは続く……

▸一番最初の値にProcが来ることもある。ので、最初がProcならば実行する。もちろん引数の数が不定なのでcallで
はなくcurryで。
▸Procに生やした|メソッドで即時curryしていたけど、thread_first(->) のときは実行する寸前までカリー化したくな
いので、実行時まで配列で持っているようにした。
▸thread_as(as->) するときは引数の挿入場所を選べる。シンボルで表現したいがProcの結果がシンボルになること
も有るので、表現しきれない。のでProcに新たなメソッド&を生やした。かつ、挿入位置を表す型を用意した。
▸map とかreduceとかするラムダ式を一々書きたくない……ので、引数で受け取ったCollectionをレシーバーとして
mapを実行するメソッド_map(proc)がincludeしたクラスのselfに生えるようにした。reduce, selectに関しても同
様。
▸↑で作ったメソッドで、Procを渡したいときとBlockを渡したいときがある。
▸Clojureの->>と同じようなメソッドのエイリアスを設けたいが、- 始まりのメソッドは書けない。マルチバイトは
いけるので、色々考えた結果これが一番近いと思う。 ``ー✈✈``
て
戦いの記録(ダイジェスト版)

て
色々やった結果
call([1, 2, 3, 4])))

て
色々やった結果
call([1, 2, 3, 4])))
thread_last(
[1, 2, 3, 4],
_select(&:even?),
_map(-> (e) { e * 2 }),
_reduce(100, &:+)
)

て
なお……
thread_last(
[1, 2, 3, 4],
_select(&:even?),
_map(-> (e) { e * 2 }),
_reduce(100, &:+)
)

て
なお……
thread_last(
[1, 2, 3, 4],
_select(&:even?),
_map(-> (e) { e * 2 }),
_reduce(100, &:+)
)
このコードをラムダ式を使わずに
普通に書くと……

て
なお……
[1, 2, 3, 4].
select(&:even?).
map {|e| e * 2}.
reduce(100, :+)
thread_last(
[1, 2, 3, 4],
_select(&:even?),
_map(-> (e) { e * 2 }),
_reduce(100, &:+)
)
このコードをラムダ式を使わずに
普通に書くと……

て
結論。

て
結論。
素のRubyすごい

Esm lt threading_macro

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Esm lt threading_macro

Similar to Esm lt threading_macro (20)

Recently uploaded

Recently uploaded (9)

Esm lt threading_macro