TYNQ - TypeScript-Integrated Query

TYNQ is a port of C# LINQ to compose enumerable sequences using the existing iterator pattern.

TYNQ defines a standard way to interact with any sequence of elements that implements an iterator. Native types that are iterable are patched by importing from the index file @tync/core. Custom types can be patched by using the patchAsEnumerable.

Install TYNQ from npm

npm install @tynq/core

IEnumerator<T>

Defines a standardized way of iterating over a sequence of elements. An Enumerator also implements Iterable<T>, meaning that it can be used by existing elements of the language like for of or the spread ... operator.

Create an enumerator from an existing iterator

1import { Enumerator } from '@tynq/core';
2
3const source = [1, 2, 3];
4const enumerator = new Enumerator(source);
5
6while (enumerator.moveNext()) {
7  console.log(enumerator.current);
8  // 1
9  // 2
10  // 3
11}

IEnumerable<T>

Exposes a generic set of methods that can be used to enumerate a sequence of elements. An IEnumerable<T> only needs to implement a single method, getEnumerator that returns the enumerator for the sequence. Because of language limitations, IEnumerable<T> is an abstract class that needs to be extended when creating a custom type that implements IEnumerable<T>. All native elements are already patched to implement the interface when the package is imported.

1import "@tynq/core";
2
3// Using arrays
4const source = [1, 2, 3];
5const first = source.first(); // 1
6const where = source
7  .where((e) => e > 1)
8  .where((e) => e < 3)
9  .single(); // 2
10
11// Using map
12const source = [
13  { username: "Michael", id: 1 }
14  { username: "Matt", id: 2 },
15  { username: "Ian", id: 3 }
16]
17
18const users = source
19      .where((e) => e.id > 1)
20      .toMap((e) => e.id, (e) => e.username)
21      .skip(1)
22      .count(); // 1

Implementing IEnumerable<T>

In order to implement IEnumerable<T>, the type needs to extend the base IEnumerable<T> class, and implement the getEnumerator method.

1import { Enumerator, IEnumerable } from '@tynq/core';
2
3export interface IList<T> extends IEnumerable<[TKey, TValue]> {
4  add(item: T): void;
5  clear(): void;
6}
7
8export class List<T> extends IEnumerable<T> implements IList<T> {
9  private _list: T[] = [];
10
11  public getEnumerator(): IEnumerator<T> {
12    const listIterator = function* () {
13      for (const element of this._list) {
14        yield element;
15      }
16    };
17
18    return new Enumerator(listIterator);
19  }
20
21  public add(item: T): void {
22    this._list.push(item);
23  }
24
25  public clear(): void {
26    this._list.length = 0;
27  }
28}

Using custom IEnumerable<T>

1import { List } from './list';
2
3const list = new List<number>();
4list.add(1);
5list.add(2);
6list.add(3);
7
8list.count(); // 3
9list.sum(); // 6
10
11list.clear();
12list.count(); // 0
13list.any(); // false