    {-# LANGUAGE DeriveTraversable #-}
    {-# LANGUAGE GeneralizedNewtypeDeriving #-}
    {-# LANGUAGE TypeFamilies #-}

    module GHC.Cmm.Dataflow.Collections
        ( IsSet(..)
        , setInsertList, setDeleteList, setUnions
        , IsMap(..)
        , mapInsertList, mapDeleteList, mapUnions
        , UniqueMap, UniqueSet
        ) where

    import GHC.Prelude

    import qualified Data.IntMap.Strict as M
    import qualified Data.IntSet as S

    import Data.List (foldl1')

    class IsSet set where
      type ElemOf set

      setNull :: set -> Bool
      setSize :: set -> Int
      setMember :: ElemOf set -> set -> Bool

      setEmpty :: set
      setSingleton :: ElemOf set -> set
      setInsert :: ElemOf set -> set -> set
      setDelete :: ElemOf set -> set -> set

      setUnion :: set -> set -> set
      setDifference :: set -> set -> set
      setIntersection :: set -> set -> set
      setIsSubsetOf :: set -> set -> Bool
      setFilter :: (ElemOf set -> Bool) -> set -> set

      setFoldl :: (b -> ElemOf set -> b) -> b -> set -> b
      setFoldr :: (ElemOf set -> b -> b) -> b -> set -> b

      setElems :: set -> [ElemOf set]
      setFromList :: [ElemOf set] -> set

    -- Helper functions for IsSet class
    setInsertList :: IsSet set => [ElemOf set] -> set -> set
    setInsertList :: forall set. IsSet set => [ElemOf set] -> set -> set
    setInsertList [ElemOf set]
    keys set
    set = (set -> ElemOf set -> set) -> set -> [ElemOf set] -> set
    forall (t :: * -> *) b a.
    Foldable t =>
    (b -> a -> b) -> b -> t a -> b
    foldl' ((ElemOf set -> set -> set) -> set -> ElemOf set -> set
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip ElemOf set -> set -> set
    forall set. IsSet set => ElemOf set -> set -> set
    setInsert) set
    set [ElemOf set]
    keys

    setDeleteList :: IsSet set => [ElemOf set] -> set -> set
    setDeleteList :: forall set. IsSet set => [ElemOf set] -> set -> set
    setDeleteList [ElemOf set]
    keys set
    set = (set -> ElemOf set -> set) -> set -> [ElemOf set] -> set
    forall (t :: * -> *) b a.
    Foldable t =>
    (b -> a -> b) -> b -> t a -> b
    foldl' ((ElemOf set -> set -> set) -> set -> ElemOf set -> set
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip ElemOf set -> set -> set
    forall set. IsSet set => ElemOf set -> set -> set
    setDelete) set
    set [ElemOf set]
    keys

    setUnions :: IsSet set => [set] -> set
    setUnions :: forall set. IsSet set => [set] -> set
    setUnions [] = set
    forall set. IsSet set => set
    setEmpty
    setUnions [set]
    sets = (set -> set -> set) -> [set] -> set
    forall a. (a -> a -> a) -> [a] -> a
    foldl1' set -> set -> set
    forall set. IsSet set => set -> set -> set
    setUnion [set]
    sets

    class IsMap map where
      type KeyOf map

      mapNull :: map a -> Bool
      mapSize :: map a -> Int
      mapMember :: KeyOf map -> map a -> Bool
      mapLookup :: KeyOf map -> map a -> Maybe a
      mapFindWithDefault :: a -> KeyOf map -> map a -> a

      mapEmpty :: map a
      mapSingleton :: KeyOf map -> a -> map a
      mapInsert :: KeyOf map -> a -> map a -> map a
      mapInsertWith :: (a -> a -> a) -> KeyOf map -> a -> map a -> map a
      mapDelete :: KeyOf map -> map a -> map a
      mapAlter :: (Maybe a -> Maybe a) -> KeyOf map -> map a -> map a
      mapAdjust :: (a -> a) -> KeyOf map -> map a -> map a

      mapUnion :: map a -> map a -> map a
      mapUnionWithKey :: (KeyOf map -> a -> a -> a) -> map a -> map a -> map a
      mapDifference :: map a -> map a -> map a
      mapIntersection :: map a -> map a -> map a
      mapIsSubmapOf :: Eq a => map a -> map a -> Bool

      mapMap :: (a -> b) -> map a -> map b
      mapMapWithKey :: (KeyOf map -> a -> b) -> map a -> map b
      mapFoldl :: (b -> a -> b) -> b -> map a -> b
      mapFoldr :: (a -> b -> b) -> b -> map a -> b
      mapFoldlWithKey :: (b -> KeyOf map -> a -> b) -> b -> map a -> b
      mapFoldMapWithKey :: Monoid m => (KeyOf map -> a -> m) -> map a -> m
      mapFilter :: (a -> Bool) -> map a -> map a
      mapFilterWithKey :: (KeyOf map -> a -> Bool) -> map a -> map a

      mapElems :: map a -> [a]
      mapKeys :: map a -> [KeyOf map]
      mapToList :: map a -> [(KeyOf map, a)]
      mapFromList :: [(KeyOf map, a)] -> map a
      mapFromListWith :: (a -> a -> a) -> [(KeyOf map,a)] -> map a

    -- Helper functions for IsMap class
    mapInsertList :: IsMap map => [(KeyOf map, a)] -> map a -> map a
    mapInsertList :: forall (map :: * -> *) a.
    IsMap map =>
    [(KeyOf map, a)] -> map a -> map a
    mapInsertList [(KeyOf map, a)]
    assocs map a
    map = (map a -> (KeyOf map, a) -> map a)
    -> map a -> [(KeyOf map, a)] -> map a
    forall (t :: * -> *) b a.
    Foldable t =>
    (b -> a -> b) -> b -> t a -> b
    foldl' (((KeyOf map, a) -> map a -> map a)
    -> map a -> (KeyOf map, a) -> map a
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip ((KeyOf map -> a -> map a -> map a)
    -> (KeyOf map, a) -> map a -> map a
    forall a b c. (a -> b -> c) -> (a, b) -> c
    uncurry KeyOf map -> a -> map a -> map a
    forall (map :: * -> *) a.
    IsMap map =>
    KeyOf map -> a -> map a -> map a
    mapInsert)) map a
    map [(KeyOf map, a)]
    assocs

    mapDeleteList :: IsMap map => [KeyOf map] -> map a -> map a
    mapDeleteList :: forall (map :: * -> *) a.
    IsMap map =>
    [KeyOf map] -> map a -> map a
    mapDeleteList [KeyOf map]
    keys map a
    map = (map a -> KeyOf map -> map a) -> map a -> [KeyOf map] -> map a
    forall (t :: * -> *) b a.
    Foldable t =>
    (b -> a -> b) -> b -> t a -> b
    foldl' ((KeyOf map -> map a -> map a) -> map a -> KeyOf map -> map a
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip KeyOf map -> map a -> map a
    forall (map :: * -> *) a. IsMap map => KeyOf map -> map a -> map a
    mapDelete) map a
    map [KeyOf map]
    keys

    mapUnions :: IsMap map => [map a] -> map a
    mapUnions :: forall (map :: * -> *) a. IsMap map => [map a] -> map a
    mapUnions [] = map a
    forall (map :: * -> *) a. IsMap map => map a
    mapEmpty
    mapUnions [map a]
    maps = (map a -> map a -> map a) -> [map a] -> map a
    forall a. (a -> a -> a) -> [a] -> a
    foldl1' map a -> map a -> map a
    forall (map :: * -> *) a. IsMap map => map a -> map a -> map a
    mapUnion [map a]
    maps

    -----------------------------------------------------------------------------
    -- Basic instances
    -----------------------------------------------------------------------------

    newtype UniqueSet = US S.IntSet deriving (UniqueSet -> UniqueSet -> Bool
    (UniqueSet -> UniqueSet -> Bool)
    -> (UniqueSet -> UniqueSet -> Bool) -> Eq UniqueSet
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: UniqueSet -> UniqueSet -> Bool
    $c/= :: UniqueSet -> UniqueSet -> Bool
    == :: UniqueSet -> UniqueSet -> Bool
    $c== :: UniqueSet -> UniqueSet -> Bool
    Eq, Eq UniqueSet
    Eq UniqueSet
    -> (UniqueSet -> UniqueSet -> Ordering)
    -> (UniqueSet -> UniqueSet -> Bool)
    -> (UniqueSet -> UniqueSet -> Bool)
    -> (UniqueSet -> UniqueSet -> Bool)
    -> (UniqueSet -> UniqueSet -> Bool)
    -> (UniqueSet -> UniqueSet -> UniqueSet)
    -> (UniqueSet -> UniqueSet -> UniqueSet)
    -> Ord UniqueSet
    UniqueSet -> UniqueSet -> Bool
    UniqueSet -> UniqueSet -> Ordering
    UniqueSet -> UniqueSet -> UniqueSet
    forall a.
    Eq a
    -> (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    min :: UniqueSet -> UniqueSet -> UniqueSet
    $cmin :: UniqueSet -> UniqueSet -> UniqueSet
    max :: UniqueSet -> UniqueSet -> UniqueSet
    $cmax :: UniqueSet -> UniqueSet -> UniqueSet
    >= :: UniqueSet -> UniqueSet -> Bool
    $c>= :: UniqueSet -> UniqueSet -> Bool
    > :: UniqueSet -> UniqueSet -> Bool
    $c> :: UniqueSet -> UniqueSet -> Bool
    <= :: UniqueSet -> UniqueSet -> Bool
    $c<= :: UniqueSet -> UniqueSet -> Bool
    < :: UniqueSet -> UniqueSet -> Bool
    $c< :: UniqueSet -> UniqueSet -> Bool
    compare :: UniqueSet -> UniqueSet -> Ordering
    $ccompare :: UniqueSet -> UniqueSet -> Ordering
    Ord, Int -> UniqueSet -> ShowS
    [UniqueSet] -> ShowS
    UniqueSet -> String
    (Int -> UniqueSet -> ShowS)
    -> (UniqueSet -> String)
    -> ([UniqueSet] -> ShowS)
    -> Show UniqueSet
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [UniqueSet] -> ShowS
    $cshowList :: [UniqueSet] -> ShowS
    show :: UniqueSet -> String
    $cshow :: UniqueSet -> String
    showsPrec :: Int -> UniqueSet -> ShowS
    $cshowsPrec :: Int -> UniqueSet -> ShowS
    Show, NonEmpty UniqueSet -> UniqueSet
    UniqueSet -> UniqueSet -> UniqueSet
    (UniqueSet -> UniqueSet -> UniqueSet)
    -> (NonEmpty UniqueSet -> UniqueSet)
    -> (forall b. Integral b => b -> UniqueSet -> UniqueSet)
    -> Semigroup UniqueSet
    forall b. Integral b => b -> UniqueSet -> UniqueSet
    forall a.
    (a -> a -> a)
    -> (NonEmpty a -> a)
    -> (forall b. Integral b => b -> a -> a)
    -> Semigroup a
    stimes :: forall b. Integral b => b -> UniqueSet -> UniqueSet
    $cstimes :: forall b. Integral b => b -> UniqueSet -> UniqueSet
    sconcat :: NonEmpty UniqueSet -> UniqueSet
    $csconcat :: NonEmpty UniqueSet -> UniqueSet
    <> :: UniqueSet -> UniqueSet -> UniqueSet
    $c<> :: UniqueSet -> UniqueSet -> UniqueSet
    Semigroup, Semigroup UniqueSet
    UniqueSet
    Semigroup UniqueSet
    -> UniqueSet
    -> (UniqueSet -> UniqueSet -> UniqueSet)
    -> ([UniqueSet] -> UniqueSet)
    -> Monoid UniqueSet
    [UniqueSet] -> UniqueSet
    UniqueSet -> UniqueSet -> UniqueSet
    forall a.
    Semigroup a -> a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
    mconcat :: [UniqueSet] -> UniqueSet
    $cmconcat :: [UniqueSet] -> UniqueSet
    mappend :: UniqueSet -> UniqueSet -> UniqueSet
    $cmappend :: UniqueSet -> UniqueSet -> UniqueSet
    mempty :: UniqueSet
    $cmempty :: UniqueSet
    Monoid)

    instance IsSet UniqueSet where
      type ElemOf UniqueSet = Int

      setNull :: UniqueSet -> Bool
    setNull (US IntSet
    s) = IntSet -> Bool
    S.null IntSet
    s
      setSize :: UniqueSet -> Int
    setSize (US IntSet
    s) = IntSet -> Int
    S.size IntSet
    s
      setMember :: ElemOf UniqueSet -> UniqueSet -> Bool
    setMember ElemOf UniqueSet
    k (US IntSet
    s) = Int -> IntSet -> Bool
    S.member Int
    ElemOf UniqueSet
    k IntSet
    s

      setEmpty :: UniqueSet
    setEmpty = IntSet -> UniqueSet
    US IntSet
    S.empty
      setSingleton :: ElemOf UniqueSet -> UniqueSet
    setSingleton ElemOf UniqueSet
    k = IntSet -> UniqueSet
    US (Int -> IntSet
    S.singleton Int
    ElemOf UniqueSet
    k)
      setInsert :: ElemOf UniqueSet -> UniqueSet -> UniqueSet
    setInsert ElemOf UniqueSet
    k (US IntSet
    s) = IntSet -> UniqueSet
    US (Int -> IntSet -> IntSet
    S.insert Int
    ElemOf UniqueSet
    k IntSet
    s)
      setDelete :: ElemOf UniqueSet -> UniqueSet -> UniqueSet
    setDelete ElemOf UniqueSet
    k (US IntSet
    s) = IntSet -> UniqueSet
    US (Int -> IntSet -> IntSet
    S.delete Int
    ElemOf UniqueSet
    k IntSet
    s)

      setUnion :: UniqueSet -> UniqueSet -> UniqueSet
    setUnion (US IntSet
    x) (US IntSet
    y) = IntSet -> UniqueSet
    US (IntSet -> IntSet -> IntSet
    S.union IntSet
    x IntSet
    y)
      setDifference :: UniqueSet -> UniqueSet -> UniqueSet
    setDifference (US IntSet
    x) (US IntSet
    y) = IntSet -> UniqueSet
    US (IntSet -> IntSet -> IntSet
    S.difference IntSet
    x IntSet
    y)
      setIntersection :: UniqueSet -> UniqueSet -> UniqueSet
    setIntersection (US IntSet
    x) (US IntSet
    y) = IntSet -> UniqueSet
    US (IntSet -> IntSet -> IntSet
    S.intersection IntSet
    x IntSet
    y)
      setIsSubsetOf :: UniqueSet -> UniqueSet -> Bool
    setIsSubsetOf (US IntSet
    x) (US IntSet
    y) = IntSet -> IntSet -> Bool
    S.isSubsetOf IntSet
    x IntSet
    y
      setFilter :: (ElemOf UniqueSet -> Bool) -> UniqueSet -> UniqueSet
    setFilter ElemOf UniqueSet -> Bool
    f (US IntSet
    s) = IntSet -> UniqueSet
    US ((Int -> Bool) -> IntSet -> IntSet
    S.filter Int -> Bool
    ElemOf UniqueSet -> Bool
    f IntSet
    s)

      setFoldl :: forall b. (b -> ElemOf UniqueSet -> b) -> b -> UniqueSet -> b
    setFoldl b -> ElemOf UniqueSet -> b
    k b
    z (US IntSet
    s) = (b -> Int -> b) -> b -> IntSet -> b
    forall a. (a -> Int -> a) -> a -> IntSet -> a
    S.foldl' b -> Int -> b
    b -> ElemOf UniqueSet -> b
    k b
    z IntSet
    s
      setFoldr :: forall b. (ElemOf UniqueSet -> b -> b) -> b -> UniqueSet -> b
    setFoldr ElemOf UniqueSet -> b -> b
    k b
    z (US IntSet
    s) = (Int -> b -> b) -> b -> IntSet -> b
    forall b. (Int -> b -> b) -> b -> IntSet -> b
    S.foldr Int -> b -> b
    ElemOf UniqueSet -> b -> b
    k b
    z IntSet
    s

      setElems :: UniqueSet -> [ElemOf UniqueSet]
    setElems (US IntSet
    s) = IntSet -> [Int]
    S.elems IntSet
    s
      setFromList :: [ElemOf UniqueSet] -> UniqueSet
    setFromList [ElemOf UniqueSet]
    ks = IntSet -> UniqueSet
    US ([Int] -> IntSet
    S.fromList [Int]
    [ElemOf UniqueSet]
    ks)

    newtype UniqueMap v = UM (M.IntMap v)
      deriving (UniqueMap v -> UniqueMap v -> Bool
    (UniqueMap v -> UniqueMap v -> Bool)
    -> (UniqueMap v -> UniqueMap v -> Bool) -> Eq (UniqueMap v)
    forall v. Eq v => UniqueMap v -> UniqueMap v -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: UniqueMap v -> UniqueMap v -> Bool
    $c/= :: forall v. Eq v => UniqueMap v -> UniqueMap v -> Bool
    == :: UniqueMap v -> UniqueMap v -> Bool
    $c== :: forall v. Eq v => UniqueMap v -> UniqueMap v -> Bool
    Eq, Eq (UniqueMap v)
    Eq (UniqueMap v)
    -> (UniqueMap v -> UniqueMap v -> Ordering)
    -> (UniqueMap v -> UniqueMap v -> Bool)
    -> (UniqueMap v -> UniqueMap v -> Bool)
    -> (UniqueMap v -> UniqueMap v -> Bool)
    -> (UniqueMap v -> UniqueMap v -> Bool)
    -> (UniqueMap v -> UniqueMap v -> UniqueMap v)
    -> (UniqueMap v -> UniqueMap v -> UniqueMap v)
    -> Ord (UniqueMap v)
    UniqueMap v -> UniqueMap v -> Bool
    UniqueMap v -> UniqueMap v -> Ordering
    UniqueMap v -> UniqueMap v -> UniqueMap v
    forall a.
    Eq a
    -> (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall {v}. Ord v => Eq (UniqueMap v)
    forall v. Ord v => UniqueMap v -> UniqueMap v -> Bool
    forall v. Ord v => UniqueMap v -> UniqueMap v -> Ordering
    forall v. Ord v => UniqueMap v -> UniqueMap v -> UniqueMap v
    min :: UniqueMap v -> UniqueMap v -> UniqueMap v
    $cmin :: forall v. Ord v => UniqueMap v -> UniqueMap v -> UniqueMap v
    max :: UniqueMap v -> UniqueMap v -> UniqueMap v
    $cmax :: forall v. Ord v => UniqueMap v -> UniqueMap v -> UniqueMap v
    >= :: UniqueMap v -> UniqueMap v -> Bool
    $c>= :: forall v. Ord v => UniqueMap v -> UniqueMap v -> Bool
    > :: UniqueMap v -> UniqueMap v -> Bool
    $c> :: forall v. Ord v => UniqueMap v -> UniqueMap v -> Bool
    <= :: UniqueMap v -> UniqueMap v -> Bool
    $c<= :: forall v. Ord v => UniqueMap v -> UniqueMap v -> Bool
    < :: UniqueMap v -> UniqueMap v -> Bool
    $c< :: forall v. Ord v => UniqueMap v -> UniqueMap v -> Bool
    compare :: UniqueMap v -> UniqueMap v -> Ordering
    $ccompare :: forall v. Ord v => UniqueMap v -> UniqueMap v -> Ordering
    Ord, Int -> UniqueMap v -> ShowS
    [UniqueMap v] -> ShowS
    UniqueMap v -> String
    (Int -> UniqueMap v -> ShowS)
    -> (UniqueMap v -> String)
    -> ([UniqueMap v] -> ShowS)
    -> Show (UniqueMap v)
    forall v. Show v => Int -> UniqueMap v -> ShowS
    forall v. Show v => [UniqueMap v] -> ShowS
    forall v. Show v => UniqueMap v -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [UniqueMap v] -> ShowS
    $cshowList :: forall v. Show v => [UniqueMap v] -> ShowS
    show :: UniqueMap v -> String
    $cshow :: forall v. Show v => UniqueMap v -> String
    showsPrec :: Int -> UniqueMap v -> ShowS
    $cshowsPrec :: forall v. Show v => Int -> UniqueMap v -> ShowS
    Show, (forall a b. (a -> b) -> UniqueMap a -> UniqueMap b)
    -> (forall a b. a -> UniqueMap b -> UniqueMap a)
    -> Functor UniqueMap
    forall a b. a -> UniqueMap b -> UniqueMap a
    forall a b. (a -> b) -> UniqueMap a -> UniqueMap b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    <$ :: forall a b. a -> UniqueMap b -> UniqueMap a
    $c<$ :: forall a b. a -> UniqueMap b -> UniqueMap a
    fmap :: forall a b. (a -> b) -> UniqueMap a -> UniqueMap b
    $cfmap :: forall a b. (a -> b) -> UniqueMap a -> UniqueMap b
    Functor, (forall m. Monoid m => UniqueMap m -> m)
    -> (forall m a. Monoid m => (a -> m) -> UniqueMap a -> m)
    -> (forall m a. Monoid m => (a -> m) -> UniqueMap a -> m)
    -> (forall a b. (a -> b -> b) -> b -> UniqueMap a -> b)
    -> (forall a b. (a -> b -> b) -> b -> UniqueMap a -> b)
    -> (forall b a. (b -> a -> b) -> b -> UniqueMap a -> b)
    -> (forall b a. (b -> a -> b) -> b -> UniqueMap a -> b)
    -> (forall a. (a -> a -> a) -> UniqueMap a -> a)
    -> (forall a. (a -> a -> a) -> UniqueMap a -> a)
    -> (forall a. UniqueMap a -> [a])
    -> (forall a. UniqueMap a -> Bool)
    -> (forall a. UniqueMap a -> Int)
    -> (forall a. Eq a => a -> UniqueMap a -> Bool)
    -> (forall a. Ord a => UniqueMap a -> a)
    -> (forall a. Ord a => UniqueMap a -> a)
    -> (forall a. Num a => UniqueMap a -> a)
    -> (forall a. Num a => UniqueMap a -> a)
    -> Foldable UniqueMap
    forall a. Eq a => a -> UniqueMap a -> Bool
    forall a. Num a => UniqueMap a -> a
    forall a. Ord a => UniqueMap a -> a
    forall m. Monoid m => UniqueMap m -> m
    forall a. UniqueMap a -> Bool
    forall a. UniqueMap a -> Int
    forall a. UniqueMap a -> [a]
    forall a. (a -> a -> a) -> UniqueMap a -> a
    forall m a. Monoid m => (a -> m) -> UniqueMap a -> m
    forall b a. (b -> a -> b) -> b -> UniqueMap a -> b
    forall a b. (a -> b -> b) -> b -> UniqueMap a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    product :: forall a. Num a => UniqueMap a -> a
    $cproduct :: forall a. Num a => UniqueMap a -> a
    sum :: forall a. Num a => UniqueMap a -> a
    $csum :: forall a. Num a => UniqueMap a -> a
    minimum :: forall a. Ord a => UniqueMap a -> a
    $cminimum :: forall a. Ord a => UniqueMap a -> a
    maximum :: forall a. Ord a => UniqueMap a -> a
    $cmaximum :: forall a. Ord a => UniqueMap a -> a
    elem :: forall a. Eq a => a -> UniqueMap a -> Bool
    $celem :: forall a. Eq a => a -> UniqueMap a -> Bool
    length :: forall a. UniqueMap a -> Int
    $clength :: forall a. UniqueMap a -> Int
    null :: forall a. UniqueMap a -> Bool
    $cnull :: forall a. UniqueMap a -> Bool
    toList :: forall a. UniqueMap a -> [a]
    $ctoList :: forall a. UniqueMap a -> [a]
    foldl1 :: forall a. (a -> a -> a) -> UniqueMap a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> UniqueMap a -> a
    foldr1 :: forall a. (a -> a -> a) -> UniqueMap a -> a
    $cfoldr1 :: forall a. (a -> a -> a) -> UniqueMap a -> a
    foldl' :: forall b a. (b -> a -> b) -> b -> UniqueMap a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> UniqueMap a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> UniqueMap a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> UniqueMap a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> UniqueMap a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> UniqueMap a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> UniqueMap a -> b
    $cfoldr :: forall a b. (a -> b -> b) -> b -> UniqueMap a -> b
    foldMap' :: forall m a. Monoid m => (a -> m) -> UniqueMap a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> UniqueMap a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> UniqueMap a -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> UniqueMap a -> m
    fold :: forall m. Monoid m => UniqueMap m -> m
    $cfold :: forall m. Monoid m => UniqueMap m -> m
    Foldable, Functor UniqueMap
    Foldable UniqueMap
    Functor UniqueMap
    -> Foldable UniqueMap
    -> (forall (f :: * -> *) a b.
        Applicative f =>
        (a -> f b) -> UniqueMap a -> f (UniqueMap b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        UniqueMap (f a) -> f (UniqueMap a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> UniqueMap a -> m (UniqueMap b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        UniqueMap (m a) -> m (UniqueMap a))
    -> Traversable UniqueMap
    forall (t :: * -> *).
    Functor t
    -> Foldable t
    -> (forall (f :: * -> *) a b.
        Applicative f =>
        (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    UniqueMap (m a) -> m (UniqueMap a)
    forall (f :: * -> *) a.
    Applicative f =>
    UniqueMap (f a) -> f (UniqueMap a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> UniqueMap a -> m (UniqueMap b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> UniqueMap a -> f (UniqueMap b)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    UniqueMap (m a) -> m (UniqueMap a)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    UniqueMap (m a) -> m (UniqueMap a)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> UniqueMap a -> m (UniqueMap b)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> UniqueMap a -> m (UniqueMap b)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    UniqueMap (f a) -> f (UniqueMap a)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    UniqueMap (f a) -> f (UniqueMap a)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> UniqueMap a -> f (UniqueMap b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> UniqueMap a -> f (UniqueMap b)
    Traversable)

    instance IsMap UniqueMap where
      type KeyOf UniqueMap = Int

      mapNull :: forall a. UniqueMap a -> Bool
    mapNull (UM IntMap a
    m) = IntMap a -> Bool
    forall a. IntMap a -> Bool
    M.null IntMap a
    m
      mapSize :: forall a. UniqueMap a -> Int
    mapSize (UM IntMap a
    m) = IntMap a -> Int
    forall a. IntMap a -> Int
    M.size IntMap a
    m
      mapMember :: forall a. KeyOf UniqueMap -> UniqueMap a -> Bool
    mapMember KeyOf UniqueMap
    k (UM IntMap a
    m) = Int -> IntMap a -> Bool
    forall a. Int -> IntMap a -> Bool
    M.member Int
    KeyOf UniqueMap
    k IntMap a
    m
      mapLookup :: forall a. KeyOf UniqueMap -> UniqueMap a -> Maybe a
    mapLookup KeyOf UniqueMap
    k (UM IntMap a
    m) = Int -> IntMap a -> Maybe a
    forall a. Int -> IntMap a -> Maybe a
    M.lookup Int
    KeyOf UniqueMap
    k IntMap a
    m
      mapFindWithDefault :: forall a. a -> KeyOf UniqueMap -> UniqueMap a -> a
    mapFindWithDefault a
    def KeyOf UniqueMap
    k (UM IntMap a
    m) = a -> Int -> IntMap a -> a
    forall a. a -> Int -> IntMap a -> a
    M.findWithDefault a
    def Int
    KeyOf UniqueMap
    k IntMap a
    m

      mapEmpty :: forall a. UniqueMap a
    mapEmpty = IntMap a -> UniqueMap a
    forall v. IntMap v -> UniqueMap v
    UM IntMap a
    forall a. IntMap a
    M.empty
      mapSingleton :: forall a. KeyOf UniqueMap -> a -> UniqueMap a
    mapSingleton KeyOf UniqueMap
    k a
    v = IntMap a -> UniqueMap a
    forall v. IntMap v -> UniqueMap v
    UM (Int -> a -> IntMap a
    forall a. Int -> a -> IntMap a
    M.singleton Int
    KeyOf UniqueMap
    k a
    v)
      mapInsert :: forall a. KeyOf UniqueMap -> a -> UniqueMap a -> UniqueMap a
    mapInsert KeyOf UniqueMap
    k a
    v (UM IntMap a
    m) = IntMap a -> UniqueMap a
    forall v. IntMap v -> UniqueMap v
    UM (Int -> a -> IntMap a -> IntMap a
    forall a. Int -> a -> IntMap a -> IntMap a
    M.insert Int
    KeyOf UniqueMap
    k a
    v IntMap a
    m)
      mapInsertWith :: forall a.
    (a -> a -> a) -> KeyOf UniqueMap -> a -> UniqueMap a -> UniqueMap a
    mapInsertWith a -> a -> a
    f KeyOf UniqueMap
    k a
    v (UM IntMap a
    m) = IntMap a -> UniqueMap a
    forall v. IntMap v -> UniqueMap v
    UM ((a -> a -> a) -> Int -> a -> IntMap a -> IntMap a
    forall a. (a -> a -> a) -> Int -> a -> IntMap a -> IntMap a
    M.insertWith a -> a -> a
    f Int
    KeyOf UniqueMap
    k a
    v IntMap a
    m)
      mapDelete :: forall a. KeyOf UniqueMap -> UniqueMap a -> UniqueMap a
    mapDelete KeyOf UniqueMap
    k (UM IntMap a
    m) = IntMap a -> UniqueMap a
    forall v. IntMap v -> UniqueMap v
    UM (Int -> IntMap a -> IntMap a
    forall a. Int -> IntMap a -> IntMap a
    M.delete Int
    KeyOf UniqueMap
    k IntMap a
    m)
      mapAlter :: forall a.
    (Maybe a -> Maybe a)
    -> KeyOf UniqueMap -> UniqueMap a -> UniqueMap a
    mapAlter Maybe a -> Maybe a
    f KeyOf UniqueMap
    k (UM IntMap a
    m) = IntMap a -> UniqueMap a
    forall v. IntMap v -> UniqueMap v
    UM ((Maybe a -> Maybe a) -> Int -> IntMap a -> IntMap a
    forall a. (Maybe a -> Maybe a) -> Int -> IntMap a -> IntMap a
    M.alter Maybe a -> Maybe a
    f Int
    KeyOf UniqueMap
    k IntMap a
    m)
      mapAdjust :: forall a. (a -> a) -> KeyOf UniqueMap -> UniqueMap a -> UniqueMap a
    mapAdjust a -> a
    f KeyOf UniqueMap
    k (UM IntMap a
    m) = IntMap a -> UniqueMap a
    forall v. IntMap v -> UniqueMap v
    UM ((a -> a) -> Int -> IntMap a -> IntMap a
    forall a. (a -> a) -> Int -> IntMap a -> IntMap a
    M.adjust a -> a
    f Int
    KeyOf UniqueMap
    k IntMap a
    m)

      mapUnion :: forall a. UniqueMap a -> UniqueMap a -> UniqueMap a
    mapUnion (UM IntMap a
    x) (UM IntMap a
    y) = IntMap a -> UniqueMap a
    forall v. IntMap v -> UniqueMap v
    UM (IntMap a -> IntMap a -> IntMap a
    forall a. IntMap a -> IntMap a -> IntMap a
    M.union IntMap a
    x IntMap a
    y)
      mapUnionWithKey :: forall a.
    (KeyOf UniqueMap -> a -> a -> a)
    -> UniqueMap a -> UniqueMap a -> UniqueMap a
    mapUnionWithKey KeyOf UniqueMap -> a -> a -> a
    f (UM IntMap a
    x) (UM IntMap a
    y) = IntMap a -> UniqueMap a
    forall v. IntMap v -> UniqueMap v
    UM ((Int -> a -> a -> a) -> IntMap a -> IntMap a -> IntMap a
    forall a. (Int -> a -> a -> a) -> IntMap a -> IntMap a -> IntMap a
    M.unionWithKey Int -> a -> a -> a
    KeyOf UniqueMap -> a -> a -> a
    f IntMap a
    x IntMap a
    y)
      mapDifference :: forall a. UniqueMap a -> UniqueMap a -> UniqueMap a
    mapDifference (UM IntMap a
    x) (UM IntMap a
    y) = IntMap a -> UniqueMap a
    forall v. IntMap v -> UniqueMap v
    UM (IntMap a -> IntMap a -> IntMap a
    forall a b. IntMap a -> IntMap b -> IntMap a
    M.difference IntMap a
    x IntMap a
    y)
      mapIntersection :: forall a. UniqueMap a -> UniqueMap a -> UniqueMap a
    mapIntersection (UM IntMap a
    x) (UM IntMap a
    y) = IntMap a -> UniqueMap a
    forall v. IntMap v -> UniqueMap v
    UM (IntMap a -> IntMap a -> IntMap a
    forall a b. IntMap a -> IntMap b -> IntMap a
    M.intersection IntMap a
    x IntMap a
    y)
      mapIsSubmapOf :: forall v. Eq v => UniqueMap v -> UniqueMap v -> Bool
    mapIsSubmapOf (UM IntMap a
    x) (UM IntMap a
    y) = IntMap a -> IntMap a -> Bool
    forall a. Eq a => IntMap a -> IntMap a -> Bool
    M.isSubmapOf IntMap a
    x IntMap a
    y

      mapMap :: forall a b. (a -> b) -> UniqueMap a -> UniqueMap b
    mapMap a -> b
    f (UM IntMap a
    m) = IntMap b -> UniqueMap b
    forall v. IntMap v -> UniqueMap v
    UM ((a -> b) -> IntMap a -> IntMap b
    forall a b. (a -> b) -> IntMap a -> IntMap b
    M.map a -> b
    f IntMap a
    m)
      mapMapWithKey :: forall a b.
    (KeyOf UniqueMap -> a -> b) -> UniqueMap a -> UniqueMap b
    mapMapWithKey KeyOf UniqueMap -> a -> b
    f (UM IntMap a
    m) = IntMap b -> UniqueMap b
    forall v. IntMap v -> UniqueMap v
    UM ((Int -> a -> b) -> IntMap a -> IntMap b
    forall a b. (Int -> a -> b) -> IntMap a -> IntMap b
    M.mapWithKey Int -> a -> b
    KeyOf UniqueMap -> a -> b
    f IntMap a
    m)
      mapFoldl :: forall b a. (b -> a -> b) -> b -> UniqueMap a -> b
    mapFoldl b -> a -> b
    k b
    z (UM IntMap a
    m) = (b -> a -> b) -> b -> IntMap a -> b
    forall a b. (a -> b -> a) -> a -> IntMap b -> a
    M.foldl' b -> a -> b
    k b
    z IntMap a
    m
      mapFoldr :: forall a b. (a -> b -> b) -> b -> UniqueMap a -> b
    mapFoldr a -> b -> b
    k b
    z (UM IntMap a
    m) = (a -> b -> b) -> b -> IntMap a -> b
    forall a b. (a -> b -> b) -> b -> IntMap a -> b
    M.foldr a -> b -> b
    k b
    z IntMap a
    m
      mapFoldlWithKey :: forall b a.
    (b -> KeyOf UniqueMap -> a -> b) -> b -> UniqueMap a -> b
    mapFoldlWithKey b -> KeyOf UniqueMap -> a -> b
    k b
    z (UM IntMap a
    m) = (b -> Int -> a -> b) -> b -> IntMap a -> b
    forall a b. (a -> Int -> b -> a) -> a -> IntMap b -> a
    M.foldlWithKey' b -> Int -> a -> b
    b -> KeyOf UniqueMap -> a -> b
    k b
    z IntMap a
    m
      mapFoldMapWithKey :: forall m a.
    Monoid m =>
    (KeyOf UniqueMap -> a -> m) -> UniqueMap a -> m
    mapFoldMapWithKey KeyOf UniqueMap -> a -> m
    f (UM IntMap a
    m) = (Int -> a -> m) -> IntMap a -> m
    forall m a. Monoid m => (Int -> a -> m) -> IntMap a -> m
    M.foldMapWithKey Int -> a -> m
    KeyOf UniqueMap -> a -> m
    f IntMap a
    m
      {-# INLINEABLE mapFilter #-}
      mapFilter :: forall a. (a -> Bool) -> UniqueMap a -> UniqueMap a
    mapFilter a -> Bool
    f (UM IntMap a
    m) = IntMap a -> UniqueMap a
    forall v. IntMap v -> UniqueMap v
    UM ((a -> Bool) -> IntMap a -> IntMap a
    forall a. (a -> Bool) -> IntMap a -> IntMap a
    M.filter a -> Bool
    f IntMap a
    m)
      {-# INLINEABLE mapFilterWithKey #-}
      mapFilterWithKey :: forall a.
    (KeyOf UniqueMap -> a -> Bool) -> UniqueMap a -> UniqueMap a
    mapFilterWithKey KeyOf UniqueMap -> a -> Bool
    f (UM IntMap a
    m) = IntMap a -> UniqueMap a
    forall v. IntMap v -> UniqueMap v
    UM ((Int -> a -> Bool) -> IntMap a -> IntMap a
    forall a. (Int -> a -> Bool) -> IntMap a -> IntMap a
    M.filterWithKey Int -> a -> Bool
    KeyOf UniqueMap -> a -> Bool
    f IntMap a
    m)

      mapElems :: forall a. UniqueMap a -> [a]
    mapElems (UM IntMap a
    m) = IntMap a -> [a]
    forall a. IntMap a -> [a]
    M.elems IntMap a
    m
      mapKeys :: forall a. UniqueMap a -> [KeyOf UniqueMap]
    mapKeys (UM IntMap a
    m) = IntMap a -> [Int]
    forall a. IntMap a -> [Int]
    M.keys IntMap a
    m
      {-# INLINEABLE mapToList #-}
      mapToList :: forall a. UniqueMap a -> [(KeyOf UniqueMap, a)]
    mapToList (UM IntMap a
    m) = IntMap a -> [(Int, a)]
    forall a. IntMap a -> [(Int, a)]
    M.toList IntMap a
    m
      mapFromList :: forall a. [(KeyOf UniqueMap, a)] -> UniqueMap a
    mapFromList [(KeyOf UniqueMap, a)]
    assocs = IntMap a -> UniqueMap a
    forall v. IntMap v -> UniqueMap v
    UM ([(Int, a)] -> IntMap a
    forall a. [(Int, a)] -> IntMap a
    M.fromList [(Int, a)]
    [(KeyOf UniqueMap, a)]
    assocs)
      mapFromListWith :: forall a. (a -> a -> a) -> [(KeyOf UniqueMap, a)] -> UniqueMap a
    mapFromListWith a -> a -> a
    f [(KeyOf UniqueMap, a)]
    assocs = IntMap a -> UniqueMap a
    forall v. IntMap v -> UniqueMap v
    UM ((a -> a -> a) -> [(Int, a)] -> IntMap a
    forall a. (a -> a -> a) -> [(Int, a)] -> IntMap a
    M.fromListWith a -> a -> a
    f [(Int, a)]
    [(KeyOf UniqueMap, a)]
    assocs)