[ruby-core:101351] Re: [Ruby master Feature#17333] Enumerable#many?

I started with the opinion that this wasn=E2=80=99t necessary, but the simp=
lest
Ruby implementation I could come up with is this:

  def many?
    reduce(false) { |f, v|
      vp =3D block_given? ? yield v : v
      break true if f && vp
      vp
    }
  end

It=E2=80=99s probably a little less efficient than the ActiveSupport extens=
ion
(which uses two different branches for `block_given?` or not). Something
similar was recently suggested to the Elixir core list, and what was
decided there is I think a little more generalizable, `count_until` (
https://github.com/elixir-lang/elixir/pull/10532).

Here=E2=80=99s a Ruby implementation of what could be Enumerable#count_unti=
l?

  def count_until(limit, match =3D nil, &block)
    cnt =3D 0

    if match
      warn 'warning: given block not used' if block
      block =3D ->(v) { v =3D=3D match }
    elsif !block
      return [limit, count].min if respond_to?(:size)
      block =3D ->(_) { true }
    end

    stop_at =3D limit - 1

    reduce(0) { |c, v|
      c +=3D 1 if block.(v)

      break limit if c =3D=3D stop_at

      c
    }
  end

  # (1..20).count_until(5) # =3D> 5
  # (1..20).count_until(50) # =3D> 20
  # (1..10).count_until(10) =3D=3D 10 # =3D> true # At least 10
  # (1..11).count_until(10) =3D=3D 10 # =3D> true # At least 10
  # (1..11).count_until(10 + 1) > 10 # =3D> true # More than 10
  # (1..5).count_until(10) < 10 # =3D> true # Less than 10
  # (1..10).count_until(10 + 1) =3D=3D 10 # =3D> true # Exactly ten

-a

On Wed, Dec 9, 2020 at 8:56 AM <[e-mail]> wrote:

> Issue #17333 has been updated by okuramasafumi (Masafumi OKURA).
>
>
> Here are a usecase where we could use `many?` over `count` for better
> performance.
>
>
> https://github.com/Homebrew/brew/blob/master/Library/Homebrew/cask/audit.=
rb#L188
>
> This code, `cask.artifacts.count { |k| k.is_a?(Artifact::Uninstall) } > 1=
`
> calls block as many times as the size of `cask.artifact`. In contrast,
> `cask.artifacts.many? { |k| k.is_a?(Artifact::Uninstall) }` calls blocks
> only before finding second matching artifact, which could improve
> performance.
> Like this case where we cannot expect the size of collection, using
> `count` could cost a lot and introducing `many?` could help.
>
> ----------------------------------------
> Feature #17333: Enumerable#many?
> https://bugs.ruby-lang.org/issues/17333#change-89042
>
> * 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
> `=3D=3D 0`, `=3D=3D 1`, `> 0` and `=3D=3D 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?)
> ```
>
> Pull Request on GitHub is available at
> https://github.com/ruby/ruby/pull/3785
>
>
>
> --
> https://bugs.ruby-lang.org/
>
> Unsubscribe: <mailto:[e-mail]?subject=3Dunsubscrib=
e>
> <http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>
>


--=20
Austin Ziegler =E2=80=A2 [e-mail] =E2=80=A2 austin@halostatue.c=
a
http://www.halostatue.ca/ =E2=80=A2 http://twitter.com/halostatue

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