Feat: Adding the equivalent of checking if two slices are the same #498
Conversation
|
Your tests are focusing on slices Did you take a look at this? |
intersect.go
Outdated
| var m = make(map[T]int, l) | ||
| for i := range collection { | ||
| m[collection[i]] += 1 | ||
| } | ||
| for i := range subset { | ||
| m[subset[i]] -= 1 | ||
| } | ||
| for _, v := range m { | ||
| if v != 0 { | ||
| return false | ||
| } | ||
| } |
There was a problem hiding this comment.
Your logic requires extra space in the map and also 3 times iterating over the map.
Why not just sort the 2 arrays and compare if both are the same ??
What are your thoughts ??
Also after adding the function, you can add the function to Readme also.
Look this PR as reference : #494
There was a problem hiding this comment.
Because just != or == is allowed on generics comparable, we can't sort this slice.
Additionally, sort.Slice() will change the parameter's original order, which I think is unsafe.
I have added doc and removed an unessential iterating based on your suggestion.
However, slice.Equal() return is effected by elements order. In my case, order is dosen't matter. |
Indeed, you may add this in the comment of method, especially how it differs from slice.Equal |
I have added the comments based on your suggestion. Additionally, I have modified the generic declaration to mirror slice.Equal. :) |
intersect.go
Outdated
| @@ -44,6 +44,28 @@ func EveryBy[T any](collection []T, predicate func(item T) bool) bool { | |||
| return true | |||
| } | |||
|
|
|||
| // Equivalent Returns true if the subset has the same elements and the same number of each element as the collection. | |||
| func Equivalent[T comparable](collection, subset []T) bool { | |||
There was a problem hiding this comment.
Following #498 (comment)
| func Equivalent[T comparable](collection, subset []T) bool { | |
| func SameItems[T comparable](collection, subset []T) bool { |
Maybe this name would be more appropriate
|
Thanks @Dokiys for your first contribution I agree with @ccoVeille: this helper's name is not self-explaining. Some ideas: EqualUnorderedSlice, EqualUnordered ("slice" is implicit because maps cannot be ordered)... Also, can the last argument be converted into a vaarg? It might slow it down at some point. Feel free to argue against it if your benchmarks show it is a bad idea. |
Dokiys
force-pushed
the
feat-add-equivalent
branch
from
1cc78ef
to
4450609
Compare
README.md
Outdated
| @@ -196,6 +196,7 @@ Supported intersection helpers: | |||
| - [ContainsBy](#containsby) | |||
| - [Every](#every) | |||
| - [EveryBy](#everyby) | |||
| - [Equivalent](#equivalent) | |||
@samber @ccoVeille Thanks for your suggestions. I agree that using the name EqualUnordered would indeed be more appropriate. However, regarding the use of vaarg, I have reservations. This isn't based on performance issues. |
Often, I need to compare if two slices are same in elements and count of each element. However, I have not found an existing method that accomplishes this functionality. Therefore, I have added this method.