proc.md

NOTE: ここでは以下のように定義します。

• functional object
  • #call (と #<< #>> ) が定義されているオブジェクト
  • e.g. Proc Method
• blockable object
  • #to_proc が定義されているオブジェクト
  • e.g. Symbol Hash

現状

• Proc#<< や Proc#>> は functional オブジェクトを受け取る
• Proc#<< や Proc#>> は内部で #to_proc を呼び出さない
• Proc#<< や Proc#>> はブロック引数は受け取らない

Ruby の関数合成

• functiona オブジェクト と functiona オブジェクトを組み合わせた式から成り立つ
• functional object >> functional object # => OK
• functional object >> other object # => NG
• other object >> functional object # => NG

Symbol は functional オブジェクト？

• Symbol は blockable オブジェクト

• Symbol は functional オブジェクトではない

• 関数合成で blockable オブジェクトを扱うのはおかしい

  • Proc << Symbol や Symbol << Proc

• 他の #to_proc が定義されているオブジェクトはどう扱うべきか

  • Hash とか
  • Hash も functional オブジェクト？

Proc#<< などで #to_proc を呼び出すべき？

• #to_proc で明示的に Proc (functional オブジェクト) に変換するべき
  • proc << :hoge => NG: :hoge は Proc ではない
  • proc << :hoge.to_proc => OK : :hoge を明示的に Proc に変換
• これは "42" が数値として扱われないのに似ている
  • 1 + "42" → NG : "42" は数値ではない
  • 1 + "42".to_i → OK : "42" を明示的に数値に変換している

案1 : Symbol を functional オブジェクトとして扱う

• Symbol#>> Symbol#<< Symbol#call を定義する
• Symbol 以外の blockable オブジェクトはどうするべき？
• この機能は本当に Symbol に必要？

class Symbol
	def call(*args, &block)
		to_proc.call(*args, &block)
	end

	def <<(other)
		to_proc << other
	end

	def >>(other)
		to_proc >> other
	end
end

p %w{72 101 108 108 111}.map(&(:to_i >> :chr))
# => ["H", "e", "l", "l", "o"]

案2 : Proc#<< などでブロック引数を受け取る

• Proc#<<(other) を Proc#<<(other, &block) にする
  • other を優先する
• ブロック引数を渡す場合は proc.<< &:hoge と書く必要がある

class Proc
	prepend Module.new {
		def <<(other = nil, &block)
			# other or block?
			super(other || block)
		end

		def >>(other = nil, &block)
			# other or block?
			super(other || block)
		end
	}
end

# :to_i convert to Proc
# must be `.>>`
p %w{72 101 108 108 111}.map(&(:to_i.to_proc.>> &:chr))
# => ["H", "e", "l", "l", "o"]

案3 : #to_proc のシンタックスシュガーを定義する

• 例えば ~@ を #to_proc のエイリアスにしてしまう
• 現行の仕様を変更する事なく Symbol などの #to_proc が定義されているオブジェクトで関数合成できる
• 現状だとこれがいいと思う

class Object
	# ~ is to_proc
	# ~ or other unary operator?
	def ~@
		to_proc
	end
end

# Use Symbol#to_proc
p %w{72 101 108 108 111}.map(&(:to_i.to_proc >> :chr.to_proc))

# alias ~ is to_proc
p %w{72 101 108 108 111}.map(&~:to_i >> ~:chr)