Hoogle Search
Within LTS Haskell 24.33 (ghc-9.10.3)
Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.
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")]))
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")]))
mapKeys :: Ord k2 => (k1 -> k2) -> NEMap k1 a -> NEMap k2 anonempty-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"
mapKeysMonotonic :: (k1 -> k2) -> NEMap k1 a -> NEMap k2 anonempty-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
mapKeysWith :: Ord k2 => (a -> a -> a) -> (k1 -> k2) -> NEMap k1 a -> NEMap k2 anonempty-containers Data.Map.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"
mapMaybe :: (a -> Maybe b) -> NEMap k a -> Map k bnonempty-containers Data.Map.NonEmpty O(n). Map values and collect the Just results. Returns a potentially empty map (Map), because the function could potentially return Nothing on all items in the NEMap.
let f x = if x == "a" then Just "new a" else Nothing mapMaybe f (fromList ((5,"a") :| [(3,"b")])) == Data.Map.singleton 5 "new a"
mapMaybeWithKey :: (k -> a -> Maybe b) -> NEMap k a -> Map k bnonempty-containers Data.Map.NonEmpty O(n). Map keys/values and collect the Just results. Returns a potentially empty map (Map), because the function could potentially return Nothing on all items in the NEMap.
let f k _ = if k < 5 then Just ("key : " ++ (show k)) else Nothing mapMaybeWithKey f (fromList ((5,"a") :| [(3,"b")])) == Data.Map.singleton 3 "key : 3"mapWithKey :: (k -> a -> b) -> NEMap k a -> NEMap k bnonempty-containers Data.Map.NonEmpty O(n). Map 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")])
mapWithIndex :: (Int -> a -> b) -> NESeq a -> NESeq bnonempty-containers Data.Sequence.NonEmpty A generalization of fmap, mapWithIndex takes a mapping function that also depends on the element's index, and applies it to every element in the sequence.
mapMonotonic :: (a -> b) -> NESet a -> NESet bnonempty-containers Data.Set.NonEmpty O(n). mapMonotonic f s == map f s, but works only when f is strictly increasing. The precondition is not checked. Semi-formally, we have:
and [x < y ==> f x < f y | x <- ls, y <- ls] ==> mapMonotonic f s == map f s where ls = Data.Foldable.toList s