| // (Tested on Node.js 18.15.0) A promise implementation that is A+ conformant | |
| // To implement something promise-ish (ignoring all edge-cases from A+ spec), there are some guidelines below: | |
| // - manage the state of promise object, to avoid transition between two settled state | |
| // - use 'then' method to store callbacks for resolving / rejecting the promise. | |
| // - implement 3 kinds of chaining behaviors of a promise | |
| // - when resolving a promise, recursively unwrap until a non-thenable value is found | |
| // - a promise can invoke then (to add callbacks) multiple times. When the promise is settled, all cbs should be invoked sequentially | |
| // - the propagation of promise chain | |
| // warn: this does not check if val.then is a function |
| function apiReq(result, delay) { | |
| return new Promise(resolve => { | |
| setTimeout(() => { | |
| resolve(result) | |
| }, delay*1000) | |
| }) | |
| } | |
| // the generator function version of async-await programming scheme | |
| // function* -> async |
| /* | |
| * a function that parses LISP like expression into AST | |
| * the CFG will be like | |
| * C = ( op args ) --- an expression is enclosed in a parenthesis, with 'op' as head, and 'args' as tail | |
| * args = arg* --- an args (argument list) contains zero or variadic-length arguments | |
| * arg => num | C --- an arg is either a num or an expression | |
| * op = +|-|*|/ | |
| * num = [0-9]* | |
| */ | |
| const parse = function(s) { |
| function curry(fn) { | |
| return function curried(...args) { | |
| if (args.length >= fn.length) { | |
| return fn.call(this, ...args) | |
| } else { | |
| return curried.bind(this, ...args) | |
| } | |
| } | |
| } |
| function sleep(ms, message) { | |
| return new Promise((resolve) => { | |
| setTimeout(() => { | |
| resolve(message) | |
| }, ms) | |
| }) | |
| } | |
| function co(fn) { | |
| const generator = fn() |
| uniform mat4 u_modelMatrix; | |
| uniform vec2 u_resolution; | |
| uniform vec3 u_camera; | |
| attribute vec4 a_position; | |
| varying vec4 v_position; | |
| attribute vec4 a_color; | |
| varying vec4 v_color; | |
| attribute vec3 a_normal; | |
| varying vec3 v_normal; |
The haversine formula is useful in calculating the distance between two locations on the Earth, when the latitudes & longitudes of the two locations are provided.
An implementation of calcDistance function based on haversine formula in JavaScript is as follows: (the degToRad function is solely a unit converter)
function degToRad(degrees) {
return degrees * Math.PI / 180;
}| // a half-adder takes 2 binary bits as input, and return as result the sum and carry flag | |
| function halfAdder(a, b) { | |
| // the sum is 0 when two bits are the same (1 + 1 or 0 + 0) | |
| var s = a ^ b | |
| // the carry flag is set when 1 + 1 | |
| // the bitwise expression !(a ^ b) is for testing equality between a and b | |
| var c = !(a ^ 1) && (!a ^ b) | |
| return [c, s] | |
| } |
| // a more declarative algorithm for finding permutations & combinations of a sequence | |
| // first, we introduce a higher-order fuction: flat-map | |
| // it works like map, but will flatten the result by one level (only one level, not recursive) | |
| // ex. | |
| // - map the procedure (x) => [x, 2 * x] onto array [1, 2, 3] will produce | |
| // a 2-dimensional array [[1, 2], [2, 4], [3, 6]] | |
| // - instead, flat-map the procedure (x) => [x, 2 * x] onto array [1, 2, 3] will produce | |
| // a flattened 1-dimensional array [1, 2, 2, 4, 3, 6] | |
| function flatMap(arr, proc) { |
| /* | |
| pattern matching | |
| - a pattern is an expression with variables | |
| - a datum is another expression to be tested if it matches the provided pattern | |
| - a dictionary is a data-structure used to record and test bindings between | |
| variables in pattern and values in datum | |
| a pattern matching procedure takes a pattern, a datum for testing and a dictionary as input | |
| - if the datum matches the pattern, the procedure will output an extended dictionary with | |
| the new bindings |