buzzdecafe

// run in ramda dir
var R = require('./ramda');
var Maybe = require('./ext/types/Maybe');

var ms = [Maybe(1), Maybe(2), Maybe(3)];
R.commute(Maybe.of, ms); //=> Maybe([1, 2, 3]) i.e., Just [1, 2, 3]

// or just use constructor fn:
R.commute(Maybe, ms); //=> Maybe([1, 2, 3])

buzzdecafe

// fizzbuzz ramda-style
var R = require('ramda');

R.forEach(R.cond(
  [R.pipe(R.modulo(R.__, 15), R.eq(0)), function() { console.log('FizzBuzz'); }],
  [R.pipe(R.modulo(R.__, 3), R.eq(0)), function() { console.log('Fizz'); }],
  [R.pipe(R.modulo(R.__, 5), R.eq(0)), function() { console.log('Buzz'); }],
  [R.alwaysTrue, function(){}]
), R.range(1, 101));

buzzdecafe

// first try:
R.cc = R.curry(function cc(f, g) {
  return R.curryN(g.length, function() {
    var gargs = Array.prototype.slice.call(arguments, 0, g.length);
    var fargs = Array.prototype.slice.call(arguments, g.length);
    return f.apply(this, [g.apply(this, gargs)].concat(fargs));
  });
});

// so this works:

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

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

const fl = require('fantasy-land')

//- Lazy holds a vaue in a thunk, effectively delaying
//- evaluation until required. This is useful when we're
//- in a situation with either very large data set or
//- cyclical data.

//@ make stack-safe.
//> type Lazy a = Unit -> a
function Lazy(run) {

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

const meta = Symbol('@@ramda-meta');

const initMeta = f => ({ func: f, arity: f.length, seenArgs: [] });

const getMeta = f => f[meta] || initMeta(f);

const setMeta = (arg, f) => {
  const fMeta = getMeta(f);
  f[meta] = {
    func: fMeta.func,

buzzdecafe

const S = {
  
  fromArray: xs => sink => {
    for (let i=0; i<xs.length; ++i)
      if (sink(xs[i]))
        return true
  },

  map: fn => stream => sink => stream(x => sink(fn(x))),

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