Closures vs Objects

**デフォルトの名無しさん** · 2024/02/19(月) 20:39:15.91

It is well-known that closures and objects are equivalent. So are actors. Which one is the most fundamental?

よく知られたように、クロージャとオブジェクトは等価です。アクターも同様です。どの概念が最も基本的なのでしょうか？

**デフォルトの名無しさん** · 2024/02/19(月) 20:49:06.93

A closure is a function with state in the local scope.
An object also has methods and state which belong to its instance.
These are compatible with each other.

クロージャはローカル・スコープに状態をもつ関数です。
オブジェクトもまたそのインスタンスに属するメソッドと状態を持ちます。
これらは互いに互換性があります。

**デフォルトの名無しさん** · 2024/02/20(火) 09:36:12.34

オブジェクトは複数のメソッドを持てる

クロージャは関数をひとつしか返せない

オブジェクトの勝ち

**デフォルトの名無しさん** · 2024/02/20(火) 11:01:18.21

>>3
ハッシュテーブルに関数を追加して返すことで、複数のメソッドを返すことが可能
より柔軟に、オブジェクトとそれを操作する関数の組を返すこともできるし、無限個のメソッドをもったオブジェクトだって作れる
これらは書く対象によって使い分ければよいのであって、オブジェクトにメソッドが属しているのが常に最適とは限らない
たとえばイベントハンドラにコールバック関数として渡すような場合は、ひとつの関数として取得できたほうが便利

**デフォルトの名無しさん** · 2024/02/20(火) 23:29:16.13

クロージャのほうがprimitive
今時、高階関数やイテレータを書くのにわざわざデザインパターンとか使いたいかって話
クラスは、レキシカル環境つきオブジェクトだけが欲しくても必ず新しい名前空間が作られるし、単品で購入できない福袋みたいなもん

**デフォルトの名無しさん** · 2024/02/21(水) 05:55:14.17

二変数以上の関数のほとんどは、どの引数のオブジェクトに属しているともアプリオリには言えないし、オブジェクト指向は不自然
オブジェクトと引数は別物だし、もし関数を特定のオブジェクトに属するようにしたいなら、クロージャでラップすれば簡単にできる

**デフォルトの名無しさん** · 2024/02/21(水) 05:56:37.93

二変数以上の関数のほとんどは、どの引数のオブジェクトに属しているともアプリオリには言えないし、オブジェクト指向は不自然
オブジェクトと関数は別物だし、もし関数を特定のオブジェクトに属するようにしたいなら、クロージャでラップすれば簡単にできる

**デフォルトの名無しさん** · 2024/02/21(水) 10:09:33.92

2変数関数をクロージャにラップして1変数関数にしても、メソッドチェーンはできないよね

**デフォルトの名無しさん** · 2024/02/21(水) 10:29:18.43

[1, 2, 3, 4, 5]にメソッドが属してれば

[1, 2, 3, 4, 5]
.filter(hoge) # ←戻り値もオブジェクト
.map(piyo) # ←これも
.sum()

みたいにできるけど、配列がオブジェクトじゃなかったら

map([1, 2, 3, 4, 5], hoge)

の戻り値はただの配列なので、繰り返し関数適用するには、Lispみたいな醜い入れ子にするしかない

sum(
　map(
　　filter([1, 2, 3, 4, 5], hoge),
　piyo))

**デフォルトの名無しさん** · 2024/02/21(水) 12:32:59.23

>>8-9
これでどうよ

chain = (obj) => {
　return (f, ...args) => {
　　if (!f) return obj
　　return chain(f(obj, ...args))
　}
}

chain([1, 2, 3, 4, 5])(
　filter, (x) => x % 2)(
　map, (x) =>x * x)(
　sum)()
// => 35

**デフォルトの名無しさん** · 2024/02/21(水) 15:43:45.17

一時期メタプログラミングとかいって、動的にクラスやメソッドを作れるのがすごいって言われてたけど、クロージャをデータ構造として使うならそれは自明にできることでは

**デフォルトの名無しさん** · 2024/02/21(水) 16:28:56.20

やり方が複数ある場合は、一番綺麗に書けるコードを採用するのが基本

**デフォルトの名無しさん** · 2024/02/21(水) 22:54:29.50

入れ子にしなくても関数合成でいいのでは？
メソッドチェーンっぽく書くには
Reverse-application operatorってのもあるけど
個人的には関数合成のほうがスッキリしててすこ

https://ideone.com/gCWxLP
let hoge n = n mod 2 = 1
let piyo = ( * ) 2
let () = print_int (List.fold_left (+) 0 (List.map piyo (List.filter hoge [1;2;3;4;5])))

(* function composition *)
let (<<) f g x = f (g x)
let f = print_int << List.fold_left (+) 0 << List.map piyo << List.filter hoge
let () = f [1;2;3;4;5]

let (>>) f g x = g (f x)
let f = List.filter hoge >> List.map piyo >> List.fold_left (+) 0 >> print_int
let () = f [1;2;3;4;5]

(* @@ Application operator *)
let () = print_int @@ List.fold_left (+) 0 @@ List.map piyo @@ List.filter hoge [1;2;3;4;5]

(* |> Reverse-application operator *)
let () = [1;2;3;4;5] |> List.filter hoge |> List.map piyo |> List.fold_left (+) 0 |> print_int

**デフォルトの名無しさん** · 2024/02/22(木) 01:30:07.21

Forth で書いてよ

**デフォルトの名無しさん** · 2024/02/22(木) 08:01:15.94

>>13
カリー化のなせる技やね

**デフォルトの名無しさん** · 2024/02/22(木) 08:40:34.15

chainl = (obj) => {
　return (f, arg) => {
　　if (!f) return obj
　　return chainl(f(arg, obj))
　}
}

cons = (x, xs) => [x, xs]

foreach = (lst, f) => {
　if(!lst) return
　[x, xs] = lst
　f(x)
　foreach(f, xs)
}

linkedList =
　chainl(null)(
　　cons, 1)(
　　cons, 2)(
　　cons, 3)()

chainl(linkedList)(foreach, console.log)()
// 3
// 2
// 1

いろいろ書けるんだな

**デフォルトの名無しさん** · 2024/02/22(木) 10:55:42.37

カリー化もクロージャと可変長引数があればできるね

currying = (f, ...args) => (...rest) => f(...args, ...rest)

**デフォルトの名無しさん** · 2024/02/22(木) 11:04:45.60

これで、mapなどが

map(f, col)

と、関数を先にとる形でも、>>16のchainlを用いて

chainl([1, 2, 3, 4, 5])(
　currying(filter, (x) => x % 2))(
　currying(map, (x) => x * x))(
　sum)()

と書けるわけか

**デフォルトの名無しさん** · 2024/02/22(木) 11:11:29.91

いや、単にchainlを

chainl = (obj) => {
　return (f, ...arg) => {
　　if (!f) return obj
　　return chainl(f(...arg, obj))
　}
}

とすればいいのか

**デフォルトの名無しさん** · 2024/02/22(木) 12:04:47.68

クロージャの真価はコンテキストを導入できること

(let ((a 1) (b 2)) (+ a b))

((lambda (a b) (+ a b)) 1 2)

は等価
なので、上のa + bの変わりに関数を返却すれば独立したスコープの状態をもつ何かを作れる

クラスベースのオブジェクト指向でも同様だが、そのようなコンテキストのテンプレート（= class）は静的にしか作れない

**デフォルトの名無しさん** · 2024/02/22(木) 12:15:29.98

静的なほうがバグの発見は早そう

**デフォルトの名無しさん** · 2024/02/22(木) 13:03:51.54

なんでも自由を許すと無秩序になる
>>10だって、シグネチャを無視することが前提の設計になってる
（最後に結果を呼び出す時は第一引数のfを省略する）

TypeScriptが使われるのもそれが理由
今やPythonやRubyにも型がある

**デフォルトの名無しさん** · 2024/02/22(木) 13:23:57.40

くだらん
https://stackoverflow.com/questions/2497801/closures-are-poor-mans-objects-and-vice-versa-what-does-this-mean