PreludeJS Global

Members

PreludeJS

Datos de la librería.

version: 0.2

autor: R. Galacho

cuasiInfinito: Constante de simulación de vectores infinitos. No es posible simular la evaluación perezosa pero sí que es posible generar un vector lo suficientemente grande como para realizar operaciones take/drop que no consuman mucho tiempo de ejecución y que proporcionen la impresión de estar trabajando con vectores cuasi-infinitos.

Source:

prelude.js, line 32

Methods

and(xs) → {Boolean}

and(xs) retorna la conjunción de un vector booleano.

Parameters:

Name	Type	Description
`xs`	Array	Vector

Since:

Source:

prelude.js, line 398

Returns:

Conjunción booleana de xs

Type: Boolean

Example

and([true, true, false]) => false

checkIfNullOrEmpty(funcion, xs) → {Exception}

checkIfNullOrEmpty chequea si un vector está vacío, lanzando una excepción en caso afirmativo.

Parameters:

Name	Type	Description
`funcion`	Function	Nombre de la función que comprueba la restricción
`xs`	Array	Vector a chequear

Since:

Source:

prelude.js, line 89

Returns:

Instancia de Exception

Type: Exception

Example

checkIfNullOrEmpty([]) => true

concat(xs, ys) → {Array}

concat(xs, ys) une dos vectores.

Parameters:

Name	Type	Description
`xs`	Array	Vector
`ys`	Array	Vector

Since:

Source:

prelude.js, line 135

Returns:

Nuevo vector resultante de unir xs e ys

Type: Array

Example

concat(['a', 'b', 'c'], [1, 2, 3]) => ['a', 'b', 'c', 1, 2, 3]

concatMap(xs) → {Array}

concatMap(xs) retorna vector obtenido de concatenar el vector resultante de aplicar f a cada elemento del vector xs.

Parameters:

Name	Type	Description
`xs`	Array	Vector

Since:

Source:

prelude.js, line 515

Returns:

El vector xs aplanado

Type: Array

Example

concatMap(function (e) { return e + "! "; }, ["Hey", "Ho", "Let's go"]) == "Hey! Ho! Let's go! "

cycle(xs) → {Array}

cycle(xs) convierte cualquier vector en un vector circular cuasi-infinito.

Parameters:

Name	Type	Description
`xs`	Array	Vector

Since:

Source:

prelude.js, line 785

Returns:

El vector circular cuasi-infinito de xs

Type: Array

Example

cycle([1, 2, 3]) => [1, 2, 3, 1, 2, 3, 1, 2, 3...]

drop(n, xs) → {Array}

drop(n, xs) retorna el vector xs sin los n primeros valores.

Parameters:

Name	Type	Description
`n`	Number	Nº de elementos a despreciar
`xs`	Array	Vector

Since:

Source:

prelude.js, line 823

Returns:

El vector xs sin los n primeros valores

Type: Array

Example

drop(3, [1, 2, 3, 4, 5]) => [4, 5]

dropWhile(p, xs) → {Array}

dropWhile(p, xs) retorna un vector con el mayor sufijo de elementos de xs que cumplen el predicado p.

Parameters:

Name	Type	Description
`p`	Function	Predicado
`xs`	Array	Vector

Since:

Source:

prelude.js, line 873

Returns:

El vector del mayor sufijo de elementos de xs que cumplen p

Type: Array

Example

dropWhile(function (it) { return it <= 2; }, [1, 2, 3, 4, 5]) => [3, 4, 5]

elem(x, xs) → {Boolean}

elem(x, xs) retorna true si x es elemento del vector xs.

Parameters:

Name	Type	Description
`x`	Object	Elemento
`xs`	Array	Vector

Since:

Source:

prelude.js, line 931

Returns:

true si x es elemento de xs, false e.o.c

Type: Boolean

Example

elem(2, [1, 2, 3]) => true

exception(nivel, mensaje, html) → {Exception}

exception crea un nuevo objeto de tipo excepción.

Parameters:

Name	Type	Description
`nivel`	String	Nivel de error
`mensaje`	String	Mensaje descriptivo en texto plano
`html`	String	Mensaje descriptivo en formato HTML

Since:

Source:

prelude.js, line 46

Returns:

Instancia Exception

Type: Exception

filter(p, xs) → {Array}

filter(p, xs) retorna aquellos elementos de xs que satisfacen el predicado p.

Parameters:

Name	Type	Description
`p`	Function	Predicado (función booleana)
`xs`	Array	Vector

Since:

Source:

prelude.js, line 159

Returns:

Elementos de xs que cumplen p

Type: Array

Example

filter(function (it) { return it % 2 == 0; }, [1, 2, 3, 4]) => [2,4]

flatten(xs) → {Array}

flatten(xs) retorna la concatenación del vector de vectores xs.

Parameters:

Name	Type	Description
`xs`	Array	Vector

Since:

Source:

prelude.js, line 500

Returns:

El vector xs aplanado

Type: Array

Example

flatten([[1, 2],  [3, 4], [5, 6]]) => [1, 2, 3, 4, 5, 6]

foldl(f, init, xs) → {Object}

foldl(f, init, xs) pliega el vector xs por la izquierda aplicando la función f con el valor inicial init.

Parameters:

Name	Type	Description
`f`	Function	Función a aplicar
`init`	Object	Valor inicial
`xs`	Array	Vector

Since:

Source:

prelude.js, line 303

Returns:

El plegado de xs aplicando f con valor inicial init

Type: Object

Example

foldl(function (accum, it) { return accum + it; }, 0, [1, 2, 3]) => 6

foldl1(f, init, xs) → {Object}

foldl(f, xs) pliega el vector xs por la izquierda aplicando la función f con el primer elemento de xs como valor inicial, luego xs no puede estar vacío.

Parameters:

Name	Type	Description
`f`	Function	Función a aplicar
`init`	Object	Valor inicial
`xs`	Array	Vector

Since:

Source:

prelude.js, line 322

Returns:

El plegado por la izquierda de xs aplicando f con el primer elemento xs como valor inicial

Type: Object

Example

foldl(function (accum, it) { return accum + it; }, [1, 2, 3]) => 6

foldlAux(f, accum, xs) → {Object}

foldlAux(f, init, xs) es una función auxiliar encargada de recorrer el vector por la izquierda aplicando la función f.

Parameters:

Name	Type	Description
`f`	Function	Función a aplicar
`accum`	Object	Valor acumulado
`xs`	Array	Vector

Since:

Source:

prelude.js, line 284

Returns:

El valor acumulado tras plegar por la izquierda el vector xs por la izquierda aplicando la función f

Type: Object

Example

foldlAux(function (accum, it) { return accum + it; }, 0, [1, 2, 3]) => 6

foldr(f, init, xs) → {Object}

foldr(f, init, xs) pliega el vector xs por la derecha aplicando la función f con el valor inicial init.

Parameters:

Name	Type	Description
`f`	Function	Función a aplicar
`init`	Object	Valor inicial
`xs`	Array	Vector

Since:

Source:

prelude.js, line 360

Returns:

El plegado por la izquierda de xs aplicando f con valor inicial init

Type: Object

Example

foldr(function (accum, it) { return accum + it; }, 0, [1, 2, 3]) => 6

foldr1(f, init, xs) → {Object}

foldr(f, xs) pliega el vector xs por la derecha aplicando la función f con el primer elemento de xs como valor inicial, luego xs no puede estar vacío.

Parameters:

Name	Type	Description
`f`	Function	Función a aplicar
`init`	Object	Valor inicial
`xs`	Array	Vector

Since:

Source:

prelude.js, line 379

Returns:

El plegado por la derecha de xs aplicando f con el primer elemento xs como valor inicial

Type: Object

Example

foldr(function (accum, it) { return accum + it; }, 0, [1, 2, 3]) => 6

foldrAux(f, accum, xs) → {Object}

foldrAux(f, init, xs) es una función auxiliar encargada de recorrer el vector por la derecha aplicando la función f.

Parameters:

Name	Type	Description
`f`	Function	Función a aplicar
`accum`	Object	Valor acumulado
`xs`	Array	Vector

Since:

Source:

prelude.js, line 341

Returns:

El valor acumulado tras plegar el vector xs por la derecha aplicando la función f

Type: Object

Example

foldrAux(function (accum, it) { return accum + it; }, 0, [1, 2, 3]) => 6

generator(f, n) → {Function}

generator(f, n) es una función auxiliar que construye un generador de la función f con el argumento n como valor inicial. El segundo argumento es opcional, si no se recibe un valor inicial, se asume una función generadora numérica y 1 como valor inicial.

Parameters:

Name	Type	Description
`f`	Function	Función
`n`	Object	Valor inicial

Since:

Source:

prelude.js, line 686

Returns:

La función generadora que aplica f

Type: Function

Example

var f = generator(function (n) { return ++n; });
f() => 2
f() => 3
...

head(xs) → {Object}

head(xs) retorna el primer elemento de xs, xs no puede estar vacío.

Parameters:

Name	Type	Description
`xs`	Array	Vector

Since:

Source:

prelude.js, line 182

Returns:

Primer elemento de xs

Type: Object

Example

head([1, 2, 3]) => 1

init(xs) → {Array}

init(xs) retorna los elementos de xs salvo el último, xs no puede estar vacío.

Parameters:

Name	Type	Description
`xs`	Array	Vector

Since:

Source:

prelude.js, line 227

Returns:

Elementos de xs salvo el último

Type: Array

Example

init([1, 2, 3]) => [1, 2]

isNull(xs) → {Boolean}

isNull testea si el vector xs es nulo.

Parameters:

Name	Type	Description
`xs`	Array	Vector

Source:

prelude.js, line 62

Returns:

true si el vector xs es nulo.

Type: Boolean

Example

isNull(null) => true

isNullOrEmpty(xs) → {Boolean}

isNullOrEmpty testea si el vector xs es nulo o está vacío.

Parameters:

Name	Type	Description
`xs`	Array	Vector

Source:

prelude.js, line 74

Returns:

true si el vector xs es nulo o está vacío.

Type: Boolean

Example

isNullOrEmpty(null) == isNullOrEmpty([]) => true

iterate(f, x) → {Array}

iterate(f, x) retorna el vector cuasi-infinito de la aplicación sucesiva de f(x)

Parameters:

Name	Type	Description
`f`	Function	Función
`x`	Object	Valor

Since:

Source:

prelude.js, line 713

Returns:

El vector resultante de aplicar sucesivamente f(x)

Type: Array

Example

iterate(function (n) { return ++n; }, 0) => [1, 2, 3, 4, 5 ...]

last(xs) → {Object}

last(xs) retorna el último elemento de xs, xs no puede estar vacío.

Parameters:

Name	Type	Description
`xs`	Array	Vector

Since:

Source:

prelude.js, line 197

Returns:

Último elemento de xs

Type: Object

Example

last([1, 2, 3]) => 3

length(xs) → {Number}

length(xs) retorna la longitud del vector xs.

Parameters:

Name	Type	Description
`xs`	Array	Vector

Since:

Source:

prelude.js, line 242

Returns:

La longitud del vector xs

Type: Number

Example

length([1, 2]) => 2

map(f, xs) → {Array}

map(f, xs) es el vector obtenida de aplicar f a cada elemento del vector.

Parameters:

Name	Type	Description
`f`	Function	Función
`xs`	Array	Array

Since:

Source:

prelude.js, line 110

Returns:

Nuevo vector resultante de aplicar f a los elementos de l

Type: Array

Example

map(f, [x1, x2, ..., xn]) => [f x1, f x2, ..., f xn]

maximum(xs) → {Object}

maximum(xs) retorna el mayor elemento de la vector xs.

Parameters:

Name	Type	Description
`xs`	Array	Vector

Since:

Source:

prelude.js, line 529

Returns:

El mayor elemento de xs

Type: Object

Example

maximum([1, 2, 3, 4]) => 4

minimum(xs) → {Object}

minimum(xs) retorna el menor elemento de la vector xs.

Parameters:

Name	Type	Description
`xs`	Array	Vector

Since:

Source:

prelude.js, line 543

Returns:

El menor elemento de xs

Type: Object

Example

maximum([1, 2, 3, 4]) => 1

notElem(x, xs) → {Boolean}

notElem(x, xs) retorna true si x no es elemento del vector xs.

Parameters:

Name	Type	Description
`x`	Object	Elemento
`xs`	Array	Vector

Since:

Source:

prelude.js, line 946

Returns:

true si x no es elemento de xs, false e.o.c

Type: Boolean

Example

elem(4, [1, 2, 3]) => flase

or(xs) → {Boolean}

or(xs) retorna la disyunción de un vector booleano.

Parameters:

Name	Type	Description
`xs`	Array	Vector

Since:

Source:

prelude.js, line 412

Returns:

Disyunción booleana de xs

Type: Boolean

Example

or([true, true, false]) => true

product(xs) → {Number}

product(xs) retorna el producto de todos los elementos de xs.

Parameters:

Name	Type	Description
`xs`	Array	Vector

Since:

Source:

prelude.js, line 486

Returns:

Productorio de xs

Type: Number

Example

sum([1, 2, 3]) => 6

repeat(x, n) → {Array}

repeat(x) retorna el vector cuasi-infinito de repeticiones de x.

Parameters:

Name	Type	Description
`x`	Object	Valor
`n`	Array	Nº de repeticiones

Since:

Source:

prelude.js, line 756

Returns:

El vector cuasi-infinito de repeticiones de x

Type: Array

Example

repeat('a') => ['a', 'a', 'a', 'a', 'a', ... ] == "aaaaa..."

repeatAux(x, n) → {Array}

repeatAux(x, n) retorna un vector con n repeticiones de x. El parámetro n es opcional, si no recibe un valor, retorna un vector cuasi-infinito.

Parameters:

Name	Type	Description
`x`	Object	Valor
`n`	Number	Nº de repeticiones

Since:

Source:

prelude.js, line 735

Returns:

El vector con n repeticiones de x

Type: Array

Example

repeatAux('a', 5) => ['a', 'a', 'a', 'a', 'a'] == "aaaaa"

replicate(x, n) → {Array}

replicate(x, n) retorna un vector con n repeticiones de x.

Parameters:

Name	Type	Description
`x`	Array	Valor
`n`	Object	Nº de repeticiones

Since:

Source:

prelude.js, line 771

Returns:

El vector con n repeticiones de x

Type: Array

Example

replicate(5, 'a') => ['a', 'a', 'a', 'a', 'a'] == "aaaaa"

reverse(xs) → {Array}

reverse(xs) invierte el vector xs.

Parameters:

Name	Type	Description
`xs`	Array	Vector

Source:

prelude.js, line 257

Returns:

El vector xs invertido

Type: Array

Example

reverse([1, 2, 3]) => [3, 2, 1]

scanl(xs, init, xs) → {Array}

scanl(f, init, xs) retorna el vector de las sucesivas aplicaciones por la izquierda acumuladas de f en xs con init como valor inicial.

Parameters:

Name	Type	Description
`xs`	Array	Vector
`init`	Object	Valor inicial
`xs`	Array	Vector

Since:

Source:

prelude.js, line 584

Returns:

El vector acumulativo de aplicar f por la izquierda en los elementos de xs con init como valor inicial

Type: Array

Example

scanl(function (ac, it) { return ac + it; }, 0, [1, 2, 3, 4]) => [0, 1, 3, 6, 10]

scanl1(xs, init, xs) → {Array}

scanl1(f, xs) retorna el vector de las sucesivas aplicaciones por la izquierda acumuladas de f en xs con el primer elemento de xs como valor inicial.

Parameters:

Name	Type	Description
`xs`	Array	Vector
`init`	Object	Valor inicial
`xs`	Array	Vector

Since:

Source:

prelude.js, line 603

Returns:

El vector acumulativo de aplicar f por la izquierda en los elementos de xs con el primer elemento como valor inicial.

Type: Array

Example

scanl1(function (ac, it) { return ac + it; }, [1, 2, 3, 4]) => [1, 3, 6, 10]

scanlAux(xs) → {Array}

scanlAux(f, xs) es una función auxiliar encargada de recorrer el vector por la izquierda acumulando los resultados de aplicar f.

Parameters:

Name	Type	Description
`xs`	Array	Vector

Since:

Source:

prelude.js, line 562

Returns:

El vector acumulativo de aplicar f por la izquierda en los elementos de xs

Type: Array

Example

scanlAux(function (ac, it) { return ac + it; }, 0, [1, 2, 3, 4]) => [0, 1, 3, 6, 10]

scanr(xs, init, xs) → {Array}

scanr(f, init, xs) retorna el vector de las sucesivas aplicaciones por la derecha acumuladas de f en xs con init como valor inicial.

Parameters:

Name	Type	Description
`xs`	Array	Vector
`init`	Object	Valor inicial
`xs`	Array	Vector

Since:

Source:

prelude.js, line 642

Returns:

El vector acumulativo de aplicar f por la derecha en los elementos de xs con init como valor inicial

Type: Array

Example

scanr(function (ac, it) { return ac + it; }, 0, [1, 2, 3, 4]) => [0, 4, 7, 9, 10]

scanr1(xs, init, xs) → {Array}

scanr1(f, xs) retorna el vector de las sucesivas aplicaciones acumuladas de f en xs con el primer elemento de xs como valor inicial.

Parameters:

Name	Type	Description
`xs`	Array	Vector
`init`	Object	Valor inicial
`xs`	Array	Vector

Since:

Source:

prelude.js, line 661

Returns:

El vector acumulativo de aplicar f por la derecha en los elementos de xs con el primer elemento como valor inicial.

Type: Array

Example

scanr(function (ac, it) { return ac + it; }, [1, 2, 3, 4]) => [4, 7, 9, 10]

scanrAux(xs) → {Array}

scanrAux(f, xs) es una función auxiliar encargada de recorrer el vector por la derecha acumulando los resultados de aplicar f.

Parameters:

Name	Type	Description
`xs`	Array	Vector

Since:

Source:

prelude.js, line 620

Returns:

El vector acumulativo de aplicar f por la derecha en los elementos de xs recorriendo por la drecha

Type: Array

Example

scanrAux(function (ac, it) { return ac + it; }, 0, [1, 2, 3, 4]) => [0, 4, 7, 9, 10]

span(p, xs) → {Array}

span(p, xs) retorna un vector donde el primer elemento es el mayor prefijo de elementos de xs que cumplen el predicado p y el segundo el resto de elementos de xs.

Parameters:

Name	Type	Description
`p`	Function	Predicado
`xs`	Array	Vector

Since:

Source:

prelude.js, line 893

Returns:

Vector cuyo primer elemento es el vector del mayor prefijo de elementos de xs que cumplen p y el resto de elementos de xs como segundo elemento

Type: Array

Example

span(function (it) { return it <=2; }, [1, 2, 3, 4, 5]) => [[1, 2], [3, 4, 5]]

splitAt(n, xs) → {Array}

splitAt(n, xs) retorna un vector cuyo primer elemento es un vector con los n primeros valores de xs y el segundo otro vector con los elementos restantes.

Parameters:

Name	Type	Description
`n`	Number	Nº de elementos a dividir
`xs`	Array	Vector

Since:

Source:

prelude.js, line 841

Returns:

El vector formado por los n primeros elementos de xs como primer elemento y el resto de valores de xs como segundo elemento.

Type: Array

Example

splitAt(3, [1, 2, 3, 4, 5]) => [[1, 2, 3], [4, 5]]

sum(xs) → {Number}

sum(xs) retorna la suma de todos los elementos de xs.

Parameters:

Name	Type	Description
`xs`	Array	Vector

Since:

Source:

prelude.js, line 472

Returns:

Sumatorio de xs

Type: Number

Example

sum([1, 3, 5, 7]) => 16

tail(xs) → {Array}

tail(xs) retorna los elementos de xs salvo el primero, xs no puede estar vacío.

Parameters:

Name	Type	Description
`xs`	Array	Vector

Since:

Source:

prelude.js, line 212

Returns:

Elementos de xs salvo el primero

Type: Array

Example

tail([1, 2, 3]) => [2, 3]

take(n, xs) → {Array}

take(n, xs) retorna los n primeros valores del vector xs.

Parameters:

Name	Type	Description
`n`	Number	Nº de elementos a tomar
`xs`	Array	Vector

Since:

Source:

prelude.js, line 808

Returns:

El vector formado por los n primeros valores de xs

Type: Array

Example

take(5, cycle([1, 2, 3])) => [1, 2, 3, 1, 2]

takeWhile(p, xs) → {Array}

takeWhile(p, xs) retorna un vector con el mayor prefijo de elementos de xs que cumplen el predicado p.

Parameters:

Name	Type	Description
`p`	Function	Predicado
`xs`	Array	Vector

Since:

Source:

prelude.js, line 857

Returns:

El vector del mayor prefijo de elementos de xs que cumplen p

Type: Array

Example

takeWhile(function (it) { return it < 4; }, [1, 2, 3, 4, 5]) => [1, 2, 3]

unSpan(p, xs) → {Array}

unSpan(p, xs) retorna un vector donde el primer elemento es el mayor prefijo de elementos de xs que no cumplen el predicado p y el segundo el resto de elementos de xs.

Parameters:

Name	Type	Description
`p`	Function	Predicado
`xs`	Array	Vector

Since:

Source:

prelude.js, line 911

Returns:

Vector cuyo primer elemento es el vector del mayor prefijo de elementos de xs que no cumplen p y el resto de elementos de xs como segundo elemento

Type: Array

Example

unSpan(function (it) { return it > 2; }, [1, 2, 3, 4, 5]) => [[1, 2], [3, 4, 5]]

unzip(xs) → {Array}

unzip(xs) transforma un vector de vectores pares en un vector par con el vector de primeros componentes y otro vector de segundos componentes. El vector de entrada debe ser un vector de pares.

Parameters:

Name	Type	Description
`xs`	Array	Vector

Since:

Source:

prelude.js, line 1131

Returns:

Vector par con el vector de primeros componentes y el vector de segundos componentes

Type: Array

Example

unzip([[1, 'a'], [2, 'b'], [3, 'c']]) => [[1, 2, 3], ['a', 'b', 'c']]

unzip3(xs) → {Array}

unzip3(xs) transforma un vector de vectores de tripletas en un vector tripleta con el vector de primeros componentes, el vector de segundos componentes y un tercer componente con el vector de terceros componentes. El vector de entrada debe ser un vector de tripletas.

Parameters:

Name	Type	Description
`xs`	Array	Vector

Since:

Source:

prelude.js, line 1157

Returns:

Vector par con el vector de primeros componentes, el vector de segundos componentes y el vector de terceros componentes

Type: Array

Example

unzip3([[1, 'a', 'x'], [2, 'b', 'y'], [3, 'c', 'z']]) => [[1, 2, 3], "abc"]

zip(xs, ys) → {Array}

zip(xs, ys) retorna el vector formado por vectores pares con un elemento de xs y otro de ys. Si alguno de los vectores de entrada es más pequeño, el resto de elementos del vector mayor se descartan.

Parameters:

Name	Type	Description
`xs`	Array	Vector
`ys`	Array	Vector

Since:

Source:

prelude.js, line 967

Returns:

Vector de vectores pares con los elementos de xs e ys correspondientes

Type: Array

Example

zip("abcd", [1, 2, 3]) => [['a', 1], ['b', 2], ['c', 3]]

zip3(xs, ys, zs) → {Array}

zip3(xs, ys, zs) retorna el vector formado por vectores tripleta con un elemento de xs, un elemento de ys y otro de zs. Si alguno de los vectores de entrada es más pequeño, el resto de elementos de vectores mayores se descartan.

Parameters:

Name	Type	Description
`xs`	Array	Vector
`ys`	Array	Vector
`zs`	Array	Vector

Since:

Source:

prelude.js, line 987

Returns:

Vector de vectores tripleta con los elementos de xs, ys y zs correspondientes

Type: Array

Example

zip("abcd", [1, 2, 3], "xyztu"]) => [['a', 1, 'x'], ['b', 2, 'y'], ['c', 3, 'z']]

zipN(args) → {Array}

zipN(xs, ys, ...) retorna el vector formado por vectores n-tupla con un elemento de cada vector recibido. Si alguno de los vectores es más pequeño, el resto de elementos de los vectores mayores se descartan.

Parameters:

Name	Type	Description
`args`	Array	Vectores

Since:

Source:

prelude.js, line 1005

Returns:

Vector de vectores n-tupla con los elementos de los vectores recibidos

Type: Array

Example

zipN([1, 2, 3], "abcd", [5, 6, 7, 8, 9]) == [[1, 'a', 5], [2, 'b', 6], [3, 'c', 7]]

zipWith(f, xs, ys) → {Array}

zipWith(f, xs, ys) generaliza zip comprimiendo xs e ys con la función f en lugar de contruir pares. Si alguno de los vectores de entrada es más pequeño, el resto de elementos del vector mayor se descartan.

Parameters:

Name	Type	Description
`f`	Function	Función
`xs`	Array	Vector
`ys`	Array	Vector

Since:

Source:

prelude.js, line 1028

Returns:

Vector de vectores pares con los elementos de xs e ys correspondientes

Type: Array

Example

zipWith(function (x, y) { return x + y; }, [1, 2, 3], [4, 5, 6]) => [5, 7, 9]

zipWith3(f, xs, ys, zs) → {Array}

zipWith3(f, xs, ys, zs) generaliza zip3 comprimiendo xs, ys y zs con la función f en lugar de construir tripletas. Si alguno de los vectores de entrada es más pequeño, el resto de elementos de vectores mayores se descartan.

Parameters:

Name	Type	Description
`f`	Function	Función
`xs`	Array	Vector
`ys`	Array	Vector
`zs`	Array	Vector

Since:

Source:

prelude.js, line 1055

Returns:

Vector de vectores tripleta con los elementos de xs, ys y zs correspondientes

Type: Array

Example

zipWith3(function (x, y, z) { return (x + y) + z; }, [1, 2, 3], [4, 5, 6], "abcdef") => [5a,7b,9c]