[ruby-core:74036] [Ruby trunk Feature#12125] Proposal: Shorthand operator for Object#method

[ruby-core:74036] [Ruby trunk Feature#12125] Proposal: Shorthand operator for Object#method

[Stefan-Merettig]

Issue #12125 has been reported by Stefan Merettig.

----------------------------------------
Feature #12125: Proposal: Shorthand operator for Object#method
https://bugs.ruby-lang.org/issues/12125

* Author: Stefan Merettig
* Status: Open
* Priority: Normal
* Assignee: 
----------------------------------------
Hello,

The `&` operator lets one pass a `#call`-able object as block.

Really useful feature, but at the moment, if you want to pass a `Method` this way the syntax is not really concise:

`Dir["*/*.c"].map(&File.method(:basename))`

More often than not, at least I end up writing this instead `.map{|a| File.basename a}` which isn't that great either.

Thus, I want to propose adding a short-hand operator to the ruby language, which simply calls `#method` on an Object.

It could look like this: `an_object->the_method` which is 100% equivalent to doing `an_object.method(:the_method)`

I'm reusing the `->` operator which is already used for the stabby lambda. But I think it makes sense: You have an object,
and from that object you point at a method to get it as `Method`.

With this, the example from above becomes: `Dir["*/*.c"].map(&File->basename)`

I attached a proof of concept patch. When you apply this to trunk, you can try the example above yourself.
Do note however that this PoC also breaks stabby lambda for the moment. I'll work on fixing that the following
days.

Thank you for reading,
Stefan.

---Files--------------------------------
method_shorthand.diff (740 Bytes)


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

[ruby-core:74037] [Ruby trunk Feature#12125] Proposal: Shorthand operator for Object#method

[Stefan-Merettig]

Issue #12125 has been updated by Stefan Merettig.


> The & operator lets one pass a #call-able object as block.

I meant `#to_proc`-able objects, sorry for the confusion.

----------------------------------------
Feature #12125: Proposal: Shorthand operator for Object#method
https://bugs.ruby-lang.org/issues/12125#change-57192

* Author: Stefan Merettig
* Status: Open
* Priority: Normal
* Assignee: 
----------------------------------------
Hello,

The `&` operator lets one pass a `#call`-able object as block.

Really useful feature, but at the moment, if you want to pass a `Method` this way the syntax is not really concise:

`Dir["*/*.c"].map(&File.method(:basename))`

More often than not, at least I end up writing this instead `.map{|a| File.basename a}` which isn't that great either.

Thus, I want to propose adding a short-hand operator to the ruby language, which simply calls `#method` on an Object.

It could look like this: `an_object->the_method` which is 100% equivalent to doing `an_object.method(:the_method)`

I'm reusing the `->` operator which is already used for the stabby lambda. But I think it makes sense: You have an object,
and from that object you point at a method to get it as `Method`.

With this, the example from above becomes: `Dir["*/*.c"].map(&File->basename)`

I attached a proof of concept patch. When you apply this to trunk, you can try the example above yourself.
Do note however that this PoC also breaks stabby lambda for the moment. I'll work on fixing that the following
days.

Thank you for reading,
Stefan.

---Files--------------------------------
method_shorthand.diff (740 Bytes)


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

[ruby-core:74038] [Ruby trunk Feature#12125] Proposal: Shorthand operator for Object#method

[matz]

Issue #12125 has been updated by Yukihiro Matsumoto.


I like the idea of short hand notation for `Object#method()`, but I don't think `->` is a good idea.

Matz.

----------------------------------------
Feature #12125: Proposal: Shorthand operator for Object#method
https://bugs.ruby-lang.org/issues/12125#change-57193

* Author: Stefan Merettig
* Status: Open
* Priority: Normal
* Assignee: 
----------------------------------------
Hello,

The `&` operator lets one pass a `#call`-able object as block.

Really useful feature, but at the moment, if you want to pass a `Method` this way the syntax is not really concise:

`Dir["*/*.c"].map(&File.method(:basename))`

More often than not, at least I end up writing this instead `.map{|a| File.basename a}` which isn't that great either.

Thus, I want to propose adding a short-hand operator to the ruby language, which simply calls `#method` on an Object.

It could look like this: `an_object->the_method` which is 100% equivalent to doing `an_object.method(:the_method)`

I'm reusing the `->` operator which is already used for the stabby lambda. But I think it makes sense: You have an object,
and from that object you point at a method to get it as `Method`.

With this, the example from above becomes: `Dir["*/*.c"].map(&File->basename)`

I attached a proof of concept patch. When you apply this to trunk, you can try the example above yourself.
Do note however that this PoC also breaks stabby lambda for the moment. I'll work on fixing that the following
days.

Thank you for reading,
Stefan.

---Files--------------------------------
method_shorthand.diff (740 Bytes)


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

[ruby-core:74050] [Ruby trunk Feature#12125] Proposal: Shorthand operator for Object#method

[zverok.offline]

Issue #12125 has been updated by Victor Shepelev.


For this kind of "conceptual" methods I sometimes define just one-letter shortcuts in core_ext.rb, like `.map(&File.m(:basename))`. I'm not sure, though, if any of existing/popular libraries will struggle from such kind of solution (or may be it would not play really well with local variables, which are frequently have one-letter names).

----------------------------------------
Feature #12125: Proposal: Shorthand operator for Object#method
https://bugs.ruby-lang.org/issues/12125#change-57205

* Author: Stefan Merettig
* Status: Open
* Priority: Normal
* Assignee: 
----------------------------------------
Hello,

The `&` operator lets one pass a `#call`-able object as block.

Really useful feature, but at the moment, if you want to pass a `Method` this way the syntax is not really concise:

`Dir["*/*.c"].map(&File.method(:basename))`

More often than not, at least I end up writing this instead `.map{|a| File.basename a}` which isn't that great either.

Thus, I want to propose adding a short-hand operator to the ruby language, which simply calls `#method` on an Object.

It could look like this: `an_object->the_method` which is 100% equivalent to doing `an_object.method(:the_method)`

I'm reusing the `->` operator which is already used for the stabby lambda. But I think it makes sense: You have an object,
and from that object you point at a method to get it as `Method`.

With this, the example from above becomes: `Dir["*/*.c"].map(&File->basename)`

I attached a proof of concept patch. When you apply this to trunk, you can try the example above yourself.
Do note however that this PoC also breaks stabby lambda for the moment. I'll work on fixing that the following
days.

Thank you for reading,
Stefan.

---Files--------------------------------
method_shorthand.diff (740 Bytes)


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

[ruby-core:74053] [Ruby trunk Feature#12125] Proposal: Shorthand operator for Object#method

[Stefan-Merettig]

Issue #12125 has been updated by Stefan Merettig.


Yukihiro Matsumoto wrote:
> but I don't think `->` is a good idea.

Other options I can think of are:

* Using `.>`: `the_object.>a_method`  While its look is nearer to a normal method call (Which I think is a plus), I fear that the period would be hard to see in some fonts. Another plus is that this would be a entirely new operator, so no (unintentional?) breaking changes in the parser.
* Using `<..>`: `the_object<a_method>`  Inspired by the look of generics/templates in other programming languages. Should not clash with existing code and parsers and is well-readable in fonts I guess. Maybe it doesn't read as well anymore though, and the intention of `<..>` may not be that clear at first to someone who doesn't know the syntax (yet). No idea if that is a concern.
* Using `&>`: `the_object&>a_method`  Also readable in any font I can think of. It's a spin on `&.`, reading like "and this"
* Using `|>`: `the_object|>a_method`  I think the *Elixir* language has this operator too (albeit with other semantics?). Its read like "and pipe it through this", so maybe it reads a bit like a shell script too?

Regards,
Stefan

----------------------------------------
Feature #12125: Proposal: Shorthand operator for Object#method
https://bugs.ruby-lang.org/issues/12125#change-57207

* Author: Stefan Merettig
* Status: Open
* Priority: Normal
* Assignee: 
----------------------------------------
Hello,

The `&` operator lets one pass a `#call`-able object as block.

Really useful feature, but at the moment, if you want to pass a `Method` this way the syntax is not really concise:

`Dir["*/*.c"].map(&File.method(:basename))`

More often than not, at least I end up writing this instead `.map{|a| File.basename a}` which isn't that great either.

Thus, I want to propose adding a short-hand operator to the ruby language, which simply calls `#method` on an Object.

It could look like this: `an_object->the_method` which is 100% equivalent to doing `an_object.method(:the_method)`

I'm reusing the `->` operator which is already used for the stabby lambda. But I think it makes sense: You have an object,
and from that object you point at a method to get it as `Method`.

With this, the example from above becomes: `Dir["*/*.c"].map(&File->basename)`

I attached a proof of concept patch. When you apply this to trunk, you can try the example above yourself.
Do note however that this PoC also breaks stabby lambda for the moment. I'll work on fixing that the following
days.

Thank you for reading,
Stefan.

---Files--------------------------------
method_shorthand.diff (740 Bytes)


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

[ruby-core:74055] [Ruby trunk Feature#12125] Proposal: Shorthand operator for Object#method

[co000ri]

Issue #12125 has been updated by Yuki Kurihara.


How about this one?

~~~ruby
File.method #=> #<UnfoundMethod receiver=File>
File.method.basename #=> #<Method: File.basename>
Dir["*/*.c"].map(&File.method.basename) #=> ["foo.c", "bar.c"]
~~~

----------------------------------------
Feature #12125: Proposal: Shorthand operator for Object#method
https://bugs.ruby-lang.org/issues/12125#change-57208

* Author: Stefan Merettig
* Status: Open
* Priority: Normal
* Assignee: 
----------------------------------------
Hello,

The `&` operator lets one pass a `#call`-able object as block.

Really useful feature, but at the moment, if you want to pass a `Method` this way the syntax is not really concise:

`Dir["*/*.c"].map(&File.method(:basename))`

More often than not, at least I end up writing this instead `.map{|a| File.basename a}` which isn't that great either.

Thus, I want to propose adding a short-hand operator to the ruby language, which simply calls `#method` on an Object.

It could look like this: `an_object->the_method` which is 100% equivalent to doing `an_object.method(:the_method)`

I'm reusing the `->` operator which is already used for the stabby lambda. But I think it makes sense: You have an object,
and from that object you point at a method to get it as `Method`.

With this, the example from above becomes: `Dir["*/*.c"].map(&File->basename)`

I attached a proof of concept patch. When you apply this to trunk, you can try the example above yourself.
Do note however that this PoC also breaks stabby lambda for the moment. I'll work on fixing that the following
days.

Thank you for reading,
Stefan.

---Files--------------------------------
method_shorthand.diff (740 Bytes)


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

[ruby-core:74056] [Ruby trunk Feature#12125] Proposal: Shorthand operator for Object#method

[funny.falcon]

Issue #12125 has been updated by Yura Sokolov.


Please don't do this!!! No need to make the language more complex just to solve such small issue!!!

If you want to do something pretty, then whole closure syntax should be simplified, not just call to '#method'.

````ruby
Dir["*/*.c"].map{File.basename(_0)} # where `_0` is magic var
````
Then bytecode compiler may optimize it to `.map(&File.method(:basename))`

But it then allows to do more pretty things, for example:

````ruby
# dumps key=>value pairs
myhash.each{|k,v| puts "#{k}=>#{v}"}
# do it in shorter way
myhash.each{puts "#{_0}=>#{_1}"}
````

----------------------------------------
Feature #12125: Proposal: Shorthand operator for Object#method
https://bugs.ruby-lang.org/issues/12125#change-57209

* Author: Stefan Merettig
* Status: Open
* Priority: Normal
* Assignee: 
----------------------------------------
Hello,

The `&` operator lets one pass a `#call`-able object as block.

Really useful feature, but at the moment, if you want to pass a `Method` this way the syntax is not really concise:

`Dir["*/*.c"].map(&File.method(:basename))`

More often than not, at least I end up writing this instead `.map{|a| File.basename a}` which isn't that great either.

Thus, I want to propose adding a short-hand operator to the ruby language, which simply calls `#method` on an Object.

It could look like this: `an_object->the_method` which is 100% equivalent to doing `an_object.method(:the_method)`

I'm reusing the `->` operator which is already used for the stabby lambda. But I think it makes sense: You have an object,
and from that object you point at a method to get it as `Method`.

With this, the example from above becomes: `Dir["*/*.c"].map(&File->basename)`

I attached a proof of concept patch. When you apply this to trunk, you can try the example above yourself.
Do note however that this PoC also breaks stabby lambda for the moment. I'll work on fixing that the following
days.

Thank you for reading,
Stefan.

---Files--------------------------------
method_shorthand.diff (740 Bytes)


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

[ruby-core:74064] [Ruby trunk Feature#12125] Proposal: Shorthand operator for Object#method

[shevegen]

Issue #12125 has been updated by Robert A. Heiler.


I think the &File->basename looks confusing since we also have
-> standalone now.

object->method reminds me a lot of php/perl and ruby uses the
prettier . instead, object.method.

I also think that :

.map{File.basename(_0)} # where `_0` is magic var

Is not good either. I like _ as a variable name a lot but on
its own, not with extra. :)

Yuki Kurihara's proposal is somewhat better as he does not 
have to use special constructs/tokens.

Dir["*/*.c"].map(&File.method.basename)

I believe that crystal allows some parameter for &; and I think
there have been earlier proposals in ruby too.

> But I think it makes sense: You have an object, and from that
> object you point at a method to get it as Method.

I do not think that this argument is a good one because the ->
is used in a dissimilar way, akin to Proc.new / lambda, 
whereas your syntax proposal would be more similar to php
and perl syntax style, which I think will be confusing in
addition to -> already having another method. So this is 
not good in my opinion.

----------------------------------------
Feature #12125: Proposal: Shorthand operator for Object#method
https://bugs.ruby-lang.org/issues/12125#change-57216

* Author: Stefan Merettig
* Status: Open
* Priority: Normal
* Assignee: 
----------------------------------------
Hello,

The `&` operator lets one pass a `#call`-able object as block.

Really useful feature, but at the moment, if you want to pass a `Method` this way the syntax is not really concise:

`Dir["*/*.c"].map(&File.method(:basename))`

More often than not, at least I end up writing this instead `.map{|a| File.basename a}` which isn't that great either.

Thus, I want to propose adding a short-hand operator to the ruby language, which simply calls `#method` on an Object.

It could look like this: `an_object->the_method` which is 100% equivalent to doing `an_object.method(:the_method)`

I'm reusing the `->` operator which is already used for the stabby lambda. But I think it makes sense: You have an object,
and from that object you point at a method to get it as `Method`.

With this, the example from above becomes: `Dir["*/*.c"].map(&File->basename)`

I attached a proof of concept patch. When you apply this to trunk, you can try the example above yourself.
Do note however that this PoC also breaks stabby lambda for the moment. I'll work on fixing that the following
days.

Thank you for reading,
Stefan.

---Files--------------------------------
method_shorthand.diff (740 Bytes)


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

[ruby-core:74072] [Ruby trunk Feature#12125] Proposal: Shorthand operator for Object#method

[nobu]

Issue #12125 has been updated by Nobuyoshi Nakada.


Stefan Merettig wrote:
> * Using `.>`: `the_object.>a_method`
> * Using `<..>`: `the_object<a_method>`

These two conflict with existing syntax and break compatibility.
Note that `object.>(other)` is a valid method call.


----------------------------------------
Feature #12125: Proposal: Shorthand operator for Object#method
https://bugs.ruby-lang.org/issues/12125#change-57223

* Author: Stefan Merettig
* Status: Open
* Priority: Normal
* Assignee: 
----------------------------------------
Hello,

The `&` operator lets one pass a `#call`-able object as block.

Really useful feature, but at the moment, if you want to pass a `Method` this way the syntax is not really concise:

`Dir["*/*.c"].map(&File.method(:basename))`

More often than not, at least I end up writing this instead `.map{|a| File.basename a}` which isn't that great either.

Thus, I want to propose adding a short-hand operator to the ruby language, which simply calls `#method` on an Object.

It could look like this: `an_object->the_method` which is 100% equivalent to doing `an_object.method(:the_method)`

I'm reusing the `->` operator which is already used for the stabby lambda. But I think it makes sense: You have an object,
and from that object you point at a method to get it as `Method`.

With this, the example from above becomes: `Dir["*/*.c"].map(&File->basename)`

I attached a proof of concept patch. When you apply this to trunk, you can try the example above yourself.
Do note however that this PoC also breaks stabby lambda for the moment. I'll work on fixing that the following
days.

Thank you for reading,
Stefan.

---Files--------------------------------
method_shorthand.diff (740 Bytes)


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

[ruby-core:74073] [Ruby trunk Feature#12125] Proposal: Shorthand operator for Object#method

[nobu]

Issue #12125 has been updated by Nobuyoshi Nakada.

Description updated

----------------------------------------
Feature #12125: Proposal: Shorthand operator for Object#method
https://bugs.ruby-lang.org/issues/12125#change-57224

* Author: Stefan Merettig
* Status: Open
* Priority: Normal
* Assignee: 
----------------------------------------
Hello,

The `&` operator lets one pass a `#call`-able object as block.

Really useful feature, but at the moment, if you want to pass a `Method` this way the syntax is not really concise:

```ruby
Dir["*/*.c"].map(&File.method(:basename))
```

More often than not, at least I end up writing this instead `.map{|a| File.basename a}` which isn't that great either.

Thus, I want to propose adding a short-hand operator to the ruby language, which simply calls `#method` on an `Object`.

It could look like this: `an_object->the_method` which is 100% equivalent to doing `an_object.method(:the_method)`

I'm reusing the `->` operator which is already used for the stabby lambda. But I think it makes sense: You have an object,
and from that object you point at a method to get it as `Method`.

With this, the example from above becomes: `Dir["*/*.c"].map(&File->basename)`

I attached a proof of concept patch. When you apply this to trunk, you can try the example above yourself.
Do note however that this PoC also breaks stabby lambda for the moment. I'll work on fixing that the following
days.

Thank you for reading,
Stefan.

---Files--------------------------------
method_shorthand.diff (740 Bytes)


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

[ruby-core:74293] [Ruby trunk Feature#12125] Proposal: Shorthand operator for Object#method

[Ruby-Lang]

Issue #12125 has been updated by Jörg W Mittag.


A proposal that has existed for years, if not decades, is to deprecate usage of the `::` double colon binary infix namespace operator for message sends, and instead re-use it for method references:

~~~ruby
Dir["*/*.c"].map(&File::basename)
~~~

This is also the syntax chosen by Java for method references.

There is one big problem, though: ambiguity with constant references for methods which start with an uppercase letter. Maybe, it would be possible to require parentheses in that case?

~~~ruby
%w[1 2 3].map(&::Integer())
~~~

----------------------------------------
Feature #12125: Proposal: Shorthand operator for Object#method
https://bugs.ruby-lang.org/issues/12125#change-57415

* Author: Stefan Merettig
* Status: Open
* Priority: Normal
* Assignee: 
----------------------------------------
Hello,

The `&` operator lets one pass a `#call`-able object as block.

Really useful feature, but at the moment, if you want to pass a `Method` this way the syntax is not really concise:

```ruby
Dir["*/*.c"].map(&File.method(:basename))
```

More often than not, at least I end up writing this instead `.map{|a| File.basename a}` which isn't that great either.

Thus, I want to propose adding a short-hand operator to the ruby language, which simply calls `#method` on an `Object`.

It could look like this: `an_object->the_method` which is 100% equivalent to doing `an_object.method(:the_method)`

I'm reusing the `->` operator which is already used for the stabby lambda. But I think it makes sense: You have an object,
and from that object you point at a method to get it as `Method`.

With this, the example from above becomes: `Dir["*/*.c"].map(&File->basename)`

I attached a proof of concept patch. When you apply this to trunk, you can try the example above yourself.
Do note however that this PoC also breaks stabby lambda for the moment. I'll work on fixing that the following
days.

Thank you for reading,
Stefan.

---Files--------------------------------
method_shorthand.diff (740 Bytes)


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

[ruby-core:74294] [Ruby trunk Feature#12125] Proposal: Shorthand operator for Object#method

[Ruby-Lang]

Issue #12125 has been updated by Jörg W Mittag.


It would be nice if we could find symmetric syntax for getting an `UnboundMethod` from a module.

----------------------------------------
Feature #12125: Proposal: Shorthand operator for Object#method
https://bugs.ruby-lang.org/issues/12125#change-57416

* Author: Stefan Merettig
* Status: Open
* Priority: Normal
* Assignee: 
----------------------------------------
Hello,

The `&` operator lets one pass a `#call`-able object as block.

Really useful feature, but at the moment, if you want to pass a `Method` this way the syntax is not really concise:

```ruby
Dir["*/*.c"].map(&File.method(:basename))
```

More often than not, at least I end up writing this instead `.map{|a| File.basename a}` which isn't that great either.

Thus, I want to propose adding a short-hand operator to the ruby language, which simply calls `#method` on an `Object`.

It could look like this: `an_object->the_method` which is 100% equivalent to doing `an_object.method(:the_method)`

I'm reusing the `->` operator which is already used for the stabby lambda. But I think it makes sense: You have an object,
and from that object you point at a method to get it as `Method`.

With this, the example from above becomes: `Dir["*/*.c"].map(&File->basename)`

I attached a proof of concept patch. When you apply this to trunk, you can try the example above yourself.
Do note however that this PoC also breaks stabby lambda for the moment. I'll work on fixing that the following
days.

Thank you for reading,
Stefan.

---Files--------------------------------
method_shorthand.diff (740 Bytes)


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

[ruby-core:74299] [Ruby trunk Feature#12125] Proposal: Shorthand operator for Object#method

[mame]

Issue #12125 has been updated by Yusuke Endoh.

File dot-symbol.patch added

+1 for this proposal.  How about `recv.:fname`?

~~~
$ ./miniruby -e 'p Dir["*/*.c"].map(&File.:basename)'
["hypot.c", "memcmp.c", "erf.c", ...]
~~~

Fortunately, it brings no conflict.

A patch is attached.  (dot-symbol.patch)

-- 
Yusuke Endoh <mame@ruby-lang.org>

----------------------------------------
Feature #12125: Proposal: Shorthand operator for Object#method
https://bugs.ruby-lang.org/issues/12125#change-57419

* Author: Stefan Merettig
* Status: Open
* Priority: Normal
* Assignee: 
----------------------------------------
Hello,

The `&` operator lets one pass a `#call`-able object as block.

Really useful feature, but at the moment, if you want to pass a `Method` this way the syntax is not really concise:

```ruby
Dir["*/*.c"].map(&File.method(:basename))
```

More often than not, at least I end up writing this instead `.map{|a| File.basename a}` which isn't that great either.

Thus, I want to propose adding a short-hand operator to the ruby language, which simply calls `#method` on an `Object`.

It could look like this: `an_object->the_method` which is 100% equivalent to doing `an_object.method(:the_method)`

I'm reusing the `->` operator which is already used for the stabby lambda. But I think it makes sense: You have an object,
and from that object you point at a method to get it as `Method`.

With this, the example from above becomes: `Dir["*/*.c"].map(&File->basename)`

I attached a proof of concept patch. When you apply this to trunk, you can try the example above yourself.
Do note however that this PoC also breaks stabby lambda for the moment. I'll work on fixing that the following
days.

Thank you for reading,
Stefan.

---Files--------------------------------
method_shorthand.diff (740 Bytes)
dot-symbol.patch (554 Bytes)


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

[ruby-core:74317] [Ruby trunk Feature#12125] Proposal: Shorthand operator for Object#method

[nobu]

Issue #12125 has been updated by Nobuyoshi Nakada.


Yusuke Endoh wrote:
> +1 for this proposal.  How about `recv.:fname`?

`dot_or_colon` means that `File:::basename` also works?

----------------------------------------
Feature #12125: Proposal: Shorthand operator for Object#method
https://bugs.ruby-lang.org/issues/12125#change-57436

* Author: Stefan Merettig
* Status: Open
* Priority: Normal
* Assignee: 
----------------------------------------
Hello,

The `&` operator lets one pass a `#call`-able object as block.

Really useful feature, but at the moment, if you want to pass a `Method` this way the syntax is not really concise:

```ruby
Dir["*/*.c"].map(&File.method(:basename))
```

More often than not, at least I end up writing this instead `.map{|a| File.basename a}` which isn't that great either.

Thus, I want to propose adding a short-hand operator to the ruby language, which simply calls `#method` on an `Object`.

It could look like this: `an_object->the_method` which is 100% equivalent to doing `an_object.method(:the_method)`

I'm reusing the `->` operator which is already used for the stabby lambda. But I think it makes sense: You have an object,
and from that object you point at a method to get it as `Method`.

With this, the example from above becomes: `Dir["*/*.c"].map(&File->basename)`

I attached a proof of concept patch. When you apply this to trunk, you can try the example above yourself.
Do note however that this PoC also breaks stabby lambda for the moment. I'll work on fixing that the following
days.

Thank you for reading,
Stefan.

---Files--------------------------------
method_shorthand.diff (740 Bytes)
dot-symbol.patch (554 Bytes)


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

[ruby-core:74323] [Ruby trunk Feature#12125] Proposal: Shorthand operator for Object#method

[mame]

Issue #12125 has been updated by Yusuke Endoh.


Nobuyoshi Nakada wrote:
> Yusuke Endoh wrote:
> > +1 for this proposal.  How about `recv.:fname`?
> 
> `dot_or_colon` means that `File:::basename` also works?

Yes it works.  But I don't think it is important.  Only `.:` is also okay to me.

-- 
Yusuke Endoh <mame@ruby-lang.org>

----------------------------------------
Feature #12125: Proposal: Shorthand operator for Object#method
https://bugs.ruby-lang.org/issues/12125#change-57443

* Author: Stefan Merettig
* Status: Open
* Priority: Normal
* Assignee: 
----------------------------------------
Hello,

The `&` operator lets one pass a `#call`-able object as block.

Really useful feature, but at the moment, if you want to pass a `Method` this way the syntax is not really concise:

```ruby
Dir["*/*.c"].map(&File.method(:basename))
```

More often than not, at least I end up writing this instead `.map{|a| File.basename a}` which isn't that great either.

Thus, I want to propose adding a short-hand operator to the ruby language, which simply calls `#method` on an `Object`.

It could look like this: `an_object->the_method` which is 100% equivalent to doing `an_object.method(:the_method)`

I'm reusing the `->` operator which is already used for the stabby lambda. But I think it makes sense: You have an object,
and from that object you point at a method to get it as `Method`.

With this, the example from above becomes: `Dir["*/*.c"].map(&File->basename)`

I attached a proof of concept patch. When you apply this to trunk, you can try the example above yourself.
Do note however that this PoC also breaks stabby lambda for the moment. I'll work on fixing that the following
days.

Thank you for reading,
Stefan.

---Files--------------------------------
method_shorthand.diff (740 Bytes)
dot-symbol.patch (554 Bytes)


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

[ruby-core:74352] [Ruby trunk Feature#12125] Proposal: Shorthand operator for Object#method

[Stefan-Merettig]

Issue #12125 has been updated by Stefan Merettig.


Yusuke Endoh wrote:
> Nobuyoshi Nakada wrote:
> > Yusuke Endoh wrote:
> > > +1 for this proposal.  How about `recv.:fname`?
> > 
> > `dot_or_colon` means that `File:::basename` also works?
> 
> Yes it works.  But I don't think it is important.  Only `.:` is also okay to me.

The tetris-operator `.:` makes sense to me, but in respect to `:::` I don't think we should allow "alternative" operators to do the same thing.



----------------------------------------
Feature #12125: Proposal: Shorthand operator for Object#method
https://bugs.ruby-lang.org/issues/12125#change-57472

* Author: Stefan Merettig
* Status: Open
* Priority: Normal
* Assignee: 
----------------------------------------
Hello,

The `&` operator lets one pass a `#call`-able object as block.

Really useful feature, but at the moment, if you want to pass a `Method` this way the syntax is not really concise:

```ruby
Dir["*/*.c"].map(&File.method(:basename))
```

More often than not, at least I end up writing this instead `.map{|a| File.basename a}` which isn't that great either.

Thus, I want to propose adding a short-hand operator to the ruby language, which simply calls `#method` on an `Object`.

It could look like this: `an_object->the_method` which is 100% equivalent to doing `an_object.method(:the_method)`

I'm reusing the `->` operator which is already used for the stabby lambda. But I think it makes sense: You have an object,
and from that object you point at a method to get it as `Method`.

With this, the example from above becomes: `Dir["*/*.c"].map(&File->basename)`

I attached a proof of concept patch. When you apply this to trunk, you can try the example above yourself.
Do note however that this PoC also breaks stabby lambda for the moment. I'll work on fixing that the following
days.

Thank you for reading,
Stefan.

---Files--------------------------------
method_shorthand.diff (740 Bytes)
dot-symbol.patch (554 Bytes)


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

[ruby-core:74353] [Ruby trunk Feature#12125] Proposal: Shorthand operator for Object#method

[funny.falcon]

Issue #12125 has been updated by Yura Sokolov.


-1000

Please, don't!!!

I don't wonna Ruby to become Perl!!!

No more unnecessary syntax!!!

You all are not so weak! you are strong humans!!

You just can type a bit more characters!!!

----------------------------------------
Feature #12125: Proposal: Shorthand operator for Object#method
https://bugs.ruby-lang.org/issues/12125#change-57473

* Author: Stefan Merettig
* Status: Open
* Priority: Normal
* Assignee: 
----------------------------------------
Hello,

The `&` operator lets one pass a `#call`-able object as block.

Really useful feature, but at the moment, if you want to pass a `Method` this way the syntax is not really concise:

```ruby
Dir["*/*.c"].map(&File.method(:basename))
```

More often than not, at least I end up writing this instead `.map{|a| File.basename a}` which isn't that great either.

Thus, I want to propose adding a short-hand operator to the ruby language, which simply calls `#method` on an `Object`.

It could look like this: `an_object->the_method` which is 100% equivalent to doing `an_object.method(:the_method)`

I'm reusing the `->` operator which is already used for the stabby lambda. But I think it makes sense: You have an object,
and from that object you point at a method to get it as `Method`.

With this, the example from above becomes: `Dir["*/*.c"].map(&File->basename)`

I attached a proof of concept patch. When you apply this to trunk, you can try the example above yourself.
Do note however that this PoC also breaks stabby lambda for the moment. I'll work on fixing that the following
days.

Thank you for reading,
Stefan.

---Files--------------------------------
method_shorthand.diff (740 Bytes)
dot-symbol.patch (554 Bytes)


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

[ruby-core:74368] [Ruby trunk Feature#12125] Proposal: Shorthand operator for Object#method

[hanachin]

Issue #12125 has been updated by Seiei Miyagi.


How about `File[.basename]` ?

----------------------------------------
Feature #12125: Proposal: Shorthand operator for Object#method
https://bugs.ruby-lang.org/issues/12125#change-57488

* Author: Stefan Merettig
* Status: Open
* Priority: Normal
* Assignee: 
----------------------------------------
Hello,

The `&` operator lets one pass a `#call`-able object as block.

Really useful feature, but at the moment, if you want to pass a `Method` this way the syntax is not really concise:

```ruby
Dir["*/*.c"].map(&File.method(:basename))
```

More often than not, at least I end up writing this instead `.map{|a| File.basename a}` which isn't that great either.

Thus, I want to propose adding a short-hand operator to the ruby language, which simply calls `#method` on an `Object`.

It could look like this: `an_object->the_method` which is 100% equivalent to doing `an_object.method(:the_method)`

I'm reusing the `->` operator which is already used for the stabby lambda. But I think it makes sense: You have an object,
and from that object you point at a method to get it as `Method`.

With this, the example from above becomes: `Dir["*/*.c"].map(&File->basename)`

I attached a proof of concept patch. When you apply this to trunk, you can try the example above yourself.
Do note however that this PoC also breaks stabby lambda for the moment. I'll work on fixing that the following
days.

Thank you for reading,
Stefan.

---Files--------------------------------
method_shorthand.diff (740 Bytes)
dot-symbol.patch (554 Bytes)


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

[ruby-core:74396] [Ruby trunk Feature#12125] Proposal: Shorthand operator for Object#method

[shyouhei]

Issue #12125 has been updated by Shyouhei Urabe.


Just a status update: I heard from Matz in this month's developer meeting that however he wants this, all proposed syntax so far didn't charm him.

----------------------------------------
Feature #12125: Proposal: Shorthand operator for Object#method
https://bugs.ruby-lang.org/issues/12125#change-57517

* Author: Stefan Merettig
* Status: Open
* Priority: Normal
* Assignee: 
----------------------------------------
Hello,

The `&` operator lets one pass a `#call`-able object as block.

Really useful feature, but at the moment, if you want to pass a `Method` this way the syntax is not really concise:

```ruby
Dir["*/*.c"].map(&File.method(:basename))
```

More often than not, at least I end up writing this instead `.map{|a| File.basename a}` which isn't that great either.

Thus, I want to propose adding a short-hand operator to the ruby language, which simply calls `#method` on an `Object`.

It could look like this: `an_object->the_method` which is 100% equivalent to doing `an_object.method(:the_method)`

I'm reusing the `->` operator which is already used for the stabby lambda. But I think it makes sense: You have an object,
and from that object you point at a method to get it as `Method`.

With this, the example from above becomes: `Dir["*/*.c"].map(&File->basename)`

I attached a proof of concept patch. When you apply this to trunk, you can try the example above yourself.
Do note however that this PoC also breaks stabby lambda for the moment. I'll work on fixing that the following
days.

Thank you for reading,
Stefan.

---Files--------------------------------
method_shorthand.diff (740 Bytes)
dot-symbol.patch (554 Bytes)


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

[ruby-core:74402] [Ruby trunk Feature#12125] Proposal: Shorthand operator for Object#method

[nobu]

Issue #12125 has been updated by Nobuyoshi Nakada.


Seiei Miyagi wrote:
> How about `File[.basename]` ?

It causes confusion if the receiver has `#[]` method.

----------------------------------------
Feature #12125: Proposal: Shorthand operator for Object#method
https://bugs.ruby-lang.org/issues/12125#change-57526

* Author: Stefan Merettig
* Status: Open
* Priority: Normal
* Assignee: 
----------------------------------------
Hello,

The `&` operator lets one pass a `#call`-able object as block.

Really useful feature, but at the moment, if you want to pass a `Method` this way the syntax is not really concise:

```ruby
Dir["*/*.c"].map(&File.method(:basename))
```

More often than not, at least I end up writing this instead `.map{|a| File.basename a}` which isn't that great either.

Thus, I want to propose adding a short-hand operator to the ruby language, which simply calls `#method` on an `Object`.

It could look like this: `an_object->the_method` which is 100% equivalent to doing `an_object.method(:the_method)`

I'm reusing the `->` operator which is already used for the stabby lambda. But I think it makes sense: You have an object,
and from that object you point at a method to get it as `Method`.

With this, the example from above becomes: `Dir["*/*.c"].map(&File->basename)`

I attached a proof of concept patch. When you apply this to trunk, you can try the example above yourself.
Do note however that this PoC also breaks stabby lambda for the moment. I'll work on fixing that the following
days.

Thank you for reading,
Stefan.

---Files--------------------------------
method_shorthand.diff (740 Bytes)
dot-symbol.patch (554 Bytes)


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

[ruby-core:74439] [Ruby trunk Feature#12125] Proposal: Shorthand operator for Object#method

[rpc]

Issue #12125 has been updated by RP C.


Stefan Merettig wrote:
> Hello,
> 
> The `&` operator lets one pass a `#call`-able object as block.
> 
> Really useful feature, but at the moment, if you want to pass a `Method` this way the syntax is not really concise:
> 
> ```ruby
> Dir["*/*.c"].map(&File.method(:basename))
> ```
> 
> More often than not, at least I end up writing this instead `.map{|a| File.basename a}` which isn't that great either.
> 
> Thus, I want to propose adding a short-hand operator to the ruby language, which simply calls `#method` on an `Object`.
> 
> It could look like this: `an_object->the_method` which is 100% equivalent to doing `an_object.method(:the_method)`
> 
> I'm reusing the `->` operator which is already used for the stabby lambda. But I think it makes sense: You have an object,
> and from that object you point at a method to get it as `Method`.
> 
> With this, the example from above becomes: `Dir["*/*.c"].map(&File->basename)`
> 
> I attached a proof of concept patch. When you apply this to trunk, you can try the example above yourself.
> Do note however that this PoC also breaks stabby lambda for the moment. I'll work on fixing that the following
> days.
> 
> Thank you for reading,
> Stefan.

Dir["*/*.c"].map(File[&:basename])

From File, employ basename method.  The referencing & should be applied to the method, not the class, as it is really the method you're concerned with. I'm not a language designer, but this is how I would *expect* this to work by looking at it.

----------------------------------------
Feature #12125: Proposal: Shorthand operator for Object#method
https://bugs.ruby-lang.org/issues/12125#change-57559

* Author: Stefan Merettig
* Status: Open
* Priority: Normal
* Assignee: 
----------------------------------------
Hello,

The `&` operator lets one pass a `#call`-able object as block.

Really useful feature, but at the moment, if you want to pass a `Method` this way the syntax is not really concise:

```ruby
Dir["*/*.c"].map(&File.method(:basename))
```

More often than not, at least I end up writing this instead `.map{|a| File.basename a}` which isn't that great either.

Thus, I want to propose adding a short-hand operator to the ruby language, which simply calls `#method` on an `Object`.

It could look like this: `an_object->the_method` which is 100% equivalent to doing `an_object.method(:the_method)`

I'm reusing the `->` operator which is already used for the stabby lambda. But I think it makes sense: You have an object,
and from that object you point at a method to get it as `Method`.

With this, the example from above becomes: `Dir["*/*.c"].map(&File->basename)`

I attached a proof of concept patch. When you apply this to trunk, you can try the example above yourself.
Do note however that this PoC also breaks stabby lambda for the moment. I'll work on fixing that the following
days.

Thank you for reading,
Stefan.

---Files--------------------------------
method_shorthand.diff (740 Bytes)
dot-symbol.patch (554 Bytes)


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

[ruby-core:74440] [Ruby trunk Feature#12125] Proposal: Shorthand operator for Object#method

[rpc]

Issue #12125 has been updated by RP C.


Another thought: Dir["/.c"].map(File.&basename)

----------------------------------------
Feature #12125: Proposal: Shorthand operator for Object#method
https://bugs.ruby-lang.org/issues/12125#change-57560

* Author: Stefan Merettig
* Status: Open
* Priority: Normal
* Assignee: 
----------------------------------------
Hello,

The `&` operator lets one pass a `#call`-able object as block.

Really useful feature, but at the moment, if you want to pass a `Method` this way the syntax is not really concise:

```ruby
Dir["*/*.c"].map(&File.method(:basename))
```

More often than not, at least I end up writing this instead `.map{|a| File.basename a}` which isn't that great either.

Thus, I want to propose adding a short-hand operator to the ruby language, which simply calls `#method` on an `Object`.

It could look like this: `an_object->the_method` which is 100% equivalent to doing `an_object.method(:the_method)`

I'm reusing the `->` operator which is already used for the stabby lambda. But I think it makes sense: You have an object,
and from that object you point at a method to get it as `Method`.

With this, the example from above becomes: `Dir["*/*.c"].map(&File->basename)`

I attached a proof of concept patch. When you apply this to trunk, you can try the example above yourself.
Do note however that this PoC also breaks stabby lambda for the moment. I'll work on fixing that the following
days.

Thank you for reading,
Stefan.

---Files--------------------------------
method_shorthand.diff (740 Bytes)
dot-symbol.patch (554 Bytes)


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

[ruby-core:74441] Re: [Ruby trunk Feature#12125] Proposal: Shorthand operator for Object#method

[Matthew Kerwin]

[-- Attachment #1.1: Type: text/plain, Size: 323 bytes --]

On 18/03/2016 6:54 AM, <rpc@bewitching.me> wrote:
>
> Issue #12125 has been updated by RP C.
>
> Another thought: Dir["/.c"].map(File.&basename)
>

Can someone please tell me what's wrong with

~~~ruby
Dir["/.c"].map{|f| File.basename f }
~~~

?

There's being concise, and there's syntax sugar, but this is getting silly.

[-- Attachment #1.2: Type: text/html, Size: 533 bytes --]

[-- Attachment #2: Type: text/plain, Size: 138 bytes --]


Unsubscribe: <mailto:ruby-core-request@ruby-lang.org?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>

[ruby-core:83043] [Ruby trunk Feature#12125] Proposal: Shorthand operator for Object#method

[vassilevsky]

Issue #12125 has been updated by vassilevsky (Ilya Vassilevsky).


Is it possible to use a single colon for this?

    object:name

    File:basename

    URI:parse

As far as I can see (not far, really, I don't even know C), it is currently not used for anything.

----------------------------------------
Feature #12125: Proposal: Shorthand operator for Object#method
https://bugs.ruby-lang.org/issues/12125#change-66965

* Author: Papierkorb (Stefan Merettig)
* Status: Open
* Priority: Normal
* Assignee: 
* Target version: 
----------------------------------------
Hello,

The `&` operator lets one pass a `#call`-able object as block.

Really useful feature, but at the moment, if you want to pass a `Method` this way the syntax is not really concise:

```ruby
Dir["*/*.c"].map(&File.method(:basename))
```

More often than not, at least I end up writing this instead `.map{|a| File.basename a}` which isn't that great either.

Thus, I want to propose adding a short-hand operator to the ruby language, which simply calls `#method` on an `Object`.

It could look like this: `an_object->the_method` which is 100% equivalent to doing `an_object.method(:the_method)`

I'm reusing the `->` operator which is already used for the stabby lambda. But I think it makes sense: You have an object,
and from that object you point at a method to get it as `Method`.

With this, the example from above becomes: `Dir["*/*.c"].map(&File->basename)`

I attached a proof of concept patch. When you apply this to trunk, you can try the example above yourself.
Do note however that this PoC also breaks stabby lambda for the moment. I'll work on fixing that the following
days.

Thank you for reading,
Stefan.

---Files--------------------------------
method_shorthand.diff (740 Bytes)
dot-symbol.patch (554 Bytes)


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

[ruby-core:83044] [Ruby trunk Feature#12125] Proposal: Shorthand operator for Object#method

[nobu]

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


A colon does too many things already, a ternary operator, a symbol literal, and a keyword argument.

----------------------------------------
Feature #12125: Proposal: Shorthand operator for Object#method
https://bugs.ruby-lang.org/issues/12125#change-66966

* Author: Papierkorb (Stefan Merettig)
* Status: Open
* Priority: Normal
* Assignee: 
* Target version: 
----------------------------------------
Hello,

The `&` operator lets one pass a `#call`-able object as block.

Really useful feature, but at the moment, if you want to pass a `Method` this way the syntax is not really concise:

```ruby
Dir["*/*.c"].map(&File.method(:basename))
```

More often than not, at least I end up writing this instead `.map{|a| File.basename a}` which isn't that great either.

Thus, I want to propose adding a short-hand operator to the ruby language, which simply calls `#method` on an `Object`.

It could look like this: `an_object->the_method` which is 100% equivalent to doing `an_object.method(:the_method)`

I'm reusing the `->` operator which is already used for the stabby lambda. But I think it makes sense: You have an object,
and from that object you point at a method to get it as `Method`.

With this, the example from above becomes: `Dir["*/*.c"].map(&File->basename)`

I attached a proof of concept patch. When you apply this to trunk, you can try the example above yourself.
Do note however that this PoC also breaks stabby lambda for the moment. I'll work on fixing that the following
days.

Thank you for reading,
Stefan.

---Files--------------------------------
method_shorthand.diff (740 Bytes)
dot-symbol.patch (554 Bytes)


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

[ruby-core:83045] [Ruby trunk Feature#12125] Proposal: Shorthand operator for Object#method

[nobu]

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


`File[&:basename]` and `File.&basename` are valid syntax already.

----------------------------------------
Feature #12125: Proposal: Shorthand operator for Object#method
https://bugs.ruby-lang.org/issues/12125#change-66967

* Author: Papierkorb (Stefan Merettig)
* Status: Open
* Priority: Normal
* Assignee: 
* Target version: 
----------------------------------------
Hello,

The `&` operator lets one pass a `#call`-able object as block.

Really useful feature, but at the moment, if you want to pass a `Method` this way the syntax is not really concise:

```ruby
Dir["*/*.c"].map(&File.method(:basename))
```

More often than not, at least I end up writing this instead `.map{|a| File.basename a}` which isn't that great either.

Thus, I want to propose adding a short-hand operator to the ruby language, which simply calls `#method` on an `Object`.

It could look like this: `an_object->the_method` which is 100% equivalent to doing `an_object.method(:the_method)`

I'm reusing the `->` operator which is already used for the stabby lambda. But I think it makes sense: You have an object,
and from that object you point at a method to get it as `Method`.

With this, the example from above becomes: `Dir["*/*.c"].map(&File->basename)`

I attached a proof of concept patch. When you apply this to trunk, you can try the example above yourself.
Do note however that this PoC also breaks stabby lambda for the moment. I'll work on fixing that the following
days.

Thank you for reading,
Stefan.

---Files--------------------------------
method_shorthand.diff (740 Bytes)
dot-symbol.patch (554 Bytes)


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