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


>We already have `none?`, `one?`, `any?` and `all?`, which translate into `== 0`, `== 1`, `> 0` and `== self.size`.
`many?` method translates into `> 1`, which is reasonable to exist.

I do not follow this argument.

Of the methods you have mentioned, `any?` and `all?` have the strongest reason to exist in Ruby as they are two of the three basic quantifiers/operators of quantificational logic:  (*not*),  (*some*; *any* as in *Is there anyone?*), and  (*all*; *any* as in *Any programmer is lazy*). `none?` has a bit weaker motivation, but is reasonable as it is simply a combination of them: ̢. The next quantifier that would be reasonable to exist in Ruby would correspond to the combination: ̢ (*not all*) (But not that I am not claiming here that such method should actually exist). These quantifiers can be paraphrased as:

* `any?`: `foo_1 || foo_2 || ... || foo_n`
* `all?`: `foo_1 && foo_2 && ... && foo_n`
* `none?`: `!(foo_1 || foo_2 || ... || foo_n)`
* not all:  `!(foo_1 && foo_2 && ... foo_n)`

Compared to them, `one?` has weaker motivation to exist in Ruby as it is not easy to express it in the above way. So it is justified by having enough use cases.

Now, `many?` has at most as less motivation as `one?` has. What are its use cases?

----------------------------------------
Feature #17333: Enumerable#many?
https://bugs.ruby-lang.org/issues/17333#change-88591

* Author: okuramasafumi (Masafumi OKURA)
* Status: Open
* Priority: Normal
----------------------------------------
`Enumerable#many?` method is implemented in ActiveSupport.
https://api.rubyonrails.org/classes/Enumerable.html#method-i-many-3F
However, it's slightly different from Ruby's core methods such as `one?` or `all?`, where they take pattern argument.
I believe these methods should behave the same so that it's easier to guess and learn.

We already have `none?`, `one?`, `any?` and `all?`, which translate into `== 0`, `== 1`, `> 0` and `== self.size`.
`many?` method translates into `> 1`, which is reasonable to exist.
Currently we need to write something this:

```ruby
[1, 2, 3].count(&:odd?) > 1
```

With `many?`, we can make it simpler:

```ruby
[1, 2, 3].many?(&:odd?)
```



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

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