Bond

Create a new Bond which represents the array of many objects' representative values.

This object will be ready if and only if all objects in list are themselves ready.

Example:

let b = new Bond;
let c = new Bond;
let t = Bond.all([b, c]);
t.tie(console.log);
b.changed(42);
c.changed(69); // logs [42, 69]
b.changed(3); // logs [3, 69]

let b = new Bond;
let c = new Bond;
let t = Bond.all(['a', {b, c}, 'd'], 2);
t.tie(console.log);
b.changed(42);
c.changed(69); // logs ['a', {b: 42, c: 69}, 'd']
b.changed(null); // logs ['a', {b: null, c: 69}, 'd']

Duck-typed alternative to instanceof Bond, when multiple instantiations of Bond may be available.

Create a new Bond which represents a functional transformation of many objects' representative values.

Example:

let b = new Bond;
b.changed(23);
let c = new Bond;
c.changed(3);
let multiply = (x, y) => x * y;
// These two are exactly equivalent:
let bc = Bond.all([b, c]).map(([b, c]) => multiply(b, c));
let bc2 = Bond.mapAll([b, c], multiply);

Create a Promise which represents one or more Bonds.

Example:

let b = new Bond;
let p = Bond.promise([b, 42])
p.then(console.log);
b.changed(69); // logs [69, 42]
b.changed(42); // nothing.

Constructs a new Bond object whose value is not ready.

Makes the object ready and sets its current value.

Any functions that are registered for notification (see Bond#notify) or are tied (see Bond#tie) will be called if this Bond is not currently ready or is ready but has a different value.

This function is a no-op if the JSON representations of v and of the current value, if any, are equal.

Provide a Bond which represents the same as this object except that it takes a particular value when this would be unready.

Alters this object so that it is always ready.

If this object is ever Bond#reset, then it will be changed to the value given.

Example:

let x = (new Bond).defaultTo(42);
x.log();	// 42
x.changed(69);
x.log();	// 69
x.reset();
x.log() // 42

Register a function to be called when this object becomes done.

For an object to be considered done, it must be ready and the function Bond#isDone should exist and return true.

If the object is already done, then f will be called immediately. If not, f will be deferred until the object assumes a value. f will be called at most once.

Example:

let x = new Bond;
x.then(console.log);
x.changed(42); // 42 is written to the console.

Unregister a single dependency for this object.

Notes that a previously registered dependency has since expired. Must be called exactly once for each time Bond#use was called.

Determine if there is a definite value that this object represents at present.

Provide a derivative Bond which represents the same as this object except that before it is ready it evaluates to a given default value and after it becomes ready for the first time it stays fixed to that value indefinitely.

Logs the current value to the console.

Make a new Bond which is the functional transformation of this object.

Example:

let b = new Bond;
let t = b.map(_ => _ * 2);
t.tie(console.log);
b.changed(21); // logs 42
b.changed(34.5); // logs 69

let b = new Bond;
let t = b.map(_ => { let r = new Bond; r.changed(_ * 2); return r; });
t.tie(console.log);
b.changed(21); // logs 42
b.changed(34.5); // logs 69

let b = new Bond;
let t = b.map(_ => { let r = new Bond; r.changed(_ * 2); return [r]; }, 1);
t.tie(console.log);
b.changed(21); // logs [42]
b.changed(34.5); // logs [69]

Create a new Bond which represents this object's array value with its elements transformed by a function.

Example:

let b = new Bond;
let t = b.mapEach(_ => _ * 2);
t.tie(console.log);
b.changed([1, 2, 3]); // logs [2, 4, 6]
b.changed([21]); // logs [42]

Maps the represented value to a string.

Convenience function for the logical negation of Bond#ready.

Example:

// These two expressions are exactly equivalent:
bond.notReady();
bond.ready().map(_ => !_);

Register a function to be called when the value or the readiness changes.

Calling this function already implies calling Bond#use - there is no need to call both.

Use this only when you need to be notified should the object be reset to a not ready state. In general you will want to use Bond#tie instead.

Provide a Bond which represents whether this object itself represents a particular value.

Lazily transforms the contents of this object's value when it is an array.

This operates on a Bond which should represent an array. It transforms this into a value based on a number of elements at the beginning of that array using a recursive reduce algorithm.

The reduce algorithm works around an accumulator model. It begins with the init value, and incremenetally accumulates elements from the array by changing its value to one returned from the accum function, when passed the current accumulator and the next value from the array. The accum function may return a Bond, in which case it will be resolved (using Bond#then) and that value used.

The accum function returns a value (or a Bond which resolves to a value) of an array with exactly two elements; the first is the new value for the accumulator. The second is a boolean early exit flag.

Accumulation will continue until either there are no more elements in the array to be processed, or until the early exit flag is true, which ever happens first.

Resets the state of this Bond into being not ready.

Any functions that are registered for notification (see Bond#notify) will be called if this Bond is currently ready.

Create a new Bond which represents this object's value when subscripted.

Example:

let b = new Bond;
let t = b.sub('foo');
t.tie(console.log);
b.changed({foo: 42}); // logs 42
b.changed({foo: 69}); // logs 69

let b = new Bond;
let c = new Bond;
let t = b.sub(c);
t.tie(console.log);
b.changed([42, 4, 2]);
c.changed(0); // logs 42
c.changed(1); // logs 4
b.changed([68, 69, 70]); // logs 69

Provides a transparently subscriptable version of this object.

The object that is returned from this function is a convenience Proxy which acts exactly equivalent to the original Bond, except that any subscripting of fields that are not members of the Bond object will create a new Bond that itself evaluates to this Bond's value when subscripted with the same field.

Example:

let x = (new Bond).subscriptable();
let y = x.foo;
y.log(); // nothing yet
x.changed({foo: 42, bar: 69});	// logs 42

Register a function to be called when this object becomes ready.

For an object to be considered ready, it must represent a definite value. In this case, Bond#isReady will return true.

If the object is already ready, then f will be called immediately. If not, f will be deferred until the object assumes a value. f will be called at most once.

Example:

let x = new Bond;
x.then(console.log);
x.changed(42); // 42 is written to the console.

Register a function to be called when the value changes.

Calling this function already implies calling Bond#use - there is no need to call both.

Unlike Bond#notify, this does not get called should the object become reset into being not ready.

Makes the object ready and sets its current value.

Any functions that are registered for notification (see Bond#notify) or are tied (see Bond#tie) will be called if this Bond is not currently ready or is ready but has a different value.

Unlike Bond#changed, this function doesn't check equivalence between the new value and the current value.

Unregister a function previously registered with Bond#notify.

Calling this function already implies calling Bond#drop - there is no need to call both.

Unregister a function previously registered with Bond#tie.

Calling this function already implies calling Bond#drop - there is no need to call both.

Register a single dependency for this object.

Notes that the object's value is in use, and that it should be computed. Bond sub-classes are allowed to not work properly unless there is at least one dependency registered.

See:

• Bond#initialise, Bond#finalise.

Just like map, except that it defaults to no latching and mayBeNull.

Uninitialise the object.

Will be called at most once after an accompanying Bond#initialise and should close/finalise/drop any resources that are required for the sub-class to maintain its value.

Initialise the object.

Will be called at most once before an accompanying Bond#finalise and should initialise/open/create any resources that are required for the sub-class to maintain its value.

Returns whether the object is currently in a terminal state.

WARNING: The output of this function should not change outside of a value change. If it ever changes without the value changing, trigger should be called to force an update.

See:

• Bond#done