Options
All
  • Public
  • Public/Protected
  • All
Menu

Class TypesafeStream<T>

Type parameters

  • T

Hierarchy

Implements

Index

Properties

Methods

Properties

constructor

constructor: TypesafeStream

Methods

__@iterator

  • __@iterator(): Iterator<T>

chunk

  • chunk(chunkSize: 0): IStream<never>
  • chunk(chunkSize: 1): IStream<Single<T>>
  • chunk(chunkSize: 2): IStream<Pair<T> | Single<T>>
  • chunk(chunkSize: 3): IStream<Triple<T> | Pair<T> | Single<T>>
  • chunk(chunkSize: 4): IStream<Quadruple<T> | Triple<T> | Pair<T> | Single<T>>
  • chunk(chunkSize: 5): IStream<Quintuple<T> | Quadruple<T> | Triple<T> | Pair<T> | Single<T>>
  • chunk(chunkSize: 6): IStream<Sextuple<T> | Quintuple<T> | Quadruple<T> | Triple<T> | Pair<T> | Single<T>>
  • chunk(chunkSize: 7): IStream<Septuple<T> | Sextuple<T> | Quintuple<T> | Quadruple<T> | Triple<T> | Pair<T> | Single<T>>
  • chunk(chunkSize: 8): IStream<Octuple<T> | Septuple<T> | Sextuple<T> | Quintuple<T> | Quadruple<T> | Triple<T> | Pair<T> | Single<T>>
  • chunk(chunkSize: 9): IStream<Nonuple<T> | Octuple<T> | Septuple<T> | Sextuple<T> | Quintuple<T> | Quadruple<T> | Triple<T> | Pair<T> | Single<T>>
  • chunk(chunkSize: 10): IStream<Decuple<T> | Nonuple<T> | Octuple<T> | Septuple<T> | Sextuple<T> | Quintuple<T> | Quadruple<T> | Triple<T> | Pair<T> | Single<T>>
  • chunk(chunkSize: number): IStream<T[]>

chunkBy

  • chunkBy<K>(classifier: TypedBiFunction<T, number, K>): IStream<T[]>

collect

  • collect<S, R>(collector: Collector<T, S, R>): R

collectWith

  • collectWith<S, R>(supplier: Supplier<S>, accumulator: BiConsumer<S, T>, finisher: TypedFunction<S, R>): R

concat

  • concat(...iterables: Iterable<T>[]): this

consume

  • consume(sink: T[] | Consumer<T>, offset?: undefined | number, maxAmount?: undefined | number): this

cycle

  • cycle(count?: undefined | number): this

end

  • end(): void

every

  • every(predicate: Predicate<T>): boolean

filter

  • filter(predicate: Predicate<T>): this

filterBy

  • filterBy<K>(target: K, keyExtractor: TypedFunction<T, K>, comparator?: Comparator<K>): this

find

  • find(predicate: BiPredicate<T, number>): Maybe<T>

findIndex

  • findIndex(predicate: BiPredicate<T, number>): number

first

  • first(): Maybe<T>

flatMap

  • flatMap<S>(mapper: TypedFunction<T, Iterable<S>>): IStream<S>

forEach

  • forEach(consumer: Consumer<T>): void

fork

  • fork(): this

group

  • group<K>(classifier: TypedFunction<T, K>): Map<K, T[]>

has

  • has(object: T): boolean

index

isEmpty

  • isEmpty(): boolean

isSizeBetween

  • isSizeBetween(lower?: undefined | number, upper?: undefined | number): boolean

join

  • join(delimiter?: undefined | string, prefix?: undefined | string, suffix?: undefined | string): string

last

  • last(): Maybe<T>

limit

  • limit(limitTo?: undefined | number): this

map

  • map<S>(mapper: TypedFunction<T, S>): IStream<S>

max

  • max(comparator?: Comparator<T>): Maybe<T>

maxBy

  • maxBy<K>(sortKey: TypedFunction<T, K>): Maybe<T>

min

  • min(comparator?: Comparator<T>): Maybe<T>

minBy

  • minBy<K>(sortKey: TypedFunction<T, K>): Maybe<T>

none

  • none(predicate: Predicate<T>): boolean

nth

  • nth(n: number): Maybe<T>

partition

  • partition(predicate: Predicate<T>): object

promise

  • promise<S>(promiseConverter: TypedFunction<any, Promise<S>>): Promise<IStream<any>>

reduce

  • reduce<S>(reducer: TypedBiFunction<S, T, S>, initialValue: S): S

reduceSame

  • reduceSame(reducer: TypedBiFunction<T, T, T>): Maybe<T>

replace

  • replace(mapper: TypedFunction<T, T>): this

reverse

  • reverse(): this

shift

  • shift(): Maybe<T>

size

  • size(): number

skip

  • skip(toSkip?: undefined | number): this

slice

  • slice(startOffset?: undefined | number, endOffset?: undefined | number): T[]

some

  • some(predicate: Predicate<T>): boolean

sort

  • sort(comparator?: Comparator<T>): this

sortBy

  • sortBy<K>(keyExtractor: TypedFunction<T, K>, comparator?: Comparator<K>): this

splice

  • splice(offset?: undefined | number, maxAmount?: undefined | number): T[]

sum

  • sum(converter?: TypedFunction<T, number>): number

toArray

  • toArray(fresh?: undefined | true | false): T[]

toJSON

  • toJSON(): T[]

toMap

  • toMap<K, V>(keyMapper: TypedFunction<T, K>, valueMapper: TypedFunction<T, V>, merger?: BinaryOperator<V>): Map<K, V>

toSet

  • toSet(fresh?: undefined | true | false): Set<T>

toString

  • toString(): string

try

  • try<S>(operation: TypedFunction<T, S>): ITryStream<S>

tryCompute

  • tryCompute<S>(operation: TypedFunction<IStream<T>, S>): ITry<S>

tryEnd

  • tryEnd(): ITry<void>

unique

  • unique(comparator?: Comparator<any>): this

uniqueBy

  • uniqueBy(keyExtractor: TypedFunction<T, any>): this

visit

  • visit(consumer: Consumer<T>): this

zip

  • zip<S>(other: Iterable<S>): IStream<[Maybe<T>, Maybe<S>]>

zipSame

  • zipSame(...others: Iterable<T>[]): IStream<Maybe<T>[]>

Generated using TypeDoc