yelouafi

// Getter a :: () -> a

// gmap :: ((a -> b), Getter a), Getter b
function gmap(fn, getter) {
  return () => fn(getter())
}

// gcombine2 :: ((a,b) -> c, Getter a, Getter ab) -> Getter c
function gcombine2(fn, getter1, getter2) {

Avaq

const I  = x => x
const K  = x => y => x
const A  = f => x => f (x)
const T  = x => f => f (x)
const W  = f => x => f (x) (x)
const C  = f => y => x => f (x) (y)
const B  = f => g => x => f (g (x))
const S  = f => g => x => f (x) (g (x))
const S_ = f => g => x => f (g (x)) (x)
const S2 = f => g => h => x => f (g (x)) (h (x))

kpuputti

/*eslint-env es6 */

// Inspired by the paper "A tutorial on the universality and
// expressiveness of fold" by Graham Hutton (available at
// http://www.cs.nott.ac.uk/~gmh/fold.pdf), implementing some generic
// list handling functions in JavaScript in terms of `fold`.

// Personally I had an enlightnening moment when I realised the
// beautiful interplay of cons lists and foldr during the FP101x
// Haskell course. JavaScript's syntax doesn't make this very apparent

tel

/* eslint-disable new-cap */

/**
 * Lens types.
 * ===========
 *
 * a * b = {fst: a, snd: b}
 * a + b = {index: Boolean, value: a | b}
 *
 * Iso   s t a b = forall (~>) . Profunctor (~>) => (a ~> b) -> (s ~> t)

tel

/// PRELIMINARIES

/**
 * Generalized "products" of any size. For gluing things together. A tuple is a
 * "2"-meet.
 *
 * The type `Meet a b c d ...` indicates a `Meet` of the given size with values
 * at each type in the sequence.
 */

tel

const IdModule = {
  fmap: (fn) => (x) => fn(x),
}

const ConstModule = {
  fmap: (fn) => (x) => x,
}

/**

tel

function Cont(contHandler) {
  this.contHandler = contHandler;
};

Cont.unit = function(value) {
  return new Cont(function (continue) { return continue(value); });
};

Cont.prototype.run = function(resume) {
  return this.contHandler(resume);

julien-f

var makeIterable = require('./make-iterable');

// Returns an iterator to the Fibonacci sequence.
function fibonacci() {
  var prev = 0;
  var curr = 1;

  return makeIterable({
    next: function () {
      var tmp = curr;

divarvel

console.log("\033[39mRunning tests…");
function assertEquals(actual, expected, description) {
    if(typeof actual === "undefined") {
        console.error("\033[31m" + description + " not implemented\033[39m");
    } else {
        if(actual !== expected) {
            console.error("\033[31m" + description + " failed, expected " + expected + ", got " + actual + "\033[39m");
        } else {
            console.log(description + " \033[32m ok\033[39m");
        }

divarvel

console.log("\033[39mRunning tests…");
function assertEquals(actual, expected, description) {
    if(typeof(actual) === "undefined") {
        console.error("\033[31m" + description + " not implemented\033[39m");
    } else {
        if(actual !== expected) {
            console.error("\033[31m" + description + " failed, expected " + expected + ", got " + actual + "\033[39m");
        } else {
            console.log(description + " \033[32m ok\033[39m");
        }