async-lazy-list

This is a Typescript implementation of lazy lists that supports asynchronously generated elements as well as asynchronous functions as arguments to map, filter, etc.

Laziness in the context of lists has two meanings, by default these lists are lazy in the sense that they do not evaluate the function that creates their elements until those elements are required. The other type of laziness means that once an element has been evaluated, it will not be evaluated again if it is subsequently requested. This type of laziness is enabled on these lists by calling the AsyncLazyList#cached() function.

The Benefits of Laziness

Laziness allows the creation of infinite lists. For example AsyncLazyList has a generator built in to create a list of all the integers starting at a given number. For example:

AsyncLazyList.integers(3);

The integers starting at 0 (the natural numbers) are a special case of this that exists as the property AsyncLazyList#naturals.

On their own, these properties are not that useful as there are few practical uses for infinitely long lists, but they can be manipulated in various ways. For example, if you had a function isPrime that returned true when a number passed to it was prime, you could get a list of the squares of all the prime numbers as follows:

AsyncLazyList.naturals.filter(isPrime).map((x) => x * x);

If you then wanted to know just the square of the tenth prime number, you could skip the first 9 and retrieve the first element of the remaining (still infinite) list.

await AsyncLazyList.naturals.filter(isPrime).map((x) => x * x).skip(9).head;

Because the list could, in general, be asynchronous, you need to use await when performing an operation or retrieving a property (such as AsyncLazyList#head) that returns a real value (as opposed to another AsyncLazyList).