<A>(predicate: (a: NoInfer<A>, i: number) => boolean): (
self: Iterable<A>
) => number
<A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): numberComputes how many elements of the iterable pass the given predicate.
Example (Counting matching elements)
import { Iterable } from "effect"
const result = Iterable.countBy([1, 2, 3, 4, 5], (n) => n % 2 === 0)
console.log(result) // 2folding
Source effect/Iterable.ts:246420 lines
export const const countBy: {
<A>(
predicate: (
a: NoInfer<A>,
i: number
) => boolean
): (self: Iterable<A>) => number
<A>(
self: Iterable<A>,
predicate: (a: A, i: number) => boolean
): number
}
Computes how many elements of the iterable pass the given predicate.
Example (Counting matching elements)
import { Iterable } from "effect"
const result = Iterable.countBy([1, 2, 3, 4, 5], (n) => n % 2 === 0)
console.log(result) // 2
countBy: {
<function (type parameter) A in <A>(predicate: (a: NoInfer<A>, i: number) => boolean): (self: Iterable<A>) => numberA>(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: Iterable<A>) => numberA>, i: numberi: number) => boolean): (self: Iterable<A>self: interface Iterable<T, TReturn = any, TNext = any>Iterable<function (type parameter) A in <A>(predicate: (a: NoInfer<A>, i: number) => boolean): (self: Iterable<A>) => numberA>) => number
<function (type parameter) A in <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): numberA>(self: Iterable<A>self: interface Iterable<T, TReturn = any, TNext = any>Iterable<function (type parameter) A in <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): numberA>, predicate: (a: A, i: number) => booleanpredicate: (a: Aa: function (type parameter) A in <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): numberA, i: numberi: number) => boolean): number
} = import dualdual(
2,
<function (type parameter) A in <A>(self: Iterable<A>, f: (a: A, i: number) => boolean): numberA>(
self: Iterable<A>self: interface Iterable<T, TReturn = any, TNext = any>Iterable<function (type parameter) A in <A>(self: Iterable<A>, f: (a: A, i: number) => boolean): numberA>,
f: (a: A, i: number) => booleanf: (a: Aa: function (type parameter) A in <A>(self: Iterable<A>, f: (a: A, i: number) => boolean): numberA, i: numberi: number) => boolean
): number => {
let let count: numbercount = 0
let let i: numberi = 0
for (const const a: Aa of self: Iterable<A>self) {
if (f: (a: A, i: number) => booleanf(const a: Aa, let i: numberi)) {
let count: numbercount++
}
let i: numberi++
}
return let count: numbercount
}
)