73 lines
3.1 KiB
JavaScript
73 lines
3.1 KiB
JavaScript
const ZERO = f => x => x;
|
|
const ONE = f => x => f(x);
|
|
const TWO = f => x => f(f(x));
|
|
const THREE = f => x => f(f(f(x)));
|
|
const TIMES = n => f => x => n(f)(x);
|
|
const INC = n => f => x => f(n(f)(x));
|
|
const ADD = n => m => n(INC)(m);
|
|
const MULT = n => m => n(ADD(m))(ZERO);
|
|
const POWER = n => m => n(MULT(m))(ONE);
|
|
// DEC is stolen from PRED here:
|
|
// https://en.wikipedia.org/wiki/Lambda_calculus#Arithmetic_in_lambda_calculus
|
|
const DEC = n => f => x => n(g => h => h(g(f)))(y => x)(y => y);
|
|
const SUB = n => m => m(DEC)(n);
|
|
const TRUE = x => y => x;
|
|
const FALSE = x => y => y;
|
|
const IF = b => b;
|
|
const NOT = b => IF(b)(FALSE)(TRUE);
|
|
const AND = a => b => IF(a)(IF(b)(TRUE)(FALSE))(FALSE);
|
|
const OR = a => b => IF(a)(TRUE)(IF(b)(TRUE)(FALSE));
|
|
const IS_ZERO = n => n(x => FALSE)(TRUE);
|
|
const IS_LEQ = n => m => IS_ZERO(SUB(n)(m)); // we only have positive ints
|
|
const IS_EQ = n => m => AND(IS_LEQ(n)(m))(IS_LEQ(m)(n)); // this is stupid
|
|
// time to get recursive!
|
|
const Y = f => (x => f(x(x)))(x => f(x(x))); // lazy recursion
|
|
const Z = f => (x => f(_ => x(x)(_)))(x => f(_ => x(x)(_))); // eager recursion
|
|
const FACT = Z(f => n => IF(IS_ZERO(n))(ONE)(_ => MULT(n)(f(DEC(n)))(_)));
|
|
const DIV = Z(f => n => m => IF(IS_LEQ(m)(n))(_ => INC(f(SUB(n)(m))(m))(_))(ZERO));
|
|
const MOD = Z(f => n => m => IF(IS_LEQ(m)(n))(_ => f(SUB(n)(m))(m)(_))(m));
|
|
const PAIR = x => y => f => f(x)(y);
|
|
const LEFT = p => p(x => y => x);
|
|
const RIGHT = p => p (x => y => y);
|
|
const EMPTY = PAIR(TRUE)(TRUE);
|
|
const UNSHIFT = l => x => PAIR(FALSE)(PAIR(x)(l));
|
|
const IS_EMPTY = LEFT;
|
|
const FIRST = l => LEFT(RIGHT(l));
|
|
const REST = l => RIGHT(RIGHT(l));
|
|
const INJECT = Z(f => l => x => g => IF(IS_EMPTY(l))(x)(_ => f(REST(l))(g(x)(FIRST(l)))(g)(_)));
|
|
const FOLD = Z(f => l => x => g => IF(IS_EMPTY(l))(x)(_ => g(f(REST(l))(x)(g))(FIRST(l))(_)));
|
|
const MAP = k => f => FOLD(k)(EMPTY)(l => x => UNSHIFT(l)(f(x)));
|
|
const RANGE = Z(f => n => m => IF(IS_LEQ(n)(m))(_ => UNSHIFT(f(INC(n))(m))(n)(_))(EMPTY));
|
|
const SUM = l => INJECT(l)(ZERO)(ADD);
|
|
const PROD = l => INJECT(l)(ONE)(MULT);
|
|
const CONCAT = k => l => FOLD(k)(l)(UNSHIFT);
|
|
const PUSH = l => x => CONCAT(l)(UNSHIFT(EMPTY)(x));
|
|
const REVERSE = l => FOLD(l)(EMPTY)(PUSH);
|
|
const INC_ALL = l => MAP(l)(INC);
|
|
const DOUBLE_ALL = l => MAP(l)(MULT(TWO));
|
|
const TEN = INC(MULT(THREE)(THREE));
|
|
const RADIX = TEN;
|
|
const FOUR = INC(THREE);
|
|
const FIVE = INC(INC(THREE));
|
|
const FIFTEEN = MULT(THREE)(FIVE);
|
|
const FIZZ = MAP(UNSHIFT(UNSHIFT(UNSHIFT(UNSHIFT(EMPTY)(FOUR))(FOUR))(TWO))(ONE))(ADD(RADIX));
|
|
const BUZZ = MAP(UNSHIFT(UNSHIFT(UNSHIFT(UNSHIFT(EMPTY)(FOUR))(FOUR))(THREE))(ZERO))(ADD(RADIX));
|
|
const FIZZBUZZ = n => MAP(RANGE(ONE)(n))(m =>
|
|
IF(IS_ZERO(MOD(m)(FIFTEEN)))(
|
|
CONCAT(FIZZ)(BUZZ)
|
|
)(IF(IS_ZERO(MOD(m)(THREE)))(
|
|
FIZZ
|
|
)(IF(IS_ZERO(MOD(m)(FIVE)))(
|
|
BUZZ
|
|
)(
|
|
m
|
|
)))
|
|
);
|
|
module.exports = {
|
|
ZERO, ONE, TWO, THREE, TIMES, INC, ADD, MULT, POWER, DEC, SUB, TRUE,
|
|
FALSE, IF, NOT, AND, OR, IS_ZERO, IS_LEQ, IS_EQ, IS_LEQ, Y, Z, FACT,
|
|
DIV, MOD, PAIR, LEFT, RIGHT, EMPTY, UNSHIFT, IS_EMPTY, FIRST, REST, INJECT,
|
|
FOLD, MAP, RANGE, SUM, PROD, CONCAT, PUSH, REVERSE, INC_ALL, DOUBLE_ALL,
|
|
TEN, RADIX, FOUR, FIVE, FIFTEEN, FIZZ, BUZZ, FIZZBUZZ
|
|
};
|