Following user feedback I've added some key "lodash" like functions to the out of the box features of js-coroutines.

I've added keyByAsync groupByAsync, includesAsync, uniqueByAsync. Here are all of the "out of the box" functions now available. They all work asynchronously, spreading the load over multiple frames to ensure that your app stays interactive.

Function	Use
`appendAsync`	Appends an array to another one, modifying the destination
`compressAsync`	Compresses a string using lz-string. All of the other lz-string methods are also available.
`concatAsync`	Concatenates two arrays creating a new one
`decompressAsync`	Decompresses a string compressed with lz-string
`everyAsync`	Validates that every member of a collection passes a predicate
`findAsync`	Finds an entry which passes a predicate function in a collection or null
`findIndexAsync`	Finds the first index which passes a predicate
`forEachAsync`	Calls a function for every element in a collection.
`groupByAsync`	Creates an index object where each key contains an array of all matching values
`includesAsync`	Returns true if an array includes a value
`indexOfAsync`	Returns the first index of an item in a collection
`keyByAsync`	Creates an index object where each key is the last item in a collection to generate the key
`lastIndexOfAsync`	Returns the last index of an item in a collection
`mapAsync`	Runs a mapping function against each element of an array and returns a new array with the results
`parseAsync`	Parses JSON into an object or value
`reduceAsync`	Runs a reduce operation on all elements of a collection and returns the result
`someAsync`	Checks if some entries in a collection match a predicate
`stringifyAsync`	Converts a JavaScript object/value into JSON
`uniqueByAsync`	Creates an array of unique values. The value determining uniqueness is produced by calling a function with the array entry.

You can now execute code like this:

     const response = await fetch("some/url")
     const data = await parseAsync(response.text())
     const index = await keyByAsync(data, v=>v.id)
     const groups = await groupByAsync(data, v=>v.category)

Of course, you can also write your own generator functions to split up any kind of processing you might need to do - and all of these functions work with the new pipe() to create functional pipelines that don't hog the main thread.


     const process = pipe(
       decompressAsync,
       parseAsync,
       keyByAsync.with(v=>v.id)
     )

Another new feature is support for "collections" where we can use objects with key value pairs as well as arrays with all of the key functions that make sense (in the table above these are shown as handling 'collection' parameters).

js-coroutines gives your code: data indexing and lookup functionality, in idle time