[ruby-core:117237] [Ruby master Feature#8421] add Enumerable#find_map and Enumerable#find_all_map

Issue #8421 has been updated by alexbarret (Alexandre Barret).


Can we reconsider introducing `#find_map` please, especially since `#find_a=
ll_map` has been introduced as `#filter_map` in Ruby in 2.7?

Here are some examples
```ruby
require "minitest/autorun"

# Option 1
def identifier(emails, pattern: /\Ausername\+(?<identifier>[a-z|0-9]+)@doma=
in\.com\z/i)
  result =3D nil
  emails.each do |email|
    if matches =3D pattern.match(email)
      result =3D matches[:identifier]
      break
    end
  end
  result
end

# Option 2
def identifier(emails, pattern: /\Ausername\+(?<identifier>[a-z|0-9]+)@doma=
in\.com\z/i)
  matches =3D nil
  matches[:identifier] if emails.find { |email| matches =3D pattern.match(e=
mail) }
end

class TestIdentifierMethod < Minitest::Test
  def test_identifier
    assert_equal 'thecode', identifier(%w[
      [e-mail]
      username+123@domainAcom
      [e-mail]
      [e-mail]
      [e-mail]
    ])

    assert_nil identifier(%w[
      [e-mail]
      username+123@domainAcom
      [e-mail]
      [e-mail]
    ])
  end
end

```

Having a find_map would ease it a bit

```ruby
def find_map(collection, &block)
  result =3D nil
  collection.each do |item|
    break if result =3D yield(item)
  end
  result
end

def identifier(emails, pattern: /\Ausername\+(?<identifier>[a-z|0-9]+)@doma=
in\.com\z/i)
  find_map(emails) do |email|
    (matches =3D pattern.match(email)) && matches[:identifier]
  end
end
```

Here is a second use case

```ruby
# Problem 2
Pet =3D Struct.new(:name)
Person =3D Struct.new(:name, :pet, keyword_init: true)
class TestPetIdentitifer < Minitest::Test
  def setup
    @some_people_with_pet =3D [
      Person.new(name: 'Alex', pet: nil),
      Person.new(name: 'Olivier', pet: nil),
      Person.new(name: 'Romain', pet: Pet.new('Darwin')),
      Person.new(name: 'Mariano', pet: nil),
      Person.new(name: 'S=E9bastien', pet: nil),
      Person.new(name: 'Ben', pet: nil)
    ]

    @people_with_no_pet =3D [
      Person.new(name: 'Mariano', pet: nil),
      Person.new(name: 'S=E9bastien', pet: nil),
      Person.new(name: 'Ben', pet: nil)
    ]
  end

  def test_pet_found
    people =3D @some_people_with_pet
    expected_pet =3D Pet.new('Darwin')
    assert_equal expected_pet, people.find(&:pet)&.pet
    assert_equal expected_pet, find_map(people, &:pet) # -> people.find_map=
(&:pet)
  end

  def test_pet_not_found
    people =3D @people_with_no_pet
    assert_nil people.find(&:pet)&.pet
    assert_nil find_map(people, &:pet) # -> people.find_map(&:pet)
  end
end
```

Having `#find_map` allows these benefits=20

* The caller does not need to guard against `nil` like when `#find` returns=
 nothing
* `#find_map` would be faster than `filter_map.first` or even `lazy.filter_=
map.first`
* It would add the parity with `filter_map`. `#find` is to `#filter` what `=
#find_map` is to `#filter_map`



----------------------------------------
Feature #8421: add Enumerable#find_map and Enumerable#find_all_map
https://bugs.ruby-lang.org/issues/8421#change-107324

* Author: Hanmac (Hans Mackowiak)
* Status: Feedback
----------------------------------------
currently if you have an Enumerable and you want to return the return value=
 of #find you need eigther:
  (o =3D enum.find(block) && block.call(o)) || nil
or
  enum.inject(nil) {|ret,el| ret || block.call(el)}

neigher of them may be better than an directly maked method

same for #find_all_map
  enum.lazy.map(&:block).find_all{|el| el}

it may work but it is not so good



--=20
https://bugs.ruby-lang.org/
 ______________________________________________
 ruby-core mailing list -- [e-mail]
 To unsubscribe send an email to [e-mail]
 ruby-core info -- https://ml.ruby-lang.org/mailman3/postorius/lists/ruby-c=
ore.ml.ruby-lang.org/