[Feature 🔨]: Add `Uniq` and `UniqF` functions to generate only unique values

[apatniv]

Is your feature request related to a problem? Please describe.

Not really. There is workarounds possible but useful to do this in the library.

A clear and concise description of what the problem is. Ex. I'm always
frustrated when [...].

Add Uniq and UniqF functions to generate only unique values

Describe the solution you'd like

Signatures of the function:

func Uniq[V comparable](seq iter.Seq[V]) iter.Seq[V] {
	
}

func UniqF[V any](seq iter.Seq[V], comparator func(v1, v2 V) int) iter.Seq[V] {

}

Does this incur a breaking change?

No.

Do you intend to build this feature yourself?

Yes

[BooleanCat]

Thanks for idea! I like the feature but would prefer different names. The functions should be "verbs" because they do something to other iterators - I'd also prefer to avoid abbreviations in function names. Perhaps FilterUnique and FilterUniqueBy or even ExcludeDuplicates might be better. Do you have other ideas?

I'm guessing you'd implement this by storing the elements you find in a map as you go along, so it would be worth mentioning in the docs that order will not be preserved if that's the route you take.

[apatniv]

Makes sense I would prefer FilterUnique and FilterUniqueBy.

For FilterUnique, can't we maintain the order by looking for the current element in map and it doesn't exist, add it and yield the item.

For FilterUniqueBy, may be change the signature so that clients provide a key that can be used for hashing. This way order can be maintained.

Like

func FilterUniqueBy[V any, K comparable](seq iter.Seq[V],  key func(value V) K) iter.Seq[V] {

}

[BooleanCat]

Ah that makes sense, keep the map referenced by the closure! Can you provide an example of how you'd use FilterUniqueBy?

As for the signatures, it's fine to return iter.Seq but the argument iterators should be func(func(V) bool) so that Go's type system allows any type alias of iter.Seq to be passed without casting.

[apatniv]

As for the signatures, it's fine to return iter.Seq but the argument iterators should be func(func(V) bool) so that Go's type system allows any type alias of iter.Seq to be passed without casting.

Ok. makes sense.

[apatniv]

Example:

type student struct {
    id    int
    class string
}
membership := []student{
    {id: 1, class: "CS"},
    {id: 1, class: "Math"},
    {id: 100, class: "Math"},
}
uniqueStudents := FilterUniqueBy(slices.Values(membership), func(st student) int {
    return st.id
})
fmt.Printf("unique studuents:%+v\n", slices.Collect(uniqueStudents))

Prints

unique studuents:[{id:1 class:CS} {id:100 class:Math}]

[BooleanCat]

Thanks @apatniv! I'd be happy to accept a pull request for FilterUnique for the time being. As for FilterUniqueBy, I'll do some reading of other similar functions in other languages and perhaps accept a second pull request afterwards. I'll update here in comments after I've done a bit of research.

[apatniv]

I did some research for other languages. Posting here for future reference:

Java

• distinct(). Uses Object.equals that is defined on each object to do comparison.

Python

• Couldn't find anything in standard library but one of the library more-itertools contains unique function that utilizes an argument key that is supposed to return what key is used for deduping.

def unique(iterable, key=None, reverse=False):
pass

Rust

• Rust standard library has three different functions for performing max on a Iterator:

  • max: Takes Orderable items like ints
  • max_by: Takes a comparison function
  • max_by_key: Takes a function that is supposed to return the key for comparison.

• Iterable Crate defines 2 methods for computing unique:

  • unique: Defined on orderable elements
  • unique_by: Uses key function for deduping.

[BooleanCat]

@apatniv thanks for the PR implementing FilterUnique. I think FilterUniqueBy could be helpful too. I guess a signature like this would be what we'd aim for:

func FilterUniqueBy[V any, W comparable](iterator func(func(V) bool), filter func(V) W) iter.Seq[V]

Were you planning on adding this too? If not I can do it.

[apatniv]

Yeah planning to do next couple of weeks.