@relax/async-utils(1) -- async implementations of common utility functions

don't block

async-utils is designed to work with the async syntax to allow you to write non-blocking
code that looks synchronous. functions like Array.prototype.map() are very useful, but
operating over large collections will always block. async-utils rethinks a full range of
useful tools to work with the event loop rather than against it.

contributors welcome! please email a patch or pull request to a
maintainer and we'll get your changes merged as quickly as possible.

Modules

checksum

forEach

matchCase

memoize

microTask

pipe

Queue

to

Classes

Queue ⏏

Functions

checksum(...input) ⇒ string ⏏

compute a the checksum of a javascript object.

forEach(collection, fn) ⏏

map(collection, fn) ⏏

matchCase() ⏏

type-directed pattern matching. compares input with the given types via
instanceof.

const [err, result] = await to(myAsyncFn())
cosnt returnValue = matchCase(err,
  [TypeError, () => {
    // handle TypeError
  }],
  [HttpError, () => {
    // handle HttpError
  }],
  () => {
    // ifNoneMatch, handle result
  }
)

Memoize([identity]) ⇒ function ⏏

cache namespace cosntructor
the passed identity function is used to track which function made a
particular call so it can be associated with the cache. by default, memoize
uses the included checksum function.

microTask(fn) ⏏

schedule a task to run on nextTick

pipe(predicate, fns) ⇒ Promise.<any> ⏏

execute a chain of async operations using the return value of each function
as the argument for the next

to() ⏏

simplify error checking for async processes. promotes shorter code with
explicit error handling up front.

const [err, result] = await to(myAsyncFn())
if (err) {
  // handle error
} else {
  // happy path
}

compared to the usual try..catch approach. these are simple contrived
examples, but in complex async processes the resulting code is typically
more linear, with less nested branches compared to the typical approach.
we give up the narrow error handling scope and handling errors is always
deferred until later by the grammar.

try {
  const result = await myAsyncFn()
  // happy path
} catch (err) {
  // handle error
}

checksum

$3

compute a the checksum of a javascript object.

Kind: global method of checksum

| Param | Type | Description |
| --- | --- | --- |
| ...input | \* |

any javascript object

|

forEach

$3

Kind: global method of forEach

| Param | Type |
| --- | --- |
| collection | array |
| fn | function |

matchCase

$3

type-directed pattern matching. compares input with the given types via
instanceof.

const [err, result] = await to(myAsyncFn())
cosnt returnValue = matchCase(err,
  [TypeError, () => {
    // handle TypeError
  }],
  [HttpError, () => {
    // handle HttpError
  }],
  () => {
    // ifNoneMatch, handle result
  }
)

Kind: global method of matchCase

memoize

* memoize
* [Memoize([identity])](#exp_module_memoize--Memoize) ⇒ function ⏏
* ~memoize(fn, args, ttl)
* .clear(cacheGroup)

$3

cache namespace cosntructor
the passed identity function is used to track which function made a
particular call so it can be associated with the cache. by default, memoize
uses the included checksum function.

Kind: global method of memoize
Returns: function -

cache instance

See: checksum

| Param | Type | Description |
| --- | --- | --- |
| [identity] | function |

optional identity function

|

#### Memoize~memoize(fn, args, ttl)

cache the result of a function call in memory.

Kind: inner method of Memoize

| Param | Type | Description |
| --- | --- | --- |
| fn | function |

the function that is being memoized

|
| args | array |

arguments that should be passed into fn

|
| ttl | number \| Object |

time to live value and cache group

|

##### memoize.clear(cacheGroup)

evict a group of cached objects

Kind: static method of memoize

| Param | Type |
| --- | --- |
| cacheGroup | string |

microTask

$3

schedule a task to run on nextTick

Kind: global method of microTask

| Param | Type |
| --- | --- |
| fn | function |

pipe

$3

execute a chain of async operations using the return value of each function
as the argument for the next

Kind: global method of pipe

| Param | Type |
| --- | --- |
| predicate | any |
| fns | Array.<function(value)> |

Queue

$3

Kind: global class of Queue

to

$3

simplify error checking for async processes. promotes shorter code with
explicit error handling up front.

const [err, result] = await to(myAsyncFn())
if (err) {
  // handle error
} else {
  // happy path
}

compared to the usual try..catch approach. these are simple contrived
examples, but in complex async processes the resulting code is typically
more linear, with less nested branches compared to the typical approach.
we give up the narrow error handling scope and handling errors is always
deferred until later by the grammar.

try {
  const result = await myAsyncFn()
  // happy path
} catch (err) {
  // handle error
}

Kind: global method of to
See: module:matchCase