[ruby-core:114314] [Ruby master Feature#19787] Add Enumerable#uniq_map, Enumerable::Lazy#uniq_map, Array#uniq_map and Array#uniq_map!

Issue #19787 has been updated by joshuay03 (Joshua Young).


> Is `.map { ... }.uniq` such a very frequent idiom?

I work on a Rails codebase and it's most commonly used to iterate through foreign keys / associated records and get the unique values (quite often in tests). That's the only real frequent use case I've come across, but I would say that outside of that, it's not an uncommon chaining pattern either.

> `.uniq_map { ... }` is not as concise as `.map { ... }.uniq`.

I'm a bit mixed on this point. I see where you're coming from, and I think the same argument can be made about `#flat_map` and `#filter_map`. But it follows a similar naming pattern where the alternative method is in the name, so I personally feel like it's it's equally as concise?

I would also like to point out that with `#uniq_map`, you don't need to read all the way to `.uniq` before inferring the output. This might help when the body of the `#map` is quite complex, but you could argue that this is a code quality / style problem...

```
some_array.map do |item|
  if some_condition
    some_method(item)
  else
    some_other_method(item)
  end
end.uniq

# vs

some_array.uniq_map do |item|
  if some_condition
    some_method(item)
  else
    some_other_method(item)
  end
end
```

> Scala doesn't seem to provide `uniqMap`.

Sorry, this is the first Ruby issue I've created or being involved with, so I'm not sure why this was pointed out. Is this a usual consideration for new features?

> Considering the above, I think the motivation is too weak to provide `uniq_map`.

Your points are very valid, and I appreciate the response. What is the usual process for deciding on whether or not to accept a feature?

----------------------------------------
Feature #19787: Add Enumerable#uniq_map, Enumerable::Lazy#uniq_map, Array#uniq_map and Array#uniq_map!
https://bugs.ruby-lang.org/issues/19787#change-104016

* Author: joshuay03 (Joshua Young)
* Status: Open
* Priority: Normal
----------------------------------------
I would like to propose a collection of new methods, `Enumerable#uniq_map`, `Enumerable::Lazy#uniq_map`, `Array#uniq_map` and `Array#uniq_map!`.

TL;DR: It's a drop in replacement for `.map { ... }.uniq`, with (hopefully) better performance.

I've quite often had to map over an array and get its unique elements. It occurred to me when doing so recently that Ruby doesn't have a short form method for doing that, similar to how `.flat_map { ... }` replaces `.map { ... }.flatten` and `.filter_map { ... }` replaces `.map { ... }.compact` (with minor differences). I think these new methods could be beneficial both in terms of better performance and writing more succinct code.

I've got a draft PR up with some initial benchmarks in the description: https://github.com/ruby/ruby/pull/8140.



-- 
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-core.ml.ruby-lang.org/