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. mapMaybe :: (a -> Maybe b) -> NEIntMap a -> IntMap b

   nonempty-containers	Data.IntMap.NonEmpty

   O(n). Map values and collect the Just results. Returns a potentially empty map (IntMap), because the function could potentially return Nothing on all items in the NEIntMap.

   let f x = if x == "a" then Just "new a" else Nothing
   mapMaybe f (fromList ((5,"a") :| [(3,"b")])) == Data.IntMap.singleton 5 "new a"
   

2. mapMaybeWithKey :: (Key -> a -> Maybe b) -> NEIntMap a -> IntMap b

   nonempty-containers	Data.IntMap.NonEmpty

   O(n). Map keys/values and collect the Just results. Returns a potentially empty map (IntMap), because the function could potentially return Nothing on all items in the NEIntMap.

   let f k _ = if k < 5 then Just ("key : " ++ (show k)) else Nothing
   mapMaybeWithKey f (fromList ((5,"a") :| [(3,"b")])) == Data.IntMap.singleton 3 "key : 3"
   

3. mapWithKey :: (Key -> a -> b) -> NEIntMap a -> NEIntMap b

   nonempty-containers	Data.IntMap.NonEmpty

   O(n). IntMap a function over all values in the map.

   let f key x = (show key) ++ ":" ++ x
   mapWithKey f (fromList ((5,"a") :| [(3,"b")])) == fromList ((3, "3:b") :| [(5, "5:a")])
   

4. mapAccum :: (a -> b -> (a, c)) -> a -> NEMap k b -> (a, NEMap k c)

   nonempty-containers	Data.Map.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")]))
   

5. mapAccumRWithKey :: (a -> k -> b -> (a, c)) -> a -> NEMap k b -> (a, NEMap k c)

   nonempty-containers	Data.Map.NonEmpty

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

6. mapAccumWithKey :: (a -> k -> b -> (a, c)) -> a -> NEMap k b -> (a, NEMap k c)

   nonempty-containers	Data.Map.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")]))
   

7. mapEither :: (a -> Either b c) -> NEMap k a -> These (NEMap k b) (NEMap k c)

   nonempty-containers	Data.Map.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")]))
   

8. mapEitherWithKey :: (k -> a -> Either b c) -> NEMap k a -> These (NEMap k b) (NEMap k c)

   nonempty-containers	Data.Map.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")]))
   

9. mapKeys :: Ord k2 => (k1 -> k2) -> NEMap k1 a -> NEMap k2 a

   nonempty-containers	Data.Map.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"
   

10. mapKeysMonotonic :: (k1 -> k2) -> NEMap k1 a -> NEMap k2 a

    nonempty-containers	Data.Map.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
    

Page 202 of many | Previous | Next