mlhaufe

interface Boolean {
  ifTrue<T>(fn: () => T): T | undefined
  ifFalse<T>(fn: () => T): T | undefined
}

Object.assign(Boolean.prototype, {
  ifTrue(fn: Function) {
    return this ? fn.apply(this) : undefined
  },
  ifFalse(fn: Function) {

mlhaufe

const memo = f => {
  const cache = new Map()
  return arg => {
    if(cache.has(arg))
      return cache.get(arg)
    return cache.set(arg, f(arg)).get(arg)
  }
}

const fix = f => x => f(fix(f))(x);

mlhaufe

function Bindable(proto: any, name: PropertyKey) {
    const desc = Object.getOwnPropertyDescriptor(proto, name)

    delete proto.name

    if ((proto['_dispatchEvent']) == undefined) {
        Object.defineProperty(proto, '_dispatchEvent', {
            value(event: Event) {
                
            }

mlhaufe

// x, y :: {0,1}
var and = (x,y) => x * y,
    not = (x)   => 1 - x,
    or  = (x,y) => 1 - (1 - x) * (1 - y)

and(0,0) // 0
and(0,1) // 0
and(1,0) // 0
and(1,1) // 1

mlhaufe

- The application is currently single threaded
- The following commands have been implemented:
    - exit
    - create <PATH>
    - open <PATH>
    - display
    - ls
    - cd <TFS> (partial)
    - mkdir <TFS> (partial). currently buggy due to nibble manipulation
    - import <PATH> <TFS> (partial) stub + error checking only

mlhaufe

function main() {
    console.log("question1(0) == 0");
    console.assert(question1(0) == 0, `${question1(0)}`);
	console.log("question1(1) == 1");
	console.assert(question1(1) == 1, `${question1(1)}`);
	console.log("question1(7) == 13");
	console.assert(question1(7) == 13, `${question1(7)}`);
	console.log("question1(12) == 144");
	console.assert(question1(12) == 144, `${question1(12)}`);

mlhaufe

Moved to https://thenewobjective.com/a-criticism-of-web-components

mlhaufe

abstract class Observer {
  abstract update(data?: any): void
}

abstract class Observable {
  protected _observers: Observer[] = []

  observe(observer: Observer) {
    if (this._observers.indexOf(observer) > -1)
      throw new Error('Observer already added')

mlhaufe

abstract class Command {
    abstract execute(): void
}

abstract class UndoableCommand extends Command {
    abstract undo(): void
}

class Direction {
    static readonly UP = 0

mlhaufe

// data
type Exp =
    { tag: 'Lit', value: number } |
    { tag: 'Add', left: Exp, right: Exp }

// operations
let evaluate = (exp: Exp) =>
    exp.tag === 'Lit' ? exp.value :
    evaluate(exp.left) + evaluate(exp.right)