A composition library for simple, straightforward serialized and parallelized processes blending synchronous and asynchronous behaviors.
Serial composition is done with monasync.binding.serial which has the signature,
function+ => function, [function] => [*+] => undefined
. It's simple to compose functions together this way:
var serialComposition = monasync.binding.serial(
asyncFn1,
asyncFn2,
asyncFn3
);
serialComposition(success, fail)(arg1, arg2, arg3);
// Composed functions are also composable:
var composedComposition = monasync.binding.serial(
serialComposition,
asyncFn4,
asyncFn5
);
Parallel executing behaviors is done with monasync.binding.parallel which has the signature,
function+ => function, [function] => [*+] => undefined
. It's simple to compose functions together this way:
var parallelComposition = monasync.binding.parallel(
asyncTypedFn1,
asyncTypedFn2,
asyncTypedFn3
);
parallelComposition(success, fail)(arg1, arg2, arg3);
// Binding multiple parallel behaviors together is simple:
var composedComposition = monasync.binding.parallel(
serialComposition,
asyncTypedFn4,
asyncTypedFn5
);
The async typed function is simply a function which has the following signature,
function, [function] => [*+] => undefined
where the first function is a success function,
the second, optional, function is a failure function.
This means, the async typed function accepts a function and an optional second function, returns a function which takes any number of optional arguments and returns undefined. A standard call example is like the following:
myAsyncBehavior(success, failure)(arg1, arg2);
It's common in Node and client-side Javascript to write functions which take callbacks as a final argument. Monasync has a function to do a function type-cast to convert your standard callback accepting function into an composable async typed function. Monatype does this by decorating your function, but you can easily write async typed functions yourself if you like.
Wrap is the method for wrapping asynchronous, callback-accepting functions in an async function
type where the signature is as follows: function => function, [function] => [*+] => undefined
.
An example is as follows:
function myAsynchronousFn (callback) {};
var myNewFn = monasync.async.wrap(myAsynchronousFn);
myNewFn(success, failure)(arg1, arg2);
Serialize returns an async-typed function which serializes a set of callback-accepting asynchronous
functions. The signature for serialize is function+ => function, [function] => [*+] => undefined
. This is
the analog to binding.serial.
function myAsyncFunction (callback) { /* does stuff and calls back */ };
var myNewFunction = monasync.async.serialize(
myAsyncFunction,
myAsyncFunction,
myAsyncFunction,
myAsyncFunction
);
myNewFunction(success, failure)(arg1, arg2);
Serialize returns an async-typed function which parallelizes a set of callback-accepting asynchronous
functions. The signature for parallelize is function+ => function, [function] => [*+] => undefined
. This is
the analog to binding.parallel.
function myAsyncFunction (callback) { /* does stuff and calls back */ };
var myNewFunction = monasync.async.parallelize(
myAsyncFunction,
myAsyncFunction,
myAsyncFunction,
myAsyncFunction
);
myNewFunction(success, failure)(arg1, arg2);
It's possible to partially apply arguments to async typed functions with the partial method. Partial will apply arguments and return a new async typed function.
var asyncAdd = monasync.sync.wrap(function (a, b) { return a + b; });
var asyncAdd3 = asyncAdd.partial(3);
asyncAdd3(function (value){
console.log(value); // 11
})(8);
Functions which are simple, data-in, data-out type behaviors can be wrapped to conform to the async function type. They can also be converted to a simple asynchronous function which accepts a callback. These behaviors are detailed below.
This wraps a synchronous function in a simple callback-accepting wrapper. This allows sync
and async behaviors to play together more directly. The signature for this function looks
like this: function => [*+], function => undefined
. The toAsync function is used as follows:
function myFunction (a, b) { /* do stuff and return */ }
var myAsyncFunction = monasync.sync.toAsync(myFunction);
myAsyncFunction(arg1, arg2, callback);
This wraps a synchronous function in an async typed function. This allows sync
and async behaviors to play together more directly. The signature for this function looks
like this: function => function, [function] => [*+] => undefined
. The toAsync function
is used as follows:
function myFunction (a, b) { /* do stuff and return */ }
var myAsyncFunction = monasync.sync.toAsync(myFunction);
myAsyncFunction(arg1, arg2, callback);
Here's an example of using multiple monasync functions together to create a complex composite behavior:
var parallelComposition = monasync.binding.parallel(
asyncTypedFn,
monasync.async.wrap(asyncFn),
);
var serialComposition = monasync.binding.serial(
parallelComposition,
asyncTypedFn1,
monasync.sync.wrap(intermediateTransformation),
asyncTypedFn2
);
serialComposition(success, fail)(arg1, arg2);