JSFiddle - React, Tailwind, and code Playground

by dimitrs_papadimitriou

JavaScript

Object.prototype.l = function () {
    console.log(JSON.stringify(this));
};

// var zeroF = (v) => ({
//     v: v,
//     mapF: f => zeroF(v),
//     show:(c)=>c(`zeroF(${v})`) 
// });
// var succF = (v) => ({
//     v: v,
//     mapF: f => succF(f(v)),
// });

// var perfT = (v) => ({
//    l:zeroF(v), 
//    v:v,
//    r:zeroF(v) ,
//     mapF: f => perfT(f(v)),
//     show:(c)=>`perf(${this.l.show(c)},${c(this.v)},${this.r.show(c)})`
// });



// var coalg = n => n > 0 ? perfT(n - 1) : zeroF(0)
// var ana = n => coalg(n).mapF(v => ana(v))
//   var t = ana(3);
//   var s = t.show(x=>x);

class Tree {}


class Node extends Tree {
    constructor(left, v, right) {
        super()
        this.v = v;
        this.left = left;
        this.right = right;
    }
    cata(algebra) {
        return algebra.Node(this.left, this.v, this.right);
    }
    show() {
        return `Node(${this.left.show( )},${ (this.v)},${this.right.show( )})`;
    }
}

class Leaf extends Tree {
    constructor(v) {
        super()
        this.v = v;
    }
    cata(algebra) {
        return algebra.Leaf(this.v);
    }
    show() {
        return (`Leaf(${ this.v} )`);
    }
}

const some = v => ({
    cata: (alg) => alg.some(v),
});

var none = _ => ({
    cata: (alg) => alg.none(),
});

var coAlgList = n => n <= 0 ? none() : some({
    h: n - 1,
    s: n - 1
});

var ana = (colAg) => oldState => colAg(oldState).cata({
    some: (v) => [v.h].concat(ana(colAg)(v.s)),
    none: (_) => []
})


var nat = ana(coAlgList)(3);


nat.l()

//  ana :: (b -> Either a (b, a, b)) -> b -> Tree a
//  ana unspool x = case unspool x of
//                    Left a          -> Leaf a
//                    Right (l, x, r) -> Branch (ana unspool l) x (ana unspool r)
const right = v => ({
    v: v,
    map: f => right(f(v)),
    cata: alg => alg.right(v)
});

const left = v => ({
    v: v,
    map: () => left(v),
    cata: alg => alg.left(v)
});

// var node = (l, v, r) => ({
//     l: l,
//     v: v,
//    ...