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

don't block

async-utils is designed to work with the new 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

checksum(...input) ⇒ string

compute a the checksum of a javascript object.

Kind: global method of checksum

Param Type Description
...input *

any javascript object

forEach

forEach(collection, fn) ⏏

Kind: global method of forEach

Param Type
collection array
fn function

matchCase

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
  }
)

Kind: global method of matchCase

memoize

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.

Kind: global method of memoize
Returns: function -

cache instance


See: checksum

Param Type Default 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

microTask(fn) ⏏

schedule a task to run on nextTick

Kind: global method of microTask

Param Type
fn function

pipe

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

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

Queue ⏏

Kind: global class of Queue

to

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
}

Kind: global method of to
See: module:matchCase