Feature #13683

Updated by nobu (Nobuyoshi Nakada) almost 4 years ago

### Summary 

 This is inspired by other languages and frameworks, such as LINQ's [Single]( (pardon MSDN reference), which has very big distinction between `first` and `single` element of a 

 - `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 

 ### Other information 

 - we may come with a better internal implementation (than ``) 
 - 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 
 But it was suggested to discuss the possibility of adding it to Ruby which would be amazing.