Hoogle Search

Within LTS Haskell 24.28 (ghc-9.10.3)

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

Exact lookup

1. mapKeys :: Ord k2 => (k1 -> k2) -> MultiMap k1 a -> MultiMap k2 a

   multimap	Data.MultiMap

   mapKeys f s is the multimap obtained by applying f to each key of s.

2. mapWithKey :: (k -> a -> b) -> MultiMap k a -> MultiMap k b

   multimap	Data.MultiMap

   Map a function over all key/value pairs in the map.

3. mapAccum :: (a -> b -> (a, c)) -> a -> NEIntMap b -> (a, NEIntMap c)

   nonempty-containers	Data.IntMap.NonEmpty

   O(n). The function mapAccum threads an accumulating argument through the map in ascending order of keys.

   let f a b = (a ++ b, b ++ "X")
   mapAccum f "Everything: " (fromList ((5,"a") :| [(3,"b")])) == ("Everything: ba", fromList ((3, "bX") :| [(5, "aX")]))
   

4. mapAccumRWithKey :: (a -> Key -> b -> (a, c)) -> a -> NEIntMap b -> (a, NEIntMap c)

   nonempty-containers	Data.IntMap.NonEmpty

   O(n). The function mapAccumRWithKey threads an accumulating argument through the map in descending order of keys.

5. mapAccumWithKey :: (a -> Key -> b -> (a, c)) -> a -> NEIntMap b -> (a, NEIntMap c)

   nonempty-containers	Data.IntMap.NonEmpty

   O(n). The function mapAccumWithKey threads an accumulating argument through the map in ascending order of keys.

   let f a k b = (a ++ " " ++ (show k) ++ "-" ++ b, b ++ "X")
   mapAccumWithKey f "Everything:" (fromList ((5,"a") :| [(3,"b")])) == ("Everything: 3-b 5-a", fromList ((3, "bX") :| [(5, "aX")]))
   

6. mapEither :: (a -> Either b c) -> NEIntMap a -> These (NEIntMap b) (NEIntMap c)

   nonempty-containers	Data.IntMap.NonEmpty

   O(n). Map values and separate the Left and Right results. Returns a These with potentially two non-empty maps:

   • This n1 means that the results were all Left.
   • That n2 means that the results were all Right.
   • These n1 n2 gives n1 (the map where the results were Left) and n2 (the map where the results were Right)

   let f a = if a < "c" then Left a else Right a
   mapEither f (fromList ((5,"a") :| [(3,"b"), (1,"x"), (7,"z")]))
   == These (fromList ((3,"b") :| [(5,"a")])) (fromList ((1,"x") :| [(7,"z")]))
   
   mapEither (\ a -> Right a) (fromList ((5,"a") :| [(3,"b"), (1,"x"), (7,"z")]))
   == That (fromList ((5,"a") :| [(3,"b"), (1,"x"), (7,"z")]))
   

7. mapEitherWithKey :: (Key -> a -> Either b c) -> NEIntMap a -> These (NEIntMap b) (NEIntMap c)

   nonempty-containers	Data.IntMap.NonEmpty

   O(n). Map keys/values and separate the Left and Right results. Returns a These with potentially two non-empty maps:

   • This n1 means that the results were all Left.
   • That n2 means that the results were all Right.
   • These n1 n2 gives n1 (the map where the results were Left) and n2 (the map where the results were Right)

   let f k a = if k < 5 then Left (k * 2) else Right (a ++ a)
   mapEitherWithKey f (fromList ((5,"a") :| [(3,"b"), (1,"x"), (7,"z")]))
   == These (fromList ((1,2) :| [(3,6)])) (fromList ((5,"aa") :| [(7,"zz")]))
   
   mapEitherWithKey (\_ a -> Right a) (fromList ((5,"a") :| [(3,"b"), (1,"x"), (7,"z")]))
   == That (fromList ((1,"x") :| [(3,"b"), (5,"a"), (7,"z")]))
   

8. mapKeys :: (Key -> Key) -> NEIntMap a -> NEIntMap a

   nonempty-containers	Data.IntMap.NonEmpty

   O(n*log n). mapKeys f s is the map obtained by applying f to each key of s. The size of the result may be smaller if f maps two or more distinct keys to the same new key. In this case the value at the greatest of the original keys is retained. While the size of the result map may be smaller than the input map, the output map is still guaranteed to be non-empty if the input map is non-empty.

   mapKeys (+ 1) (fromList ((5,"a") :| [(3,"b")]))                        == fromList ((4, "b") :| [(6, "a")])
   mapKeys (\ _ -> 1) (fromList ((1,"b") :| [(2,"a"), (3,"d"), (4,"c")])) == singleton 1 "c"
   mapKeys (\ _ -> 3) (fromList ((1,"b") :| [(2,"a"), (3,"d"), (4,"c")])) == singleton 3 "c"
   

9. mapKeysMonotonic :: (Key -> Key) -> NEIntMap a -> NEIntMap a

   nonempty-containers	Data.IntMap.NonEmpty

   O(n). mapKeysMonotonic f s == mapKeys f s, but works only when f is strictly monotonic. That is, for any values x and y, if x < y then f x < f y. The precondition is not checked. Semi-formally, we have:

   and [x < y ==> f x < f y | x <- ls, y <- ls]
   ==> mapKeysMonotonic f s == mapKeys f s
   where ls = keys s
   

   This means that f maps distinct original keys to distinct resulting keys. This function has better performance than mapKeys. While the size of the result map may be smaller than the input map, the output map is still guaranteed to be non-empty if the input map is non-empty.

   mapKeysMonotonic (\ k -> k * 2) (fromList ((5,"a") :| [(3,"b")])) == fromList ((6, "b") :| [(10, "a")])
   valid (mapKeysMonotonic (\ k -> k * 2) (fromList ((5,"a") :| [(3,"b")]))) == True
   valid (mapKeysMonotonic (\ _ -> 1)     (fromList ((5,"a") :| [(3,"b")]))) == False
   

10. mapKeysWith :: (a -> a -> a) -> (Key -> Key) -> NEIntMap a -> NEIntMap a

    nonempty-containers	Data.IntMap.NonEmpty

    O(n*log n). mapKeysWith c f s is the map obtained by applying f to each key of s. The size of the result may be smaller if f maps two or more distinct keys to the same new key. In this case the associated values will be combined using c. The value at the greater of the two original keys is used as the first argument to c. While the size of the result map may be smaller than the input map, the output map is still guaranteed to be non-empty if the input map is non-empty.

    mapKeysWith (++) (\ _ -> 1) (fromList ((1,"b") :| [(2,"a"), (3,"d"), (4,"c")])) == singleton 1 "cdab"
    mapKeysWith (++) (\ _ -> 3) (fromList ((1,"b") :| [(2,"a"), (3,"d"), (4,"c")])) == singleton 3 "cdab"
    

Page 201 of many | Previous | Next