packages feed

containers 0.2.0.0 → 0.2.0.1

raw patch · 3 files changed

+3/−3 lines, 3 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

- Data.IntMap: instance (Data a) => Data (IntMap a)
- Data.IntMap: instance (Eq a) => Eq (IntMap a)
- Data.IntMap: instance (Ord a) => Ord (IntMap a)
- Data.IntMap: instance (Read e) => Read (IntMap e)
- Data.IntMap: instance (Show a) => Show (IntMap a)
- Data.Map: instance (Ord k) => Monoid (Map k v)
- Data.Sequence: instance (Data a) => Data (Seq a)
- Data.Sequence: instance (Data a) => Data (ViewL a)
- Data.Sequence: instance (Data a) => Data (ViewR a)
- Data.Sequence: instance (Eq a) => Eq (Seq a)
- Data.Sequence: instance (Eq a) => Eq (ViewL a)
- Data.Sequence: instance (Eq a) => Eq (ViewR a)
- Data.Sequence: instance (Ord a) => Ord (Seq a)
- Data.Sequence: instance (Ord a) => Ord (ViewL a)
- Data.Sequence: instance (Ord a) => Ord (ViewR a)
- Data.Sequence: instance (Read a) => Read (Seq a)
- Data.Sequence: instance (Read a) => Read (ViewL a)
- Data.Sequence: instance (Read a) => Read (ViewR a)
- Data.Sequence: instance (Show a) => Show (Seq a)
- Data.Sequence: instance (Show a) => Show (ViewL a)
- Data.Sequence: instance (Show a) => Show (ViewR a)
- Data.Sequence: instance (Sized a) => Sized (Digit a)
- Data.Sequence: instance (Sized a) => Sized (FingerTree a)
- Data.Set: instance (Eq a) => Eq (Set a)
- Data.Set: instance (Ord a) => Monoid (Set a)
- Data.Set: instance (Ord a) => Ord (Set a)
- Data.Set: instance (Show a) => Show (Set a)
- Data.Tree: instance (Data a) => Data (Tree a)
- Data.Tree: instance (Eq a) => Eq (Tree a)
- Data.Tree: instance (Read a) => Read (Tree a)
- Data.Tree: instance (Show a) => Show (Tree a)
+ Data.IntMap: instance Data a => Data (IntMap a)
+ Data.IntMap: instance Eq a => Eq (IntMap a)
+ Data.IntMap: instance Ord a => Ord (IntMap a)
+ Data.IntMap: instance Read e => Read (IntMap e)
+ Data.IntMap: instance Show a => Show (IntMap a)
+ Data.Map: instance Ord k => Monoid (Map k v)
+ Data.Sequence: instance Data a => Data (Seq a)
+ Data.Sequence: instance Data a => Data (ViewL a)
+ Data.Sequence: instance Data a => Data (ViewR a)
+ Data.Sequence: instance Eq a => Eq (Seq a)
+ Data.Sequence: instance Eq a => Eq (ViewL a)
+ Data.Sequence: instance Eq a => Eq (ViewR a)
+ Data.Sequence: instance Ord a => Ord (Seq a)
+ Data.Sequence: instance Ord a => Ord (ViewL a)
+ Data.Sequence: instance Ord a => Ord (ViewR a)
+ Data.Sequence: instance Read a => Read (Seq a)
+ Data.Sequence: instance Read a => Read (ViewL a)
+ Data.Sequence: instance Read a => Read (ViewR a)
+ Data.Sequence: instance Show a => Show (Seq a)
+ Data.Sequence: instance Show a => Show (ViewL a)
+ Data.Sequence: instance Show a => Show (ViewR a)
+ Data.Sequence: instance Sized a => Sized (Digit a)
+ Data.Sequence: instance Sized a => Sized (FingerTree a)
+ Data.Set: instance Eq a => Eq (Set a)
+ Data.Set: instance Ord a => Monoid (Set a)
+ Data.Set: instance Ord a => Ord (Set a)
+ Data.Set: instance Show a => Show (Set a)
+ Data.Tree: instance Data a => Data (Tree a)
+ Data.Tree: instance Eq a => Eq (Tree a)
+ Data.Tree: instance Read a => Read (Tree a)
+ Data.Tree: instance Show a => Show (Tree a)
- Data.Graph: graphFromEdges :: (Ord key) => [(node, key, [key])] -> (Graph, Vertex -> (node, key, [key]), key -> Maybe Vertex)
+ Data.Graph: graphFromEdges :: Ord key => [(node, key, [key])] -> (Graph, Vertex -> (node, key, [key]), key -> Maybe Vertex)
- Data.Graph: graphFromEdges' :: (Ord key) => [(node, key, [key])] -> (Graph, Vertex -> (node, key, [key]))
+ Data.Graph: graphFromEdges' :: Ord key => [(node, key, [key])] -> (Graph, Vertex -> (node, key, [key]))
- Data.Graph: stronglyConnComp :: (Ord key) => [(node, key, [key])] -> [SCC node]
+ Data.Graph: stronglyConnComp :: Ord key => [(node, key, [key])] -> [SCC node]
- Data.Graph: stronglyConnCompR :: (Ord key) => [(node, key, [key])] -> [SCC (node, key, [key])]
+ Data.Graph: stronglyConnCompR :: Ord key => [(node, key, [key])] -> [SCC (node, key, [key])]
- Data.IntMap: isProperSubmapOf :: (Eq a) => IntMap a -> IntMap a -> Bool
+ Data.IntMap: isProperSubmapOf :: Eq a => IntMap a -> IntMap a -> Bool
- Data.IntMap: isSubmapOf :: (Eq a) => IntMap a -> IntMap a -> Bool
+ Data.IntMap: isSubmapOf :: Eq a => IntMap a -> IntMap a -> Bool
- Data.IntMap: showTree :: (Show a) => IntMap a -> String
+ Data.IntMap: showTree :: Show a => IntMap a -> String
- Data.IntMap: showTreeWith :: (Show a) => Bool -> Bool -> IntMap a -> String
+ Data.IntMap: showTreeWith :: Show a => Bool -> Bool -> IntMap a -> String
- Data.Map: (!) :: (Ord k) => Map k a -> k -> a
+ Data.Map: (!) :: Ord k => Map k a -> k -> a
- Data.Map: (\\) :: (Ord k) => Map k a -> Map k b -> Map k a
+ Data.Map: (\\) :: Ord k => Map k a -> Map k b -> Map k a
- Data.Map: adjust :: (Ord k) => (a -> a) -> k -> Map k a -> Map k a
+ Data.Map: adjust :: Ord k => (a -> a) -> k -> Map k a -> Map k a
- Data.Map: adjustWithKey :: (Ord k) => (k -> a -> a) -> k -> Map k a -> Map k a
+ Data.Map: adjustWithKey :: Ord k => (k -> a -> a) -> k -> Map k a -> Map k a
- Data.Map: alter :: (Ord k) => (Maybe a -> Maybe a) -> k -> Map k a -> Map k a
+ Data.Map: alter :: Ord k => (Maybe a -> Maybe a) -> k -> Map k a -> Map k a
- Data.Map: delete :: (Ord k) => k -> Map k a -> Map k a
+ Data.Map: delete :: Ord k => k -> Map k a -> Map k a
- Data.Map: difference :: (Ord k) => Map k a -> Map k b -> Map k a
+ Data.Map: difference :: Ord k => Map k a -> Map k b -> Map k a
- Data.Map: differenceWith :: (Ord k) => (a -> b -> Maybe a) -> Map k a -> Map k b -> Map k a
+ Data.Map: differenceWith :: Ord k => (a -> b -> Maybe a) -> Map k a -> Map k b -> Map k a
- Data.Map: differenceWithKey :: (Ord k) => (k -> a -> b -> Maybe a) -> Map k a -> Map k b -> Map k a
+ Data.Map: differenceWithKey :: Ord k => (k -> a -> b -> Maybe a) -> Map k a -> Map k b -> Map k a
- Data.Map: filter :: (Ord k) => (a -> Bool) -> Map k a -> Map k a
+ Data.Map: filter :: Ord k => (a -> Bool) -> Map k a -> Map k a
- Data.Map: filterWithKey :: (Ord k) => (k -> a -> Bool) -> Map k a -> Map k a
+ Data.Map: filterWithKey :: Ord k => (k -> a -> Bool) -> Map k a -> Map k a
- Data.Map: findIndex :: (Ord k) => k -> Map k a -> Int
+ Data.Map: findIndex :: Ord k => k -> Map k a -> Int
- Data.Map: findWithDefault :: (Ord k) => a -> k -> Map k a -> a
+ Data.Map: findWithDefault :: Ord k => a -> k -> Map k a -> a
- Data.Map: fromAscList :: (Eq k) => [(k, a)] -> Map k a
+ Data.Map: fromAscList :: Eq k => [(k, a)] -> Map k a
- Data.Map: fromAscListWith :: (Eq k) => (a -> a -> a) -> [(k, a)] -> Map k a
+ Data.Map: fromAscListWith :: Eq k => (a -> a -> a) -> [(k, a)] -> Map k a
- Data.Map: fromAscListWithKey :: (Eq k) => (k -> a -> a -> a) -> [(k, a)] -> Map k a
+ Data.Map: fromAscListWithKey :: Eq k => (k -> a -> a -> a) -> [(k, a)] -> Map k a
- Data.Map: fromList :: (Ord k) => [(k, a)] -> Map k a
+ Data.Map: fromList :: Ord k => [(k, a)] -> Map k a
- Data.Map: fromListWith :: (Ord k) => (a -> a -> a) -> [(k, a)] -> Map k a
+ Data.Map: fromListWith :: Ord k => (a -> a -> a) -> [(k, a)] -> Map k a
- Data.Map: fromListWithKey :: (Ord k) => (k -> a -> a -> a) -> [(k, a)] -> Map k a
+ Data.Map: fromListWithKey :: Ord k => (k -> a -> a -> a) -> [(k, a)] -> Map k a
- Data.Map: insert :: (Ord k) => k -> a -> Map k a -> Map k a
+ Data.Map: insert :: Ord k => k -> a -> Map k a -> Map k a
- Data.Map: insertLookupWithKey :: (Ord k) => (k -> a -> a -> a) -> k -> a -> Map k a -> (Maybe a, Map k a)
+ Data.Map: insertLookupWithKey :: Ord k => (k -> a -> a -> a) -> k -> a -> Map k a -> (Maybe a, Map k a)
- Data.Map: insertWith :: (Ord k) => (a -> a -> a) -> k -> a -> Map k a -> Map k a
+ Data.Map: insertWith :: Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
- Data.Map: insertWith' :: (Ord k) => (a -> a -> a) -> k -> a -> Map k a -> Map k a
+ Data.Map: insertWith' :: Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
- Data.Map: insertWithKey :: (Ord k) => (k -> a -> a -> a) -> k -> a -> Map k a -> Map k a
+ Data.Map: insertWithKey :: Ord k => (k -> a -> a -> a) -> k -> a -> Map k a -> Map k a
- Data.Map: insertWithKey' :: (Ord k) => (k -> a -> a -> a) -> k -> a -> Map k a -> Map k a
+ Data.Map: insertWithKey' :: Ord k => (k -> a -> a -> a) -> k -> a -> Map k a -> Map k a
- Data.Map: intersection :: (Ord k) => Map k a -> Map k b -> Map k a
+ Data.Map: intersection :: Ord k => Map k a -> Map k b -> Map k a
- Data.Map: intersectionWith :: (Ord k) => (a -> b -> c) -> Map k a -> Map k b -> Map k c
+ Data.Map: intersectionWith :: Ord k => (a -> b -> c) -> Map k a -> Map k b -> Map k c
- Data.Map: intersectionWithKey :: (Ord k) => (k -> a -> b -> c) -> Map k a -> Map k b -> Map k c
+ Data.Map: intersectionWithKey :: Ord k => (k -> a -> b -> c) -> Map k a -> Map k b -> Map k c
- Data.Map: isProperSubmapOfBy :: (Ord k) => (a -> b -> Bool) -> Map k a -> Map k b -> Bool
+ Data.Map: isProperSubmapOfBy :: Ord k => (a -> b -> Bool) -> Map k a -> Map k b -> Bool
- Data.Map: isSubmapOfBy :: (Ord k) => (a -> b -> Bool) -> Map k a -> Map k b -> Bool
+ Data.Map: isSubmapOfBy :: Ord k => (a -> b -> Bool) -> Map k a -> Map k b -> Bool
- Data.Map: lookup :: (Ord k) => k -> Map k a -> Maybe a
+ Data.Map: lookup :: Ord k => k -> Map k a -> Maybe a
- Data.Map: lookupIndex :: (Ord k) => k -> Map k a -> Maybe Int
+ Data.Map: lookupIndex :: Ord k => k -> Map k a -> Maybe Int
- Data.Map: mapEither :: (Ord k) => (a -> Either b c) -> Map k a -> (Map k b, Map k c)
+ Data.Map: mapEither :: Ord k => (a -> Either b c) -> Map k a -> (Map k b, Map k c)
- Data.Map: mapEitherWithKey :: (Ord k) => (k -> a -> Either b c) -> Map k a -> (Map k b, Map k c)
+ Data.Map: mapEitherWithKey :: Ord k => (k -> a -> Either b c) -> Map k a -> (Map k b, Map k c)
- Data.Map: mapKeys :: (Ord k2) => (k1 -> k2) -> Map k1 a -> Map k2 a
+ Data.Map: mapKeys :: Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
- Data.Map: mapKeysWith :: (Ord k2) => (a -> a -> a) -> (k1 -> k2) -> Map k1 a -> Map k2 a
+ Data.Map: mapKeysWith :: Ord k2 => (a -> a -> a) -> (k1 -> k2) -> Map k1 a -> Map k2 a
- Data.Map: mapMaybe :: (Ord k) => (a -> Maybe b) -> Map k a -> Map k b
+ Data.Map: mapMaybe :: Ord k => (a -> Maybe b) -> Map k a -> Map k b
- Data.Map: mapMaybeWithKey :: (Ord k) => (k -> a -> Maybe b) -> Map k a -> Map k b
+ Data.Map: mapMaybeWithKey :: Ord k => (k -> a -> Maybe b) -> Map k a -> Map k b
- Data.Map: member :: (Ord k) => k -> Map k a -> Bool
+ Data.Map: member :: Ord k => k -> Map k a -> Bool
- Data.Map: notMember :: (Ord k) => k -> Map k a -> Bool
+ Data.Map: notMember :: Ord k => k -> Map k a -> Bool
- Data.Map: partition :: (Ord k) => (a -> Bool) -> Map k a -> (Map k a, Map k a)
+ Data.Map: partition :: Ord k => (a -> Bool) -> Map k a -> (Map k a, Map k a)
- Data.Map: partitionWithKey :: (Ord k) => (k -> a -> Bool) -> Map k a -> (Map k a, Map k a)
+ Data.Map: partitionWithKey :: Ord k => (k -> a -> Bool) -> Map k a -> (Map k a, Map k a)
- Data.Map: split :: (Ord k) => k -> Map k a -> (Map k a, Map k a)
+ Data.Map: split :: Ord k => k -> Map k a -> (Map k a, Map k a)
- Data.Map: splitLookup :: (Ord k) => k -> Map k a -> (Map k a, Maybe a, Map k a)
+ Data.Map: splitLookup :: Ord k => k -> Map k a -> (Map k a, Maybe a, Map k a)
- Data.Map: union :: (Ord k) => Map k a -> Map k a -> Map k a
+ Data.Map: union :: Ord k => Map k a -> Map k a -> Map k a
- Data.Map: unionWith :: (Ord k) => (a -> a -> a) -> Map k a -> Map k a -> Map k a
+ Data.Map: unionWith :: Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
- Data.Map: unionWithKey :: (Ord k) => (k -> a -> a -> a) -> Map k a -> Map k a -> Map k a
+ Data.Map: unionWithKey :: Ord k => (k -> a -> a -> a) -> Map k a -> Map k a -> Map k a
- Data.Map: unions :: (Ord k) => [Map k a] -> Map k a
+ Data.Map: unions :: Ord k => [Map k a] -> Map k a
- Data.Map: unionsWith :: (Ord k) => (a -> a -> a) -> [Map k a] -> Map k a
+ Data.Map: unionsWith :: Ord k => (a -> a -> a) -> [Map k a] -> Map k a
- Data.Map: update :: (Ord k) => (a -> Maybe a) -> k -> Map k a -> Map k a
+ Data.Map: update :: Ord k => (a -> Maybe a) -> k -> Map k a -> Map k a
- Data.Map: updateLookupWithKey :: (Ord k) => (k -> a -> Maybe a) -> k -> Map k a -> (Maybe a, Map k a)
+ Data.Map: updateLookupWithKey :: Ord k => (k -> a -> Maybe a) -> k -> Map k a -> (Maybe a, Map k a)
- Data.Map: updateWithKey :: (Ord k) => (k -> a -> Maybe a) -> k -> Map k a -> Map k a
+ Data.Map: updateWithKey :: Ord k => (k -> a -> Maybe a) -> k -> Map k a -> Map k a
- Data.Map: valid :: (Ord k) => Map k a -> Bool
+ Data.Map: valid :: Ord k => Map k a -> Bool
- Data.Set: (\\) :: (Ord a) => Set a -> Set a -> Set a
+ Data.Set: (\\) :: Ord a => Set a -> Set a -> Set a
- Data.Set: delete :: (Ord a) => a -> Set a -> Set a
+ Data.Set: delete :: Ord a => a -> Set a -> Set a
- Data.Set: difference :: (Ord a) => Set a -> Set a -> Set a
+ Data.Set: difference :: Ord a => Set a -> Set a -> Set a
- Data.Set: filter :: (Ord a) => (a -> Bool) -> Set a -> Set a
+ Data.Set: filter :: Ord a => (a -> Bool) -> Set a -> Set a
- Data.Set: fromAscList :: (Eq a) => [a] -> Set a
+ Data.Set: fromAscList :: Eq a => [a] -> Set a
- Data.Set: fromList :: (Ord a) => [a] -> Set a
+ Data.Set: fromList :: Ord a => [a] -> Set a
- Data.Set: insert :: (Ord a) => a -> Set a -> Set a
+ Data.Set: insert :: Ord a => a -> Set a -> Set a
- Data.Set: intersection :: (Ord a) => Set a -> Set a -> Set a
+ Data.Set: intersection :: Ord a => Set a -> Set a -> Set a
- Data.Set: isProperSubsetOf :: (Ord a) => Set a -> Set a -> Bool
+ Data.Set: isProperSubsetOf :: Ord a => Set a -> Set a -> Bool
- Data.Set: isSubsetOf :: (Ord a) => Set a -> Set a -> Bool
+ Data.Set: isSubsetOf :: Ord a => Set a -> Set a -> Bool
- Data.Set: member :: (Ord a) => a -> Set a -> Bool
+ Data.Set: member :: Ord a => a -> Set a -> Bool
- Data.Set: notMember :: (Ord a) => a -> Set a -> Bool
+ Data.Set: notMember :: Ord a => a -> Set a -> Bool
- Data.Set: partition :: (Ord a) => (a -> Bool) -> Set a -> (Set a, Set a)
+ Data.Set: partition :: Ord a => (a -> Bool) -> Set a -> (Set a, Set a)
- Data.Set: showTree :: (Show a) => Set a -> String
+ Data.Set: showTree :: Show a => Set a -> String
- Data.Set: showTreeWith :: (Show a) => Bool -> Bool -> Set a -> String
+ Data.Set: showTreeWith :: Show a => Bool -> Bool -> Set a -> String
- Data.Set: split :: (Ord a) => a -> Set a -> (Set a, Set a)
+ Data.Set: split :: Ord a => a -> Set a -> (Set a, Set a)
- Data.Set: splitMember :: (Ord a) => a -> Set a -> (Set a, Bool, Set a)
+ Data.Set: splitMember :: Ord a => a -> Set a -> (Set a, Bool, Set a)
- Data.Set: union :: (Ord a) => Set a -> Set a -> Set a
+ Data.Set: union :: Ord a => Set a -> Set a -> Set a
- Data.Set: unions :: (Ord a) => [Set a] -> Set a
+ Data.Set: unions :: Ord a => [Set a] -> Set a
- Data.Set: valid :: (Ord a) => Set a -> Bool
+ Data.Set: valid :: Ord a => Set a -> Bool
- Data.Tree: unfoldForestM :: (Monad m) => (b -> m (a, [b])) -> [b] -> m (Forest a)
+ Data.Tree: unfoldForestM :: Monad m => (b -> m (a, [b])) -> [b] -> m (Forest a)
- Data.Tree: unfoldForestM_BF :: (Monad m) => (b -> m (a, [b])) -> [b] -> m (Forest a)
+ Data.Tree: unfoldForestM_BF :: Monad m => (b -> m (a, [b])) -> [b] -> m (Forest a)
- Data.Tree: unfoldTreeM :: (Monad m) => (b -> m (a, [b])) -> b -> m (Tree a)
+ Data.Tree: unfoldTreeM :: Monad m => (b -> m (a, [b])) -> b -> m (Tree a)
- Data.Tree: unfoldTreeM_BF :: (Monad m) => (b -> m (a, [b])) -> b -> m (Tree a)
+ Data.Tree: unfoldTreeM_BF :: Monad m => (b -> m (a, [b])) -> b -> m (Tree a)

Files

Data/IntMap.hs view
@@ -652,7 +652,7 @@  -- | /O(n+m)/. The union with a combining function. ----- > let f key new_value old_value = (show key) ++ ":" ++ new_value ++ "|" ++ old_value+-- > let f key left_value right_value = (show key) ++ ":" ++ left_value ++ "|" ++ right_value -- > unionWithKey f (fromList [(5, "a"), (3, "b")]) (fromList [(5, "A"), (7, "C")]) == fromList [(3, "b"), (5, "5:a|A"), (7, "C")]  unionWithKey :: (Key -> a -> a -> a) -> IntMap a -> IntMap a -> IntMap a
Data/Map.hs view
@@ -930,7 +930,7 @@ -- Union with a combining function. The implementation uses the efficient /hedge-union/ algorithm. -- Hedge-union is more efficient on (bigset \``union`\` smallset). ----- > let f key new_value old_value = (show key) ++ ":" ++ new_value ++ "|" ++ old_value+-- > let f key left_value right_value = (show key) ++ ":" ++ left_value ++ "|" ++ right_value -- > unionWithKey f (fromList [(5, "a"), (3, "b")]) (fromList [(5, "A"), (7, "C")]) == fromList [(3, "b"), (5, "5:a|A"), (7, "C")]  unionWithKey :: Ord k => (k -> a -> a -> a) -> Map k a -> Map k a -> Map k a
containers.cabal view
@@ -1,5 +1,5 @@ name:       containers-version:    0.2.0.0+version:    0.2.0.1 license:    BSD3 license-file:    LICENSE maintainer:    libraries@haskell.org