[ruby-dev:50384] [Ruby trunk Feature#14223] Refinements で定義した #to_proc が &hoge 時に呼ばれないのを緩和する提案

[ruby-dev:50384] [Ruby trunk Feature#14223] Refinements で定義した #to_proc が &hoge 時に呼ばれないのを緩和する提案

[manga.osyo]

Issue #14223 has been reported by osyo (manga osyo).

----------------------------------------
Feature #14223: Refinements で定義した #to_proc が &hoge 時に呼ばれないのを緩和する提案
https://bugs.ruby-lang.org/issues/14223

* Author: osyo (manga osyo)
* Status: Open
* Priority: Normal
* Assignee: 
* Target version: 
----------------------------------------
Refinements に関する提案です。  
現行の仕様では Refinements で定義された `#to_proc` は `&hoge` 時に暗黙的に呼びだされません。  

```ruby
class X
end

using Module.new {
	refine String do
		def to_proc
			proc { |it| it.send self }
		end

		def refine_method
			"X#refine_method"
		end
	end
}

def func &block
end

p "upcase".refine_method
# => "X#refine_method"

p "upcase".to_proc.call "homu"
# => "HOMU"

# Error: wrong argument type X (expected Proc) (TypeError)
func &"upcase"
```

実行結果:https://wandbox.org/permlink/sbvsCeXwXzwp1WxA


最近の傾向として `Kernel#send` や式展開時の `#to_s` などで Refinements が有効になっています。
そういう意味では `&hoge` で暗黙的に呼び出される `#to_proc` も Refinements が有効になってもよいのではないでしょうか。  
この件に関して、他の方の意見を聞かせていただけると助かります。  
また、自分で実装を書いてみたのですが『とりあえず動いている』というレベルなので、Refinements の実装に詳しい方がいればパッチもみていただけると助かります。  


---Files--------------------------------
refinemetns_to_proc.patch (3.73 KB)


-- 
https://bugs.ruby-lang.org/

[ruby-dev:50395] [Ruby trunk Feature#14223] Refinements で定義した #to_proc が &hoge 時に呼ばれないのを緩和する提案

[nobu]

Issue #14223 has been updated by nobu (Nobuyoshi Nakada).


賛成です。

できれば不要なインデントの変更などは混ぜないでください。

----------------------------------------
Feature #14223: Refinements で定義した #to_proc が &hoge 時に呼ばれないのを緩和する提案
https://bugs.ruby-lang.org/issues/14223#change-68973

* Author: osyo (manga osyo)
* Status: Open
* Priority: Normal
* Assignee: 
* Target version: 
----------------------------------------
Refinements に関する提案です。  
現行の仕様では Refinements で定義された `#to_proc` は `&hoge` 時に暗黙的に呼びだされません。  

```ruby
using Module.new {
	refine String do
		def to_proc
			proc { |it| it.send self }
		end

		def refine_method
			"X#refine_method"
		end
	end
}

def func &block
end

p "upcase".refine_method
# => "X#refine_method"

p "upcase".to_proc.call "homu"
# => "HOMU"

# Error: wrong argument type X (expected Proc) (TypeError)
func &"upcase"
```

実行結果:https://wandbox.org/permlink/j8Hhavy7LoKYjrnz


最近の傾向として `Kernel#send` や式展開時の `#to_s` などで Refinements が有効になっています。
そういう意味では `&hoge` で暗黙的に呼び出される `#to_proc` も Refinements が有効になってもよいのではないでしょうか。  
この件に関して、他の方の意見を聞かせていただけると助かります。  
また、自分で実装を書いてみたのですが『とりあえず動いている』というレベルなので、Refinements の実装に詳しい方がいればパッチもみていただけると助かります。  


---Files--------------------------------
refinemetns_to_proc.patch (3.73 KB)


-- 
https://bugs.ruby-lang.org/

[ruby-dev:50405] [Ruby trunk Feature#14223] Refinements で定義した #to_proc が &hoge 時に呼ばれないのを緩和する提案

[manga.osyo]

Issue #14223 has been updated by osyo (manga osyo).

File refinemetns_to_proc.patch added

nobu (Nobuyoshi Nakada) wrote:
> 賛成です。

返信して頂き、ありがとうございます。

> できれば不要なインデントの変更などは混ぜないでください。

ありがとうございます。修正しました。
これで問題ないでしょうか。

----------------------------------------
Feature #14223: Refinements で定義した #to_proc が &hoge 時に呼ばれないのを緩和する提案
https://bugs.ruby-lang.org/issues/14223#change-69089

* Author: osyo (manga osyo)
* Status: Open
* Priority: Normal
* Assignee: 
* Target version: 
----------------------------------------
Refinements に関する提案です。  
現行の仕様では Refinements で定義された `#to_proc` は `&hoge` 時に暗黙的に呼びだされません。  

```ruby
using Module.new {
	refine String do
		def to_proc
			proc { |it| it.send self }
		end

		def refine_method
			"X#refine_method"
		end
	end
}

def func &block
end

p "upcase".refine_method
# => "X#refine_method"

p "upcase".to_proc.call "homu"
# => "HOMU"

# Error: wrong argument type X (expected Proc) (TypeError)
func &"upcase"
```

実行結果:https://wandbox.org/permlink/j8Hhavy7LoKYjrnz


最近の傾向として `Kernel#send` や式展開時の `#to_s` などで Refinements が有効になっています。
そういう意味では `&hoge` で暗黙的に呼び出される `#to_proc` も Refinements が有効になってもよいのではないでしょうか。  
この件に関して、他の方の意見を聞かせていただけると助かります。  
また、自分で実装を書いてみたのですが『とりあえず動いている』というレベルなので、Refinements の実装に詳しい方がいればパッチもみていただけると助かります。  


---Files--------------------------------
refinemetns_to_proc.patch (3.73 KB)
refinemetns_to_proc.patch (3.26 KB)


-- 
https://bugs.ruby-lang.org/

[ruby-dev:50422] [Ruby trunk Feature#14223] Refinements で定義した #to_proc が &hoge 時に呼ばれないのを緩和する提案

[matz]

Issue #14223 has been updated by matz (Yukihiro Matsumoto).


良さそうに思えます。取り込んでみましょう。

Matz.


----------------------------------------
Feature #14223: Refinements で定義した #to_proc が &hoge 時に呼ばれないのを緩和する提案
https://bugs.ruby-lang.org/issues/14223#change-69734

* Author: osyo (manga osyo)
* Status: Open
* Priority: Normal
* Assignee: 
* Target version: 
----------------------------------------
Refinements に関する提案です。  
現行の仕様では Refinements で定義された `#to_proc` は `&hoge` 時に暗黙的に呼びだされません。  

```ruby
using Module.new {
	refine String do
		def to_proc
			proc { |it| it.send self }
		end

		def refine_method
			"X#refine_method"
		end
	end
}

def func &block
end

p "upcase".refine_method
# => "X#refine_method"

p "upcase".to_proc.call "homu"
# => "HOMU"

# Error: wrong argument type X (expected Proc) (TypeError)
func &"upcase"
```

実行結果:https://wandbox.org/permlink/j8Hhavy7LoKYjrnz


最近の傾向として `Kernel#send` や式展開時の `#to_s` などで Refinements が有効になっています。
そういう意味では `&hoge` で暗黙的に呼び出される `#to_proc` も Refinements が有効になってもよいのではないでしょうか。  
この件に関して、他の方の意見を聞かせていただけると助かります。  
また、自分で実装を書いてみたのですが『とりあえず動いている』というレベルなので、Refinements の実装に詳しい方がいればパッチもみていただけると助かります。  


---Files--------------------------------
refinemetns_to_proc.patch (3.73 KB)
refinemetns_to_proc.patch (3.26 KB)


-- 
https://bugs.ruby-lang.org/

[ruby-dev:50434] [Ruby trunk Feature#14223] Refinements で定義した #to_proc が &hoge 時に呼ばれないのを緩和する提案

[manga.osyo]

Issue #14223 has been updated by osyo (manga osyo).


ありがとうございます！

----------------------------------------
Feature #14223: Refinements で定義した #to_proc が &hoge 時に呼ばれないのを緩和する提案
https://bugs.ruby-lang.org/issues/14223#change-69849

* Author: osyo (manga osyo)
* Status: Closed
* Priority: Normal
* Assignee: 
* Target version: 
----------------------------------------
Refinements に関する提案です。  
現行の仕様では Refinements で定義された `#to_proc` は `&hoge` 時に暗黙的に呼びだされません。  

```ruby
using Module.new {
	refine String do
		def to_proc
			proc { |it| it.send self }
		end

		def refine_method
			"X#refine_method"
		end
	end
}

def func &block
end

p "upcase".refine_method
# => "X#refine_method"

p "upcase".to_proc.call "homu"
# => "HOMU"

# Error: wrong argument type X (expected Proc) (TypeError)
func &"upcase"
```

実行結果:https://wandbox.org/permlink/j8Hhavy7LoKYjrnz


最近の傾向として `Kernel#send` や式展開時の `#to_s` などで Refinements が有効になっています。
そういう意味では `&hoge` で暗黙的に呼び出される `#to_proc` も Refinements が有効になってもよいのではないでしょうか。  
この件に関して、他の方の意見を聞かせていただけると助かります。  
また、自分で実装を書いてみたのですが『とりあえず動いている』というレベルなので、Refinements の実装に詳しい方がいればパッチもみていただけると助かります。  


---Files--------------------------------
refinemetns_to_proc.patch (3.73 KB)
refinemetns_to_proc.patch (3.26 KB)


-- 
https://bugs.ruby-lang.org/