[ruby-core:99770] [Ruby master Feature#13683] Add strict Enumerable#single
From:
sawadatsuyoshi@...
Date:
2020-08-29 12:29:13 UTC
List:
ruby-core #99770
Issue #13683 has been updated by sawa (Tsuyoshi Sawada).
Dan0042 (Daniel DeLorme) wrote in #note-25:
> I really think the block form should be like find/select
>
> ```ruby
> [1,2,3].one{ _1.even? } #=> 2
> [1,2,3,4].one{ _1.even? } #=> error
> [1,2,3,4].one(nil){ _1.even? } #=> nil
> ```
...
> continue searching [...] that alters the fundamental behavior too much imho.
I think you are right.
I think the English word that best matches the concept is the definite article. This word presupposes that there is exactly one corresponding entity in the context, and picks that entity. If the presupposition is not satisfied, then the entire expression would be uninterpretable in the case of natural languages, which amounts to raising an exception in the case of programming languages.
```ruby
[1,2,3].the{_1.even?} # => 2
[1,2,3,4].the{_1.even?} # >> error
```
Using the usual block parameter, `[1,2,3].the{|x| x.even?}` could be read as "**the** `x` (out of `[1, 2, 3]`) such that `x` is even." If such `x` does not uniquely exist, this expression is uninterpretable.
----------------------------------------
Feature #13683: Add strict Enumerable#single
https://bugs.ruby-lang.org/issues/13683#change-87282
* Author: dnagir (Dmytrii Nagirniak)
* Status: Feedback
* Priority: Normal
----------------------------------------
### Summary
This is inspired by other languages and frameworks, such as LINQ's [Single](https://msdn.microsoft.com/en-us/library/bb155325%28v=vs.110%29.aspx) (pardon MSDN reference), which has very big distinction between `first` and `single` element of a
collection.
- `first` normally returns the top element, and the developer assumes
there could be many;
- `single` returns one and only one element, and it is an error if there
are none or more than one.
We, in Ruby world, very often write `fetch_by('something').first`
assuming there's only one element that can be returned there.
But in majority of the cases, we really want a `single` element.
The problems with using `first` in this case:
- developer needs to explicitly double check the result isn't `nil`
- in case of corrupted data (more than one item returned), it will never
be noticed
`Enumerable#single` addresses those problems in a very strong and
specific way that may save the world by simply switching from `first` to
`single`.
### Other information
- we may come with a better internal implementation (than `self.map`)
- better name could be used, maybe `only` is better, or a bang version?
- re-consider the "block" implementation in favour of a separate method (`single!`, `single_or { 'default' }`)
The original implementation is on the ActiveSupport https://github.com/rails/rails/pull/26206
But it was suggested to discuss the possibility of adding it to Ruby which would be amazing.
--
https://bugs.ruby-lang.org/
Unsubscribe: <mailto:[email protected]?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>