leseq
TypeScript icon, indicating that this package has built-in type declarations

1.11.1 • Public • Published

npm version

Lazy list(lazy list) with high tree-shaking affinity and easy customization.

Features

  • 🎁 Lazy Collection: 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

Advanced

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, asyncSeq} 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]).to(asyncSeq()).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

It is possible to generate sequences (Seq<T>/AsyncSeq<T> object) with Generator, convert them to sequences with different characteristics with To, perform operations such as value conversion and filtering with any number of Operators, and convert them to a single value with Value.

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

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

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

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

Because it is a lazy list, it does not execute processing when pipe()/to() 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 .to(asyncSeq()). but Once the chain is changed to "Async Iterable" by .to(asyncSeq()) 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/To/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

Generator Description
defer Generates a sequence that delays the generation of sources until the actual enumeration is performed. (async version: deferAsAsync )
deferFromPromise [Async Only] Generates a sequence whose values are the result of sequential execution of a single Promise or multiple Promises; Promise execution is delayed until the sequence is enumerated.
deferValue Generates a sequence that delays the generation of the source until the actual enumeration is performed. the source in deferValue consists of a single value. (async version: deferValueAsAsync )
from Generates a sequence from an iterable object. (async version: fromAsAsync )
fromConcat Generates a concatenated sequence of multiple iterable objects. (async version: fromConcatAsAsync )
fromValue Generates a sequence from a single value. (async version: fromValueAsAsync )
range Generates a sequential number sequence. (async version: rangeAsAsync )
zip Generates a sequence of arrays made by concatenating the elements of multiple sequences one at a time. (async version: zipAsAsync )

Predefined To

To Description
async Converts the current sequence to AsyncSeq<T> and returns it.
share Converts the current sequence to SharedSeq<T> and returns it; in a SharedSeq<T>, iterator is share until close method is called. (async version: shareAsync )

Predefined Operators

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

Operator Description
catchError If the original iterable sequence raises an exception, the specified action is performed, terminating the enumeration or enumerating an alternate sequence. (async version: catchErrorAsync )
chunk Returns a sequence divided into array of the specified size. (async version: chunkAsync )
concat Returns a sequence in which the current sequence and the specified sequence are concatenated. (async version: concatAsync )
concatValue Returns the sequence to which the specified value is added. (async version: concatValueAsync )
difference Returns the sequence that is the difference set between the current sequence and the specified sequence. (async version: differenceAsync )
filter Returns a sequence that has been filtered by the specified condition. (async version: filterAsync )
finalize Invokes a specified action after the source iterable sequence terminates normally or exceptionally. (async version: finalizeAsync )
flatten Returns a flattened sequence. (async version: flattenAsync )
groupBy Returns a sequence grouped by a specified key. (async version: groupByAsync )
intersect Returns a sequence that is the product set of the current sequence and the specified sequence. (async version: intersectAsync )
map Returns the sequence in which each element has been transformed by the specified transformation function. (async version: mapAsync )
orderBy Returns a sequence sorted by a specified key. (async version: orderByAsync )
repeat Returns a sequence that repeats the source sequence a specified number of times. (async version: repeatAsync )
reverse Returns a sequence in reverse order of the current sequence. (async version: reverseAsync )
scan Returns the resulting sequence after applying the aggregate function to the elements of the current sequence. (async version: scanAsync )
skip Returns the sequence with the specified number of skips. (async version: skipAsync )
skipWhile Returns the sequence of elements skipped while matching the condition. (async version: skipWhileAsync )
take Returns a sequence that enumerates the specified number of items. (async version: takeAsync )
takeWhile Returns a sequence to be enumerated only while the condition is matched. (async version: takeWhileAsync )
tap Run side effects. (async version: tapAsync )
union Returns a sequence that is the union set of the current sequence and the specified sequence. (async version: unionAsync )
uniq Returns a deduplicated sequence. (async version: uniqAsync )
zipWith Returns a sequence of arrays consisting of the elements of the source array and the elements of the multiple sequences given as arguments, concatenated one by one. (async version: zipWithAsync )

Predefined Values

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

Value Description
every Returns whether or not all elements of a sequence meet the specified conditions. (async version: everyAsync )
find Returns the first element that satisfies the condition. If no element satisfying the condition is found, an error is thrown. (async version: findAsync )
findOrDefault Returns the first element that satisfies the condition. If no element is found that satisfies the condition, it returns the specified default value. (async version: findOrDefaultAsync )
reduce Returns the result of applying the aggregate function to the elements of the current sequence. (async version: reduceAsync )
some Returns whether or not any element of the sequence satisfies the specified condition. (async version: someAsync )

Package Sidebar

Install

npm i leseq

Weekly Downloads

168

Version

1.11.1

License

MIT

Unpacked Size

548 kB

Total Files

306

Last publish

Collaborators

  • ugaya40