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

A strongly-typed TypeScript implementation of Microsoft dotnet's LINQ to Objects using ES6 iterables.

With the advent of javascript iterators and generators, its possible to pipe sequences through a bunch of transformations without materializing collections (arrays) for the intermediate steps. This library attempts to recreate the dotnet linq-to-objects api to provide a number of standard operations on iterable sequences.

The following operations are available, and the user can optionally supply their own EqualityComparer (implementing equals and getHashCode) when using the set-based operations.

aggregate, all, any, append, average, concat, count, defaultIfEmpty, distinctBy, distinct, elementAt, except, firstOrDefault, first, flatten, forEach, fullOuterGroupJoin, fullOuterJoin, groupAdjacent, groupBy, groupJoin, intersect, isSubsetOf, isSupersetOf, join, lastOrDefault, last, leftOuterJoin, maxBy, max, minBy, min, orderBy / orderByDescending / thenBy / thenByDescending, preprend, reverse, selectMany, select, sequenceEqual, singleOrDefault, single, skip, skipWhile, sum, take, takeWhile, toArray, toLookup, toMap, toSet, union, where, zipAll, zip

Build Status Coverage Status

NPM package can be downloaded here.

documentation

Generated documentation can be found at https://biggyspender.github.io/blinq/

How?

Import blinq ES6 style:

import {
  blinq,
  range,
  empty,
  fromGenerator,
  fromSingleValue,
  repeatGenerate,
  repeat,
  EqualityComparer,
  hashString
} from "blinq";

or nodejs style:

const {
  blinq,
  range,
  empty,
  fromGenerator,
  fromSingleValue,
  repeatGenerate,
  repeat,
  EqualityComparer,
  hashString
} = require("blinq")

Now, just wrap your iterable with a call to blinq(myIterable), and start transforming your data:

const someNumbers = [1, 2, 3, 4];
const squares = blinq(someNumbers).select(n => n * n);
for(let v of squares){
    console.log(v);
}

...or if you'd like an array of your results, you can materialize a blinq query with the .toArray() method:

const someNumbers = range(1, 4);
const squaresBelowTen = someNumbers.select(n => n * n).where(n => n < 10);
const arr = squaresBelowTen.toArray();
console.log(arr);

or even spread your results into an array:

const arr2 = [...squaresBelowTen]

A case-insensitive set, using EqualityComparer

const names = ["zebra", "antelope", "ardvaark", "tortoise", "turtle", "dog", "frog"]
const comparer: EqualityComparer<string> = {
    equals: (a, b) => a.toLowerCase() === b.toLowerCase(),
    getHashCode: (x) => hashString(x.toLowerCase())
}
const set = blinq(names).toSet(comparer)
expect(set.has("DOg")).toBeTruthy()

More examples:

Let's make a collection of cars:

const cars = [{
    manufacturer:"Ford",
    model:"Escort"
  },{
    manufacturer:"Ford",
    model:"Cortina"
  },{
    manufacturer:"Renault",
    model:"Clio"
  },{
    manufacturer:"Vauxhall",
    model:"Corsa"
  },{
    manufacturer:"Ford",
    model:"Fiesta"
  },{
    manufacturer:"Fiat",
    model:"500"
  }
];

...and sort them by manufacturer, and then by model:

const orderedCars = blinq(cars).orderBy(c => c.manufacturer).thenBy(c => c.model);
console.log(orderedCars.toArray());

Or we could count the number of cars for each manufacturer:

const carsPerManufacturer = blinq(cars)
  .groupBy(c => c.manufacturer)
  .select(g => ({
    manufacturer:g.key, 
    count:g.count()
  }))
  .orderBy(c => c.manufacturer);
for(var c of carsPerManufacturer){
  console.log(`${c.manufacturer} : ${c.count}`);
}

What next?

The tests for this project are kept up to date and are the best place to look for other examples.

acknowledgements

Created using the wonderful https://github.com/alexjoverm/typescript-library-starter.

Index

Modules

Classes

Interfaces

Type aliases

Variables

Functions

Object literals

Type aliases

Comparer

Comparer: function

Type declaration

    • (a: T, b: T): number

    • Parameters

      • a: T
      • b: T

      Returns number

HashFunc

HashFunc: function

Type declaration

    • (obj: any, set: Set<number>): number

    • Parameters

      • obj: any
      • set: Set<number>

      Returns number

IndexedPredicate

IndexedPredicate: function

Type declaration

    • (x: T, i: number): Boolean

    • Parameters

      • x: T
      • i: number

      Returns Boolean

IndexedSelector

IndexedSelector: function

Type declaration

    • (x: T, i: number): TOut

    • Parameters

      • x: T
      • i: number

      Returns TOut

KeyValuePair

KeyValuePair: [TKey, TValue, number]

Variables

Const defaultComparer

defaultComparer: (Anonymous function) = getDefaultComparer()

Const dummy

dummy: any

Const getObjectId

getObjectId: (Anonymous function) = (() => {let currentId = 0const map = new WeakMap<{}, number>()return (object: {}) => {if (!map.has(object)) {map.set(object, currentId)return currentId++}return map.get(object)!}})()

Const hashObject

hashObject: _hashObject = _hashObject

Const identity

identity: (Anonymous function) = getIdentity()

Const primes

primes: number[] = [3,7,11,17,23,29,37,47,59,71,89,107,131,163,197,239,293,353,431,521,631,761,919,1103,1327,1597,1931,2333,2801,3371,4049,4861,5839,7013,8419,10103,12143,14591,17519,21023,25229,30293,36353,43627,52361,62851,75431,90523,108631,130363,156437,187751,225307,270371,324449,389357,467237,560689,672827,807403,968897,1162687,1395263,1674319,2009191,2411033,2893249,3471899,4166287,4999559,5999471,7199369]

Let seed

seed: number = 737245463

Functions

Const _hashObject

  • _hashObject<T>(obj: T, visited: Set<number>, hash: HashFunc): number

aggregate

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

  • Type parameters

    • T

    • TOut

    Parameters

    • this: Enumerable<T>
    • seed: TOut
    • aggFunc: function
        • (prev: TOut, curr: T, idx: number): TOut

        • Parameters

          • prev: TOut
          • curr: T
          • idx: number

          Returns TOut

    Returns TOut

all

any

  • any<T>(this: Enumerable<T>): boolean

append

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

  • Type parameters

    • T

    Parameters

    • this: Enumerable<T>
    • item: T

    Returns Enumerable<T>

average

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

blinq

  • blinq<T>(it: Iterable<T>): Enumerable<T>

  • Type parameters

    • T

    Parameters

    • it: Iterable<T>

    Returns Enumerable<T>

concat

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

  • Type parameters

    • T

    Parameters

    • this: Enumerable<T>
    • Rest ...sequences: Array<Iterable<T>>

    Returns Enumerable<T>

count

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

Const createComparerMap

  • createComparerMap<K, V>(capacity?: number, comparer?: EqualityComparer<K>): Map<K, V>

Const createComparerSet

  • createComparerSet<K>(capacity?: number, comparer?: EqualityComparer<K>): Set<K>

Const createHashTable

Const deepEqual

  • deepEqual(obj1: any, obj2: any): boolean

defaultIfEmpty

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

Const defaultSortMethod

  • defaultSortMethod(a: any, b: any): 0 | 1 | -1

distinct

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

distinctBy

elementAt

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

Const empty

  • empty<T>(): Enumerable<T>

Const entries

  • entries<T, TK, TV, TEntry>(o: T): TEntry[]

  • Type parameters

    • T

    • TK: Extract<keyof T, string>

    • TV: T[TK]

    • TEntry: [TK, TV]

    Parameters

    • o: T

    Returns TEntry[]

except

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

first

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

firstOrDefault

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

flatten

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

  • Type parameters

    • T

    Parameters

    • this: Enumerable<Enumerable<T>>

    Returns Enumerable<T>

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

Const fromGenerator

  • fromGenerator<T>(gen: function): Enumerable<T>

  • Type parameters

    • T

    Parameters

    • gen: function
        • (): Iterable<T>

        • Returns Iterable<T>

    Returns Enumerable<T>

fromIterable

  • fromIterable<T>(value: Iterable<T>): Enumerable<T>

Const fromSingleValue

  • fromSingleValue<T>(value: T): Enumerable<T>

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>

  • Type parameters

    • T

    • TRight

    • TKey

    • TOut

    Parameters

    • this: Enumerable<T>
    • rightSeq: Iterable<TRight>
    • leftKeySelector: IndexedSelector<T, TKey>
    • rightKeySelector: IndexedSelector<TRight, TKey>
    • selector: function
        • (o: Enumerable<T>, v: Enumerable<TRight>, k: TKey): TOut

        • Parameters

          • o: Enumerable<T>
          • v: Enumerable<TRight>
          • k: TKey

          Returns TOut

    • Optional equalityComparer: EqualityComparer<TKey>

    Returns Enumerable<TOut>

fullOuterJoin

  • fullOuterJoin<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>

  • Type parameters

    • T

    • TRight

    • TKey

    • TOut

    Parameters

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

        • Parameters

          • o: T | undefined
          • v: TRight | undefined
          • k: TKey

          Returns TOut

    • Optional equalityComparer: EqualityComparer<TKey>

    Returns Enumerable<TOut>

Const getBucket

  • getBucket<TKey, TValue>(key: TKey, buckets: KeyValuePair<TKey, TValue>[][], __namedParameters: object, create?: boolean): null | Object[]

  • Type parameters

    • TKey

    • TValue

    Parameters

    • key: TKey
    • buckets: KeyValuePair<TKey, TValue>[][]
    • __namedParameters: object
      • getHashCode: function
          • (value: T): number

          • Parameters

            • value: T

            Returns number

    • Default value create: boolean = false

    Returns null | Object[]

getDefaultComparer

  • getDefaultComparer(): (Anonymous function)

getIdentity

  • getIdentity(): (Anonymous function)

groupAdjacent

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

  • Type parameters

    • TSource

    • TKey

    • TElement

    • TResult

    Parameters

    • this: Enumerable<TSource>
    • keySelector: IndexedSelector<TSource, TKey>
    • elementSelector: IndexedSelector<TSource, TElement>
    • resultSelector: function
        • (key: TKey, items: Enumerable<TElement>): TResult

        • Parameters

          • key: TKey
          • items: Enumerable<TElement>

          Returns TResult

    • Optional equalityComparer: EqualityComparer<TKey>

    Returns 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>

  • Type parameters

    • T

    • TInner

    • TKey

    • TOut

    Parameters

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

        • Parameters

          • o: T
          • v: Enumerable<TInner>

          Returns TOut

    • Optional equalityComparer: EqualityComparer<TKey>

    Returns Enumerable<TOut>

Const hash

  • hash(value: any, visited?: Set<number>): number

  • Parameters

    • value: any
    • Optional visited: Set<number>

    Returns number

Const hashBoolean

  • hashBoolean(value: boolean): number

Const hashNumber

  • hashNumber(value: number): number

Const hashSequence

  • hashSequence<T>(items: Iterable<T>, visited: Set<number>, hash: HashFunc): number

Const hashString

  • hashString(value: string): number

Const initializeArrayForCapacity

  • initializeArrayForCapacity<T>(capacity: number): T[]

intersect

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

Const isEqualityComparer

  • isEqualityComparer<T>(obj: any): boolean

Const isIndexedSelector

  • isIndexedSelector<T, TKey>(f: any): boolean

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

Const isValueSelector

  • isValueSelector<T, TValue>(obj: any): 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>

last

lastOrDefault

  • 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>

  • 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 | undefined): TOut

        • Parameters

          • outer: T
          • inner: TInner | undefined

          Returns TOut

    • Optional equalityComparer: EqualityComparer<TKey>

    Returns Enumerable<TOut>

max

maxBy

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

min

minBy

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

minMaxByImpl

  • minMaxByImpl<T, TKey>(src: Iterable<T>, selector: IndexedSelector<T, TKey>, comparer: Comparer<TKey>): Enumerable<T>

Const mod

  • mod(x: number, n: number): number

  • Parameters

    • x: number
    • n: number

    Returns number

orderBy

  • orderBy<T, TCmp>(this: Enumerable<T>, selector: function): OrderedIterable<T>

orderByDescending

  • orderByDescending<T, TCmp>(this: Enumerable<T>, selector: function): OrderedIterable<T>

prepend

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

Const range

  • range(start: number, range: number): Enumerable<number>

Const repeat

  • repeat<T>(item: T, numRepeats: number): Enumerable<T>

Const repeatGenerate

  • repeatGenerate<T>(generator: function, numRepeats: number): Enumerable<T>

  • Type parameters

    • T

    Parameters

    • generator: function
        • (i: number): T

        • Parameters

          • i: number

          Returns T

    • numRepeats: number

    Returns Enumerable<T>

Const resize

  • resize<TKey, TValue>(count: number, buckets: Iterable<KeyValuePair<TKey, TValue>[] | undefined>, __namedParameters: object, hashTableFactory: function): Object[][]

  • Type parameters

    • TKey

    • TValue

    Parameters

    • count: number
    • buckets: Iterable<KeyValuePair<TKey, TValue>[] | undefined>
    • __namedParameters: object
      • equals: function
          • (a: T, b: T): boolean

          • Parameters

            • a: T
            • b: T

            Returns boolean

      • getHashCode: function
          • (value: T): number

          • Parameters

            • value: T

            Returns number

    • hashTableFactory: function

    Returns Object[][]

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

singleOrDefault

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

skip

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

  • Type parameters

    • T

    Parameters

    • this: Enumerable<T>
    • numItems: number

    Returns Enumerable<T>

skipWhile

sum

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

take

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

  • Type parameters

    • T

    Parameters

    • this: Enumerable<T>
    • numItems: number

    Returns Enumerable<T>

takeWhile

toArray

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

toLookup

toMap

Const toSet

union

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

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>>

  • Type parameters

    • TT

    Parameters

    • this: Enumerable<Enumerable<TT>>

    Returns Enumerable<Enumerable<TT>>

Object literals

Const deepEqualityComparer

deepEqualityComparer: object

equals

equals: deepEqual = deepEqual

getHashCode

getHashCode: hash = hash

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