(a -> b -> c) -> b -> a -> c +containers

fold :: (a -> b -> b) -> b -> IntMap a -> b
containers Data.IntMap
Deprecated. As of version 0.5, replaced by foldr. O(n). Fold the values in the map using the given right-associative binary operator. This function is an equivalent of foldr and is present for compatibility only.
foldr :: (a -> b -> b) -> b -> IntMap a -> b
containers Data.IntMap.Strict, containers Data.IntMap.Lazy
O(n). Fold the values in the map using the given right-associative binary operator, such that foldr f z == foldr f z . elems. For example, > elems map = foldr (:) [] map > let f a len = len + (length a) > foldr f 0 (fromList [(5,"a"), (3,"bbb")]) == 4
foldr' :: (a -> b -> b) -> b -> IntMap a -> b
containers Data.IntMap.Strict, containers Data.IntMap.Lazy
O(n). A strict version of foldr. Each application of the operator is evaluated before using the result in the next application. This function is strict in the starting value.
fold :: (a -> b -> b) -> b -> Set a -> b
containers Data.Set
O(n). Fold the elements in the set using the given right-associative binary operator. This function is an equivalent of foldr and is present for compatibility only. Please note that fold will be deprecated in the future and removed.
foldr :: (a -> b -> b) -> b -> Set a -> b
containers Data.Set
O(n). Fold the elements in the set using the given right-associative binary operator, such that foldr f z == foldr f z . toAscList. For example, > toAscList set = foldr (:) [] set
foldr' :: (a -> b -> b) -> b -> Set a -> b
containers Data.Set
O(n). A strict version of foldr. Each application of the operator is evaluated before using the result in the next application. This function is strict in the starting value.
foldl :: (a -> b -> a) -> a -> Set b -> a
containers Data.Set
O(n). Fold the elements in the set using the given left-associative binary operator, such that foldl f z == foldl f z . toAscList. For example, > toDescList set = foldl (flip (:)) [] set
foldl' :: (a -> b -> a) -> a -> Set b -> a
containers Data.Set
O(n). A strict version of foldl. Each application of the operator is evaluated before using the result in the next application. This function is strict in the starting value.
foldl :: (a -> b -> a) -> a -> IntMap b -> a
containers Data.IntMap.Strict, containers Data.IntMap.Lazy
O(n). Fold the values in the map using the given left-associative binary operator, such that foldl f z == foldl f z . elems. For example, > elems = reverse . foldl (flip (:)) [] > let f len a = len + (length a) > foldl f 0 (fromList [(5,"a"), (3,"bbb")]) == 4
foldl' :: (a -> b -> a) -> a -> IntMap b -> a
containers Data.IntMap.Strict, containers Data.IntMap.Lazy
O(n). A strict version of foldl. Each application of the operator is evaluated before using the result in the next application. This function is strict in the starting value.
scanr :: (a -> b -> b) -> b -> Seq a -> Seq b
containers Data.Sequence
scanr is the right-to-left dual of scanl.
scanl :: (a -> b -> a) -> a -> Seq b -> Seq a
containers Data.Sequence
scanl is similar to foldl, but returns a sequence of reduced values from the left: > scanl f z (fromList [x1, x2, ...]) = fromList [z, z `f` x1, (z `f` x1) `f` x2, ...]
intersectionWith :: (a -> b -> c) -> IntMap a -> IntMap b -> IntMap c
containers Data.IntMap.Strict, containers Data.IntMap.Lazy
O(n+m). The intersection with a combining function. > intersectionWith (++) (fromList [(5, "a"), (3, "b")]) (fromList [(5, "A"), (7, "C")]) == singleton 5 "aA"
zipWith :: (a -> b -> c) -> Seq a -> Seq b -> Seq c
containers Data.Sequence
O(min(n1,n2)). zipWith generalizes zip by zipping with the function given as the first argument, instead of a tupling function. For example, zipWith (+) is applied to two sequences to take the sequence of corresponding sums.
isProperSubmapOfBy :: (a -> b -> Bool) -> IntMap a -> IntMap b -> Bool
containers Data.IntMap.Strict, containers Data.IntMap.Lazy
O(n+m). Is this a proper submap? (ie. a submap but not equal). The expression (isProperSubmapOfBy f m1 m2) returns True when m1 and m2 are not equal, all keys in m1 are in m2, and when f returns True when applied to their respective values. For example, the following expressions are all True: > isProperSubmapOfBy (==) (fromList [(1,1)]) (fromList [(1,1),(2,2)]) > isProperSubmapOfBy (<=) (fromList [(1,1)]) (fromList [(1,1),(2,2)]) But the following are all False: > isProperSubmapOfBy (==) (fromList [(1,1),(2,2)]) (fromList [(1,1),(2,2)]) > isProperSubmapOfBy (==) (fromList [(1,1),(2,2)]) (fromList [(1,1)]) > isProperSubmapOfBy (<) (fromList [(1,1)]) (fromList [(1,1),(2,2)])
isSubmapOfBy :: (a -> b -> Bool) -> IntMap a -> IntMap b -> Bool
containers Data.IntMap.Strict, containers Data.IntMap.Lazy
O(n+m). The expression (isSubmapOfBy f m1 m2) returns True if all keys in m1 are in m2, and when f returns True when applied to their respective values. For example, the following expressions are all True: > isSubmapOfBy (==) (fromList [(1,1)]) (fromList [(1,1),(2,2)]) > isSubmapOfBy (<=) (fromList [(1,1)]) (fromList [(1,1),(2,2)]) > isSubmapOfBy (==) (fromList [(1,1),(2,2)]) (fromList [(1,1),(2,2)]) But the following are all False: > isSubmapOfBy (==) (fromList [(1,2)]) (fromList [(1,1),(2,2)]) > isSubmapOfBy (<) (fromList [(1,1)]) (fromList [(1,1),(2,2)]) > isSubmapOfBy (==) (fromList [(1,1),(2,2)]) (fromList [(1,1)])
foldl :: (a -> Key -> a) -> a -> IntSet -> a
containers Data.IntSet
O(n). Fold the elements in the set using the given left-associative binary operator, such that foldl f z == foldl f z . toAscList. For example, > toDescList set = foldl (flip (:)) [] set
foldl' :: (a -> Key -> a) -> a -> IntSet -> a
containers Data.IntSet
O(n). A strict version of foldl. Each application of the operator is evaluated before using the result in the next application. This function is strict in the starting value.
adjustWithKey :: (Key -> a -> a) -> Key -> IntMap a -> IntMap a
containers Data.IntMap.Strict, containers Data.IntMap.Lazy
O(min(n,W)). Adjust a value at a specific key. When the key is not a member of the map, the original map is returned. > let f key x = (show key) ++ ":new " ++ x > adjustWithKey f 5 (fromList [(5,"a"), (3,"b")]) == fromList [(3, "b"), (5, "5:new a")] > adjustWithKey f 7 (fromList [(5,"a"), (3,"b")]) == fromList [(3, "b"), (5, "a")] > adjustWithKey f 7 empty == empty
insertWith :: (a -> a -> a) -> Key -> a -> IntMap a -> IntMap a
containers Data.IntMap.Strict, containers Data.IntMap.Lazy
O(min(n,W)). Insert with a combining function. insertWith f key value mp will insert the pair (key, value) into mp if key does not exist in the map. If the key does exist, the function will insert f new_value old_value. > insertWith (++) 5 "xxx" (fromList [(5,"a"), (3,"b")]) == fromList [(3, "b"), (5, "xxxa")] > insertWith (++) 7 "xxx" (fromList [(5,"a"), (3,"b")]) == fromList [(3, "b"), (5, "a"), (7, "xxx")] > insertWith (++) 5 "xxx" empty == singleton 5 "xxx"

Show more results