Intersection - Core helpers

This page lists all intersection helpers, available in the core package of lo.

Help improve this documentation

This documentation is still new and evolving. If you spot any mistakes, unclear explanations, or missing details, please open an issue.

Your feedback helps us improve!

Contains
intersectcore
🧩 Source 📚 GoDoc 🎮 Try on Go Playground
Returns true if an element is present in a collection.
present := lo.Contains([]int{0, 1, 2, 3, 4, 5}, 5) // true
Similar:
containsby every find none some
Prototype:
func Contains[T comparable](collection []T, element T) bool

Returns true if the predicate returns true for any element in the collection.

exists := lo.ContainsBy(
    []int{0, 1, 2, 3},
    func(x int) bool {
        return x == 3
    },
)
// true

Prototype:

func ContainsBy[T any](collection []T, predicate func(item T) bool) bool

Every
intersectcore
🧩 Source 📚 GoDoc 🎮 Try on Go Playground
Returns true if all elements of a subset are contained in a collection, or if the subset is empty.
ok := lo.Every([]int{0, 1, 2, 3, 4, 5}, []int{0, 2}) // true
Similar:
contains containsby elementsmatch elementsmatchby everyby none noneby some someby
Prototype:
func Every[T comparable](collection []T, subset []T) bool
EveryBy
intersectcore
🧩 Source 📚 GoDoc 🎮 Try on Go Playground
Returns true if the predicate returns true for all elements in the collection, or if the collection is empty.
ok := lo.EveryBy( []int{1, 2, 3, 4}, func(x int) bool { return x < 5 }, ) // true
Similar:
contains containsby elementsmatch elementsmatchby every none noneby some someby
Prototype:
func EveryBy[T any](collection []T, predicate func(item T) bool) bool
Some
intersectcore
🧩 Source 📚 GoDoc 🎮 Try on Go Playground
Returns true if at least one element of a subset is contained in a collection. Returns false for an empty subset.
ok := lo.Some([]int{0, 1, 2, 3, 4, 5}, []int{0, 6}) // true
Similar:
contains containsby every everyby none noneby someby
Prototype:
func Some[T comparable](collection []T, subset []T) bool
SomeBy
intersectcore
🧩 Source 📚 GoDoc 🎮 Try on Go Playground
Returns true if the predicate returns true for any element in the collection. Returns false for an empty collection.
ok := lo.SomeBy( []int{1, 2, 3, 4}, func(x int) bool { return x < 3 }, ) // true
Similar:
contains containsby every everyby none noneby some
Prototype:
func SomeBy[T any](collection []T, predicate func(item T) bool) bool
None
intersectcore
🧩 Source 📚 GoDoc 🎮 Try on Go Playground
Returns true if no element of a subset is contained in a collection, or if the subset is empty.
ok := lo.None([]int{0, 1, 2, 3, 4, 5}, []int{-1, 6}) // true
Similar:
contains containsby every noneby some
Prototype:
func None[T comparable](collection []T, subset []T) bool
NoneBy
intersectcore
🧩 Source 📚 GoDoc 🎮 Try on Go Playground
Returns true if the predicate returns true for none of the elements in the collection, or if the collection is empty.
ok := lo.NoneBy( []int{1, 2, 3, 4}, func(x int) bool { return x < 0 }, ) // true
Similar:
contains containsby every everyby none some someby
Prototype:
func NoneBy[T any](collection []T, predicate func(item T) bool) bool
Intersect
intersectcore
🧩 Source 📚 GoDoc 🎮 Try on Go Playground
Returns the intersection between collections.
lo.Intersect([]int{0, 3, 5, 7}, []int{3, 5}, []int{0, 1, 2, 0, 3, 0}) // []int{3}
Similar:
difference intersectby union uniq without iter› intersect iter› intersectby
Prototype:
func Intersect[T comparable, Slice ~[]T](lists ...Slice) Slice

Returns the intersection between two collections using a custom key selector function.

transform := func(v int) string {
  return strconv.Itoa(v)
}

lo.IntersectBy(transform, []int{0, 3, 5, 7}, []int{3, 5}, []int{0, 1, 2, 0, 3, 0})
// []int{3}

Prototype:

func IntersectBy[T any, K comparable, Slice ~[]T](transform func(T) K, lists ...Slice) Slice

Difference
intersectcore
🧩 Source 📚 GoDoc 🎮 Try on Go Playground
Returns the difference between two collections. The first slice contains elements absent from list2; the second contains elements absent from list1.
left, right := lo.Difference([]int{0, 1, 2, 3, 4, 5}, []int{0, 2, 6}) // []int{1, 3, 4, 5}, []int{6}
Similar:
intersect union uniq uniqby without withoutby
Prototype:
func Difference[T comparable, Slice ~[]T](list1 Slice, list2 Slice) (Slice, Slice)
Union
intersectcore
🧩 Source 📚 GoDoc 🎮 Try on Go Playground
Returns all distinct elements from given collections while preserving relative order.
lo.Union([]int{0, 1, 2, 3, 4, 5}, []int{0, 2}, []int{0, 10}) // []int{0, 1, 2, 3, 4, 5, 10}
Similar:
difference intersect uniq uniqby without
Prototype:
func Union[T comparable, Slice ~[]T](lists ...Slice) Slice
Without
intersectcore
🧩 Source 📚 GoDoc 🎮 Try on Go Playground
Returns a slice excluding all given values.
lo.Without([]int{0, 2, 10}, 2) // []int{0, 10}
Similar:
difference intersect reject union withoutby
Prototype:
func Without[T comparable, Slice ~[]T](collection Slice, exclude ...T) Slice

Filters a slice by excluding elements whose extracted keys match any in the exclude list.

type User struct {
  ID int
  Name string
}

users := []User{
  {1, "Alice"},
  {2, "Bob"},
  {3, "Charlie"},
}

filtered := lo.WithoutBy(users, func(u User) int {
    return u.ID
}, 2, 3)
// []User{{1, "Alice"}}

Prototype:

func WithoutBy[T any, K comparable, Slice ~[]T](collection Slice, iteratee func(item T) K, exclude ...K) Slice

Filters a slice by excluding elements whose extracted keys match any in the exclude list. Returns an error if the iteratee function fails, stopping iteration immediately.

type User struct {
  ID int
  Name string
}

users := []User{
  {1, "Alice"},
  {2, "Bob"},
  {3, "Charlie"},
}

filtered, err := lo.WithoutByErr(users, func(u User) (int, error) {
  if u.ID == 2 {
    return 0, fmt.Errorf("Bob not allowed")
  }
  return u.ID, nil
}, 2, 3)
// []User(nil), error("Bob not allowed")

type User struct {
  ID int
  Name string
}

users := []User{
  {1, "Alice"},
  {2, "Bob"},
  {3, "Charlie"},
}

filtered, err := lo.WithoutByErr(users, func(u User) (int, error) {
  return u.ID, nil
}, 2, 3)
// []User{{1, "Alice"}}, nil

Similar:

rejectbyerr without withoutby

Prototype:

func WithoutByErr[T any, K comparable, Slice ~[]T](collection Slice, iteratee func(item T) (K, error), exclude ...K) (Slice, error)

WithoutEmpty
intersectcore
🧩 Source 📚 GoDoc 🎮 Try on Go Playground
Returns a slice excluding zero values. Deprecated: use Compact instead.
lo.WithoutEmpty([]int{0, 2, 10}) // []int{2, 10}
Similar:
compact without withoutby
Prototype:
func WithoutEmpty[T comparable, Slice ~[]T](collection Slice) Slice
WithoutNth
intersectcore
🧩 Source 📚 GoDoc 🎮 Try on Go Playground
Returns a slice excluding the elements at the given indexes.
lo.WithoutNth([]int{-2, -1, 0, 1, 2}, 3) // []int{-2, -1, 0, 2}
Similar:
dropbyindex without withoutby
Prototype:
func WithoutNth[T comparable, Slice ~[]T](collection Slice, nths ...int) Slice
ElementsMatch
intersectcore
🧩 Source 📚 GoDoc 🎮 Try on Go Playground
Returns true if lists contain the same set of elements (including empty set). If there are duplicate elements, occurrences must match. Order is not checked.
lo.ElementsMatch([]int{1, 1, 2}, []int{2, 1, 1}) // true
Similar:
contains containsby difference elementsmatchby every everyby intersect none noneby some someby union
Prototype:
func ElementsMatch[T comparable, Slice ~[]T](list1 Slice, list2 Slice) bool
ElementsMatchBy
intersectcore
🧩 Source 📚 GoDoc 🎮 Try on Go Playground
Returns true if lists contain the same set of keys computed by the predicate, with matching multiplicities. Order is not checked.
type Item struct{ ID string } lo.ElementsMatchBy( []Item{{"a"}, {"b"}}, []Item{{"b"}, {"a"}}, func(i Item) string { return i.ID }, ) // true
Similar:
contains containsby difference elementsmatch every everyby intersect none noneby some someby union
Prototype:
func ElementsMatchBy[T any, K comparable](list1 []T, list2 []T, iteratee func(item T) K) bool

Contains​

ContainsBy​

Every​

EveryBy​

Some​

SomeBy​

None​

NoneBy​

Intersect​

IntersectBy​

Difference​

Union​

Without​

WithoutBy​

WithoutByErr​

WithoutEmpty​

WithoutNth​

ElementsMatch​

ElementsMatchBy​

Contains

ContainsBy

Every

EveryBy

Some

SomeBy

None

NoneBy

Intersect

IntersectBy

Difference

Union

Without

WithoutBy

WithoutByErr

WithoutEmpty

WithoutNth

ElementsMatch

ElementsMatchBy