Effectuality self-tests

input01: 7 output01:
input02: 7 output02: input02: 7
input03: 7 output03: input03 * 2: 14
input04: 7 output04: input04 * 10 + input04 * input04: 96.6
input05: 1 output05: input05 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2: 1024
input06: 1 output06: input06 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2: 1024
input07: 6 output07: input07 * 10 + input07 * input07 + input07 / 10: 96.6
input08: 6 output08: input08 * input08 + input08: 42
input09: 6 output09: 75
input10: 6 output10: input10 * 10 + input10 * input10 + input10 / 10: 96.6
input11: 6 output11: PretechEnergy
input13: 6 output13: AtlasIntercom
input14: 6 output14: 75
input15: 6 output15: 51
input16: 6 output16: 15.6
input17: 6 output17: 51
input18: 6 output18: 75
input19: 6 output19: 51
input20: 6 output20: 15.6
input31: 1 output31: 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024
input32: 1 output32: 1, 2, 4, 8, 16, 32, 64, 128, 256, 512
input33: 1 output33: 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024
input34: 1 output34: 1, 2, 4, 8, 16, 32, 64, 128, 256, 512
input41: 6 output41: 0, 6000, 12000, 18000, 24000, 30000, 36000, 42000, 48000
input42: 6 output42: 0, 12000, 24000, 36000, 48000
input50: 2 output50: input50 * 6: 12
input51: 3 output51: input51 * 7: 21
input52: 2 output52: input52 * 10: 20
input53: 3 output53: input53 * 10: 30
input54: 2 output54: 2, 7, 9, 12, 16, 17, 23, 22, 30
input55: 3 output55: 3, 8, 10, 13, 17, 18, 24, 23, 31
input56: 2 output56: 2, 7, 9, 12, 16, 17, 23, 22, 30
input57: 3 output57: 3, 8, 10, 13, 17, 18, 24, 23, 31
input58: 2 output58: 2, 12, 22, 32, 42, 52, 62, 72, 82, 92
input59: 3 output59: 3, 13, 23, 33, 43, 53, 63, 73, 83, 93
input60: 2 output60: input60 * 6: 12
input61: 3 output61: input61 * 7: 21
input70: 6 output70: input70 * 7: 42
input71: 6 output71: input71 * 7: 42
input72: 6 output72: input72 * 7: 42
input73: 6 output73: input73 * 7: 42

Effectuality sample

input
asynchronous output (3 second delay): input * input
run sample

Sample source: // the output of a 3 second delay square of the input (output)(square)(delay)(input)

Implementation of an HTML input side-effect Effectuality: // input: Effectuality (((String, u1, u2, ...) -> ()) -> ((u1, u2, ...) -> ())) const input = effectuality(function implication(effect){ // effect: (String, u1, u2, ...) -> () // cause: (u1, u2, ...) -> () return function cause(...x){ const element = document.getElementById("sample-input"); const value = element? element.value: ""; effect(value, ...x); }; });

Implementation of an HTML output side-effect Effectuality: // output: Effectuality (((String, u1, u2, ...) -> ()) -> ((String, u1, u2, ...) -> ())) const output = effectuality(function implication(effect){ // effect: (String, u1, u2, ...) -> () // cause: (String, u1, u2, ...) -> () return function cause(value, ...x){ const element = document.getElementById("sample-output"); if (element){ element.value = value; } effect(value, ...x); }; });

Implementation of an asynchronous 3 second delay side-effect Effectuality: // delay: Effectuality (((u1, u2, ...) -> ()) -> ((u1, u2, ...) -> ())) const delay = effectuality(function implication(effect){ // effect: (u1, u2, ...) -> () // cause: (u1, u2, ...) -> () return function cause(...x){ setTimeout(function(){ return effect(...x); }, 3000); }; });

Implementation of a square pure function Effectuality: // square: Effectuality (((Number, Number, u1, u2, ...) -> ()) -> ((Number, u1, u2, ...) -> ())) const square = effectuality(function implication(effect){ // effect: (Number, Number, u1, u2, ...) -> () // cause: (Number, u1, u2, ...) -> () return function cause(value, ...x){ return effect(value * value, value, ...x); }; });

Effectuality core implementation: the Effectuality function returns the effectuality functional type constructor:

Framework core implementation: the execution function executes an Effectuality defined by the application: // safe access to the effectuality encapulation by the framework let decryption; function decryption1(decryptionEffectuality){ // private decryption = undefined; // unpure decryptionEffectuality(encryption); return decryption; } function decryption2(decryptionImplication){ // private decryption = decryptionImplication; // unpure } function encryption(){ // public } // Effectuality definition const effectuality = Effectuality(encryption, decryption1, decryption2); // interpretation: Efectuality (((t1, t2, ...) -> ()) -> ((s1, s2, ...) -> ())) -> ((s1, s2, ...) -> ()) function interpretation(interpretationEffectuality){ return function(...x){ // implication: ((t1, t2, ...) -> ()) -> ((s1, s2, ...) -> ()) const implication = decryption1(interpretationEffectuality); if (implication !== undefined){ const probe = []; let count = 0; const cause = implication(function effect(...y){ if (++count > 1){ console.error("Effectuality error: an effect should not be called more than once: " + count); } if (y[y.length - 1] !== probe){ console.error("Effectuality error: cause arguments should be passed to the effect: " + y); } }); return cause(...x, probe); } }; } // execution: (s1, s2, ...) -> () const execution = interpretation(effectuality1);