@relax/async-utils

@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

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
  • Memoize([identity]) ⇒ function ⏏
    • ~memoize(fn, args, ttl)
      • .clear(cacheGroup)

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