<A>(a: A): (self: Iterable<A>) => boolean
<A>(self: Iterable<A>, a: A): booleanChecks whether an iterable contains a value using Effect's default Equal
equivalence.
Details
Can be called as contains(self, value) or curried as
contains(value)(self).
Example (Checking membership)
import { Iterable } from "effect"
const numbers = [1, 2, 3, 4, 5]
console.log(Iterable.contains(numbers, 3)) // true
console.log(Iterable.contains(numbers, 6)) // false
const letters = "hello"
console.log(Iterable.contains(letters, "l")) // true
console.log(Iterable.contains(letters, "x")) // false
// Works with any iterable
const range = Iterable.range(1, 100)
console.log(Iterable.contains(range, 50)) // true
console.log(Iterable.contains(range, 150)) // false
// Curried version
const containsThree = Iterable.contains(3)
console.log(containsThree([1, 2, 3])) // true
console.log(containsThree([4, 5, 6])) // falseelements
Source effect/Iterable.ts:11104 lines
export const const contains: {
<A>(a: A): (self: Iterable<A>) => boolean
<A>(self: Iterable<A>, a: A): boolean
}
Checks whether an iterable contains a value using Effect's default Equal
equivalence.
Details
Can be called as contains(self, value) or curried as
contains(value)(self).
Example (Checking membership)
import { Iterable } from "effect"
const numbers = [1, 2, 3, 4, 5]
console.log(Iterable.contains(numbers, 3)) // true
console.log(Iterable.contains(numbers, 6)) // false
const letters = "hello"
console.log(Iterable.contains(letters, "l")) // true
console.log(Iterable.contains(letters, "x")) // false
// Works with any iterable
const range = Iterable.range(1, 100)
console.log(Iterable.contains(range, 50)) // true
console.log(Iterable.contains(range, 150)) // false
// Curried version
const containsThree = Iterable.contains(3)
console.log(containsThree([1, 2, 3])) // true
console.log(containsThree([4, 5, 6])) // false
contains: {
<function (type parameter) A in <A>(a: A): (self: Iterable<A>) => booleanA>(a: Aa: function (type parameter) A in <A>(a: A): (self: Iterable<A>) => booleanA): (self: Iterable<A>self: interface Iterable<T, TReturn = any, TNext = any>Iterable<function (type parameter) A in <A>(a: A): (self: Iterable<A>) => booleanA>) => boolean
<function (type parameter) A in <A>(self: Iterable<A>, a: A): booleanA>(self: Iterable<A>self: interface Iterable<T, TReturn = any, TNext = any>Iterable<function (type parameter) A in <A>(self: Iterable<A>, a: A): booleanA>, a: Aa: function (type parameter) A in <A>(self: Iterable<A>, a: A): booleanA): boolean
} = const containsWith: <unknown>(
isEquivalent: (
self: unknown,
that: unknown
) => boolean
) => {
(a: unknown): (
self: Iterable<unknown>
) => boolean
(self: Iterable<unknown>, a: unknown): boolean
}
Returns a function that checks if an Iterable contains a given value using a provided isEquivalent function.
Example (Checking membership with custom equivalence)
import { Iterable } from "effect"
// Custom equivalence for objects
const byId = (a: { id: number }, b: { id: number }) => a.id === b.id
const containsById = Iterable.containsWith(byId)
const users = [{ id: 1 }, { id: 2 }]
const hasUser1 = containsById(users, { id: 1 })
console.log(hasUser1) // true (same id)
// Case-insensitive string comparison
const caseInsensitive = (a: string, b: string) =>
a.toLowerCase() === b.toLowerCase()
const containsCaseInsensitive = Iterable.containsWith(caseInsensitive)
const words = ["Hello", "World"]
const hasHello = containsCaseInsensitive(words, "hello")
console.log(hasHello) // true
// Approximate number comparison
const approxEqual = (a: number, b: number) => Math.abs(a - b) < 0.1
const containsApprox = Iterable.containsWith(approxEqual)
const values = [1.0, 2.0, 3.0]
const hasAlmostTwo = containsApprox(values, 2.05)
console.log(hasAlmostTwo) // true
containsWith(import EqualEqual.const asEquivalence: <
A
>() => Equivalence<A>
Wraps
equals
as an Equivalence<A>.
When to use
Use when you want to pass Equal.equals to APIs that require an
Equivalence.
Details
- Returns a function
(a: A, b: A) => boolean that delegates to
equals
.
- Pure; allocates a thin wrapper on each call.
Example (Deduplicating with Equal semantics)
import { Array, Equal } from "effect"
const eq = Equal.asEquivalence<number>()
const result = Array.dedupeWith([1, 2, 2, 3, 1], eq)
console.log(result) // [1, 2, 3]
asEquivalence())