[ruby-core:82353] [Ruby trunk Feature#13807] A method to filter the receiver against some condition

[ruby-core:82353] [Ruby trunk Feature#13807] A method to filter the receiver against some condition

[sawadatsuyoshi]

Issue #13807 has been reported by sawa (Tsuyoshi Sawada).

----------------------------------------
Feature #13807: A method to filter the receiver against some condition
https://bugs.ruby-lang.org/issues/13807

* Author: sawa (Tsuyoshi Sawada)
* Status: Open
* Priority: Normal
* Assignee: 
* Target version: 
----------------------------------------
I frequently see code that uses some value if that value satisfies a certain condition, and something else otherwise.

```ruby
a.some_condition ? a : b
```

And in most cases, the value of `a` is non-nil when the condition is satisfied.

I propose to have a method, perhaps named `verify`, which would implemented to be equivalent to this definition:

```ruby
class Object
  def verify
    self if yield(self)
  end
end
```

Then, we can write the expression above (assuming `a` is non-nil when the condition is satisfied) like this:

```ruby
a.verify{|a| a.some_condition} || b
```

Perhaps it would also be useful to do something like:

```ruby
a.verify{|a| a.some_condition}&.chaining_of_more_methods
```



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

[ruby-core:82357] [Ruby trunk Feature#13807] A method to filter the receiver against some condition

[shevegen]

Issue #13807 has been updated by shevegen (Robert A. Heiler).


I have no particular pro or con opinion about your proposal, but I just
want to say that the last variant is not very pretty.

The lonely guy operator staring at the dot before him is pressed hard
against the wall behind him there, the "}" character!

----------------------------------------
Feature #13807: A method to filter the receiver against some condition
https://bugs.ruby-lang.org/issues/13807#change-66150

* Author: sawa (Tsuyoshi Sawada)
* Status: Open
* Priority: Normal
* Assignee: 
* Target version: 
----------------------------------------
I frequently see code that uses some value if that value satisfies a certain condition, and something else otherwise.

```ruby
a.some_condition ? a : b
```

And in most cases, the value of `a` is non-nil when the condition is satisfied.

I propose to have a method, perhaps named `verify`, which would implemented to be equivalent to this definition:

```ruby
class Object
  def verify
    self if yield(self)
  end
end
```

Then, we can write the expression above (assuming `a` is non-nil when the condition is satisfied) like this:

```ruby
a.verify{|a| a.some_condition} || b
```

Perhaps it would also be useful to do something like:

```ruby
a.verify{|a| a.some_condition}&.chaining_of_more_methods
```



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

[ruby-core:82360] [Ruby trunk Feature#13807] A method to filter the receiver against some condition

[duerst]

Issue #13807 has been updated by duerst (Martin Dürst).


I don't see any improvement. The new way that would be possible with the `verify` method is longer and more complicated than the simple and straightforward `a.some_condition ? a : b`.

----------------------------------------
Feature #13807: A method to filter the receiver against some condition
https://bugs.ruby-lang.org/issues/13807#change-66157

* Author: sawa (Tsuyoshi Sawada)
* Status: Open
* Priority: Normal
* Assignee: 
* Target version: 
----------------------------------------
I frequently see code that uses some value if that value satisfies a certain condition, and something else otherwise.

```ruby
a.some_condition ? a : b
```

And in most cases, the value of `a` is non-nil when the condition is satisfied.

I propose to have a method, perhaps named `verify`, which would implemented to be equivalent to this definition:

```ruby
class Object
  def verify
    self if yield(self)
  end
end
```

Then, we can write the expression above (assuming `a` is non-nil when the condition is satisfied) like this:

```ruby
a.verify{|a| a.some_condition} || b
```

Perhaps it would also be useful to do something like:

```ruby
a.verify{|a| a.some_condition}&.chaining_of_more_methods
```



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

[ruby-core:82361] [Ruby trunk Feature#13807] A method to filter the receiver against some condition

[nobu]

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


It seems useless without method chain, i.e., variable `a` is too simple as an example.

That is, this is a variant of `yield_self`.

```ruby
foo.bar.zot.yield_self {|a| a.some_condition ? a : b}
```

or

```ruby
foo.bar.zot.verify {|a| a.some_condition} || b
foo.bar.zot.verify(&:some_condition) || b
```

But `verify` is long and sounds ambiguous.

This came to my mind, but looks magical a little.

```ruby
foo.bar.zot.if?(&:some_condition) || b
```


----------------------------------------
Feature #13807: A method to filter the receiver against some condition
https://bugs.ruby-lang.org/issues/13807#change-66158

* Author: sawa (Tsuyoshi Sawada)
* Status: Open
* Priority: Normal
* Assignee: 
* Target version: 
----------------------------------------
I frequently see code that uses some value if that value satisfies a certain condition, and something else otherwise.

```ruby
a.some_condition ? a : b
```

And in most cases, the value of `a` is non-nil when the condition is satisfied.

I propose to have a method, perhaps named `verify`, which would implemented to be equivalent to this definition:

```ruby
class Object
  def verify
    self if yield(self)
  end
end
```

Then, we can write the expression above (assuming `a` is non-nil when the condition is satisfied) like this:

```ruby
a.verify{|a| a.some_condition} || b
```

Perhaps it would also be useful to do something like:

```ruby
a.verify{|a| a.some_condition}&.chaining_of_more_methods
```



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

[ruby-core:91221] [Ruby trunk Feature#13807] A method to filter the receiver against some condition

[sawadatsuyoshi]

Issue #13807 has been updated by sawa (Tsuyoshi Sawada).


I came up with an idea better than this (https://bugs.ruby-lang.org/issues/15557).

So I withdraw this proposal. Please close it.

----------------------------------------
Feature #13807: A method to filter the receiver against some condition
https://bugs.ruby-lang.org/issues/13807#change-76459

* Author: sawa (Tsuyoshi Sawada)
* Status: Open
* Priority: Normal
* Assignee: 
* Target version: 
----------------------------------------
I frequently see code that uses some value if that value satisfies a certain condition, and something else otherwise.

```ruby
a.some_condition ? a : b
```

And in most cases, the value of `a` is non-nil when the condition is satisfied.

I propose to have a method, perhaps named `verify`, which would implemented to be equivalent to this definition:

```ruby
class Object
  def verify
    self if yield(self)
  end
end
```

Then, we can write the expression above (assuming `a` is non-nil when the condition is satisfied) like this:

```ruby
a.verify{|a| a.some_condition} || b
```

Perhaps it would also be useful to do something like:

```ruby
a.verify{|a| a.some_condition}&.chaining_of_more_methods
```



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