Class Seq<T>

Type parameters

T

Hierarchy

Seq

Implements

Iterable<T>

Index

Constructors

constructor

Properties

iter

Accessors

arr

Methods

[iterator]

[iterator](): Iterator<T, any, undefined>

Implementation of Iterable.__@iterator@93
- Defined in seq/index.ts:16
Returns Iterator<T, any, undefined>

Static empty

empty<T>(): Seq<T>

- Defined in seq/index.ts:21
Create empty seq

Type parameters
- T
Returns Seq<T>

Static by

by<T>(iter: () => Iterable<T>): Seq<T>

- Defined in seq/index.ts:25
Type parameters
- T
Parameters
- iter: () => Iterable<T>
  - - (): Iterable<T>
    - Returns Iterable<T>
Returns Seq<T>

Static of

of<T>(...iter: T[]): Seq<T>

- Defined in seq/index.ts:29
Type parameters
- T
Parameters
- Rest ...iter: T[]
Returns Seq<T>

Static to

to(to: number, step?: number): Seq<number>

- Defined in seq/index.ts:34
Create a Seq from a range starting from 0

Parameters
- to: number
- step: number = 1
Returns Seq<number>

Static range

range(from: number, to: number, step?: number): Seq<number>

- Defined in seq/index.ts:45
Create a Seq from a range

Parameters
- from: number
- to: number
- step: number = 1
Returns Seq<number>

Static repeat

repeat<T>(v: T, n: number): Seq<T>

- Defined in seq/index.ts:56
Type parameters
- T
Parameters
- v: T
- n: number
Returns Seq<T>

linq

linq(): SeqLinq<T>

- Defined in seq/index.ts:64
Returns SeqLinq<T>

flu

flu(): Flu<T>

- Defined in seq/index.ts:68
Returns Flu<T>

toFlu

toFlu(): T extends R | Promise<R> ? Flu<R> : never

- Defined in seq/index.ts:72
Returns T extends R | Promise<R> ? Flu<R> : never

collect

collect(): T[]

- Defined in seq/index.ts:76
Returns T[]

join

join(separator?: string): string

- Defined in seq/index.ts:80
Parameters
- Optional separator: string
Returns string

count

count(): number

- Defined in seq/index.ts:84
Returns number

isEmpty

isEmpty(): boolean

- Defined in seq/index.ts:88
Returns boolean

first

first(): Voidable<T>

- Defined in seq/index.ts:92
Returns Voidable<T>

firstO

firstO(): Option<T>

- Defined in seq/index.ts:96
Returns Option<T>

last

last(): Voidable<T>

- Defined in seq/index.ts:100
Returns Voidable<T>

lastO

lastO(): Option<T>

- Defined in seq/index.ts:104
Returns Option<T>

nth

nth(n: number): Voidable<T>

- Defined in seq/index.ts:108
Parameters
- n: number
Returns Voidable<T>

nthO

nthO(n: number): Option<T>

- Defined in seq/index.ts:112
Parameters
- n: number
Returns Option<T>

stepBy

stepBy(step: number): Seq<T>

- Defined in seq/index.ts:116
Parameters
- step: number
Returns Seq<T>

chain

chain(other: Iterable<T>, ...more: Iterable<T>[]): Seq<T>

- Defined in seq/index.ts:120
Parameters
- other: Iterable<T>
- Rest ...more: Iterable<T>[]
Returns Seq<T>

zip

zip<U>(other: Iterable<U>): Seq<[T, U]>

- Defined in seq/index.ts:124
Type parameters
- U
Parameters
- other: Iterable<U>
Returns Seq<[T, U]>

unzip

unzip(): [(T extends [A, any] | readonly [A, any] | A[] ? A : unknown)[], (T extends [any, B] | readonly [any, B] | B[] ? B : unknown)[]]

- Defined in seq/index.ts:128
Returns [(T extends [A, any] | readonly [A, any] | A[] ? A : unknown)[], (T extends [any, B] | readonly [any, B] | B[] ? B : unknown)[]]

map

map<R>(f: (v: T) => R): Seq<R>

- Defined in seq/index.ts:136
Type parameters
- R
Parameters
- f: (v: T) => R
  - - (v: T): R
    - Parameters
      - v: T
      Returns R
Returns Seq<R>

fill

fill<R>(v: R): Seq<R>

- Defined in seq/index.ts:140
Type parameters
- R
Parameters
- v: R
Returns Seq<R>

forEach

forEach(f: (v: T) => unknown): void

- Defined in seq/index.ts:144
Parameters
- f: (v: T) => unknown
  - - (v: T): unknown
    - Parameters
      - v: T
      Returns unknown
Returns void

run

run(): void

- Defined in seq/index.ts:148
Returns void

filter

filter<S>(f: (v: T) => v is S): Seq<S>
filter(f: (v: T) => unknown): Seq<T>

- Defined in seq/index.ts:152
Type parameters
- S
Parameters
- f: (v: T) => v is S
  - - (v: T): v is S
    - Parameters
      - v: T
      Returns v is S
Returns Seq<S>
- Defined in seq/index.ts:153
Parameters
- f: (v: T) => unknown
  - - (v: T): unknown
    - Parameters
      - v: T
      Returns unknown
Returns Seq<T>

enumerate

enumerate(): Seq<[T, number]>

- Defined in seq/index.ts:158
Returns Seq<[T, number]>

indexed

indexed(): Seq<[number, T]>

- Defined in seq/index.ts:162
Returns Seq<[number, T]>

skip

skip(n: number): Seq<T>

- Defined in seq/index.ts:166
Parameters
- n: number
Returns Seq<T>

take

take(n: number): Seq<T>

- Defined in seq/index.ts:170
Parameters
- n: number
Returns Seq<T>

slice

slice(from: number, to: number): Seq<T>

- Defined in seq/index.ts:174
Parameters
- from: number
- to: number
Returns Seq<T>

sub

sub(from: number, count: number): Seq<T>

- Defined in seq/index.ts:178
Parameters
- from: number
- count: number
Returns Seq<T>

scan

scan<R>(init: R, f: (acc: R, val: T) => R): Seq<R>

- Defined in seq/index.ts:182
Type parameters
- R
Parameters
- init: R
- f: (acc: R, val: T) => R
  - - (acc: R, val: T): R
    - Parameters
      - acc: R
      - val: T
      Returns R
Returns Seq<R>

flatMap

flatMap<R>(f: (v: T) => Iterable<R>): Seq<R>

- Defined in seq/index.ts:186
Type parameters
- R
Parameters
- f: (v: T) => Iterable<R>
  - - (v: T): Iterable<R>
    - Parameters
      - v: T
      Returns Iterable<R>
Returns Seq<R>

flatten

flatten(): T extends Iterable<R> ? Seq<R> : never

- Defined in seq/index.ts:190
Returns T extends Iterable<R> ? Seq<R> : never

also

also(f: (v: T) => void): Seq<T>

- Defined in seq/index.ts:194
Parameters
- f: (v: T) => void
  - - (v: T): void
    - Parameters
      - v: T
      Returns void
Returns Seq<T>

fold

fold<R>(init: R, f: (acc: R, val: T) => R): R

- Defined in seq/index.ts:198
Type parameters
- R
Parameters
- init: R
- f: (acc: R, val: T) => R
  - - (acc: R, val: T): R
    - Parameters
      - acc: R
      - val: T
      Returns R
Returns R

reduce

reduce(f: (acc: T, val: T) => T): T

- Defined in seq/index.ts:202
Parameters
- f: (acc: T, val: T) => T
  - - (acc: T, val: T): T
    - Parameters
      - acc: T
      - val: T
      Returns T
Returns T

all

all<S>(f: (v: T) => v is S): this is Seq<S>
all(f: (v: T) => unknown): boolean

- Defined in seq/index.ts:206
Type parameters
- S
Parameters
- f: (v: T) => v is S
  - - (v: T): v is S
    - Parameters
      - v: T
      Returns v is S
Returns this is Seq<S>
- Defined in seq/index.ts:207
Parameters
- f: (v: T) => unknown
  - - (v: T): unknown
    - Parameters
      - v: T
      Returns unknown
Returns boolean

any

any(f: (v: T) => unknown): boolean

- Defined in seq/index.ts:212
Parameters
- f: (v: T) => unknown
  - - (v: T): unknown
    - Parameters
      - v: T
      Returns unknown
Returns boolean

find

find(f: (v: T) => unknown): Voidable<T>

- Defined in seq/index.ts:216
Parameters
- f: (v: T) => unknown
  - - (v: T): unknown
    - Parameters
      - v: T
      Returns unknown
Returns Voidable<T>

findO

findO(f: (v: T) => unknown): Option<T>

- Defined in seq/index.ts:220
Parameters
- f: (v: T) => unknown
  - - (v: T): unknown
    - Parameters
      - v: T
      Returns unknown
Returns Option<T>

position

position(f: (v: T) => unknown): number

- Defined in seq/index.ts:224
Parameters
- f: (v: T) => unknown
  - - (v: T): unknown
    - Parameters
      - v: T
      Returns unknown
Returns number

indexOf

indexOf(v: T): number

- Defined in seq/index.ts:228
Parameters
- v: T
Returns number

includes

includes(v: T): boolean

- Defined in seq/index.ts:232
Parameters
- v: T
Returns boolean

max

max(): Voidable<T>

- Defined in seq/index.ts:236
Returns Voidable<T>

maxO

maxO(): Option<T>

- Defined in seq/index.ts:240
Returns Option<T>

min

min(): Voidable<T>

- Defined in seq/index.ts:244
Returns Voidable<T>

minO

minO(): Option<T>

- Defined in seq/index.ts:248
Returns Option<T>

sum

sum(defv: T): T extends string | number | bigint ? T : never
sum(): T extends string | number | bigint ? Voidable<T> : never

- Defined in seq/index.ts:252
Parameters
- defv: T
Returns T extends string | number | bigint ? T : never
- Defined in seq/index.ts:253
Returns T extends string | number | bigint ? Voidable<T> : never

avg

avg(defv: T): T extends number | bigint ? T : never
avg(): T extends number | bigint ? Voidable<T> : never

- Defined in seq/index.ts:258
Parameters
- defv: T
Returns T extends number | bigint ? T : never
- Defined in seq/index.ts:259
Returns T extends number | bigint ? Voidable<T> : never

push

push(...items: T[]): Seq<T>

- Defined in seq/index.ts:264
Parameters
- Rest ...items: T[]
Returns Seq<T>

unshift

unshift(...items: T[]): Seq<T>

- Defined in seq/index.ts:268
Parameters
- Rest ...items: T[]
Returns Seq<T>

as

as<U>(): Seq<U>

- Defined in seq/index.ts:272
Type parameters
- U
Returns Seq<U>

toArray

toArray(): T[]

- Defined in seq/index.ts:276
Returns T[]

toSet

toSet(): Set<T>

- Defined in seq/index.ts:280
Returns Set<T>

toMap

toMap(): T extends AnyPair<K, V> ? Map<K, V> : never

- Defined in seq/index.ts:284
Returns T extends AnyPair<K, V> ? Map<K, V> : never

groupBy

groupBy<K>(keyf: (v: T) => K): Seq<[K, T[]]>
groupBy<K, V>(keyf: (v: T) => K, valf: (v: T) => V): Seq<[K, V[]]>

- Defined in seq/index.ts:288
Type parameters
- K
Parameters
- keyf: (v: T) => K
  - - (v: T): K
    - Parameters
      - v: T
      Returns K
Returns Seq<[K, T[]]>
- Defined in seq/index.ts:289
Type parameters
- K
- V
Parameters
- keyf: (v: T) => K
  - - (v: T): K
    - Parameters
      - v: T
      Returns K
- valf: (v: T) => V
  - - (v: T): V
    - Parameters
      - v: T
      Returns V
Returns Seq<[K, V[]]>

relate

relate<I, K>(inner: Iterable<I>, outerKey: (a: T) => K, innerKey: (b: I) => K): Seq<[T, I]>

- Defined in seq/index.ts:294
Type parameters
- I
- K
Parameters
- inner: Iterable<I>
- outerKey: (a: T) => K
  - - (a: T): K
    - Parameters
      - a: T
      Returns K
- innerKey: (b: I) => K
  - - (b: I): K
    - Parameters
      - b: I
      Returns K
Returns Seq<[T, I]>

relateMap

relateMap<I, K, R>(inner: Iterable<I>, outerKey: (a: T) => K, innerKey: (b: I) => K, selector: (a: T, b: I) => R): Seq<R>

- Defined in seq/index.ts:298
Type parameters
- I
- K
- R
Parameters
- inner: Iterable<I>
- outerKey: (a: T) => K
  - - (a: T): K
    - Parameters
      - a: T
      Returns K
- innerKey: (b: I) => K
  - - (b: I): K
    - Parameters
      - b: I
      Returns K
- selector: (a: T, b: I) => R
  - - (a: T, b: I): R
    - Parameters
      - a: T
      - b: I
      Returns R
Returns Seq<R>

mapKey

mapKey<R>(f: (key: PairKey<T>) => R): T extends AnyPair<any, V> ? Seq<Pair<R, V>> : never

- Defined in seq/index.ts:306
Type parameters
- R
Parameters
- f: (key: PairKey<T>) => R
  - - (key: PairKey<T>): R
    - Parameters
      - key: PairKey<T>
      Returns R
Returns T extends AnyPair<any, V> ? Seq<Pair<R, V>> : never

mapValue

mapValue<R>(f: (key: PairValue<T>) => R): T extends AnyPair<K, any> ? Seq<Pair<K, R>> : never

- Defined in seq/index.ts:310
Type parameters
- R
Parameters
- f: (key: PairValue<T>) => R
  - - (key: PairValue<T>): R
    - Parameters
      - key: PairValue<T>
      Returns R
Returns T extends AnyPair<K, any> ? Seq<Pair<K, R>> : never

Constructors

constructor

new Seq<T>(iter: () => Iterable<T>): Seq<T>

- Defined in seq/index.ts:14
Type parameters
- T
Parameters
- iter: () => Iterable<T>
  - - (): Iterable<T>
    - Returns Iterable<T>
Returns Seq<T>

Properties

Readonly iter

iter: () => Iterable<T>

Type declaration

- (): Iterable<T>
- Returns Iterable<T>

Accessors

arr

get arr(): T[]

- Defined in seq/index.ts:302
Returns T[]

Generated using TypeDoc