buzzdecafe

/*
S : \x y z -> x z (y z)
*/
// S :: (z -> (a -> b)) -> (z -> a) -> z -> b
function S(x, y, z) {
  return x(z)(y(z));
}

// example:
// add :: a -> a -> a

buzzdecafe

(function(global) {

    global.Functor = function(conf) {
        Functor.types[conf.key] = {
            obj: conf.obj,
            fmap: conf.fmap
        };
    };
    
    Functor.types = {};

buzzdecafe

# recurly does not document using cURL to access their API, they really want you to use their libraries.
# Sometimes i need to test something quick. I do not want to write a script importing your stupid library.
# So here's how you do it:

APIKEY=<get your API key from your recurly.com site>

curl -H "Accept: application/vnd.recurly.v2021-02-25+json" -u $APIKEY: https://v3.recurly.com/accounts

buzzdecafe

const Loop = (fn, ... init) => { 
  let r = fn (... init)
  while (r instanceof Recur) r = fn (... r)
  return r
}

const Recur = ( ...v) => Object .create (
  Recur .prototype, 
  {[Symbol .iterator]: {value: _ => v .values ()}}
)

buzzdecafe

CATEGORY THEORY FOR PROGRAMMERS

Category Theory 1.1: Motivation and Philosophy 
https://www.youtube.com/watch?v=I8LbkfSSR58&index=1&list=PLbgaMIhjbmEnaH_LTkxLI7FMa2HsnawM_

Composability, Abstraction, Reusability

Category Theory is a higher-level language.
Not a practical, executable language.

buzzdecafe

// clean and pure:
function cons(x, y) {
    return function(pick) {
        return pick(x, y);
    }
}

// does more stuff:
function cons(x, y) {
    var fn = function(pick) {

buzzdecafe

import Type from 'union-type';


// `tail` function must be return a Stream type, but no way to enforce that without evaluating it :-(
const Stream = Type({
  Empty: [],
  Cons:  [() => true, Function]
});

Stream.prototype.chain = function(f) {

buzzdecafe

(*
#1
loop : ('a -> bool) -> ('a -> 'a) -> 'a -> 'a 
such that loop p f x = x when p x = true and loop p f x = loop p f (f x) otherwise. 
*)
let rec loop p f x = if p x then x else loop p f (f x);;

(*
#2
exists : ('a -> bool) -> 'a list -> bool 

buzzdecafe

const NIL = Symbol('~~NIL~~');
const isNil = x => typeof x === 'symbol' &&  x.toString() === NIL.toString();

const pair = (a, b) => ({
  fst: function* () { yield a; },
  snd: function* () { yield b; },
  [Symbol.iterator]: function* () { yield a; (b[Symbol.iterator] ? yield* b : yield b); }
});

buzzdecafe

/*
data Store s a = Store (s -> a) s

instance Functor (Store s) where
  fmap f (Store g s) = Store (f . g) s

instance Extend (Store s) where
  duplicate (Store f s) = Store (Store f) s

instance Comonad (Store s) where