lqt0223

// (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

lqt0223

function apiReq(result, delay) {
  return new Promise(resolve => {
    setTimeout(() => {
      resolve(result)
    }, delay*1000)
  })
}

// the generator function version of async-await programming scheme
// function* -> async

lqt0223

/*
 * 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) {

lqt0223

function curry(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) {
      return fn.call(this, ...args)
    } else {
      return curried.bind(this, ...args)
    }
  }
}

lqt0223

function sleep(ms, message) {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve(message)
    }, ms)
  })
}

function co(fn) {
  const generator = fn()

lqt0223

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;

lqt0223

Deriving the Haversine Formula

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;
}

lqt0223

// 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]
}

lqt0223

// 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) {

lqt0223

/* 
 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