feat: add WithoutBy

README.md

@@ -206,6 +206,7 @@ Supported intersection helpers:
 - [Difference](#difference)
 - [Union](#union)
 - [Without](#without)
+- [WithoutBy](#withoutby)
 - [WithoutEmpty](#withoutempty)
 
 Supported search helpers:
@@ -2097,6 +2098,38 @@ subset := lo.Without([]int{0, 2, 10}, 0, 1, 2, 3, 4, 5)
 // []int{10}
 ```
 
+### WithoutBy
+
+WithoutBy filters a slice by excluding elements whose extracted keys match any in the exclude list.
+It returns a new slice containing only the elements whose keys are not in the exclude list.
+
+
+```go
+type struct User {
+    ID int
+    Name string
+}
+
+// original users
+users := []User{
+    {ID: 1, Name: "Alice"},
+    {ID: 2, Name: "Bob"},
+    {ID: 3, Name: "Charlie"},
+}
+
+// exclude users with IDs 2 and 3
+excludedIDs := []int{2, 3}
+
+// extract function to get the user ID
+extractID := func(user User) int {
+    return user.ID
+}
+
+// filtering users
+filteredUsers := WithoutBy(users, extractID, excludedIDs...)
+// []User[{ID: 1, Name: "Alice"}]
+```
+
 ### WithoutEmpty
 
 Returns slice excluding empty values.

intersect.go

@@ -167,10 +167,21 @@ func Union[T comparable, Slice ~[]T](lists ...Slice) Slice {
 
 // Without returns slice excluding all given values.
 func Without[T comparable, Slice ~[]T](collection Slice, exclude ...T) Slice {
-	result := make(Slice, 0, len(collection))
-	for i := range collection {
-		if !Contains(exclude, collection[i]) {
-			result = append(result, collection[i])
+	return WithoutBy(collection, func(item T) T { return item }, exclude...)
+}
+
+// WithoutBy filters a slice by excluding elements whose extracted keys match any in the exclude list.
+// It returns a new slice containing only the elements whose keys are not in the exclude list.
+func WithoutBy[T any, K comparable](collection []T, extract func(item T) K, exclude ...K) []T {
+	blacklist := make(map[K]struct{}, len(exclude))
+	for _, e := range exclude {
+		blacklist[e] = struct{}{}
+	}
+
+	result := make([]T, 0, len(collection))
+	for _, item := range collection {
+		if _, ok := blacklist[extract(item)]; !ok {
+			result = append(result, item)
 		}
 	}
 	return result

intersect_example_test.go

@@ -0,0 +1,34 @@
+package lo
+
+import (
+	"fmt"
+)
+
+func ExampleWithoutBy() {
+	type User struct {
+		ID   int
+		Name string
+	}
+	// original users
+	users := []User{
+		{ID: 1, Name: "Alice"},
+		{ID: 2, Name: "Bob"},
+		{ID: 3, Name: "Charlie"},
+	}
+
+	// exclude users with IDs 2 and 3
+	excludedIDs := []int{2, 3}
+
+	// extract function to get the user ID
+	extractID := func(user User) int {
+		return user.ID
+	}
+
+	// filtering users
+	filteredUsers := WithoutBy(users, extractID, excludedIDs...)
+
+	// output the filtered users
+	fmt.Printf("%v\n", filteredUsers)
+	// Output:
+	// [{1 Alice}]
+}

intersect_test.go

@@ -270,6 +270,26 @@ func TestWithout(t *testing.T) {
 	is.IsType(nonempty, allStrings, "type preserved")
 }
 
+func TestWithoutBy(t *testing.T) {
+	t.Parallel()
+	is := assert.New(t)
+
+	type User struct {
+		Name string
+		Age  int
+	}
+
+	result1 := WithoutBy([]User{{Name: "nick"}, {Name: "peter"}},
+		func(item User) string {
+			return item.Name
+		}, "nick", "lily")
+	result2 := WithoutBy([]User{}, func(item User) int { return item.Age }, 1, 2, 3)
+	result3 := WithoutBy([]User{}, func(item User) string { return item.Name })
+	is.Equal(result1, []User{{Name: "peter"}})
+	is.Equal(result2, []User{})
+	is.Equal(result3, []User{})
+}
+
 func TestWithoutEmpty(t *testing.T) {
 	t.Parallel()
 	is := assert.New(t)