Data.List

De Wikihaskell
Saltar a: navegación, buscar
Data.List
Data.List
Lenguaje Haskell
Biblioteca Data.List
Autores Francisco José Aguilar Sánchez
Manuel Caucelo Pecci
Adolfo Barroso Espinosa

Contenido

Introducción

Si las funciones son uno de los dos bloques de construcción principales de cualquier programa Haskell, las listas son el complemento perfecto debido a su versatilidad. El uso que se le da a las listas es muy extenso y las operaciones de las que disponemos para trabajar con ellas son muy ricas y nos permiten realizar operaciones complejas en una sola línea.

List> [1,2,3,4]
List> [True, False, False]
List> ["Lista", "de", "cadenas"]

Los corchetes delimitan la lista, y los elementos de la misma se encuentran separados por comas. La principal restricción de las listas es que todos los elementos de la misma deben ser del mismo tipo.

Intentar definir una lista con tipos de elementos mezclados es un error típico de principiantes:

List> [True, 2, 3, 4, 5]
ERROR - Cannot infer instance
*** Instance   : Num Bool
*** Expression : [True,2,3,4,5]

Instalación

Instalación de Cabal

Para instalar la Biblioteca de empaquetamiento Cabal en Windows podemos seguir los pasos indicados [aquí], si por el contrario se quiere instalar en Linux se instalará del mismo modo que se explica en Data.Vector.

Instalación de Data.List

Una vez hayamos instalado Cabal debemos instalar la biblioteca Data.List para aprovechar toda la funcionalidad de la misma. Para ello debemos hacer:

   $ cabal install list

desde la consola del sistema.

Funciones

A continuación vamos a analizar algunos de los paquetes de funciones que contiene la librería Data.List


Funciones Básicas

(++)

 (++) :: [a] -> [a] -> [a]
Concatena dos listas.
Si x e y son dos listas el resultado de aplicar (++) sería:
[x1, ..., xm] ++ [y1, ..., yn] == [x1, ..., xm, y1, ..., yn]
Si la primera lista no es finita el resultado sería directamente la primera lista.
DataListBasica-Estructura.png

head

 head :: [a] -> a
Extrae el primer elemento de una lista, la cual no puede estar vacía.

tail

 tail :: [a] -> [a]
Extrae los elementos siguientes a la cabecera de la lista, la cual no puede estar vacía.

last

 last :: [a] -> a
Extrae el último elemento de una lista, la cual no puede estar vacía y debe ser finita.

init

 init :: [a] -> [a]
Extrae todos los elementos de una lista excepto el último. Como en las operaciones anteriores, la lista no puede estar vacía.

null

 null :: [a] -> Bool
Comprueba si una lista está vacía

length

 length :: [a] -> Int
O(n) devuelve la longitud de una lista finita como un Entero. Es una instancia de una operación más genérica Data.List.genericLength.

Funciones de Transformación

map

map :: (a -> b) -> [a] -> [b]

La función map recibe como argumentos una función y una lista de elementos, devuelve el resultado de aplicar la función a cada uno de los elementos de la lista.

reverse

reverse :: [a] -> [a]

La función reverse devuelve la inversión de la lista que recibe como argumento. La lista a revertir debe ser una lista finita de elementos.

Hugs> reverse [1..10]
[10,9,8,7,6,5,4,3,2,1]


intersperse

intersperse :: a -> [a] -> [a]

La función intersperse recibe un elemento y una lista de elementos. Como resultado devuelve una lista donde se intercala cada elemento en medio de cada uno de los elementos de la lista.

List> intersperse ',' "123455"
"1,2,3,4,5,5"

intercalate

intercalate :: [a] -> [[a]] -> [a]

Esta función es equivalente a concat (intersperse xs xss) y básicamente inserta la lista xs entre las listas de xss. Como podemos apreciar el primer argumento es una lista y el segundo una lista de listas.

Prelude Data.List> intercalate "::" ["89","32","34","01"]
"89::32::34::01"

transpose

transpose :: [[a]] -> [[a]]

transpose transpone filas y columnas de las listas que se le pasan como argumento. Puede asemejarse al termino matemático obtener la [traspuesta de una matriz].

Prelude Data.List> transpose [[1,2,3],[4,5,6]]
[[1,4],[2,5],[3,6]]


subsequences

subsequences :: [a] -> [[a]]

La función subsequences genera todos los subconjuntos posibles de la lista que recibe como parámetro.

Prelude Data.List> subsequences [1,2,3]
[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]


permutations

permutations :: [a] -> [[a]]

De una lista también pueden calcularse todas las posibles [permutaciones] de sus elementos mediante la función permutations. Podemos ver un ejemplo aquí:

Prelude Data.List> permutations "XYZ"
["XYZ","YXZ","ZYX","YZX","ZXY","XZY"]

Funciones de Plegado

foldl

foldl :: (a -> b -> a) -> a -> [b] -> a

foldl, aplicado a un operador binario, un valor inicial (normalmente, el que está a la izquierda del operador) y una lista, reduce la lista usando el operador binario, de izquierda a derecha:

foldl f z [x1, x2, ..., xn] == (...((z `f` x1) `f` x2) `f`...) `f` xn

La lista debe ser finita.


foldl'

foldl' :: (a -> b -> a) -> a -> [b] -> a

Una versión estricta de foldl.


foldl1

foldl1 :: (a -> a -> a) -> [a] -> a

foldl1 es una variante de foldl sin valor inicial, que debe ser aplicada a listas no vacías.


foldl1'

foldl1' :: (a -> a -> a) -> [a] -> a

Una versión estricta de foldl1.


foldr

foldr :: (a -> b -> b) -> b -> [a] -> b

foldr, aplicado a un operador binario, un valor inicial (normalmente, el que está a la derecha del operador) y una lista, reduce la lista usando el operador binario, de derecha a izquierda:

 foldr f z [x1, x2, ..., xn] == x1 `f` (x2 `f` ... (xn `f` z)...)


foldr1

foldr1 :: (a -> a -> a) -> [a] -> a

foldr1 es una variante de foldr sin valor inicial, que debe ser aplicada a listas no vacías.


Plegados especiales


concat

concat :: [[a]] -> [a]

Concatena una lista de listas.


concatmap

concatmap :: (a -> [b]) -> [a] -> [b]

Ejecuta una función sobre los elementos de una lista y concatena los resultados.


and

and :: [Bool] -> Bool 

Devuelve la conjunción de una lista de booleanos. Para que el resultado sea True, la lista debe ser finita. Para que sea False, debe existir un valor False en un índice finito de una lista finita o infinita.


or

or :: [Bool] -> Bool 

Devuelve la disyunción de una lista de booleanos. Para que el resultado sea False, la lista debe ser finita. Para que sea True, debe existir un valor True en un índice finito de una lista finita o infinita.


any

any :: (a -> Bool) -> [a] -> Bool

Aplicada a un predicado y a una lista, any determina si algún elemento de la lista satisface el predicado. Para que el resultado sea False, la lista debe ser finita. Para que sea True, debe existir un valor True en un índice finito de una lista finita o infinita.


all

all :: (a -> Bool) -> [a] -> Bool

Aplicada a un predicado y a una lista, all determina si todos los elementos de la lista satisfacen el predicado. Para que el resultado sea True, la lista debe ser finita. Para que sea False, debe existir un valor False en un índice finito de una lista finita o infinita.


sum

sum :: Num a => [a] -> a

La función sum calcula la suma de una lista finita de números.


product

product :: Num a => [a] -> a

La función product calcula el producto de una lista finita de números.


maximum

maximum :: Ord a => [a] -> a

Devuelve el valor máximo de una lista, la cual debe ser no vacía, finita y de un tipo ordenado. Es un caso especial de maximumBy, que permite al programador utilizar su propia función de comparación.


minimum

minimum :: Ord a => [a] -> a

Devuelve el valor mínimo de una lista, la cual debe ser no vacía, finita y de un tipo ordenado. Es un caso especial de minimumBy, que permite al programador utilizar su propia función de comparación.


Construyendo Listas por Comprensión

Haskell permite definir listas mediante una notación por comprensión.


Escaneos

Un "scan" es una mezcla entre un "map" o mapeado y un "fold" o plegado. Plegar una lista devuelve un valor acomulado, mientras que al mapearla aplicamos una función a cada elemento sin acumular los resultados. Un escaneado realiza ambas operaciones: acumula el valor como un plegado pero en lugar de retornar el valor final devuelve una lista de valores.


scanl

scanl :: (a -> b -> a) -> a -> [b] -> [a] 

Vamos acumulando de izquierda a derecha, y el segundo argumento se convierte en el primer elemento de la lista resultante.

scanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...]

Es similar a foldl, de hecho podemos decir que:

last (scanl f z xs) == foldl f z xs.


scanl1

scanl1 :: (a -> a -> a) -> [a] -> [a] 

Es una variante de scanl, pero sin parametro inicial:

scanl1 f [x1, x2, ...] == [x1, x1 `f` x2, ...]



scanr

scanr :: (a -> b -> b) -> b -> [a] -> [b] 

Vamos acumulando de derecha a izquierda; el comportamiento es idéntico a scanl pero cambiando el sentido del mismo.

scanr :: (a -> b -> b) -> b -> [a] -> [b]

De hecho, se mantiene además la misma relación con foldr:

head (scanr f z xs) == foldr f z xs


scanr1

 scanr1 :: (a -> a -> a) -> [a] -> [a] 

Es una variante de scanr, pero sin parametro inicial.


Mapeos


mapAccumL

mapAccumL :: (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])

La función mapAccumL se comporta como una combinación de las funciones "map" y "foldl"; lo que hace es aplicar una función a cada elemento de una lista, pasando posteriormente un parametro acumulativo de izquierda a derecha, retornando el valor final acumulado y la nueva lista.


mapAccumR

mapAccumR :: (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])

La función mapAccumR se comporta como una combinación de las funciones "map" y "foldr"; lo que hace es aplicar una función a cada elemento de una lista, pasando posteriormente un parametro acumulativo de derecha a izquierda, retornando el valor final acumulado y la nueva lista.


Listas infinitas


iterate

iterate :: (a -> a) -> a -> [a]

iterate f x devuelve una lista infinita del resultado de aplicar f a x

iterate f x == [x, f x, f (f x), ...]


repeat

repeat :: a -> [a]

Genera una lista infinita de elementos a.

replicate

replicate :: Int -> a -> [a]

Genera una lista de longitud n con el valor de cada elemento a. Es una instancia de Data.List.genericReplicate, en la que n puede ser de cualquier tipo integral.

cycle

cycle :: [a] -> [a]

Convierte una lista finita en una circular, o lo que es lo mismo, es la repetición infinita de la lista original.

Desplegado de listas


unfoldr

unfoldr :: (b -> Maybe (a, b)) -> b -> [a]

La función unfoldr es la contraria a  foldr: mientras foldr reduce la lista a un valor, unfoldr crea una lista partiendo de un valor de inicialización. La función toma el elemento y devuelve Nothing si no se crea la lista o devuelve Just(a, b), en cuyo caso, a es un  valor que se antepone a la lista y b se utiliza como el elemento siguiente de una llamada recursiva. Por ejemplo,

iterate f == unfoldr (\x -> Just (x, f x))

En algunos casos, unfoldr puede servirnos para deshacer un foldr:

 unfoldr f' (foldr f z xs) == xs

si se cumple la siguiente condición:

f' (f x y) = Just (x,y)
f' z = Nothing

Sublistas

Extracción de sublistas

take

take :: Int -> [a] -> [a]

La función take recibe un entero n y una lista xs. Devulve los n primeros elementos de la lista xs. En caso de que n sea mayor que el tamaño total de la lista se devolverá la lista xs completa.

Prelude Data.List> take 3 [1..10]
[1,2,3]

drop

drop :: Int -> [a] -> [a]

Esta función de Data.List es inversa a la anterior, es decir, en vez de devolver los n primeros elementos de la lista suprime los n primeros elementos de la lista. Como ocurría con take si n es mayor que el tamaño total de la lista ahora se devuelve la lista vacía.

Prelude Data.List> drop 3 [1..10]
[4,5,6,7,8,9,10]

Como vemos las dos funciones anteriores son complementarias. Por ejemplo podemos hacer lo siguiente:

Prelude Data.List> take 3 [1..10] ++ drop 3 [1..10]
[1,2,3,4,5,6,7,8,9,10]

splitAt

splitAt :: Int -> [a] -> ([a], [a])

La función devuelve una tupla formada por los n primeros elementos de la lista en su primera componente, en su segunda componente recibiremos el resto de elementos. Siendo n un número entero que se recibe por parámetro.

Prelude Data.List> splitAt 4 ['a'..'z']
("abcd","efghijklmnopqrstuvwxyz")

takeWhile

takeWhile :: (a -> Bool) -> [a] -> [a] 

Esta función extrae elementos de la lista que recibe como segundo parámetro, siempre y cuando, los elementos de la lista vayan cumpliendo el predicado p que recibe como primer parámetro.

Prelude Data.List> takeWhile (< 5) [1..10]++[1..5]
[1,2,3,4,1,2,3,4,5]

El ejemplo extra de la lista que recibe por parámetro todos aquellos elementos que cumplen el predicado p = x < 5.

dropWhile

dropWhile :: (a -> Bool) -> [a] -> [a] 

Se eliminan de la lista [a] aquellos elementos que cumplan el predicado del tipo (a -> Bool). Se deja de evaluar en cuanto aparezca un elemento que no cumpla el predicado.

Prelude Data.List> dropWhile (< 3)
[1..8] [3,4,5,6,7,8] 

La expresión del ejemplo elimina de la lista aquellos elementos menores que 3.

span

span :: (a -> Bool) -> [a] -> ([a], [a]) 

Nos devuelve una tupla formada en su primera componente por los elementos de la lista [a] que cumplen el predicado del tipo (a -> Bool) que recibe por parámetro, la segunda componente de la tupla está formada por los elementos que no cumplen el predicado.

Prelude Data.List> span (< 5) [1..10]
([1,2,3,4],[5,6,7,8,9,10])

break

break :: (a -> Bool) -> [a] -> ([a], [a]) 

break Devuelve una tupla formada por dos componentes: La primera corresponde con los elementos de la lista [a] que no cumplen el predicado (a -> Bool), la segunda tiene el resto de elementos. La primera componente puede ser la lista vacía [].

Prelude Data.List> break (> 3) [1,2,3,4,1,2,3,4]
([1,2,3],[4,1,2,3,4])

Como ven en cuanto se encuentra un elemento que si cumple el predicado, se deja de evaluar el resto de la lista.

stripPrefix

stripPrefix :: Eq a => [a] -> [a] -> Maybe [a]

Borra de la lista [a] que recibe como segundo argumento, el prefijo formado por la lista que recibe como primer argumento. La función devuelve Nothing si no concuerdan los prefijos, y Just y el resto de la lista si es cierto que hay concordancia.

Prelude Data.List> stripPrefix "foo" "foobar"
Just "bar"

group

group :: Eq a => [a] -> [[a]]

La función group devuelve una lista de listas formada por donde cada sublista está formada por una ocurrencia distinta de los elementos que conforman [a] que recibe como parámetro.

Prelude Data.List> group "aabbcde"
["aa","bb","c","d","e"]

inits

inits :: [a] -> [[a]]

Se devuelven todos los segmentos iniciales de la lista que recibe como argumento. Los más cortos primero.

Prelude Data.List> inits "adolfo"
["","a","ad","ado","adol","adolf","adolfo"]

tails

tails :: [a] -> [[a]]

Nos proporciona todos los segmentos finales del argumento. Los más largos primero.

Prelude Data.List> tails "adolfo"
["adolfo","dolfo","olfo","lfo","fo","o",""]

Funciones de Búsqueda

Búsquedas por igualdad


elem

elem :: Eq a => a -> [a] -> Bool

elem es el predicado de pertenencia a listas, normalmente escrito en notación infija (por ejemplo, x `elem` xs). Para que el resultado sea False, la lista debe ser finita. Para que sea True, debe encontrarse un elemento igual a x en un índice finito de una lista finita o infinita.


notElem

notElem :: Eq a => a -> [a] -> Bool

notElem es la negación de elem.


lookup

lookup :: Eq a => a -> [(a, b)] -> Maybe b

lookup busca una key en una lista de asociación.

Búsquedas con un predicado


find

find :: (a -> Bool) -> [a] -> Maybe a

La función find recibe un predicado y una lista y devuelve el primer elemento de la lista que satisfaga el predicado, o Nothing si no hay ninguno.


filter

filter :: (a -> Bool) -> [a] -> [a]

filter, aplicada a un predicado y una lista, devuelve la lista de elementos que satisfacen el predicado. Es decir,

filter p xs = [ x | x <- xs, p x]


partition

partition :: (a -> Bool) -> [a] -> ([a], [a])

La funcion partition recibe un predicado y una lista y devuelve el par de listas de elementos que satisfacen y no satisfacen el predicado, respectivamente. Es decir,

partition p xs == (filter p xs, filter (not . p) xs)


Indexando Listas

Estas funciones tratan una lista xs como una colección indexada, cuyos índices van desde 0 a xs -1.

(!!)

(!!) :: [a] -> Int -> a

Es una instancia de genericIndex, es un operador que se usa para devolver un índice.


elemIndex

elemIndex :: Eq a => a -> [a] -> Maybe Int

La función elemIndex devuelve el índice del primer elemento de la lista dada que sea igual al elemento buscado o Nothing si no se encuentra dicho elemento.


elemIndices

elemIndices :: Eq a => a -> [a] -> [Int]

La función elemIndices amplía a elemIndex, devolviendo los índices de todos los elementos iguales al solicitado en la búsqueda en orden ascendente.


findIndex

findIndex :: (a -> Bool) -> [a] -> Maybe Int

La función findIndex toma un predicado y una lista y devuelve el índice del primer elemento de la lista que tasiface el predicado o Nothing si no hay ninguno que lo haga.


findIndices

findIndices :: (a -> Bool) -> [a] -> [Int]

La función findIndices amplía a findIndex, devolviendo los índices de todos los elementos que satisfacen el predicado en orden ascendente.

Comprimiento y Descomprimiendo listas

zip, zip3, zip4, zip5, zip6, zip7

zip :: [a] -> [b] -> [(a, b)]

zip toma dos listas y devuelve una lista de pares. Si una lista es más corta que la otra, los elementos sobrantes de la mayor son descartados.

Existen una serie de funciones análogas a esta que funcionan con 3,4,5,6 y 7 listas respectivamente:

zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]
zip4 :: [a] -> [b] -> [c] -> [d] -> [(a, b, c, d)]
zip5 :: [a] -> [b] -> [c] -> [d] -> [e] -> [(a, b, c, d, e)]
zip6 :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [(a, b, c, d, e, f)]
zip7 :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [(a, b, c, d, e, f, g)]


zipWith

zipWith es una generalización de zip que usa una función para comprimir las dos listas. Por ejemplo zipWith con la función (+) como parámetro y dos listas, devolvería como resultado la lista resultado de la suma de las dos facilitadas por parámetro. Si una lista es más corta que la otra, los elementos sobrantes de la mayor son descartados.

zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]

Existen una serie de funciones análogas a esta que funcionan con 3,4,5,6 y 7 listas respectivamente:

zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
zipWith4 :: (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e]
zipWith5 :: (a -> b -> c -> d -> e -> f) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f]
zipWith6 :: (a -> b -> c -> d -> e -> f -> g) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g]
zipWith7 :: (a -> b -> c -> d -> e -> f -> g -> h) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [h]


unzip

unzip transforma una lista de pares en dos listas independientes cada una formada por cad auno de los componentes del par.

unzip :: [(a, b)] -> ([a], [b])

Existen una serie de funciones análogas a esta que funcionan con 3,4,5,6 y 7 listas respectivamente:

unzip3 :: [(a, b, c)] -> ([a], [b], [c])
unzip4 :: [(a, b, c, d)] -> ([a], [b], [c], [d])
unzip5 :: [(a, b, c, d, e)] -> ([a], [b], [c], [d], [e])
unzip6 :: [(a, b, c, d, e, f)] -> ([a], [b], [c], [d], [e], [f])
unzip7 :: [(a, b, c, d, e, f, g)] -> ([a], [b], [c], [d], [e], [f], [g])


Listas especiales

Funciones sobre cadenas de caracteres (String)

lines

lines :: String -> [String]

La función lines rompe una cadena de caracteres en líneas de caracteres. Cada nueva cadena se produce al encontrarse con el caracter de salto de línea (\n)

Prelude Data.List> lines "data\nlist"
["data","list"]

words

words :: String -> [String]

words rompe una cadena de caracteres que recibe como parámetro en palabras, separando cada palabra a partir del carácter espacio en blanco.

Prelude Data.List> words "data list es una fantastica libreria de haskell"
["data","list","es","una","fantastica","libreria","de","haskell"]

unlines

unlines :: [String] -> String

unlines podemos decir que es la función inversa de lines. Recibe una lisa de String y devuelve un solo String con todas las Strings de la lista que ha recibido por parámetro concatenadas insertado entre cada String un carácter especial de salto de línea.

Prelude Data.List> unlines ["data","list"]
"data\nlist\n"

unwords

unwords :: [String] -> String

Esta función es la inversa de words. Devuelve un solo String con un carácter espacio en blanco entre cada cadena de las recibidas como parámetro.

Prelude Data.List> unlines ["data","list"]
"data\nlist\n"

Operaciones sobre conjuntos (sets)

nub

nub :: Eq a => [a] -> [a]

La función nub elimina los elementos duplicados de la lista que recibe por parámetor. En particular se deja solo la primera ocurrencia del elemento. Esta función pertenece al orden de complejidad O(n^2).

Prelude Data.List> nub "data.list"
"dat.lis"

delete

delete :: Eq a => a -> [a] -> [a]

delete elimina la primera ocurrencia de x en la lista xs que recibe como segundo parámetro.

Prelude Data.List> delete 'a' "data.list"
"dta.list"

(\\)

(\\) :: Eq a => [a] -> [a] -> [a]

El operador (\\) devuelve una lista con aquellos elementos que pertenecen a la primera lista pasada por parámetro y no están en la segunda lista.

Prelude Data.List> (\\) "data.list" "data.vector"
"lis"

union

union :: Eq a => [a] -> [a] -> [a]

union devuelve la unión de aquellas dos listas que recibe por parámetro. Esto quiere decir que aquellos elementos de la primera lista que estén también en la segunda lista no aparecerán repetidos.

Prelude Data.List> union "data" "list"
"datalis"

intersect

intersect :: Eq a => [a] -> [a] -> [a]

Devuelve la intersección de las dos listas que recibe como parámetros. Esto quiere decir aquellos elementos que son comunes a las dos listas.

Prelude Data.List> intersect "data" "list"
"t"

Listas ordenadas

sort

sort :: Ord a => [a] -> [a]

La función sort ordena la lista que recibe como parámetro. La ordenación se realiza de menor a mayor.

Prelude Data.List> sort "data.list"
".aadilstt"

insert

insert :: Ord a => a -> [a] -> [a]

insert inserta el elemento x que recibe como parámetro delante de la primera ocurrencia de ese mismo elemento en la lista que recibe como parámetro. Si el elemento no se encuentra en la lista se colocará al final.

Prelude Data.List> insert 'x' "data.list"
"data.listx"

Funciones Generalizadas

Las operaciones "By"

Por convenio, las funciones sobrecargadas tienen una contrapartida no sobrecargado cuyo nombre añade el sufijo By.

A menudo, es conveniente utilizar estas funciones junto con Data.Function.on, por ejemplo sortBy.

Igualdad facilitada por el usuario (reemplazando Eq)

Se asume que el predicado define una equivalencia.


nubBy

nubBy :: (a -> a -> Bool) -> [a] -> [a]

La función nubBy se comporta como num, salvo que usa un predicado de igualdad facilitado por el usuario en lugar de la función sobrecargada ==.


deleteBy

deleteBy :: (a -> a -> Bool) -> a -> [a] -> [a]

La función deleteBy se comporta como delete, pero usa un predicado de igualdad facilitado por el usuario.


deleteFirstsBy

deleteFirstsBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]

La función deleteFirstsBy recibe un predicado y dos listas, y devuelve la primera lista con la primera ocurrencia de cada elemento de la segunda eliminada.


unionBy

unionBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]

La función unionBy es una versión no sobrecargada de union.


intersectBy

intersectBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]

La función intersectBy es una versión no sobrecargada de intersect.


groupBy

groupBy :: (a -> a -> Bool) -> [a] -> [[a]]

La función groupBy es una versión no sobrecargada de group.

Comparación facilitada por el usuario (reemplazando Ord)

Se asume que la función define una ordenación total.


sortBy

sortBy :: (a -> a -> Ordering) -> [a] -> [a]

La función sortBy es una versión no sobrecargada de sort.


insertBy

insertBy :: (a -> a -> Ordering) -> a -> [a] -> [a]

Una versión no sobrecargada de insert.


maximumBy

maximumBy :: (a -> a -> Ordering) -> [a] -> a

La función maximumBy recibe una función de comparación y una lista, y devuelve el mayor de los elementos de la lista según la función de comparación. La lista debe ser finita y no estar vacía.


minimumBy

minimumBy :: (a -> a -> Ordering) -> [a] -> a

La función minimumBy recibe una función de comparación y una lista, y devuelve el menor de los elementos de la lista según la función de comparación. La lista debe ser finita y no estar vacía.

Las operaciones "generic"

El prefijo 'generic' indica una función sobrecargada que es una versión generalizada de una del preludio.


genericLength

genericLength :: Num i => [b] -> i

La función genericLenght es una versión sobrecargada de length. En particular, en lugar de devolver un entero, devuelve cualquier tipo que sea una instancia de Num. Sin embargo, es menos eficiente que length.


genericTake

genericTake :: Integral i => i -> [a] -> [a]

La función genericTake es una versión sobrecargada de take, que acepta cualquier valor Integral como número de elementos.


genericDrop

genericDrop :: Integral i => i -> [a] -> [a]

La función genericTake es una versión sobrecargada de take, que acepta cualquier valor Integral como número de elementos.


genericSplitAt

genericSplitAt :: Integral i => i -> [b] -> ([b], [b])

La función genericSplitAt es una versión sobrecargada de splitAt, que acepta cualquier valor Integral como la posición desde la cual se divide.


genericIndex

genericIndex :: Integral a => [b] -> a -> b

La función genericIndex es una versión sobrecargada de !!, que acepta cualquier valor Integral como índice.


genericReplicate

genericReplicate :: Integral i => i -> a -> [a]

La función genericReplicate es una versión sobrecargada de replicate, que acepta cualquier valor Integral como número de repeticiones a realizar.


Referencias

http://users.skynet.be/jyp/html/base/Data-List.html

http://en.wikibooks.org/wiki/Haskell/Lists_and_tuples

http://www.willamette.edu/~fruehr/haskell/lectures/tutorial3.html#@sli@24

http://www.sc.ehu.es/jiwlucap/FuncionesListas.pdf


Herramientas personales