* It should generally be avoided in favour of {@link listen(Handler)} so you don't * miss any updates, but in many circumstances it makes sense. *
* NOTE: In the Java and other versions of Sodium, using sample() inside map(), filter() and * merge() is encouraged. In the Javascript/Typescript version, not so much, for the * following reason: The memory management is different in the Javascript version, and this * requires us to track all dependencies. In order for the use of sample() inside * a closure to be correct, the cell that was sample()d inside the closure would have to be * declared explicitly using the helpers lambda1(), lambda2(), etc. Because this is * something that can be got wrong, we don't encourage this kind of use of sample() in * Javascript. Better and simpler to use snapshot(). *
* NOTE: If you need to sample() a cell, you have to make sure it's "alive" in terms of
* memory management or it will ignore updates. To make a cell work correctly
* with sample(), you have to ensure that it's being used. One way to guarantee this is
* to register a dummy listener on the cell. It will also work to have it referenced
* by something that is ultimately being listened to.
*/
sample() : A {
return Transaction.run(() => { return this.sampleNoTrans__(); });
}
sampleNoTrans__() : A { // TO DO figure out how to hide this
return this.value;
}
/**
* A variant of {@link sample()} that works with {@link CellLoop}s when they haven't been looped yet.
* It should be used in any code that's general enough that it could be passed a {@link CellLoop}.
* @see Stream#holdLazy(Lazy) Stream.holdLazy()
*/
sampleLazy() : Lazy {
const me = this;
return Transaction.run(() => me.sampleLazyNoTrans__());
}
sampleLazyNoTrans__() : Lazy { // TO DO figure out how to hide this
const me = this,
s = new LazySample(me);
Transaction.currentTransaction.sample(() => {
s.value = me.valueUpdate != null ? me.valueUpdate : me.sampleNoTrans__();
s.hasValue = true;
s.cell = null;
});
return new Lazy(() => {
if (s.hasValue)
return s.value;
else
return s.cell.sample();
});
}
/**
* Transform the cell's value according to the supplied function, so the returned Cell
* always reflects the value of the function applied to the input Cell's value.
* @param f Function to apply to convert the values. It must be referentially transparent.
*/
map(f : ((a : A) => B) | Lambda1