getify

function A() {
  var x = 1;
  C(B);
  
  function B() { console.log(x); }
  
  function C(callback) {
    B === callback;      // true
    
    B();                 // is this console.log() using a closure or not? depends on perspective.

getify

// ..

self.addEventListener("periodicsync",onPeriodicSync);

// ..

await registerPeriodicSync();

// ..

getify

if my three friends and I split a pizza evenly, and we all want more than one piece, how many slices should we cut the pizza into?

If you and your three friends want to split a pizza evenly and each person wants more than one piece, you should cut the pizza into at least 8 slices.

If you cut the pizza into 8 slices, each person can have two slices, and there will be two slices left over. You can decide how to split the remaining slices among yourselves, or you could also save them for later.

getify

(* as checked here: https://mdkrajnak.github.io/ebnftest/ *)
(* ebnf syntax rules defined here: https://github.com/Engelberg/instaparse *)

Program                 := WhSp* (StmtSemi WhSp*)* StmtSemiOpt? WhSp*;

Stmt                    := AStmt | BStmt | CStmt | DStmt;
StmtSemi                := Stmt? (WhSp* ";")+;
StmtSemiOpt             := Stmt? (WhSp* ";")*;

WhSp                    := "_";

getify

Comparing: array method chaining, generator delegations, and transducing

I'm writing this quick post to respond to a recent twitter conversation where claims were made about the merits (or lack thereof) of transducers, as they relate to composing list comprehensions (map, filter).

For comparison sake throughout the rest of my post, below you'll find three (actually four!) implementations of a simple list operation demo:

• Array Method Chaining (jump to analysis)
  • Alternate: Array Method Composition (jump to analysis)
• Generator/Iterator Delegations (jump to analysis)
• Transducing (jump to analysis)

getify

// this is an experimental Foi (https://github.com/getify/foi-lang) implementation of
// the BFS solution to https://gist.github.com/getify/59ab7443723564eb40d20ab7c45d5f0a

def < :size, :log >: import "#Std";

def M1: <
    < 0, 0, 1, 1, 0 >,
    < 1, 0, 1, 1, 0 >,
    < 0, 1, 0, 0, 0 >,
    < 0, 0, 0, 1, 1 >

getify

// Adapted from: https://www.geeksforgeeks.org/find-length-largest-region-boolean-matrix/

"use strict";

var M1 = [
	[ 0, 0, 1, 1, 0 ],
	[ 1, 0, 1, 1, 0 ],
	[ 0, 1, 0, 0, 0 ],
	[ 0, 0, 0, 1, 1 ]
];

getify

function flow(...fns) {
	return arg => fns.reduce((res,fn) => fn(res),arg);
}
function partial(fn,initialArgs) {
	return (nextArgs = []) => fn(...initialArgs,...nextArgs);
}
function pick(prop) {
	return obj => obj[prop];	
}
function prepend(prefix) {

getify

// abstract class, not intended to be instantiated directly
class CalendarItem {
    static #UNSET = Symbol("unset")
    static #isUnset(v) {
        return v === this.#UNSET;
    }
    static {
        for (let [idx,msg] of [
            "ID is already set.",
            "ID is unset.",

getify

class Point2d {
    #ID = null

    constructor(id) {
      this.#ID = id;
    }
    getID() {
        return this.#ID;
    }
}