<A, B extends A>(refinement: (a: NoInfer<A>, i: number) => a is B): (
self: ReadonlyArray<A>
) => self is ReadonlyArray<B>
<A>(predicate: (a: NoInfer<A>, i: number) => boolean): (
self: ReadonlyArray<A>
) => boolean
<A, B extends A>(
self: ReadonlyArray<A>,
refinement: (a: A, i: number) => a is B
): self is ReadonlyArray<B>
<A>(
self: ReadonlyArray<A>,
predicate: (a: A, i: number) => boolean
): booleanChecks whether all elements satisfy the predicate. Supports refinements for type narrowing.
When to use
Use to check whether every array element satisfies a predicate, including refinement-based type narrowing.
Example (Testing all elements)
import { Array } from "effect"
console.log(Array.every([2, 4, 6], (x) => x % 2 === 0)) // true
console.log(Array.every([2, 3, 6], (x) => x % 2 === 0)) // falseelementssome
Source effect/Array.ts:414112 lines
export const const every: {
<A, B extends A>(
refinement: (
a: NoInfer<A>,
i: number
) => a is B
): (
self: ReadonlyArray<A>
) => self is ReadonlyArray<B>
<A>(
predicate: (
a: NoInfer<A>,
i: number
) => boolean
): (self: ReadonlyArray<A>) => boolean
<A, B extends A>(
self: ReadonlyArray<A>,
refinement: (a: A, i: number) => a is B
): self is ReadonlyArray<B>
<A>(
self: ReadonlyArray<A>,
predicate: (a: A, i: number) => boolean
): boolean
}
Checks whether all elements satisfy the predicate. Supports refinements for
type narrowing.
When to use
Use to check whether every array element satisfies a predicate, including
refinement-based type narrowing.
Example (Testing all elements)
import { Array } from "effect"
console.log(Array.every([2, 4, 6], (x) => x % 2 === 0)) // true
console.log(Array.every([2, 3, 6], (x) => x % 2 === 0)) // false
every: {
<function (type parameter) A in <A, B extends A>(refinement: (a: NoInfer<A>, i: number) => a is B): (self: ReadonlyArray<A>) => self is ReadonlyArray<B>A, function (type parameter) B in <A, B extends A>(refinement: (a: NoInfer<A>, i: number) => a is B): (self: ReadonlyArray<A>) => self is ReadonlyArray<B>B extends function (type parameter) A in <A, B extends A>(refinement: (a: NoInfer<A>, i: number) => a is B): (self: ReadonlyArray<A>) => self is ReadonlyArray<B>A>(
refinement: (a: NoInfer<A>, i: number) => a is Brefinement: (a: NoInfer<A>a: type NoInfer<A> = [A][A extends any ? 0 : never]Prevents TypeScript from inferring a type parameter from a specific
position.
When to use
Use when a function parameter must match an inferred type without becoming
an inference source.
Details
The parameter using NoInfer must still match the inferred type.
Example (Controlling inference)
import type { Types } from "effect"
declare function withDefault<T>(value: T, fallback: Types.NoInfer<T>): T
// T is inferred as "a" | "b" from the first argument only
const result = withDefault<"a" | "b">("a", "b")
NoInfer<function (type parameter) A in <A, B extends A>(refinement: (a: NoInfer<A>, i: number) => a is B): (self: ReadonlyArray<A>) => self is ReadonlyArray<B>A>, i: numberi: number) => a: NoInfer<A>a is function (type parameter) B in <A, B extends A>(refinement: (a: NoInfer<A>, i: number) => a is B): (self: ReadonlyArray<A>) => self is ReadonlyArray<B>B
): (self: readonly A[]self: interface ReadonlyArray<T>ReadonlyArray<function (type parameter) A in <A, B extends A>(refinement: (a: NoInfer<A>, i: number) => a is B): (self: ReadonlyArray<A>) => self is ReadonlyArray<B>A>) => self: readonly A[]self is interface ReadonlyArray<T>ReadonlyArray<function (type parameter) B in <A, B extends A>(refinement: (a: NoInfer<A>, i: number) => a is B): (self: ReadonlyArray<A>) => self is ReadonlyArray<B>B>
<function (type parameter) A in <A>(predicate: (a: NoInfer<A>, i: number) => boolean): (self: ReadonlyArray<A>) => booleanA>(predicate: (a: NoInfer<A>, i: number) => booleanpredicate: (a: NoInfer<A>a: type NoInfer<A> = [A][A extends any ? 0 : never]Prevents TypeScript from inferring a type parameter from a specific
position.
When to use
Use when a function parameter must match an inferred type without becoming
an inference source.
Details
The parameter using NoInfer must still match the inferred type.
Example (Controlling inference)
import type { Types } from "effect"
declare function withDefault<T>(value: T, fallback: Types.NoInfer<T>): T
// T is inferred as "a" | "b" from the first argument only
const result = withDefault<"a" | "b">("a", "b")
NoInfer<function (type parameter) A in <A>(predicate: (a: NoInfer<A>, i: number) => boolean): (self: ReadonlyArray<A>) => booleanA>, i: numberi: number) => boolean): (self: readonly A[]self: interface ReadonlyArray<T>ReadonlyArray<function (type parameter) A in <A>(predicate: (a: NoInfer<A>, i: number) => boolean): (self: ReadonlyArray<A>) => booleanA>) => boolean
<function (type parameter) A in <A, B extends A>(self: ReadonlyArray<A>, refinement: (a: A, i: number) => a is B): self is ReadonlyArray<B>A, function (type parameter) B in <A, B extends A>(self: ReadonlyArray<A>, refinement: (a: A, i: number) => a is B): self is ReadonlyArray<B>B extends function (type parameter) A in <A, B extends A>(self: ReadonlyArray<A>, refinement: (a: A, i: number) => a is B): self is ReadonlyArray<B>A>(self: readonly A[]self: interface ReadonlyArray<T>ReadonlyArray<function (type parameter) A in <A, B extends A>(self: ReadonlyArray<A>, refinement: (a: A, i: number) => a is B): self is ReadonlyArray<B>A>, refinement: (a: A, i: number) => a is Brefinement: (a: Aa: function (type parameter) A in <A, B extends A>(self: ReadonlyArray<A>, refinement: (a: A, i: number) => a is B): self is ReadonlyArray<B>A, i: numberi: number) => a: Aa is function (type parameter) B in <A, B extends A>(self: ReadonlyArray<A>, refinement: (a: A, i: number) => a is B): self is ReadonlyArray<B>B): self: readonly A[]self is interface ReadonlyArray<T>ReadonlyArray<function (type parameter) B in <A, B extends A>(self: ReadonlyArray<A>, refinement: (a: A, i: number) => a is B): self is ReadonlyArray<B>B>
<function (type parameter) A in <A>(self: ReadonlyArray<A>, predicate: (a: A, i: number) => boolean): booleanA>(self: readonly A[]self: interface ReadonlyArray<T>ReadonlyArray<function (type parameter) A in <A>(self: ReadonlyArray<A>, predicate: (a: A, i: number) => boolean): booleanA>, predicate: (a: A, i: number) => booleanpredicate: (a: Aa: function (type parameter) A in <A>(self: ReadonlyArray<A>, predicate: (a: A, i: number) => boolean): booleanA, i: numberi: number) => boolean): boolean
} = dual<(...args: Array<any>) => any, <A, B extends A>(self: ReadonlyArray<A>, refinement: (a: A, i: number) => a is B) => self is ReadonlyArray<B>>(arity: 2, body: <A, B extends A>(self: ReadonlyArray<A>, refinement: (a: A, i: number) => a is B) => self is ReadonlyArray<B>): ((...args: Array<any>) => any) & (<A, B extends A>(self: ReadonlyArray<A>, refinement: (a: A, i: number) => a is B) => self is ReadonlyArray<B>) (+1 overload)Creates a function that can be called in data-first style or data-last
(pipe-friendly) style.
When to use
Use to expose one implementation through both direct and pipe-friendly
call styles.
Details
Pass either the arity of the uncurried function or a predicate that decides
whether the current call is data-first. Arity is the common case. Use a
predicate when optional arguments make arity ambiguous.
Example (Selecting data-first or data-last style by arity)
import { Function, pipe } from "effect"
const sum = Function.dual<
(that: number) => (self: number) => number,
(self: number, that: number) => number
>(2, (self, that) => self + that)
console.log(sum(2, 3)) // 5
console.log(pipe(2, sum(3))) // 5
Example (Defining overloads with call signatures)
import { Function, pipe } from "effect"
const sum: {
(that: number): (self: number) => number
(self: number, that: number): number
} = Function.dual(2, (self: number, that: number): number => self + that)
console.log(sum(2, 3)) // 5
console.log(pipe(2, sum(3))) // 5
Example (Selecting data-first or data-last style with a predicate)
import { Function, pipe } from "effect"
const sum = Function.dual<
(that: number) => (self: number) => number,
(self: number, that: number) => number
>(
(args) => args.length === 2,
(self, that) => self + that
)
console.log(sum(2, 3)) // 5
console.log(pipe(2, sum(3))) // 5
dual(
2,
<function (type parameter) A in <A, B extends A>(self: ReadonlyArray<A>, refinement: (a: A, i: number) => a is B): self is ReadonlyArray<B>A, function (type parameter) B in <A, B extends A>(self: ReadonlyArray<A>, refinement: (a: A, i: number) => a is B): self is ReadonlyArray<B>B extends function (type parameter) A in <A, B extends A>(self: ReadonlyArray<A>, refinement: (a: A, i: number) => a is B): self is ReadonlyArray<B>A>(self: readonly A[]self: interface ReadonlyArray<T>ReadonlyArray<function (type parameter) A in <A, B extends A>(self: ReadonlyArray<A>, refinement: (a: A, i: number) => a is B): self is ReadonlyArray<B>A>, refinement: (a: A, i: number) => a is Brefinement: (a: Aa: function (type parameter) A in <A, B extends A>(self: ReadonlyArray<A>, refinement: (a: A, i: number) => a is B): self is ReadonlyArray<B>A, i: numberi: number) => a: Aa is function (type parameter) B in <A, B extends A>(self: ReadonlyArray<A>, refinement: (a: A, i: number) => a is B): self is ReadonlyArray<B>B): self: readonly A[]self is interface ReadonlyArray<T>ReadonlyArray<function (type parameter) B in <A, B extends A>(self: ReadonlyArray<A>, refinement: (a: A, i: number) => a is B): self is ReadonlyArray<B>B> =>
self: readonly A[]self.globalThis.ReadonlyArray<A>.every<B>(predicate: (value: A, index: number, array: readonly A[]) => value is B, thisArg?: any): this is readonly S[] (+1 overload)Determines whether all the members of an array satisfy the specified test.
every(refinement: (a: A, i: number) => a is Brefinement)
)