[ruby-core:65170] [ruby-trunk - Feature #10095] Object#as

Issue #10095 has been updated by Jihwan Song.


Matthew Kerwin wrote:
> How often do you see the keyword `yield` without arguments? Even in your examples you are clearly passing arguments (direct objects) to it.
Well, arguments are not he one 'yield' shall yield, but the block is...

> But you don't pass a block to the keyword; you're not saying "yield this block." Rather, you're instructing the scope (i.e. the function) to yield *values* (direct objects) *to the block* (indirect object).

Actually, I always thought I instructed Ruby to yield the block.

> 
> Translating from Ruby to English:
> 
> ~~~
> def foo *a, &b
>   yield *a
> end
> ~~~
> 
> ...becomes...
> 
> "foo, yield *a to &b"
> 

Rather, "yield &b with *a"

> So the subject is the function, the direct object is the args (which defaults to an empty list), and the indirect object is the block. ......

I'd say.. the subject is the class instance, direct object is the block args are specifics. like "I.yield(red) {|o| bread} if morning"

> I still assert that it isn't coherent. Since the method receiver is the first (or only) of the direct objects, the message you are sending it should be "be yielded ...", not "yield".

The code almost reads "Object, yield is to yield with more specific." I think.
Well, I did not like the part subject being the first passed parameter to the block. That, I did it that way only to show how it can be done with current Ruby. However, I think it may be much better if the new 'yield' verb passes the subject implied. So that following should be enough:
Milk.yield {cheese}
Acre.new(10).yield { Bath.new(_.count / 10) }



----------------------------------------
Feature #10095: Object#as
https://bugs.ruby-lang.org/issues/10095#change-49012

* Author: Akira Matsuda
* Status: Open
* Priority: Normal
* Assignee: 
* Category: core
* Target version: current: 2.2.0
----------------------------------------
We've had so many times of feature requests for a method similar to Object#tap that doesn't return self but returns the given block's execution result (e.g. #7388, #6684, #6721 ).

I'm talking about something like this in Ruby of course:
Object.class_eval { def as() yield(self) end }

IIRC Matz is not against introducing this feature but he didn't like any of the names proposed in the past, such as embed, do, identity, ergo, reference, yield_self, itself, apply, map, tap!, etc.

So, let us propose a new name, Object#as today.
It's named from the aspect of the feature that it gives the receiver a new name "as" a block local variable.
For instance, the code reads so natural and intuitive like this:

(1 + 2 + 3 + 4).as {|x| x ** 2}
=> 100

Array.new.as {|a| a << 1; a << 2}
=> [1, 2]

---Files--------------------------------
itself-block.patch (1.35 KB)


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