Interface List<A>

Immutable List. Covariant in A (<out A>) — mirrors Scala's List[+A].

Methods that would otherwise force A-invariance use TS equivalents of Scala's co-variance patterns:

query/removal ops (contains, indexOf, remove) take unknown, matching Scala's -(elem: Any) / contains(elem: Any) — if the value can't possibly be in the list, it's a no-op, not a type error.
additive ops (add, prepend, concat) widen the element type, matching Scala's ::[B >: A] / ++[B >: A] — List<A> + B produces List<A | B>.
reduce / reduceRight accept a wider accumulator type, matching Scala's reduce[B >: A].

interface List<out A> {
 _tag: "List";
 "[iterator]": () => Iterator<A>;
 "[toStringTag]": string;
 ap: (ff: List<(value: A) => B>) => List;
 distinct: () => List<A>;
 filterNot: (p: (a: A) => boolean) => List<A>;
 flatMap: (f: (a: A) => Iterable) => List;
 flatMapAsync: (
 f: (a: A) => PromiseLike<Iterable<B, any, any>>,
 ) => PromiseLike<List>;
 get: (index: number) => Option<A>;
 groupBy: <K>(f: (a: A) => K) => Map<K, List<A>>;
 indexOf: (value: unknown) => number;
 isEmpty: boolean;
 length: number;
 map: (f: (a: A) => B) => List;
 partition: (p: (a: A) => boolean) => [List<A>, List<A>];
 remove: (value: unknown) => List<A>;
 removeAt: (index: number) => List<A>;
 reverse: () => List<A>;
 size: number;
 slice: (start: number, end: number) => List<A>;
 sortBy: (f: (a: A) => B, compareFn?: (a: B, b: B) => number) => List<A>;
 sorted: (compareFn?: (a: A, b: A) => number) => List<A>;
 span: (p: (a: A) => boolean) => [List<A>, List<A>];
 take: (n: number) => List<A>;
 takeRight: (n: number) => List<A>;
 takeWhile: (p: (a: A) => boolean) => List<A>;
 zip: (other: List) => List<[A, B]>;
 zipWithIndex: () => List<[A, number]>;
 get head(): A | undefined;
 get headOption(): Option<A>;
 get init(): List<A>;
 get last(): A | undefined;
 get lastOption(): Option<A>;
 get tail(): List<A>;
 add(item: B): List<A | B>;
 concat(other: List): List<A | B>;
 contains(value: unknown): boolean;
 count(p: (x: A) => boolean): number;
 doUnwrap(): DoResult<A>;
 drop(n: number): FunctypeCollection;
 dropRight(n: number): FunctypeCollection;
 dropWhile(p: (a: A) => boolean): FunctypeCollection;
 exists(p: (a: A) => boolean): boolean;
 filter<S>(predicate: (a: A) => a is S): List<S>;
 filter(predicate: (a: A) => unknown): List<A>;
 find(p: (a: A) => boolean): Option<A>;
 flatten(): FunctypeCollection;
 fold(initial: B, fn: (acc: B, a: A) => B): B;
 foldLeft(z: B): (op: (b: B, a: A) => B) => B;
 foldRight(z: B): (op: (a: A, b: B) => B) => B;
 forEach(f: (a: A) => void): void;
 match<R>(patterns: { Empty: () => R; NonEmpty: (values: A[]) => R }): R;
 pipe(f: (value: A[]) => U): U;
 prepend(item: B): List<A | B>;
 reduce(
 op: (b: Widen<A, B>, a: Widen<A, B>) => Widen<A, B>,
 ): Widen<A, B>;
 reduceRight(
 op: (b: Widen<A, B>, a: Widen<A, B>) => Widen<A, B>,
 ): Widen<A, B>;
 serialize(): SerializationMethods<A>;
 toArray(): B[];
 toEither<E extends unknown>(leftValue: E): Either<E, A>;
 toList(): List<A>;
 toOption(): Option<A>;
 toSet(): Set<A>;
 toString(): string;
 toTry(): Try<A>;
 toValue(): { _tag: "List"; value: A[] };
}

Type Parameters

out A

Hierarchy (View Summary)

FunctypeCollection<A, "List">
Doable<A>
Reshapeable<A>
- List

Properties

`Readonly`_tag

_tag: "List"

`Readonly`[iterator]

"[iterator]": () => Iterator<A>

`Readonly`[toStringTag]

"[toStringTag]": string

ap

ap: (ff: List<(value: A) => B>) => List

distinct

distinct: () => List<A>

filterNot

filterNot: (p: (a: A) => boolean) => List<A>

flatMap

flatMap: (f: (a: A) => Iterable) => List

flatMapAsync

flatMapAsync: (
f: (a: A) => PromiseLike<Iterable<B, any, any>>,
) => PromiseLike<List>

get

get: (index: number) => Option<A>

groupBy

groupBy: <K>(f: (a: A) => K) => Map<K, List<A>>

indexOf

indexOf: (value: unknown) => number

Find the index of a value. Accepts unknown (Scala: indexOf(elem: Any)).

isEmpty

isEmpty: boolean

`Readonly`length

length: number

map

map: (f: (a: A) => B) => List

partition

partition: (p: (a: A) => boolean) => [List<A>, List<A>]

remove

remove: (value: unknown) => List<A>

Remove a value. Accepts unknown so an unrelated-type arg is a safe no-op (Scala: -(elem: Any)).

removeAt

removeAt: (index: number) => List<A>

reverse

reverse: () => List<A>

size

size: number

slice

slice: (start: number, end: number) => List<A>

sortBy

sortBy: (f: (a: A) => B, compareFn?: (a: B, b: B) => number) => List<A>

sorted

sorted: (compareFn?: (a: A, b: A) => number) => List<A>

span

span: (p: (a: A) => boolean) => [List<A>, List<A>]

take

take: (n: number) => List<A>

Takes the first n elements from the collection.

takeRight

takeRight: (n: number) => List<A>

Takes the last n elements from the collection.

takeWhile

takeWhile: (p: (a: A) => boolean) => List<A>

Takes elements from the start while the predicate is true.

zip

zip: (other: List) => List<[A, B]>

zipWithIndex

zipWithIndex: () => List<[A, number]>

Accessors

head

get head(): A | undefined
Gets the first element of the collection.

Returns A | undefined
Inherited from FunctypeCollection.head

headOption

get headOption(): Option<A>
Gets the first element wrapped in Option.

Returns Option<A>
Inherited from FunctypeCollection.headOption

init

get init(): List<A>
Gets all elements except the last.

Returns List<A>
Overrides FunctypeCollection.init

last

get last(): A | undefined
Gets the last element of the collection.

Returns A | undefined
Overrides FunctypeCollection.last

lastOption

get lastOption(): Option<A>
Gets the last element wrapped in Option.

Returns Option<A>
Overrides FunctypeCollection.lastOption

tail

get tail(): List<A>
Gets all elements except the first.

Returns List<A>
Overrides FunctypeCollection.tail

Methods

add

add(item: B): List<A | B>
Add a value, possibly widening the element type (Scala: :+[B >: A]).
Type Parameters
- B
Parameters
- item: B
Returns List<A | B>

concat

concat(other: List): List<A | B>
Concatenate with another list, possibly widening (Scala: ++[B >: A]).
Type Parameters
- B
Parameters
- other: List
Returns List<A | B>

contains

contains(value: unknown): boolean
Parameters
- value: unknown
Returns boolean
Inherited from FunctypeCollection.contains

count

count(p: (x: A) => boolean): number
Counts elements that satisfy the predicate. For single-value containers: returns 0 or 1 For collections: returns the count of matching elements
Parameters
- p: (x: A) => boolean
Returns number
Inherited from FunctypeCollection.count

doUnwrap

doUnwrap(): DoResult<A>
Returns DoResult<A>
Inherited from Doable.doUnwrap

drop

drop(n: number): FunctypeCollection
Drops the first n elements from the collection.
Parameters
- n: number
Returns FunctypeCollection
Inherited from FunctypeCollection.drop

dropRight

dropRight(n: number): FunctypeCollection
Drops the last n elements from the collection.
Parameters
- n: number
Returns FunctypeCollection
Inherited from FunctypeCollection.dropRight

dropWhile

dropWhile(p: (a: A) => boolean): FunctypeCollection
Drops elements from the start while the predicate is true.
Parameters
- p: (a: A) => boolean
Returns FunctypeCollection
Inherited from FunctypeCollection.dropWhile

exists

exists(p: (a: A) => boolean): boolean
Tests whether any element satisfies the predicate. For single-value containers: tests the single value For collections: returns true if any element matches
Parameters
- p: (a: A) => boolean
Returns boolean
Inherited from FunctypeCollection.exists

filter

filter<S>(predicate: (a: A) => a is S): List<S>
Type Parameters
- S
Parameters
- predicate: (a: A) => a is S
Returns List<S>
filter(predicate: (a: A) => unknown): List<A>
Parameters
- predicate: (a: A) => unknown
Returns List<A>

find

find(p: (a: A) => boolean): Option<A>
Finds the first element that satisfies the predicate. For single-value containers: returns Some(value) if predicate matches, None otherwise For collections: returns the first matching element wrapped in Option
Parameters
- p: (a: A) => boolean
Returns Option<A>
Inherited from FunctypeCollection.find

flatten

flatten(): FunctypeCollection
Flattens a collection of collections into a single collection.
Type Parameters
- B
Returns FunctypeCollection
Inherited from FunctypeCollection.flatten

fold

fold(initial: B, fn: (acc: B, a: A) => B): B
Left-associative fold over all elements using an initial value and combining function. Unlike foldLeft (which is curried), this provides a convenient uncurried signature.
Type Parameters
- B
Parameters
- initial: B
 The initial accumulator value
- fn: (acc: B, a: A) => B
 A function that combines the accumulator with each element
Returns B
The final accumulated value
Example
```
List([1, 2, 3]).fold(0, (acc, x) => acc + x) // 6
```
Inherited from FunctypeCollection.fold

foldLeft

foldLeft(z: B): (op: (b: B, a: A) => B) => B
Left-associative fold using the provided zero value and operation
Type Parameters
- B
Parameters
- z: B
 Zero/identity value
Returns (op: (b: B, a: A) => B) => B
A function that takes an operation to apply

Inherited from FunctypeCollection.foldLeft

foldRight

foldRight(z: B): (op: (a: A, b: B) => B) => B
Right-associative fold using the provided zero value and operation
Type Parameters
- B
Parameters
- z: B
 Zero/identity value
Returns (op: (a: A, b: B) => B) => B
A function that takes an operation to apply

Inherited from FunctypeCollection.foldRight

forEach

forEach(f: (a: A) => void): void
Applies an effect function to each element. For single-value containers: applies to the value if present For collections: applies to each element
Parameters
- f: (a: A) => void
Returns void
Inherited from FunctypeCollection.forEach

match

match<R>(patterns: { Empty: () => R; NonEmpty: (values: A[]) => R }): R
Pattern matches over the List, applying a handler function based on whether it's empty
Type Parameters
- R
Parameters
- patterns: { Empty: () => R; NonEmpty: (values: A[]) => R }
 Object with handler functions for Empty and NonEmpty variants
Returns R
The result of applying the matching handler function

pipe

pipe(f: (value: A[]) => U): U
Pipes the value through the provided function
Type Parameters
- U extends unknown
 The return type of the function
Parameters
- f: (value: A[]) => U
 The function to apply to the value
Returns U
The result of applying the function to the value

Inherited from FunctypeCollection.pipe

prepend

prepend(item: B): List<A | B>
Prepend a value, possibly widening (Scala: +:[B >: A]).
Type Parameters
- B
Parameters
- item: B
Returns List<A | B>

reduce

reduce(op: (b: Widen<A, B>, a: Widen<A, B>) => Widen<A, B>): Widen<A, B>
Type Parameters
- B = A
Parameters
- op: (b: Widen<A, B>, a: Widen<A, B>) => Widen<A, B>
Returns Widen<A, B>
Inherited from FunctypeCollection.reduce

reduceRight

reduceRight(
op: (b: Widen<A, B>, a: Widen<A, B>) => Widen<A, B>,
): Widen<A, B>
Type Parameters
- B = A
Parameters
- op: (b: Widen<A, B>, a: Widen<A, B>) => Widen<A, B>
Returns Widen<A, B>
Inherited from FunctypeCollection.reduceRight

serialize

serialize(): SerializationMethods<A>
Returns SerializationMethods<A>
Inherited from FunctypeCollection.serialize

toArray

toArray(): B[]
Converts the collection to an array.
Type Parameters
- B = A
Returns B[]
Inherited from FunctypeCollection.toArray

toEither

toEither<E extends unknown>(leftValue: E): Either<E, A>
Converts this monad to an Either.

Conversion rules:
- Option: Some → Right, None → Left(leftValue)
- Either: returns self
- List: non-empty → Right(head), empty → Left(leftValue)
- Try: Success → Right, Failure → Left(error)
Type Parameters
- E extends unknown
Parameters
- leftValue: E
 The value to use for the Left case when the source is empty/none/failure
Returns Either<E, A>
An Either with the value as Right or the provided leftValue as Left

Inherited from Reshapeable.toEither

toList

toList(): List<A>
Returns List<A>
Inherited from FunctypeCollection.toList

toOption

toOption(): Option<A>
Converts this monad to an Option.

Conversion rules:
- Option: returns self
- Either: Right → Some, Left → None
- List: non-empty → Some(head), empty → None
- Try: Success → Some, Failure → None
Returns Option<A>
An Option containing the value if present, None otherwise

Inherited from Reshapeable.toOption

toSet

toSet(): Set<A>
Returns Set<A>
Inherited from FunctypeCollection.toSet

toString

toString(): string
Returns string
Inherited from FunctypeCollection.toString

toTry

toTry(): Try<A>
Converts this monad to a Try.

Conversion rules:
- Option: Some → Success, None → Failure(Error("None"))
- Either: Right → Success, Left → Failure(Error(leftValue))
- List: non-empty → Success(head), empty → Failure(Error("Empty list"))
- Try: returns self
Returns Try<A>
A Try containing Success with the value or Failure with an appropriate error

Inherited from Reshapeable.toTry

toValue

toValue(): { _tag: "List"; value: A[] }
Returns { _tag: "List"; value: A[] }
Inherited from FunctypeCollection.toValue

Interface List<A>

Type Parameters

Hierarchy (View Summary)

Index

Properties

Accessors

Methods

Properties

Readonly_tag

Readonly[iterator]

Readonly[toStringTag]

ap

distinct

filterNot

flatMap

flatMapAsync

get

groupBy

indexOf

isEmpty

Readonlylength

map

partition

remove

removeAt

reverse

size

slice

sortBy

sorted

span

take

takeRight

takeWhile

zip

zipWithIndex

Accessors

head

Returns A | undefined

headOption

Returns Option<A>

init

Returns List<A>

last

Returns A | undefined

lastOption

Returns Option<A>

tail

Returns List<A>

Methods

add

Type Parameters

Parameters

Returns List<A | B>

concat

Type Parameters

Parameters

Returns List<A | B>

contains

Parameters

Returns boolean

count

Parameters

Returns number

doUnwrap

Returns DoResult<A>

drop

Parameters

Returns FunctypeCollection

dropRight

Parameters

Returns FunctypeCollection

dropWhile

Parameters

Returns FunctypeCollection

exists

Parameters

Returns boolean

filter

Type Parameters

`Readonly`_tag

`Readonly`[iterator]

`Readonly`[toStringTag]

`Readonly`length