blinq
Options
All
  • Public
  • Public/Protected
  • All
Menu

Type parameters

  • TKey

  • TValue

Hierarchy

Implements

  • Iterable<[TKey, TValue]>

Index

Constructors

Properties

Methods

Constructors

constructor

Properties

Private _underlyingMap

_underlyingMap: Map<TKey, TValue>

gen

gen: function

Type declaration

    • (): IterableIterator<[TKey, TValue]>

    • Returns IterableIterator<[TKey, TValue]>

Methods

__@iterator

  • __@iterator(): IterableIterator<[TKey, TValue]>

aggregate

  • aggregate<TOut>(seed: TOut, aggFunc: function): TOut

  • Type parameters

    • TOut

    Parameters

    • seed: TOut
    • aggFunc: function
        • (prev: TOut, curr: [TKey, TValue], idx: number): TOut

        • Parameters

          • prev: TOut
          • curr: [TKey, TValue]
          • idx: number

          Returns TOut

    Returns TOut

all

any

  • any<T>(this: Enumerable<T>): boolean
  • any<T>(this: Enumerable<T>, pred: IndexedPredicate<T>): boolean

append

  • append<T>(this: Enumerable<T>, item: T): Enumerable<T>

average

  • average<T>(this: Enumerable<number>): number

concat

  • concat<T>(this: Enumerable<T>, ...sequences: Array<Iterable<T>>): Enumerable<T>

convertToObject

  • convertToObject(this: MapIterable<string, TValue>): any

count

  • count<T>(this: Enumerable<T>): number
  • count<T>(this: Enumerable<T>, pred: IndexedPredicate<T>): number

defaultIfEmpty

  • defaultIfEmpty<T>(this: Enumerable<T>): Enumerable<T | undefined>

distinct

  • distinct<T>(this: Enumerable<T>, equalityComparer?: EqualityComparer<T>): Enumerable<T>

distinctBy

elementAt

  • elementAt<T>(this: Enumerable<T>, index: number): T

entries

except

  • except<T>(this: Enumerable<T>, seq: Iterable<T>, equalityComparer?: EqualityComparer<T>): Enumerable<T>

first

  • first<T>(this: Enumerable<T>): T
  • first<T>(this: Enumerable<T>, pred: IndexedPredicate<T>): T

firstOrDefault

  • firstOrDefault(this: Enumerable<[TKey, TValue]>): [TKey, TValue] | undefined
  • firstOrDefault(this: Enumerable<[TKey, TValue]>, pred: IndexedPredicate<[TKey, TValue]>): [TKey, TValue] | undefined

flatten

  • flatten<TT>(this: Enumerable<Enumerable<TT>>): Enumerable<[TKey, TValue]>

forEach

  • forEach<T>(this: Enumerable<T>, action: function): void

  • Type parameters

    • T

    Parameters

    • this: Enumerable<T>
    • action: function
        • (x: T, i: number): void

        • Parameters

          • x: T
          • i: number

          Returns void

    Returns void

fullOuterGroupJoin

  • fullOuterGroupJoin<T, TRight, TKey, TOut>(this: Enumerable<T>, rightSeq: Iterable<TRight>, leftKeySelector: IndexedSelector<T, TKey>, rightKeySelector: IndexedSelector<TRight, TKey>, selector: function, equalityComparer?: EqualityComparer<TKey>): Enumerable<TOut>

fullOuterJoin

  • fullOuterJoin<TRight, TKey, TOut>(this: Enumerable<[TKey, TValue]>, rightSeq: Iterable<TRight>, leftKeySelector: IndexedSelector<[TKey, TValue], TKey>, rightKeySelector: IndexedSelector<TRight, TKey>, selector: function, equalityComparer?: EqualityComparer<TKey>): Enumerable<TOut>

  • Type parameters

    • TRight

    • TKey

    • TOut

    Parameters

    • this: Enumerable<[TKey, TValue]>
    • rightSeq: Iterable<TRight>
    • leftKeySelector: IndexedSelector<[TKey, TValue], TKey>
    • rightKeySelector: IndexedSelector<TRight, TKey>
    • selector: function
        • (o: [TKey, TValue] | undefined, v: TRight | undefined, k: TKey): TOut

        • Parameters

          • o: [TKey, TValue] | undefined
          • v: TRight | undefined
          • k: TKey

          Returns TOut

    • Optional equalityComparer: EqualityComparer<TKey>

    Returns Enumerable<TOut>

get

  • get(key: TKey): undefined | TValue

groupAdjacent

  • groupAdjacent<TSource, TKey, TElement, TResult>(this: Enumerable<TSource>, keySelector: IndexedSelector<TSource, TKey>, elementSelector: IndexedSelector<TSource, TElement>, resultSelector: function, equalityComparer?: EqualityComparer<TKey>): Enumerable<TResult>

groupBy

groupJoin

  • groupJoin<T, TInner, TKey, TOut>(this: Enumerable<T>, innerSeq: Iterable<TInner>, outerKeySelector: IndexedSelector<T, TKey>, innerKeySelector: IndexedSelector<TInner, TKey>, selector: function, equalityComparer?: EqualityComparer<TKey>): Enumerable<TOut>

has

  • has(v: TKey): boolean

intersect

  • intersect<T>(this: Enumerable<T>, seq: Iterable<T>, equalityComparer?: EqualityComparer<T>): Enumerable<T>

isSubsetOf

  • isSubsetOf<T>(this: Enumerable<T>, seq: Iterable<T>, equalityComparer?: EqualityComparer<T>): boolean

isSupersetOf

  • isSupersetOf<T>(this: Enumerable<T>, seq: Iterable<T>, equalityComparer?: EqualityComparer<T>): boolean

join

  • join<T, TInner, TKey, TOut>(this: Enumerable<T>, innerSeq: Iterable<TInner>, outerKeySelector: IndexedSelector<T, TKey>, innerKeySelector: IndexedSelector<TInner, TKey>, selector: function, equalityComparer?: EqualityComparer<TKey>): Enumerable<TOut>

  • Type parameters

    • T

    • TInner

    • TKey

    • TOut

    Parameters

    • this: Enumerable<T>
    • innerSeq: Iterable<TInner>
    • outerKeySelector: IndexedSelector<T, TKey>
    • innerKeySelector: IndexedSelector<TInner, TKey>
    • selector: function
        • (outer: T, inner: TInner): TOut

        • Parameters

          • outer: T
          • inner: TInner

          Returns TOut

    • Optional equalityComparer: EqualityComparer<TKey>

    Returns Enumerable<TOut>

keys

last

  • last<T>(this: Enumerable<T>): T
  • last<T>(this: Enumerable<T>, pred: IndexedPredicate<T>): T

lastOrDefault

  • lastOrDefault<T>(this: Enumerable<T>): T | undefined
  • lastOrDefault<T>(this: Enumerable<T>, pred: IndexedPredicate<T>): T | undefined

leftOuterJoin

  • leftOuterJoin<T, TInner, TKey, TOut>(this: Enumerable<T>, innerSeq: Iterable<TInner>, outerKeySelector: IndexedSelector<T, TKey>, innerKeySelector: IndexedSelector<TInner, TKey>, selector: function, equalityComparer?: EqualityComparer<TKey>): Enumerable<TOut>

max

  • max(): [TKey, TValue] | undefined
  • max<TOut>(selector: IndexedSelector<[TKey, TValue], TOut>): TOut | undefined
  • max<TOut>(selector: IndexedSelector<[TKey, TValue], TOut>, comparer: Comparer<TOut>): TOut | undefined
  • max<TOut>(this: Enumerable<[TKey, TValue]>, selector: IndexedSelector<[TKey, TValue], [TKey, TValue] | TOut>, comparer: Comparer<[TKey, TValue] | TOut>): [TKey, TValue] | TOut | undefined

maxBy

  • maxBy<T, TKey>(this: Enumerable<T>, selector: IndexedSelector<T, TKey>): Enumerable<T>
  • maxBy<T, TKey>(this: Enumerable<T>, selector: IndexedSelector<T, TKey>, comparer: Comparer<TKey>): Enumerable<T>

min

  • min(): [TKey, TValue] | undefined
  • min<TOut>(selector: IndexedSelector<[TKey, TValue], TOut>): TOut | undefined
  • min<TOut>(selector: IndexedSelector<[TKey, TValue], TOut>, comparer: Comparer<TOut>): TOut | undefined
  • min<TOut>(this: Enumerable<[TKey, TValue]>, selector: IndexedSelector<[TKey, TValue], [TKey, TValue] | TOut>, comparer: Comparer<[TKey, TValue] | TOut>): [TKey, TValue] | TOut | undefined

minBy

  • minBy<T, TKey>(this: Enumerable<T>, selector: IndexedSelector<T, TKey>): Enumerable<T>
  • minBy<T, TKey>(this: Enumerable<T>, selector: IndexedSelector<T, TKey>, comparer: Comparer<TKey>): Enumerable<T>

orderBy

  • orderBy<TCmp>(this: Enumerable<[TKey, TValue]>, selector: function): OrderedIterable<[TKey, TValue]>

orderByDescending

  • orderByDescending<TCmp>(this: Enumerable<[TKey, TValue]>, selector: function): OrderedIterable<[TKey, TValue]>

prepend

  • prepend<T>(this: Enumerable<T>, item: T): Enumerable<T>

reverse

  • reverse<T>(this: Enumerable<T>): Enumerable<T>

select

  • select<T, TOut>(this: Enumerable<T>, selector: IndexedSelector<T, TOut>): Enumerable<TOut>

selectMany

  • selectMany<T, TOut>(this: Enumerable<T>, selector: IndexedSelector<T, Iterable<TOut>>): Enumerable<TOut>

sequenceEqual

  • sequenceEqual<T>(this: Enumerable<T>, seq: Iterable<T>, equalityComparer?: EqualityComparer<T>): boolean

single

  • single<T>(this: Enumerable<T>): T
  • single<T>(this: Enumerable<T>, pred: IndexedPredicate<T>): T

singleOrDefault

  • singleOrDefault<T>(this: Enumerable<T>): T | undefined
  • singleOrDefault<T>(this: Enumerable<T>, pred: IndexedPredicate<T>): T | undefined

skip

  • skip<T>(this: Enumerable<T>, numItems: number): Enumerable<T>

skipWhile

sum

  • sum(this: Enumerable<number>): number

take

  • take<T>(this: Enumerable<T>, numItems: number): Enumerable<T>

takeWhile

toArray

  • toArray<T>(this: Enumerable<T>): T[]

toLookup

toMap

toSet

union

  • union<T>(this: Enumerable<T>, seq: Iterable<T>, equalityComparer?: EqualityComparer<T>): Enumerable<T>

values

where

zip

  • zip<T, TOther, TOut>(this: Enumerable<T>, seq: Iterable<TOther>, selector: function): Enumerable<TOut>

  • Type parameters

    • T

    • TOther

    • TOut

    Parameters

    • this: Enumerable<T>
    • seq: Iterable<TOther>
    • selector: function
        • (item1: T, item2: TOther): TOut

        • Parameters

          • item1: T
          • item2: TOther

          Returns TOut

    Returns Enumerable<TOut>

zipAll

  • zipAll<TT>(this: Enumerable<Enumerable<TT>>): Enumerable<Enumerable<TT>>

Legend

  • Module
  • Object literal
  • Variable
  • Function
  • Function with type parameter
  • Index signature
  • Type alias
  • Enumeration
  • Enumeration member
  • Property
  • Method
  • Interface
  • Interface with type parameter
  • Constructor
  • Property
  • Method
  • Index signature
  • Class
  • Class with type parameter
  • Constructor
  • Property
  • Method
  • Accessor
  • Index signature
  • Inherited constructor
  • Inherited property
  • Inherited method
  • Inherited accessor
  • Protected property
  • Protected method
  • Protected accessor
  • Private property
  • Private method
  • Private accessor
  • Static property
  • Static method

Generated using TypeDoc