currificando_javascript_como_Haskell.js

// La currificación (estilo Haskell) se consigue
// de forma efectiva con sólo separar los
// argumentos 1º, 2º, ... con paréntesis en lugar
// de comas.
//
// Por ejemplo, en lugar de
//
//      miFuncion(arg1, arg2, arg3)
//
// Hacer
//
//      miFuncion (arg1) (arg2) (arg3)
//
// La composición de funciones queda fea bajo la
// currificación, porque no hay un operador de
// composición (muchos paréntesis).
//
// Sin operador, la cosa queda
//
//      miFuncion (arg1) (otraFunc (arg4))
//
// pero si tuviéramos el operador, sería
//
//      miFunction (arg1) . otraFunc (arg4)
//
// que es casi como en Haskell.


// Map :: (a -> b) -> [a] -> [b]
function Map (f) {
    return function (xs) {
        return xs.map(f)
    }
}

// Fold :: ((a, a) -> c) -> a -> [a] -> c
function Fold (f) {
    return function (z) {
        return function (xs) {
            return xs.reduce(f, z)
        }
    }
}

// Enum :: a -> a -> [a]
function Enum (a) {
    return function (b) {
        var i = a, v = []; while(i <= b) v.push(i++); return v
    }
}

// ¡ésta función tiene un único argumento (no dos) que es una tupla!
// Add :: (a, a) -> a
function Add (x, y) {
    return ~~x + ~~y
}

// Sumar el triángulo {{1}, {1,2}, {1,2,3}, ..., {1, ..., n}}
function SumaTri(n) {
    var foldAdd = Fold (Add) (0)
    return foldAdd
                (Map
                    (foldAdd)
                    (Map
                        (Enum (1))
                        (Enum (1) (n))
                    )
                )

    // Con el operador de composición, sería
    // foldAdd . Map (foldAdd) . Map (Enum (1)) . Enum (1) (n)

}

// Ejemplo 1
SumaTri (5)

// Ejemplo 2
Map (SumaTri) (Enum (1) (3))