Los diccionarios (también llamados listas de asociación) son listas utilizadas para almacenar pares clave-valor donde el orden no importa. Por ejemplo, podemos tener un diccionario para almacenar números de teléfono, donde los números de telefono serían los valores y los nombres de la gente serían las claves. No nos importa el orden en el que estén almacenados, sólo queremos obtener el número correspondiente cada persona.
En este manual se presentan ejemplos de las funciones de la librería de diccionarios Data.Map 0.5.5.1. En los ejemplos se supone que se han importado la siguiente librería
ghci> import Data.Map as M
(Map k a)
es el tipo de los diccionarios con las claves de tipo k ylos valores de tipo a. Por ejemplo,ghci> let d1 = fromList [("Ana",5),("Juan",7),("Eva",6)]
ghci> :t d1
d1 :: Map [Char] Integer
ghci> let d2 = fromList [("Ana",5),("Eva",6),("Juan",7)]
ghci> d1 == d2
True
empty
es el diccionario vacío. Por ejemplo,ghci> empty
fromList []
(singleton k x)
es el diccionario cuya única clave es k
u su valor es x
. Por ejemplo,ghci> singleton 'd' 4
fromList [('d',4)]
(insert k x d)
es el diccionario obtenido añadiéndole a d
el par (k,x)
y eliminando el valor de k
en d
en el caso de que existiera. Por ejemplo,ghci> insert 3 7 empty
fromList [(3,7)]
ghci> insert 3 'c' (fromList [(4,'a'),(6,'b'),(8,'e')])
fromList [(3,'c'),(4,'a'),(6,'b'),(8,'e')]
ghci> insert 6 'c' (fromList [(4,'a'),(6,'b'),(8,'e')])
fromList [(4,'a'),(6,'c'),(8,'e')]
(insertWith f k x d)
es el diccionario obtenido añadiéndole a d
el par (k,x)
si k
no es una clave de d
o el par (k,f x y)
si el par (k,y)
pertenece a d
. Por ejemplo,ghci> insertWith (++) 7 "d" (fromList [(5,"a"), (3,"b")])
fromList [(3,"b"),(5,"a"),(7,"d")]
ghci> insertWith (++) 3 "d" (fromList [(5,"a"), (3,"b")])
fromList [(3,"db"),(5,"a")]
ghci> insertWith (*) 3 2 (fromList [(5,6), (3,4)])
fromList [(3,8),(5,6)]
ghci> insertWith (*) 3 2 empty
fromList [(3,2)]
(insertWithKey f k x d)
es el diccionario obtenido añadiéndole a d
el par (k,x)
si k
no es una clave de d
o el par (k,f k x y)
si el par (k,y)
pertenece a d
. Por ejemplo,ghci> let f k x y = y ++ concat (replicate k x)
ghci> insertWithKey f 7 "d" (fromList [(5,"a"), (3,"b")])
fromList [(3,"b"),(5,"a"),(7,"d")]
ghci> insertWithKey f 3 "m" (fromList [(5,"a"), (3,"b")])
fromList [(3,"bmmm"),(5,"a")]
(insertLookupWithKey f k x d)
es el par (lookup k d,insertWithKey f k x d)
. Por ejemplo,ghci> let f k x y = y ++ concat (replicate k x)
ghci> insertLookupWithKey f 7 "m" (fromList [(5,"a"), (3,"b")])
(Nothing,fromList [(3,"b"),(5,"a"),(7,"m")])
ghci> insertLookupWithKey f 3 "m" (fromList [(5,"a"), (3,"b")])
(Just "b",fromList [(3,"bmmm"),(5,"a")])
(delete k d)
es el diccionario obtenido eliminando en d
la clave k
y su valor. Por ejemplo,ghci> delete 3 (fromList [(5,"a"),(3,"b"),(7,"d")])
fromList [(5,"a"),(7,"d")]
ghci> delete 4 (fromList [(5,"a"),(3,"b"),(7,"d")])
fromList [(3,"b"),(5,"a"),(7,"d")]
(adjust f k d)
cambia el par (k,x)
por (k,f x)
, si k
es una clave de d
y lo deja igual, en caso contrario. Por ejemplo,ghci> adjust (+2) 3 (fromList [(5,1),(3,6)])
fromList [(3,8),(5,1)]
ghci> adjust (+2) 4 (fromList [(5,1),(3,6)])
fromList [(3,6),(5,1)]
(adjustWithKey f k d)
cambia el par (k,x)
por (k,f k x)
, si k
es una clave de d
y lo deja igual, en caso contrario. Por ejemplo,ghci> let f k x = k*x
ghci> adjustWithKey f 3 (fromList [(5,1),(3,6)])
fromList [(3,18),(5,1)]
ghci> adjustWithKey f 4 (fromList [(5,1),(3,6)])
fromList [(3,6),(5,1)]
ghci> adjustWithKey f 4 empty
fromList []
(update f k d)
actualiza el diccionario d
de la siguiente forma:
k
es una clave de d
con valor x
y f x
es Just y
, cambia (k,x)
por (k,y)
;k
es una clave de d
con valor x
y f x
es Nothing
, borra (k,x)
yk
no es una clave de d
, deja d
igual. Por ejemplo,ghci> let f x = if odd x then Just (2*x) else Nothing
ghci> update f 4 (fromList [(3,2),(4,5)])
fromList [(3,2),(4,10)]
ghci> update f 3 (fromList [(3,2),(4,5)])
fromList [(4,5)]
ghci> update f 6 (fromList [(3,2),(4,5)])
fromList [(3,2),(4,5)]
(updateWithKey f k d)
actualiza el diccionario d
de la siguiente forma:
k
es una clave de d
con valor x
y f k x
es Just y
, cambia (k,x)
por (k,y)
;k
es una clave de d
con valor x
y f k x
es Nothing
, borra (k,x)
yk
no es una clave de d
, deja d
igual. Por ejemplo,ghci> let f k x = if odd x then Just (k*x) else Nothing
ghci> updateWithKey f 4 (fromList [(3,2),(4,5)])
fromList [(3,2),(4,20)]
ghci> updateWithKey f 3 (fromList [(3,2),(4,5)])
fromList [(4,5)]
ghci> updateWithKey f 6 (fromList [(3,2),(4,5)])
fromList [(3,2),(4,5)]
(updateLookupWithKey f k d)
actualiza el diccionario d
de la siguiente forma:
k
es una clave de d
con valor x
y f k x
es Just y
, devuelve (Just y,d')
donde d'
se obtiene cambiando en d
el par (k,x)
por (k,y)
;k
es una clave de d
con valor x
y f k x
es Nothing
, devuelve (Just y,d')
donde d'
se obtiene borrando en d
el par (k,x)
yk
no es una clave de d
, devuelve (Nothing,d)
. Por ejemplo,ghci> let f k x = if odd x then Just (k*x) else Nothing
ghci> updateLookupWithKey f 4 (fromList [(3,2),(4,5)])
(Just 20,fromList [(3,2),(4,20)])
ghci> updateLookupWithKey f 3 (fromList [(3,2),(4,5)])
(Just 2,fromList [(4,5)])
ghci> updateLookupWithKey f 6 (fromList [(3,2),(4,5)])
(Nothing,fromList [(3,2),(4,5)])
(alter f k d)
permite insertar, eliminar o actualizar el valor de la clave k
en el diccionario d
. Por ejemplo,ghci> let f _ = Nothing
ghci> alter f 4 (fromList [(3,2),(4,5)])
fromList [(3,2)]
ghci> alter f 7 (fromList [(3,2),(4,5)])
fromList [(3,2),(4,5)]
ghci> let f _ = Just 9
ghci> alter f 4 (fromList [(3,2),(4,5)])
fromList [(3,2),(4,9)]
ghci> alter f 7 (fromList [(3,2),(4,5)])
fromList [(3,2),(4,5),(7,9)]
null d
se verifica si el diccionario d
es vacío. Por ejemplo,ghci> M.null (fromList [])
True
ghci> M.null (fromList [(3,2)])
False
(size d)
es el número de elementos del diccionario d
. Por ejemplo,ghci> size empty
0
ghci> size (fromList [(4,'a'),(5,'b'),(2,'e')])
3
ghci> size (fromList [(4,'a'),(5,'b'),(2,'e'),(4,'a')])
3
ghci> size (fromList [(4,'a'),(5,'b'),(2,'e'),(4,'c')])
3
(lookup x d)
es justo el valor del elemento del diccionario d
cuya clave es x
, si hay alguno y Nothing
, en caso contrario. Por ejemplo,ghci> M.lookup 5 (fromList [(4,'a'),(5,'b'),(2,'e')])
Just 'b'
ghci> M.lookup 7 (fromList [(4,'a'),(5,'b'),(2,'e')])
Nothing
(member x d)
se verifica si x
es un elemento del diccionadio d
. Por ejemplo,ghci> member 5 (fromList [(4,'a'),(5,'b'),(2,'e')])
True
ghci> member 7 (fromList [(4,'a'),(5,'b'),(2,'e')])
False
(notMember x d)
se verifica si x
no es un elemento del diccionadio d
. Por ejemplo,ghci> notMember 7 (fromList [(4,'a'),(5,'b'),(2,'e')])
True
ghci> notMember 5 (fromList [(4,'a'),(5,'b'),(2,'e')])
False
(d ! x)
es el valor de la clave x
en el diccionario d
. Por ejemplo,ghci> fromList [(4,'a'),(5,'b'),(2,'e')] ! 5
'b'
ghci> fromList [(4,'a'),(5,'b'),(2,'e')] ! 7
*** Exception: Map.!: given key is not an element in the map
(findWithDefault v k d)
es el valor de la clave k
en el diccionario d
, si k
es una clave de d
y es v
, en caso contrario. Por ejemplo,ghci> findWithDefault 'p' 5 (fromList [(4,'a'),(5,'b'),(2,'e')])
'b'
ghci> findWithDefault 'p' 7 (fromList [(4,'a'),(5,'b'),(2,'e')])
'p'
(lookupLT x d)
es justo el valor de la mayor clave de d
menor que x
, si hay alguna y Nothing
, en caso contrario. Por ejemplo,ghci> lookupLT 3 (fromList [(4,'a'),(5,'b'),(2,'e')])
Just (2,'e')
ghci> lookupLT 2 (fromList [(4,'a'),(5,'b'),(2,'e')])
Nothing
(lookupGT x d)
es justo el valor de la menor clave de d
mayor que x
, si hay alguna y Nothing
, en caso contrario. Por ejemplo,ghci> lookupGT 4 (fromList [(4,'a'),(6,'b'),(8,'e')])
Just (6,'b')
ghci> lookupGT 9 (fromList [(4,'a'),(6,'b'),(8,'e')])
Nothing
(lookupLE x d)
es justo el valor de la mayor clave de d
menor o igual que x
, si hay alguna y Nothing
, en caso contrario. Por ejemplo,ghci> lookupLE 3 (fromList [(4,'a'),(5,'b'),(2,'e')])
Just (2,'e')
ghci> lookupLE 2 (fromList [(4,'a'),(5,'b'),(2,'e')])
Just (2,'e')
ghci> lookupLE 1 (fromList [(4,'a'),(5,'b'),(2,'e')])
Nothing
(lookupGE x d)
es justo el valor de la menor clave de d
mayor o igual que x
, si hay alguna y Nothing
, en caso contrario. Por ejemplo,ghci> lookupGE 4 (fromList [(4,'a'),(6,'b'),(8,'e')])
Just (4,'a')
ghci> lookupGE 8 (fromList [(4,'a'),(6,'b'),(8,'e')])
Just (8,'e')
ghci> lookupGE 9 (fromList [(4,'a'),(6,'b'),(8,'e')])
Nothing
(findIndex k d)
es la posición de la clave k
en d
, contando a partir de 0. Por ejemplo,ghci> findIndex 3 (fromList [(5,"a"), (3,"b")])
0
ghci> findIndex 5 (fromList [(5,"a"), (3,"b")])
1
ghci> findIndex 7 (fromList [(5,"a"), (3,"b")])
*** Exception: Map.findIndex: element is not in the map
(lookupIndex k d)
es justo la posición de la clavek
en d
, contando a partir de 0. Por ejemplo,ghci> lookupIndex 3 (fromList [(5,"a"), (3,"b")])
Just 0
ghci> lookupIndex 5 (fromList [(5,"a"), (3,"b")])
Just 1
ghci> lookupIndex 7 (fromList [(5,"a"), (3,"b")])
Nothing
(elemAt n d)
es el elemento de d
en la posición n, contando a partir de 0. Por ejemplo,ghci> elemAt 0 (fromList [(5,"a"), (3,"b")])
(3,"b")
ghci> elemAt 1 (fromList [(5,"a"), (3,"b")])
(5,"a")
ghci> elemAt 2 (fromList [(5,"a"), (3,"b")])
*** Exception: Map.elemAt: index out of range
(updateAt f n x)
actualiza el diccionario d
de la siguiente forma:
(k,x)
es la clave de d
en la posición n
(empezando en 0) y f k x
es Just y
, cambia (k,x)
por (k,f k x)
;(k,x)
es la clave de d
en la posición n
(empezando en 0) y f k x
es Nothing
, borra (k,x)
yn
es mayor que la longitud de d
, da un error. Por ejemplo,ghci> let f k x = if odd x then Just (k*x) else Nothing
ghci> updateAt f 0 (fromList [(5,4), (3,1)])
fromList [(3,3),(5,4)]
ghci> updateAt f 1 (fromList [(5,4), (3,1)])
fromList [(3,1)]
ghci> updateAt f 2 (fromList [(5,4), (3,1)])
fromList *** Exception: Map.updateAt: index out of range
(deleteAt n d)
es el diccionario obtenido eiminando el elemento de d
en la posición n
, contando a partir de 0. Por ejemplo,ghci> deleteAt 0 (fromList [(5,4), (3,1)])
fromList [(5,4)]
ghci> deleteAt 1 (fromList [(5,4), (3,1)])
fromList [(3,1)]
ghci> deleteAt 2 (fromList [(5,4), (3,1)])
fromList *** Exception: Map.deleteAt: index out of range
(isSubmapOf d1 d2)
se verifica si d1
es un subdiccionario de d2
; es decir, todas las claves de d1
están en d2
. Por ejemplo,ghci> isSubmapOf (fromList [(5,2),(3,7)]) (fromList [(3,7),(5,2),(7,8)])
True
ghci> isSubmapOf (fromList [(5,2),(3,7)]) (fromList [(3,4),(5,2),(7,8)])
False
(isSubmapOfBy f d1 d2)
se verifica si d1
es un subdiccionario de d2
respecto de f
; es decir, si para clave k
tal que (k,x)
está en d1
y (k,y)
está en d2
se verifica f x y
. Por ejemplo,ghci> isSubmapOfBy (<=) (fromList [(5,2),(3,7)]) (fromList [(3,7),(5,4),(7,8)])
True
ghci> isSubmapOfBy (<=) (fromList [(5,2),(3,7)]) (fromList [(3,1),(5,6),(7,8)])
False
(isProperSubmapOf d1 d2)
se verifica si d1
es un subdiccionario propio de d2
; es decir, todas las claves de d1
están en d2
pero no son iguales. Por ejemplo,ghci> isProperSubmapOf (fromList [(5,2),(3,7)]) (fromList [(3,7),(5,2),(7,8)])
True
ghci> isProperSubmapOf (fromList [(5,2),(3,7)]) (fromList [(3,7),(5,2)])
False
(isProperSubmapOfBy f d1 d2)
se verifica si d1
es un subdiccionario propio de d2
respecto de f
; es decir, son distintos y si para clave k
tal que (k,x)
está en d1
y (k,y)
está en d2
se verifica f x y
. Por ejemplo,ghci> isProperSubmapOfBy (<=) (fromList [(5,2),(3,7)]) (fromList [(3,7),(5,4),(7,8)])
True
ghci> isProperSubmapOfBy (<=) (fromList [(5,2),(3,7)]) (fromList [(3,7),(5,4)])
False
(findMin d)
es el elemento del diccionario d
con la menor clave. Por ejemplo,ghci> findMin (fromList [(5,1), (3,7)])
(3,7)
ghci> findMin empty
*** Exception: Map.findMin: empty map has no minimal element
(findMax d)
es el elemento del diccionario d
con la mayor clave. Por ejemplo,ghci> findMax (fromList [(5,1), (3,7)])
(5,1)
ghci> findMax empty
*** Exception: Map.findMax: empty map has no maximal element
(deleteMin d)
es el diccionario obtenido eliminando el elemento de d
de menor clave. Por ejemplo,ghci> deleteMin (fromList [(5,1), (3,7)])
fromList [(5,1)]
ghci> deleteMin empty
fromList []
(deleteMax d)
es el diccionario obtenido eliminando el elemento de d
de mayor clave. Por ejemplo,ghci> deleteMax (fromList [(5,1), (3,7)])
fromList [(3,7)]
ghci> deleteMax empty
fromList []
(updateMin f d)
sustituye el elemento mínimo (k,x)
de d
por (k,y)
si f x
es Just y
y lo borra en caso contrario. Por ejemplo,ghci> let f x = if x < 5 then Just (x+1) else Nothing
ghci> updateMin f (fromList [("p",7),("b",3)])
fromList [("b",4),("p",7)]
ghci> updateMin f (fromList [("p",7),("b",6)])
fromList [("p",7)]
(updateMax f d)
sustituye el elemento máximo (k,x)
de d
por (k,y)
si f x
es Just y
y lo borra en caso contrario. Por ejemplo,ghci> let f x = if x < 5 then Just (x+1) else Nothing
ghci> updateMax f (fromList [("p",2),("b",6)])
fromList [("b",6),("p",3)]
ghci> updateMax f (fromList [("p",7),("b",6)])
fromList [("b",6)]
(updateMinWithKey f d)
sustituye el elemento mínimo (k,x)
de d
por (k,y)
si f k x
es Just y
y lo borra en caso contrario. Por ejemplo,ghci> let f k x = if odd x then Just (k*x) else Nothing
ghci> updateMinWithKey f (fromList [(3,7),(4,5)])
fromList [(3,21),(4,5)]
ghci> updateMinWithKey f (fromList [(3,6),(4,5)])
fromList [(4,5)]
(updateMaxWithKey f d)
sustituye el elemento mínimo (k,x)
de d
por (k,y)
si f k x
es Just y
y lo borra en caso contrario. Por ejemplo,ghci> let f k x = if odd x then Just (k*x) else Nothing
ghci> updateMaxWithKey f (fromList [(3,6),(4,5)])
fromList [(3,6),(4,20)]
ghci> updateMaxWithKey f (fromList [(3,6),(4,8)])
fromList [(3,6)]
(minView d)
es justo el par formado por el valor del menor elemento de d
y los restantes elementos, si d
es no vacío y Nothing
en caso contrario. Por ejemplo,ghci> minView (fromList [(5,"a"), (3,"b")])
Just ("b",fromList [(5,"a")])
ghci> minView empty
Nothing
(maxView d)
es justo el par formado por el valor del mayor elemento de d
y los restantes elementos, si d
es no vacío y Nothing
en caso contrario. Por ejemplo,ghci> maxView (fromList [(5,"a"), (3,"b")])
Just ("a",fromList [(3,"b")])
ghci> maxView empty
Nothing
(minViewWithKey d)
es justo el par formado por el menor elemento de d
y los restantes elementos, si d
es no vacío y Nothing
en caso contrario. Por ejemplo,ghci> minViewWithKey (fromList [(5,"a"), (3,"b")])
Just ((3,"b"),fromList [(5,"a")])
ghci> minViewWithKey empty
Nothing
(maxViewWithKey d)
es justo el par formado por el mayor elemento de d
y los restantes elementos, si d
es no vacío y Nothing
en caso contrario. Por ejemplo,ghci> maxViewWithKey (fromList [(5,"a"), (3,"b")])
Just ((5,"a"),fromList [(3,"b")])
ghci> maxViewWithKey empty
Nothing
(deleteFindMin d)
es el par formado por el mínimo elemento del diccionario d
y el resto del diccionario. Por ejemplo,ghci> deleteFindMin (fromList [(5,"a"),(3,"b"),(10,"c")])
((3,"b"),fromList [(5,"a"),(10,"c")])
(deleteFindMax d)
es el par formado por el máximo elemento del diccionario d
y el resto del diccionario. Por ejemplo,ghci> deleteFindMax (fromList [(5,"a"),(3,"b"),(10,"c")])
((10,"c"),fromList [(3,"b"),(5,"a")])
(union d1 d2)
es la unión de los diccionarios d1
y d2
(si una clave ocurre en los dos diccionarios coge el valor en el primero). Por ejemplo,ghci> union (fromList [(5,7),(3,4)]) (fromList [(5,9),(7,2),(6,1)])
fromList [(3,4),(5,7),(6,1),(7,2)]
(unionWith f d1 d2)
es la unión de los diccionarios d1
y d2
usando la función f
para combinar las claves (si una clave k
aparece en d1
con el valor x
y en d2
con el valor y
en la unión aparece con el valor f x y
). Por ejemplo,ghci> unionWith (+) (fromList [(5,7),(3,4)]) (fromList [(5,9),(7,2),(6,1)])
fromList [(3,4),(5,16),(6,1),(7,2)]
(unionWithKey f d1 d2)
es la unión de los diccionarios d1
y d2
usando la función f
para combinar las claves (si una clave k
aparece en d1
con el valor x
y en d2
con el valor y
en la unión aparece con el valor f k x y
). Por ejemplo,ghci> let f k x y = k*(x+y)
ghci> unionWithKey f (fromList [(5,7),(3,4)]) (fromList [(5,9),(3,2)])
fromList [(3,18),(5,80)]
(unions ds)
es la unión de los diccionarios ds
(si una clave ocurre en varios diccionarios coge el valor del primero en el que ocurre). Por ejemplo,ghci> unions [fromList [(5,7)], fromList [(5,9),(3,4)], fromList [(3,8)]]
fromList [(3,4),(5,7)]
(unionsWith f ds)
es la unión de los diccionarios ds
usando la función f
para combinar las claves. Por ejemplo,ghci> unionsWith (+) [fromList [(5,7)], fromList [(5,9),(3,4)], fromList [(3,8)]]
fromList [(3,12),(5,16)]
(intersection d1 d2)
es la intersección de los diccionarios d1
y d2
(si una clave ocurre en los dos diccionarios coge el valor en el primero). Por ejemplo,ghci> intersection (fromList [(5,7),(3,4)]) (fromList [(5,9),(7,2),(6,1)])
fromList [(5,7)]
(intersectionWith f d1 d2)
es la intersección de los diccionarios d1
y d2
usando la función f
para combinar las claves (si una clave k
aparece en d1
con el valor x
y en d2
con el valor y
en la intersección aparece con el valor f x y
). Por ejemplo,ghci> intersectionWith (+) (fromList [(5,7),(3,4)]) (fromList [(5,9),(7,2),(6,1)])
fromList [(5,16)]
(intersectionWithKey f d1 d2)
es la intersección de los diccionarios d1
y d2
usando la función f
para combinar las claves (si una clave k
aparece en d1
con el valor x
y en d2
con el valor y
en la intersección aparece con el valor f k x y
). Por ejemplo,ghci> let f k x y = k*(x+y)
ghci> intersectionWithKey f (fromList [(5,7),(3,4)]) (fromList [(5,9),(4,2)])
fromList [(5,80)]
(difference d1 d2)
es la diferencia de los diccionarios d1
y d2
. Por ejemplo,ghci> difference (fromList [(5,7),(3,4)]) (fromList [(5,9),(7,2),(6,1)])
fromList [(3,4)]
(d1 \\ d2)
es la diferencia de los diccionarios d1
y d2
. Por ejemplo,ghci> fromList [(5,7),(3,4)] \\ fromList [(5,9),(7,2),(6,1)]
fromList [(3,4)]
(differenceWith f d1 d2)
es la diferencia de los diccionarios d1
y d2
con la función de combinación f
; es decir, si una clave k
aparece en d1
con el valor x
y en d2
con el valor y
y f x y
es Just z
, en la unión aparece con el valor z
y si el valor de f x y
es Nothing
entonces se elimina) . Por ejemplo,ghci> let f x y = if x < y then Just (x+y) else Nothing
ghci> differenceWith f (fromList [(5,1),(3,4)]) (fromList [(5,2),(7,2)])
fromList [(3,4),(5,3)]
ghci> differenceWith f (fromList [(5,6),(3,4)]) (fromList [(5,2),(7,2)])
fromList [(3,4)]
(differenceWithKey f d1 d2)
es la diferencia de los diccionarios d1
y d2
con la función de combinación f
; es decir, si una clave k
aparece en d1
con el valor x
y en d2
con el valor y
y f k x y
es Just z
, en la unión aparece con el valor z
y si el valor de f k x y
es Nothing
entonces se elimina) . Por ejemplo,ghci> let f k x y = if x+y < k then Just (x+y) else Nothing
ghci> differenceWithKey f (fromList [(5,1),(3,4)]) (fromList [(5,2),(7,2)])
fromList [(3,4),(5,3)]
ghci> differenceWithKey f (fromList [(5,6),(3,4)]) (fromList [(5,2),(7,2)])
fromList [(3,4)]
(filter p d)
es el diccionario formado por los elementos de d
cuyo valor cumple el predicado p
. Por ejemplo,ghci> M.filter (>5) (fromList [("b",4),("e",8),("d",3),("a",7)])
fromList [("a",7),("e",8)]
(filterWithKey p d)
es el diccionario formado por los elementos (k,x)
de d
tales que se verifica p k x
. Por ejemplo,ghci> let p k x = k >= x
ghci> M.filterWithKey p (fromList [(8,4),(3,8),(7,3),(6,7)])
fromList [(7,3),(8,4)]
(partition p d)
es el par cuya primera componente consta de los elementos de d
que cumplen p
y la segunda por los que no lo cumplen. Por ejemplo,ghci> partition (>6) (fromList [(8,4),(3,8),(7,3),(6,7)])
(fromList [(3,8),(6,7)],fromList [(7,3),(8,4)])
(partitionWithKey p d)
es el par cuya primera componente consta de los elementos (k,x)
de d
tales que p k x
se cumple y la segunda por los que no lo cumplen. Por ejemplo,ghci> let p k x = k >= x
ghci> partitionWithKey p (fromList [(8,4),(3,8),(7,3),(6,7)])
(fromList [(7,3),(8,4)],fromList [(3,8),(6,7)])
(split x d)
es el par de diccionarios (d1,d2)
tales que los elementos de d1
son los de d
cuya clave es menor que x
y los de d2
los que son mayores. Por ejemplo,ghci> split 5 (fromList [(7,'a'),(4,'b'),(6,'b'),(5,'e')])
(fromList [(4,'b')],fromList [(6,'b'),(7,'a')])
(map f d)
aplica f
a todos los valores de d
. Por ejemplo,ghci> M.map (+1) (fromList [(8,4),(3,8),(7,3),(6,7)])
fromList [(3,9),(6,8),(7,4),(8,5)]
(fmap f d)
aplica f
a todos los valores de d
. Por ejemplo,ghci> fmap (+1) (fromList [(8,4),(3,8),(7,3),(6,7)])
fromList [(3,9),(6,8),(7,4),(8,5)]
(mapWithKey f d)
sustituye cada elemento (k,x)
de d
por (k,f k x)
. Por ejemplo,ghci> let f k x = k + x
ghci> mapWithKey f (fromList [(8,4),(3,8),(7,3),(6,7)])
fromList [(3,11),(6,13),(7,10),(8,12)]
(mapKeys f d)
aplica f
a las claves de d
(si una clave tiene más de un valor, sólo se conserva la de mayor valor). Por ejemplo,ghci> mapKeys (+ 1) (fromList [(5,"a"), (3,"b")])
fromList [(4,"b"),(6,"a")]
ghci> mapKeys (+ 1) (fromList [(5,"a"), (3,"b"), (5,"d")])
fromList [(4,"b"),(6,"d")]
(mapKeysWith c f d)
aplica f
a las claves de d
(si una clave tiene más de un valor, se combinan con c
). Por ejemplo,ghci> mapKeysWith (++) (^2) (fromList [(-1,"a"), (1,"b"), (2,"d")])
fromList [(1,"ba"),(4,"d")]
(mapMaybe f d)
sustituye cada elemento (k,x)
de d
por (k,y)
si el valor de f x
es Just y
y lo elimina en caso contrario. Por ejemplo,ghci> let f x = if x < 5 then Just (x+1) else Nothing
ghci> mapMaybe f (fromList [(2,4),(6,8),(4,3),(9,7)])
fromList [(2,5),(4,4)]
(mapMaybeWithKey f d)
sustituye cada elemento (k,x)
de d
por (k,y)
si el valor de f k x
es Just y
y lo elimina en caso contrario. Por ejemplo,ghci> let f k x = if k < x then Just (x+1) else Nothing
ghci> mapMaybeWithKey f (fromList [(2,4),(6,8),(4,3),(9,7)])
fromList [(2,5),(6,9)]
(mapAccum f a d)
es el par cuya primera componente es el acumulado de a
junto con las primera componentes de f
aplicada a los valores de d
y la segunad componente se obtiene con las segundas componentes de f. Por ejemplo,ghci> let f x y = (x-y,2*x)
ghci> mapAccum f 10 (fromList [(5,7),(3,2)])
(1,fromList [(3,20),(5,16)])
ghci> let f a b = (a ++ b, b ++ "X")
ghci> mapAccum f "Res: " (fromList [(5,"a"), (3,"b")])
("Res: ba",fromList [(3,"bX"),(5,"aX")])
(mapAccumWithKey f a d)
es el par cuya primera componente es el acumulado de a
junto con las primera componentes de f
aplicada a las claves y valores de d
y la segunad componente se obtiene con las segundas componentes de f. Por ejemplo,ghci> let f a k b = (a ++ " " ++ (show k) ++ "-" ++ b, b ++ "X")
ghci> mapAccumWithKey f "Res:" (fromList [(5,"a"), (3,"b")])
("Res: 3-b 5-a",fromList [(3,"bX"),(5,"aX")])
(foldr f e d)
es el plegado por la derecha de los valores del diccionario d
a partir de e
. Por ejemplo,ghci> M.foldr (-) 0 (fromList [('a',3),('b',2),('c',4)])
5
ghci> Prelude.foldr (-) 0 [3,2,4]
5
ghci> 3-(2-(4-0))
5
ghci> M.foldr (-) 0 (fromList [('a',3),('c',4),('b',2)])
5
(foldr' f e c)
es la versión estricta de foldr
. Por ejemplo,ghci> M.foldr' (-) 0 (fromList [('a',3),('b',2),('c',4)])
5
(foldl f e d)
es el plegado por la izquierda de los valores del diccionario d
a partir de e
. Por ejemplo,ghci> M.foldl (-) 0 (fromList [('a',3),('b',2),('c',4)])
-9
ghci> Prelude.foldl (-) 0 [3,2,4]
-9
ghci> ((0-3)-2)-4
-9
ghci> M.foldl (-) 0 (fromList [('a',3),('c',4),('b',2)])
-9
(foldl' f e c)
es la versión estricta de foldr
. Por ejemplo,ghci> M.foldl' (-) 0 (fromList [('a',3),('b',2),('c',4)])
-9
(foldrWithKey f e d)
es el plegado por la derecha de las claves y los valores del diccionario d
a partir de e
. Por ejemplo,ghci> let f k v s = s ++ (replicate k v)
ghci> foldrWithKey f "" (fromList [(5,'a'), (3,'b')])
"aaaaabbb"
ghci> let f k v s = k*v-s
ghci> foldrWithKey f 0 (fromList [(1,7),(2,8),(3,5)])
6
ghci> let f k v s = k*v-s
(foldrWithKey' f e d)
es la versión estricta de foldrWithKey
. Por ejemplo,ghci> let f k v s = s ++ (replicate k v)
ghci> foldrWithKey' f "" (fromList [(5,'a'), (3,'b')])
"aaaaabbb"
ghci> let f k v s = k*v-s
ghci> foldrWithKey' f 0 (fromList [(1,7),(2,8),(3,5)])
6
(foldlWithKey f e d)
es el plegado por la izquierda de las claves y los valores del diccionario d
a partir de e
. Por ejemplo,ghci> let f s k v = s ++ replicate k v
ghci> foldlWithKey f "" (fromList [(5,'a'), (3,'b')])
"bbbaaaaa"
ghci> let f s k v = s-k*v
ghci> foldlWithKey f 0 (fromList [(1,7),(2,8),(3,5)])
-38
ghci> ((0-1*7)-2*8)-3*5
-38
(foldlWithKey' f e d)
es la versión estricta de foldlWithKey
. Por ejemplo,ghci> let f s k v = s ++ replicate k v
ghci> foldlWithKey' f "" (fromList [(5,'a'), (3,'b')])
"bbbaaaaa"
ghci> let f s k v = s-k*v
ghci> foldlWithKey' f 0 (fromList [(1,7),(2,8),(3,5)])
-38
ghci> ((0-1*7)-2*8)-3*5
-38
(elems d)
es a lista de los valores del diccionario d
ordenados según sus claves. Por ejemplo,ghci> elems (fromList [(1,7),(3,5),(2,8)])
[7,8,5]
(keys d)
es a lista ordenada de las claves del diccionario d
. Por ejemplo,ghci> keys (fromList [(1,7),(3,5),(2,8)])
[1,2,3]
(assocs d)
es la lista ordenada de los elementos del diccionario d
. Por ejemplo,ghci> assocs (fromList [(1,7),(3,5),(2,8)])
[(1,7),(2,8),(3,5)]
(toList d)
es la lista ordenada de los elementos del diccionario d
. Por ejemplo,ghci> toList (fromList [(1,7),(3,5),(2,8)])
[(1,7),(2,8),(3,5)]
(keysSet d)
es el conjunto de las claves del diccionario d
. Por ejemplo,ghci> keysSet (fromList [(1,7),(3,5),(2,8)])
fromList [1,2,3]
(fromList ps)
es el diccionario cuyos elementos es la lista de pares ps
. Si la lista tiene más de un valor para una clave, sólo se conserva el último. Por ejemplo,ghci> fromList [(5,"a"),(3,"b"),(5,"c")]
fromList [(3,"b"),(5,"c")]
ghci> fromList [(5,"a"),(3,"b"),(5,"c"),(3,"a")]
fromList [(3,"a"),(5,"c")]
(fromListWith f ps)
es el diccionario cuyos elementos es la lista de pares ps
combinados con la operación f
. Por ejemplo,ghci> fromListWith (++) [(5,"a"),(3,"b"),(5,"c")]
fromList [(3,"b"),(5,"ca")]
ghci> fromListWith (++) [(5,"a"),(3,"b"),(5,"c"),(3,"a")]
fromList [(3,"ab"),(5,"ca")]
ghci> fromListWith (-) [(5,4),(3,6),(5,2),(3,1)]
fromList [(3,-5),(5,-2)]
(fromListWithKey f ps)
es el diccionario cuyos elementos es la lista de pares ps
combinados con la operación f
. Por ejemplo,ghci> let f k v1 v2 = show k ++ v1 ++ v2
ghci> fromListWithKey f [(5,"a"),(3,"b"),(5,"c"),(3,"a")]
fromList [(3,"3ab"),(5,"5ca")]
(fromSet f c)
es el diccionario cuyos elementos son los pares obtenidos aplicando la función f
a los elementos del conjunto c
. Por ejemplo,ghci> fromSet (\k -> replicate k 'a') (Data.Set.fromList [3,5])
fromList [(3,"aaa"),(5,"aaaaa")]
ghci> fromSet (*2) (Data.Set.fromList [3,5])
fromList [(3,6),(5,10)]
(toAscList d)
es la lista de los elementos del diccionario d
crecientemente ordenada. Por ejemplo,ghci> toAscList (fromList [(5,"a"), (3,"b")])
[(3,"b"),(5,"a")]
(toDescList d)
es la lista de los elementos del diccionario d
decrecientemente ordenada. Por ejemplo,ghci> toDescList (fromList [(5,"a"), (3,"b")])
[(5,"a"),(3,"b")]
(fromAscList ps)
es el diccionario cuyos elementos es la lista de pares ps
ordenada crecientemente. Si la lista tiene más de un valor para una clave, sólo se conserva el último. Por ejemplo,ghci> fromAscList [(3,"b"),(5,"a"),(5,"c")]
fromList [(3,"b"),(5,"c")]
(fromAscListWith f ps)
es el diccionario cuyos elementos es la lista de pares ps
(que están ordenados crecientemente) combinados con la operación f
. Por ejemplo,ghci> fromAscListWith (++) [(3,"b"),(5,"a"),(5,"c")]
fromList [(3,"b"),(5,"ca")]
(fromAscListWithKey f ps)
es el diccionario cuyos elementos es la lista de pares ps
(que está ordenada crecientemente) combinados con la operación f
. Por ejemplo,ghci> let f k v1 v2 = show k ++ v1 ++ v2
ghci> fromAscListWithKey f [(3,"a"),(3,"b"),(5,"c"),(5,"a")]
fromList [(3,"3ba"),(5,"5ac")]
(showTree d)
es la cadena correspondient al árbol del diccionario d
. Por ejemplo,ghci> putStrLn (showTree (fromList [(8,'b'),(3,'a'),(7,'d'),(6,'c')]))
7:='d'
+--3:='a'
| +--|
| +--6:='c'
+--8:='b'
ghci> putStrLn (showTree (fromList [(n,2*n) | n <- [1..5]]))
2:=4
+--1:=2
+--4:=8
+--3:=6
+--5:=10
ghci> putStrLn (showTree (fromList [(n,2*n) | n <- [5,4..1]]))
4:=8
+--2:=4
| +--1:=2
| +--3:=6
+--5:=10
(showTreeWith x y d)
es la cadena correspondient al árbol del diccionario d
donde se puede elegir el aspecto según los valores de x
e `y. Por ejemplo,ghci> let d = fromList [(n,2*n) | n <- [1..5]]
ghci> let f k v = show (k,v)
ghci> putStrLn $ showTreeWith f True False d
(2,4)
+--(1,2)
+--(4,8)
+--(3,6)
+--(5,10)
ghci> putStrLn $ showTreeWith f True True d
(2,4)
|
+--(1,2)
|
+--(4,8)
|
+--(3,6)
|
+--(5,10)
ghci> putStrLn $ showTreeWith f False True d
+--(5,10)
|
+--(4,8)
| |
| +--(3,6)
|
(2,4)
|
+--(1,2)
ghci> putStrLn $ showTreeWith f False False d
+--(5,10)
+--(4,8)
| +--(3,6)
(2,4)
+--(1,2)