Lazy evaluation list with high tree-shaking affinity and easy customization.

Features

• 🎁 Lazy Evaluation: The collections are only enumerated to the minimum necessary. Infinite sequences are supported.
• 🎄 Tree-Shakeable: Only the features you use will be bundled.
• 👻 Async Iterator Support: Iterable can also be seamlessly treated as Async Iterator.
• 📎 Easy-Customization: You can easily create the functions you need by yourself. In this way.
• 🗂 Rxjs-like Syntax: To achieve tree-shaking, we use an rxjs-like syntax.
• ✅ Simple Equality Strategy: It uses a simple Equality Strategy.
• 💯 All Typed: The whole thing is written in TypeScript, which also provides completion for type conversion between operators.
• 💨 No dependencies

import {from, map, take} from 'leseq';

const result1 = from([1,2,3,4,5]).pipe(
  map(i => i * i),
  take(3)
).toArray();

//result1: [1,4,9]

This is the result of bundle visualizer in the example above (1.21KB gzipped).

Resource

• Demo(StackBlitz)

• Docs

Advanced

• Create Original Functions

• Equality Strategy

• Finalization, and Resource Management

Getting Started

npm install leseq

If you are using Async Iterable and "target " in tsconfig.json is smaller than "es2018", you must add "ES2018.AsyncGenerator " and "ES2018.AsyncIterable " in tsconfig.json/lib or the type will not display properly.

{
  "compilerOptions": {
    "target": "es6",
    "lib": ["DOM", "ES6", "ES2018.AsyncGenerator", "ES2018.AsyncIterable"]
  }
}

Iterable

import {from, map, take, find, range, reverse, filter} from 'leseq';

const result1 = from([1,2,3,4,5]).pipe(
  map(i => i * i),
  take(3)
)

for (const one of result1) {
  console.log(one)
}

//result: 1
//result: 4
//result: 9

const result2 = from([1,2,3,4,5]).pipe(
  filter(i => i % 2 == 0)
).value(
  find(i => i > 2)
);

//result2: 4

//lazy
const result3 = range(1, 10000000).pipe(
  take(3),
  reverse(),
  map((i) => i * i)
).toArray();

//result3: [9,4,1]

Async Iterable

import {from, mapAsync, filterAsync, fromAsAsync, findAsync, toAsync} from 'leseq';

const sleep = (milliseconds: number) => new Promise(resolve => setTimeout(resolve,milliseconds));

//from iterable to async iterable.
const result1 = await from([1,2,3,4,5]).value(toAsync()).pipe(
  mapAsync(async i => {
    await sleep(1000);
    return i * i;
  }),
  filterAsync(async i => i % 2 == 0)
).toArrayAsync();

//5 seconds later... result1: [4,16]

const result2 = await fromAsAsync([1,2,3,4,5]).pipe(
  mapAsync(async i => {
    await sleep(1000);
    return i * i;
  }),
  filterAsync(async i => i % 2 == 0)
).valueAsync(findAsync());

//2 seconds later... result2: 4

const result3 = await fromConcatAsAsync([1,2],[3,4]).pipe(
  mapAsync(async i => {
    await sleep(1000);
    return i * i;
  }),
);

for await (const one of result3) {
  console.log(one);
}

//1 seconds later... result: 1
//2 seconds later... result: 4
//3 seconds later... result: 9
//4 seconds later... result: 16

Usage

You can generate a sequence(Seq<T>/AsyncSeq<T> object) with Generator, perform transformations and other operations with any number of Operators, and convert it to a value with Value.

// sync iterator
SyncSource = 
  Generators(ex: from, fromConcat, ..etc) | 
  SyncSource.pipe(
    ...SyncOperators(ex: map, filter, ...etc)
  );

value = SyncSource.value(SyncValues(ex: find,some, ...etc));

// async iterator
AsyncSource = 
  AsyncGenerators(ex: fromAsAsync, fromConcatAsAsync, ...etc) |
  SyncSource.value(toAsync()) | // iterable to async iterable.
  AsyncSource.pipe(
    ...AsyncOperators(ex: mapAsync, filterAsync, ...etc)
  );

value = await AsyncSource.valueAsync(AsyncValues(ex: findAsync,someAsync, ...etc));

Since lazy evaluation is employed, the process is not executed when pipe() is called, but only when value(valueAsync), toArray(toArrayAsync)/toMutableArray(toMutableArrayAsync), or forEach(forEachAsync) is called.

Changes from "Iterable" or Seq<T> to "Async Iterable" can be made at any time with .value(toAsync()). but Once the chain is changed to "Async Iterable" by .value(toAsync()) or other means, only the asynchronous version of Operator/Value can be used in the same chain thereafter. This is because, in principle, it is impossible to change from an "Async Iterable" to "Iterable".

The predefined Generators/Operators/Values are as follows. And all of them have asynchronous versions(xxxAsAsync or xxxAsync).

If the function you want to use does not exist, you can also define your own Operator/Value function in this way.

Predefined Generators

Predefined Operators

It is used within the pipe method of the Seq<T> object. Any number of operators can be connected.

Predefined Values

Generates a value from a sequence. Used in the value method of the Seq<T> object.