Data.Edison.Assoc.Defaults: exported symbols usage examples

Symbols

  • adjustOrDeleteAllDefault See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    adjust _ _ E = E
    adjust f key (I k x m) | key == k  = I key (f x) m
                           | otherwise = I k x (adjust f key m)
    
    adjustAll = adjust
    
    adjustOrInsert _ z key E = singleton key z
    adjustOrInsert f z key (I k x m)
        | key == k  = I key (f x) m
        | otherwise = I k x (adjustOrInsert f z key m)
    
    adjustAllOrInsert = adjustOrInsert
    
    adjustOrDelete = adjustOrDeleteDefault
    adjustOrDeleteAll = adjustOrDeleteAllDefault
    
    map _ E = E
    map f (I k x m) = I k (f x) (map f m)
    
    fold _ c E = c
    

    adjustOrDeleteDefault See 3 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    adjust _ _ E = E
    adjust f key (I k x m) | key == k  = I key (f x) m
                           | otherwise = I k x (adjust f key m)
    
    adjustAll = adjust
    
    adjustOrInsert _ z key E = singleton key z
    adjustOrInsert f z key (I k x m)
        | key == k  = I key (f x) m
        | otherwise = I k x (adjustOrInsert f z key m)
    
    adjustAllOrInsert = adjustOrInsert
    
    adjustOrDelete = adjustOrDeleteDefault
    adjustOrDeleteAll = adjustOrDeleteAllDefault
    
    map _ E = E
    map f (I k x m) = I k (f x) (map f m)
    

    Found in Data.Edison.Assoc.PatriciaLoMap from the package EdisonCore
                         else B p m t0 (adjust f k t1)
        else t
    
    -- FIXME can we do better than this?
    adjustOrInsert :: (a -> a) -> a -> Int -> FM a -> FM a
    adjustOrInsert = adjustOrInsertUsingMember
    
    adjustAllOrInsert :: (a -> a) -> a -> Int -> FM a -> FM a
    adjustAllOrInsert = adjustOrInsertUsingMember
    
    adjustOrDelete :: (a -> Maybe a) -> Int -> FM a -> FM a
    adjustOrDelete = adjustOrDeleteDefault
    
    adjustOrDeleteAll :: (a -> Maybe a) -> Int -> FM a -> FM a
    adjustOrDeleteAll = adjustOrDeleteDefault
    
    map :: (a -> b) -> FM a -> FM b
    map _ E = E
    map f (L k x) = L k (f x)
    map f (B p m t0 t1) = B p m (map f t0) (map f t1)
    

    Found in Data.Edison.Assoc.PatriciaLoMap from the package EdisonCore
    adjust f k t@(B p m t0 t1) =
        if matchPrefix k p m then
          if zeroBit k m then B p m (adjust f k t0) t1
                         else B p m t0 (adjust f k t1)
        else t
    
    -- FIXME can we do better than this?
    adjustOrInsert :: (a -> a) -> a -> Int -> FM a -> FM a
    adjustOrInsert = adjustOrInsertUsingMember
    
    adjustAllOrInsert :: (a -> a) -> a -> Int -> FM a -> FM a
    adjustAllOrInsert = adjustOrInsertUsingMember
    
    adjustOrDelete :: (a -> Maybe a) -> Int -> FM a -> FM a
    adjustOrDelete = adjustOrDeleteDefault
    
    adjustOrDeleteAll :: (a -> Maybe a) -> Int -> FM a -> FM a
    adjustOrDeleteAll = adjustOrDeleteDefault
    
    map :: (a -> b) -> FM a -> FM b
    

    adjustOrInsertUsingMember See 4 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.PatriciaLoMap from the package EdisonCore
    adjust :: (a -> a) -> Int -> FM a -> FM a
    adjust _ _ E = E
    adjust f k t@(L j x) = if k == j then L k (f x) else t
    adjust f k t@(B p m t0 t1) =
        if matchPrefix k p m then
          if zeroBit k m then B p m (adjust f k t0) t1
                         else B p m t0 (adjust f k t1)
        else t
    
    -- FIXME can we do better than this?
    adjustOrInsert :: (a -> a) -> a -> Int -> FM a -> FM a
    adjustOrInsert = adjustOrInsertUsingMember
    
    adjustAllOrInsert :: (a -> a) -> a -> Int -> FM a -> FM a
    adjustAllOrInsert = adjustOrInsertUsingMember
    
    adjustOrDelete :: (a -> Maybe a) -> Int -> FM a -> FM a
    adjustOrDelete = adjustOrDeleteDefault
    
    adjustOrDeleteAll :: (a -> Maybe a) -> Int -> FM a -> FM a
    

    Found in Data.Edison.Assoc.PatriciaLoMap from the package EdisonCore
                               k m
    
    
    adjust :: (a -> a) -> Int -> FM a -> FM a
    adjust _ _ E = E
    adjust f k t@(L j x) = if k == j then L k (f x) else t
    adjust f k t@(B p m t0 t1) =
        if matchPrefix k p m then
          if zeroBit k m then B p m (adjust f k t0) t1
                         else B p m t0 (adjust f k t1)
        else t
    
    -- FIXME can we do better than this?
    adjustOrInsert :: (a -> a) -> a -> Int -> FM a -> FM a
    adjustOrInsert = adjustOrInsertUsingMember
    
    adjustAllOrInsert :: (a -> a) -> a -> Int -> FM a -> FM a
    adjustAllOrInsert = adjustOrInsertUsingMember
    
    adjustOrDelete :: (a -> Maybe a) -> Int -> FM a -> FM a
    

    Found in Data.Edison.Assoc.StandardMap from the package EdisonCore
    null               = DM.null
    size               = DM.size
    member             = DM.member
    count              = countUsingMember
    lookup k m         = maybe (error (moduleName ++ ".lookup: failed")) id (DM.lookup k m)
    lookupM k m        = maybe (fail (moduleName ++ ".lookupM: failed")) return (DM.lookup k m)
    lookupAll          = lookupAllUsingLookupM
    lookupWithDefault  = DM.findWithDefault
    lookupAndDelete    = lookupAndDeleteDefault
    lookupAndDeleteM   = lookupAndDeleteMDefault
    lookupAndDeleteAll = lookupAndDeleteAllDefault
    adjust             = DM.adjust
    adjustAll          = DM.adjust
    adjustOrInsert     = adjustOrInsertUsingMember
    adjustAllOrInsert  = adjustOrInsertUsingMember
    adjustOrDelete     = DM.update
    adjustOrDeleteAll  = DM.update
    strict xs          = DM.foldr (flip const) () xs `seq` xs
    strictWith f xs    = DM.foldr (\x z -> f x `seq` z) () xs `seq` xs
    map                = fmap
    

    Found in Data.Edison.Assoc.StandardMap from the package EdisonCore
    deleteSeq          = deleteSeqUsingFoldr
    null               = DM.null
    size               = DM.size
    member             = DM.member
    count              = countUsingMember
    lookup k m         = maybe (error (moduleName ++ ".lookup: failed")) id (DM.lookup k m)
    lookupM k m        = maybe (fail (moduleName ++ ".lookupM: failed")) return (DM.lookup k m)
    lookupAll          = lookupAllUsingLookupM
    lookupWithDefault  = DM.findWithDefault
    lookupAndDelete    = lookupAndDeleteDefault
    lookupAndDeleteM   = lookupAndDeleteMDefault
    lookupAndDeleteAll = lookupAndDeleteAllDefault
    adjust             = DM.adjust
    adjustAll          = DM.adjust
    adjustOrInsert     = adjustOrInsertUsingMember
    adjustAllOrInsert  = adjustOrInsertUsingMember
    adjustOrDelete     = DM.update
    adjustOrDeleteAll  = DM.update
    strict xs          = DM.foldr (flip const) () xs `seq` xs
    strictWith f xs    = DM.foldr (\x z -> f x `seq` z) () xs `seq` xs
    

    compareUsingToOrdList See 3 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    instance Eq k => A.FiniteMap (FM k) k where
      {unionWithKey = unionWithKey; unionSeqWithKey = unionSeqWithKey;
       intersectionWithKey = intersectionWithKey}
    
    instance Ord k => A.OrdFiniteMap (FM k) k
    
    instance Eq k => Functor (FM k) where
      fmap =  map
    
    instance (Eq k,Eq a) => Eq (FM k a) where
      (==) = sameMap
    
    instance (Ord k, Ord a) => Ord (FM k a) where
      compare = compareUsingToOrdList
    
    instance (Eq k,Show k,Show a) => Show (FM k a) where
      showsPrec = showsPrecUsingToList
    
    instance (Eq k,Read k,Read a) => Read (FM k a) where
    

    Found in Data.Edison.Assoc.PatriciaLoMap from the package EdisonCore
    instance Functor FM where
      fmap = map
    
    instance (Show a) => Show (FM a) where
      showsPrec = showsPrecUsingToList
    
    instance (Read a) => Read (FM a) where
      readsPrec = readsPrecUsingFromList
    
    instance (Eq a) => Eq (FM a) where
      (==) = sameMap
    
    instance (Ord a) => Ord (FM a) where
      compare = compareUsingToOrdList
    
    instance (Arbitrary a) => Arbitrary (FM a) where
       arbitrary = do (xs::[(Int,a)]) <- arbitrary
                      return (Prelude.foldr (uncurry insert) empty xs)
    

    Found in Data.Edison.Assoc.TernaryTrie from the package EdisonCore
    instance Ord k => Functor (FM k) where
      fmap = map
    
    instance (Ord k, Show k, Show a) => Show (FM k a) where
      showsPrec = showsPrecUsingToList
    
    instance (Ord k, Read k, Read a) => Read (FM k a) where
      readsPrec = readsPrecUsingFromList
    
    instance (Ord k, Eq a) => Eq (FM k a) where
      (==) = sameMap
    
    instance (Ord k, Ord a) => Ord (FM k a) where
      compare = compareUsingToOrdList
    
    --
    -- Test code follows
    --
    

    countUsingMember See 3 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.PatriciaLoMap from the package EdisonCore
    insertSeq :: S.Sequence seq => seq (Int,a) -> FM a -> FM a
    insertSeq = insertSeqUsingFoldr
    
    unionSeq :: S.Sequence seq => seq (FM a) -> FM a
    unionSeq = unionSeqUsingReduce
    
    deleteAll :: Int -> FM a -> FM a
    deleteAll = delete
    
    deleteSeq :: S.Sequence seq => seq Int -> FM a -> FM a
    deleteSeq = deleteSeqUsingFoldr
    
    count :: Int -> FM a -> Int
    count = countUsingMember
    
    lookupAll :: S.Sequence seq => Int -> FM a -> seq a
    lookupAll = lookupAllUsingLookupM
    
    lookupWithDefault :: a -> Int -> FM a -> a
    

    Found in Data.Edison.Assoc.StandardMap from the package EdisonCore
    empty              = DM.empty
    singleton          = DM.singleton
    fromSeq            = fromSeqUsingInsertSeq
    insert             = DM.insert
    insertSeq          = insertSeqUsingFoldr
    union              = DM.union
    unionSeq           = DM.unions . S.toList
    delete             = DM.delete
    deleteAll          = DM.delete -- by finite map property
    deleteSeq          = deleteSeqUsingFoldr
    null               = DM.null
    size               = DM.size
    member             = DM.member
    count              = countUsingMember
    lookup k m         = maybe (error (moduleName ++ ".lookup: failed")) id (DM.lookup k m)
    lookupM k m        = maybe (fail (moduleName ++ ".lookupM: failed")) return (DM.lookup k m)
    lookupAll          = lookupAllUsingLookupM
    lookupWithDefault  = DM.findWithDefault
    lookupAndDelete    = lookupAndDeleteDefault
    

    Found in Data.Edison.Assoc.TernaryTrie from the package EdisonCore
    deleteSeq = deleteSeqUsingFoldr
    
    null = nullFM
    
    size (FM k fmb)
        | isNothing k = fmb_size fmb 0
        | otherwise   = fmb_size fmb 1
        where fmb_size E k = k
              fmb_size (I _ _ Nothing l (FMB' m) r) k = fmb_size l $ fmb_size m $ fmb_size r k
              fmb_size (I _ _ _ l (FMB' m) r ) k      = fmb_size l $ fmb_size m $ fmb_size r $! k+1
    
    
    member = memberUsingLookupM
    
    count = countUsingMember
    
    lookup m k = runIdentity (lookupM m k)
    
    lookupM [] (FM Nothing _)
      = fail "TernaryTrie.lookup: lookup failed"
    

    deleteMaxUsingMaxView See 2 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.PatriciaLoMap from the package EdisonCore
    minElemWithKey :: FM a -> (Int,a)
    minElemWithKey = minElemWithKeyUsingMinViewWithKey
    
    deleteMin :: FM a -> FM a
    deleteMin = deleteMinUsingMinView
    
    unsafeInsertMin :: Int -> a -> FM a -> FM a
    unsafeInsertMin = insert
    
    maxElem :: FM a -> a
    maxElem = maxElemUsingMaxView
    
    deleteMax :: FM a -> FM a
    deleteMax = deleteMaxUsingMaxView
    
    maxElemWithKey :: FM a -> (Int,a)
    maxElemWithKey = maxElemWithKeyUsingMaxViewWithKey
    
    unsafeInsertMax :: Int -> a -> FM a -> FM a
    

    Found in Data.Edison.Assoc.TernaryTrie from the package EdisonCore
    maxElemWithKeyFMB (I _ k (Just v) _ (FMB' E) E) kf = (kf [k],v)
    maxElemWithKeyFMB (I _ _ Nothing  _ (FMB' E) E) _ = error $ moduleName++".maxElemWithKey: bug!"
    maxElemWithKeyFMB (I _ k _ _ (FMB' m) E)       kf = maxElemWithKeyFMB m (kf . (k:))
    maxElemWithKeyFMB (I _ _ _ _ _ r)              kf = maxElemWithKeyFMB r kf
    maxElemWithKeyFMB E                             _ = error $ moduleName++".maxElemWithKey: bug!"
    
    
    maxElemWithKey :: FM k a -> ([k],a)
    maxElemWithKey (FM (Just v) E) = ([],v)
    maxElemWithKey (FM Nothing E)  = error $ moduleName++".maxElemWithKey: empty map"
    maxElemWithKey (FM _ fmb)      = maxElemWithKeyFMB fmb id
    
    
    deleteMax :: Ord k => FM k a -> FM k a
    deleteMax = deleteMaxUsingMaxView
    
    unsafeInsertMax :: Ord k => [k] -> a -> FM k a -> FM k a
    unsafeInsertMax = insert
    
    unsafeFromOrdSeq :: (Ord k,S.Sequence seq) => seq ([k],a) -> FM k a
    

    deleteMinUsingMinView See 2 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.PatriciaLoMap from the package EdisonCore
    maxViewWithKey :: Monad m => FM a -> m ((Int, a), FM a)
    maxViewWithKey fm =
       case ordListFM_rev fm of
         [] -> fail $ moduleName++".maxViewWithKey: empty map"
         ((k,x):_) -> return ((k,x),delete k fm)
    
    minElem :: FM a -> a
    minElem = minElemUsingMinView
    
    minElemWithKey :: FM a -> (Int,a)
    minElemWithKey = minElemWithKeyUsingMinViewWithKey
    
    deleteMin :: FM a -> FM a
    deleteMin = deleteMinUsingMinView
    
    unsafeInsertMin :: Int -> a -> FM a -> FM a
    unsafeInsertMin = insert
    
    maxElem :: FM a -> a
    

    Found in Data.Edison.Assoc.TernaryTrie from the package EdisonCore
    minElem (FM Nothing  fmb) = minElemFMB fmb
    
    
    minElemWithKeyFMB :: ([k] -> [k]) -> FMB k a -> ([k],a)
    minElemWithKeyFMB _ E = error $ moduleName++".minElemWithKey: empty map"
    minElemWithKeyFMB kf (I _ k (Just v) E _ _)        = (kf [k],v)
    minElemWithKeyFMB kf (I _ k Nothing  E (FMB' m) _) = minElemWithKeyFMB (kf . (k:)) m
    minElemWithKeyFMB kf (I _ _ _ l _ _)              = minElemWithKeyFMB kf l
    
    minElemWithKey :: FM k a -> ([k],a)
    minElemWithKey (FM (Just v) _) = ([],v)
    minElemWithKey (FM Nothing  fmb) = minElemWithKeyFMB id fmb
    
    deleteMin :: Ord k => FM k a -> FM k a
    deleteMin = deleteMinUsingMinView
    
    unsafeInsertMin :: Ord k => [k] -> a -> FM k a -> FM k a
    unsafeInsertMin = insert
    
    maxViewFMB :: Monad m => FMB k a -> (FMB k a -> FM k a) -> m (a, FM k a)
    

    deleteSeqUsingFoldr See 4 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    foldlWithKey  f x   = foldlWithKeyFM  f x . mergeSortFM
    foldlWithKey' f x   = foldlWithKeyFM' f x . mergeSortFM
    toOrdSeq            = toSeq . mergeSortFM
    
    
    strict n@E = n
    strict n@(I _ _ m) = strict m `seq` n
    
    strictWith _ n@E = n
    strictWith f n@(I _ a m) = f a `seq` strictWith f m `seq` n
    
    
    -- defaults
    
    deleteSeq = deleteSeqUsingFoldr
    insertWith = insertWithUsingLookupM
    insertSeqWith = insertSeqWithUsingInsertWith
    insertWithKey = insertWithKeyUsingInsertWith
    insertSeqWithKey = insertSeqWithKeyUsingInsertWithKey
    unionWith = unionWithUsingInsertWith
    

    Found in Data.Edison.Assoc.PatriciaLoMap from the package EdisonCore
    toOrdSeq = L.foldr S.lcons S.empty . ordListFM
    
    -- defaults
    
    insertSeq :: S.Sequence seq => seq (Int,a) -> FM a -> FM a
    insertSeq = insertSeqUsingFoldr
    
    unionSeq :: S.Sequence seq => seq (FM a) -> FM a
    unionSeq = unionSeqUsingReduce
    
    deleteAll :: Int -> FM a -> FM a
    deleteAll = delete
    
    deleteSeq :: S.Sequence seq => seq Int -> FM a -> FM a
    deleteSeq = deleteSeqUsingFoldr
    
    count :: Int -> FM a -> Int
    count = countUsingMember
    
    lookupAll :: S.Sequence seq => Int -> FM a -> seq a
    

    Found in Data.Edison.Assoc.StandardMap from the package EdisonCore
    structuralInvariant :: Ord k => FM k a -> Bool
    structuralInvariant = DM.valid
    
    
    empty              = DM.empty
    singleton          = DM.singleton
    fromSeq            = fromSeqUsingInsertSeq
    insert             = DM.insert
    insertSeq          = insertSeqUsingFoldr
    union              = DM.union
    unionSeq           = DM.unions . S.toList
    delete             = DM.delete
    deleteAll          = DM.delete -- by finite map property
    deleteSeq          = deleteSeqUsingFoldr
    null               = DM.null
    size               = DM.size
    member             = DM.member
    count              = countUsingMember
    lookup k m         = maybe (error (moduleName ++ ".lookup: failed")) id (DM.lookup k m)
    

    Found in Data.Edison.Assoc.TernaryTrie from the package EdisonCore
    fromSeq = fromSeqUsingInsertSeq
    
    insert k v fm = addToFM k (\_ -> Just v) fm
    
    insertSeq = insertSeqUsingFoldr
    
    union = mergeVFM mplus
    
    unionSeq = unionSeqUsingReduce
    
    delete k fm = delFromFM k fm
    
    deleteAll = delete
    
    deleteSeq = deleteSeqUsingFoldr
    
    null = nullFM
    
    size (FM k fmb)
        | isNothing k = fmb_size fmb 0
    

    differenceUsingDelete See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    -- defaults
    
    deleteSeq = deleteSeqUsingFoldr
    insertWith = insertWithUsingLookupM
    insertSeqWith = insertSeqWithUsingInsertWith
    insertWithKey = insertWithKeyUsingInsertWith
    insertSeqWithKey = insertSeqWithKeyUsingInsertWithKey
    unionWith = unionWithUsingInsertWith
    unionSeqWith = unionSeqWithUsingFoldr
    fromSeqWith = fromSeqWithUsingInsertSeqWith
    fromSeqWithKey = fromSeqWithKeyUsingInsertSeqWithKey
    intersectionWith = intersectionWithUsingLookupM
    difference = differenceUsingDelete
    properSubset = properSubsetUsingSubset
    subset = subsetUsingMember
    properSubmapBy = properSubmapByUsingSubmapBy
    submapBy = submapByUsingLookupM
    sameMapBy = sameMapByUsingSubmapBy
    

    elementsUsingFold See 3 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.PatriciaLoMap from the package EdisonCore
    deleteSeq :: S.Sequence seq => seq Int -> FM a -> FM a
    deleteSeq = deleteSeqUsingFoldr
    
    count :: Int -> FM a -> Int
    count = countUsingMember
    
    lookupAll :: S.Sequence seq => Int -> FM a -> seq a
    lookupAll = lookupAllUsingLookupM
    
    lookupWithDefault :: a -> Int -> FM a -> a
    lookupWithDefault = lookupWithDefaultUsingLookupM
    
    elements :: S.Sequence seq => FM a -> seq a
    elements = elementsUsingFold
    
    fromSeqWithKey ::
        S.Sequence seq => (Int -> a -> a -> a) -> seq (Int,a) -> FM a
    fromSeqWithKey = fromSeqWithKeyUsingInsertSeqWithKey
    

    Found in Data.Edison.Assoc.StandardMap from the package EdisonCore
    adjustAll          = DM.adjust
    adjustOrInsert     = adjustOrInsertUsingMember
    adjustAllOrInsert  = adjustOrInsertUsingMember
    adjustOrDelete     = DM.update
    adjustOrDeleteAll  = DM.update
    strict xs          = DM.foldr (flip const) () xs `seq` xs
    strictWith f xs    = DM.foldr (\x z -> f x `seq` z) () xs `seq` xs
    map                = fmap
    fold               = DM.foldr
    fold' f x xs       = L.foldl' (flip f) x (DM.elems xs)
    fold1  f xs        = L.foldr1 f (DM.elems xs)
    fold1' f xs        = L.foldl1' (flip f) (DM.elems xs)
    filter             = DM.filter
    partition          = DM.partition
    elements           = elementsUsingFold
    
    minView m          = if DM.null m
                           then fail (moduleName ++ ".minView: failed")
                           else let ((_,x),m') = DM.deleteFindMin m
                                in return (x,m')
    

    Found in Data.Edison.Assoc.TernaryTrie from the package EdisonCore
    -- FIXME, undestand this code to strictify it
    foldr1' = foldr1
    foldl1' :: (b -> b -> b) -> FM k b -> b
    foldl1' = foldl1
    
    
    filter p = mapVFM (\mv -> case mv of
                                Nothing -> mv
                                Just v  -> if p v then mv else Nothing)
    
    partition = partitionUsingFilter
    
    elements = elementsUsingFold
    
    strict z@(FM _ fmb) = strictFMB fmb `seq` z
     where strictFMB n@E = n
           strictFMB n@(I _ _ _ l (FMB' m) r) =
               strictFMB l `seq` strictFMB m `seq` strictFMB r `seq` n
    

    fold1UsingElements No usage example found for this symbol :( Collapse [-]
    fromSeqUsingInsertSeq See 2 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.StandardMap from the package EdisonCore
    foldlWithKey'     :: (b -> k -> a -> b) -> b -> FM k a -> b
    toOrdSeq          :: (Ord k,S.Sequence seq) => FM k a -> seq (k,a)
    
    unionWithKey      :: Ord k => (k -> a -> a -> a) -> FM k a -> FM k a -> FM k a
    unionSeqWithKey   :: (Ord k,S.Sequence seq) => (k -> a -> a -> a)
                            -> seq (FM k a) -> FM k a
    intersectionWithKey  :: Ord k => (k -> a -> b -> c) -> FM k a -> FM k b -> FM k c
    
    structuralInvariant :: Ord k => FM k a -> Bool
    structuralInvariant = DM.valid
    
    
    empty              = DM.empty
    singleton          = DM.singleton
    fromSeq            = fromSeqUsingInsertSeq
    insert             = DM.insert
    insertSeq          = insertSeqUsingFoldr
    union              = DM.union
    unionSeq           = DM.unions . S.toList
    delete             = DM.delete
    

    Found in Data.Edison.Assoc.TernaryTrie from the package EdisonCore
    mergeKVFM f (FM vx fmbx) (FM vy fmby)
      = FM (f [] vx vy) (mergeKVFMB f fmbx fmby)
    
    
    -- The public interface.
    --
    
    -- AssocX
    
    empty = FM Nothing E
    
    singleton [] v = FM (Just v) E
    singleton xs v = FM Nothing (listToFMB xs (\_ -> Just v))
    
    fromSeq = fromSeqUsingInsertSeq
    
    insert k v fm = addToFM k (\_ -> Just v) fm
    
    insertSeq = insertSeqUsingFoldr
    

    fromSeqWithKeyUsingInsertSeqWithKey See 3 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    strictWith _ n@E = n
    strictWith f n@(I _ a m) = f a `seq` strictWith f m `seq` n
    
    
    -- defaults
    
    deleteSeq = deleteSeqUsingFoldr
    insertWith = insertWithUsingLookupM
    insertSeqWith = insertSeqWithUsingInsertWith
    insertWithKey = insertWithKeyUsingInsertWith
    insertSeqWithKey = insertSeqWithKeyUsingInsertWithKey
    unionWith = unionWithUsingInsertWith
    unionSeqWith = unionSeqWithUsingFoldr
    fromSeqWith = fromSeqWithUsingInsertSeqWith
    fromSeqWithKey = fromSeqWithKeyUsingInsertSeqWithKey
    intersectionWith = intersectionWithUsingLookupM
    difference = differenceUsingDelete
    properSubset = properSubsetUsingSubset
    subset = subsetUsingMember
    properSubmapBy = properSubmapByUsingSubmapBy
    

    Found in Data.Edison.Assoc.PatriciaLoMap from the package EdisonCore
    count :: Int -> FM a -> Int
    count = countUsingMember
    
    lookupAll :: S.Sequence seq => Int -> FM a -> seq a
    lookupAll = lookupAllUsingLookupM
    
    lookupWithDefault :: a -> Int -> FM a -> a
    lookupWithDefault = lookupWithDefaultUsingLookupM
    
    elements :: S.Sequence seq => FM a -> seq a
    elements = elementsUsingFold
    
    fromSeqWithKey ::
        S.Sequence seq => (Int -> a -> a -> a) -> seq (Int,a) -> FM a
    fromSeqWithKey = fromSeqWithKeyUsingInsertSeqWithKey
    
    insertWithKey :: (Int -> a -> a -> a) -> Int -> a -> FM a -> FM a
    insertWithKey = insertWithKeyUsingInsertWith
    
    insertSeqWith ::
    

    Found in Data.Edison.Assoc.TernaryTrie from the package EdisonCore
    strictWith f z@(FM v fmb) = f' v `seq` strictWithFMB fmb `seq` z
       where f' v@Nothing  = v
             f' v@(Just x) = f x `seq` v
    
             strictWithFMB n@E = n
             strictWithFMB n@(I _ _ v l (FMB' m) r) =
               f' v `seq` strictWithFMB l `seq` strictWithFMB m `seq` strictWithFMB r `seq` n
    
    
    -- FiniteMapX
    
    fromSeqWith = fromSeqWithUsingInsertSeqWith
    
    fromSeqWithKey = fromSeqWithKeyUsingInsertSeqWithKey
    
    insertWith f k v
      = addToFM k (\vem ->
          case vem of
              Nothing -> Just v
    

    fromSeqWithUsingInsertSeqWith See 2 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    strictWith _ n@E = n
    strictWith f n@(I _ a m) = f a `seq` strictWith f m `seq` n
    
    
    -- defaults
    
    deleteSeq = deleteSeqUsingFoldr
    insertWith = insertWithUsingLookupM
    insertSeqWith = insertSeqWithUsingInsertWith
    insertWithKey = insertWithKeyUsingInsertWith
    insertSeqWithKey = insertSeqWithKeyUsingInsertWithKey
    unionWith = unionWithUsingInsertWith
    unionSeqWith = unionSeqWithUsingFoldr
    fromSeqWith = fromSeqWithUsingInsertSeqWith
    fromSeqWithKey = fromSeqWithKeyUsingInsertSeqWithKey
    intersectionWith = intersectionWithUsingLookupM
    difference = differenceUsingDelete
    properSubset = properSubsetUsingSubset
    subset = subsetUsingMember
    

    Found in Data.Edison.Assoc.TernaryTrie from the package EdisonCore
           strictFMB n@(I _ _ _ l (FMB' m) r) =
               strictFMB l `seq` strictFMB m `seq` strictFMB r `seq` n
    
    strictWith f z@(FM v fmb) = f' v `seq` strictWithFMB fmb `seq` z
       where f' v@Nothing  = v
             f' v@(Just x) = f x `seq` v
    
             strictWithFMB n@E = n
             strictWithFMB n@(I _ _ v l (FMB' m) r) =
               f' v `seq` strictWithFMB l `seq` strictWithFMB m `seq` strictWithFMB r `seq` n
    
    
    -- FiniteMapX
    
    fromSeqWith = fromSeqWithUsingInsertSeqWith
    
    fromSeqWithKey = fromSeqWithKeyUsingInsertSeqWithKey
    
    insertWith f k v
      = addToFM k (\vem ->
    

    insertSeqUsingFoldr See 3 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.PatriciaLoMap from the package EdisonCore
    partitionLT_GE k fm = (filterLT k fm,filterGE k fm)
    
    partitionLE_GT :: Int -> FM a -> (FM a,FM a)
    partitionLE_GT k fm = (filterLE k fm,filterGT k fm)
    
    partitionLT_GT :: Int -> FM a -> (FM a,FM a)
    partitionLT_GT k fm = (filterLT k fm,filterGT k fm)
    
    toOrdSeq :: S.Sequence seq => FM a -> seq (Int,a)
    toOrdSeq = L.foldr S.lcons S.empty . ordListFM
    
    -- defaults
    
    insertSeq :: S.Sequence seq => seq (Int,a) -> FM a -> FM a
    insertSeq = insertSeqUsingFoldr
    
    unionSeq :: S.Sequence seq => seq (FM a) -> FM a
    unionSeq = unionSeqUsingReduce
    
    deleteAll :: Int -> FM a -> FM a
    

    Found in Data.Edison.Assoc.StandardMap from the package EdisonCore
    unionWithKey      :: Ord k => (k -> a -> a -> a) -> FM k a -> FM k a -> FM k a
    unionSeqWithKey   :: (Ord k,S.Sequence seq) => (k -> a -> a -> a)
                            -> seq (FM k a) -> FM k a
    intersectionWithKey  :: Ord k => (k -> a -> b -> c) -> FM k a -> FM k b -> FM k c
    
    structuralInvariant :: Ord k => FM k a -> Bool
    structuralInvariant = DM.valid
    
    
    empty              = DM.empty
    singleton          = DM.singleton
    fromSeq            = fromSeqUsingInsertSeq
    insert             = DM.insert
    insertSeq          = insertSeqUsingFoldr
    union              = DM.union
    unionSeq           = DM.unions . S.toList
    delete             = DM.delete
    deleteAll          = DM.delete -- by finite map property
    deleteSeq          = deleteSeqUsingFoldr
    

    Found in Data.Edison.Assoc.TernaryTrie from the package EdisonCore
    -- The public interface.
    --
    
    -- AssocX
    
    empty = FM Nothing E
    
    singleton [] v = FM (Just v) E
    singleton xs v = FM Nothing (listToFMB xs (\_ -> Just v))
    
    fromSeq = fromSeqUsingInsertSeq
    
    insert k v fm = addToFM k (\_ -> Just v) fm
    
    insertSeq = insertSeqUsingFoldr
    
    union = mergeVFM mplus
    
    unionSeq = unionSeqUsingReduce
    

    insertSeqWithKeyUsingInsertWithKey See 4 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    strict n@E = n
    strict n@(I _ _ m) = strict m `seq` n
    
    strictWith _ n@E = n
    strictWith f n@(I _ a m) = f a `seq` strictWith f m `seq` n
    
    
    -- defaults
    
    deleteSeq = deleteSeqUsingFoldr
    insertWith = insertWithUsingLookupM
    insertSeqWith = insertSeqWithUsingInsertWith
    insertWithKey = insertWithKeyUsingInsertWith
    insertSeqWithKey = insertSeqWithKeyUsingInsertWithKey
    unionWith = unionWithUsingInsertWith
    unionSeqWith = unionSeqWithUsingFoldr
    fromSeqWith = fromSeqWithUsingInsertSeqWith
    fromSeqWithKey = fromSeqWithKeyUsingInsertSeqWithKey
    intersectionWith = intersectionWithUsingLookupM
    

    Found in Data.Edison.Assoc.PatriciaLoMap from the package EdisonCore
    fromSeqWithKey ::
        S.Sequence seq => (Int -> a -> a -> a) -> seq (Int,a) -> FM a
    fromSeqWithKey = fromSeqWithKeyUsingInsertSeqWithKey
    
    insertWithKey :: (Int -> a -> a -> a) -> Int -> a -> FM a -> FM a
    insertWithKey = insertWithKeyUsingInsertWith
    
    insertSeqWith ::
        S.Sequence seq => (a -> a -> a) -> seq (Int,a) -> FM a -> FM a
    insertSeqWith = insertSeqWithUsingInsertWith
    
    insertSeqWithKey ::
        S.Sequence seq =>
          (Int -> a -> a -> a) -> seq (Int,a) -> FM a -> FM a
    insertSeqWithKey = insertSeqWithKeyUsingInsertWithKey
    
    adjustAll :: (a -> a) -> Int -> FM a -> FM a
    adjustAll = adjust
    
    unionSeqWith :: S.Sequence seq => (a -> a -> a) -> seq (FM a) -> FM a
    

    Found in Data.Edison.Assoc.StandardMap from the package EdisonCore
    unsafeFromOrdSeq   = DM.fromAscList . S.toList
    unsafeAppend       = DM.union
    filterLT k         = fst . DM.split k
    filterGT k         = snd . DM.split k
    filterLE k m       = let (lt, mx, _ ) = DM.splitLookup k m in maybe lt (\x -> insert k x lt) mx
    filterGE k m       = let (_ , mx, gt) = DM.splitLookup k m in maybe gt (\x -> insert k x gt) mx
    partitionLT_GE k m = let (lt, mx, gt) = DM.splitLookup k m in (lt, maybe gt (\x -> insert k x gt) mx)
    partitionLE_GT k m = let (lt, mx, gt) = DM.splitLookup k m in (maybe lt (\x -> insert k x lt) mx, gt)
    partitionLT_GT     = DM.split
    fromSeqWith    f s = DM.fromListWith    f (S.toList s)
    fromSeqWithKey f s = DM.fromListWithKey f (S.toList s)
    insertWith         = DM.insertWith
    insertWithKey      = insertWithKeyUsingInsertWith
    insertSeqWith      = insertSeqWithUsingInsertWith
    insertSeqWithKey   = insertSeqWithKeyUsingInsertWithKey
    unionl             = DM.union
    unionr             = flip DM.union
    unionWith          = DM.unionWith
    unionSeqWith       = unionSeqWithUsingReduce
    intersectionWith   = DM.intersectionWith
    

    Found in Data.Edison.Assoc.TernaryTrie from the package EdisonCore
    fromSeqWith = fromSeqWithUsingInsertSeqWith
    
    fromSeqWithKey = fromSeqWithKeyUsingInsertSeqWithKey
    
    insertWith f k v
      = addToFM k (\vem ->
          case vem of
              Nothing -> Just v
              Just ve -> Just (f ve v))
    
    insertWithKey = insertWithKeyUsingInsertWith
    
    insertSeqWith = insertSeqWithUsingInsertWith
    
    insertSeqWithKey = insertSeqWithKeyUsingInsertWithKey
    
    unionl = union
    unionr = flip union
    
    unionWith f = unionWithKey (const f)
    

    insertSeqWithUsingInsertWith See 4 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    toOrdSeq            = toSeq . mergeSortFM
    
    
    strict n@E = n
    strict n@(I _ _ m) = strict m `seq` n
    
    strictWith _ n@E = n
    strictWith f n@(I _ a m) = f a `seq` strictWith f m `seq` n
    
    
    -- defaults
    
    deleteSeq = deleteSeqUsingFoldr
    insertWith = insertWithUsingLookupM
    insertSeqWith = insertSeqWithUsingInsertWith
    insertWithKey = insertWithKeyUsingInsertWith
    insertSeqWithKey = insertSeqWithKeyUsingInsertWithKey
    unionWith = unionWithUsingInsertWith
    unionSeqWith = unionSeqWithUsingFoldr
    fromSeqWith = fromSeqWithUsingInsertSeqWith
    

    Found in Data.Edison.Assoc.PatriciaLoMap from the package EdisonCore
    lookupWithDefault = lookupWithDefaultUsingLookupM
    
    elements :: S.Sequence seq => FM a -> seq a
    elements = elementsUsingFold
    
    fromSeqWithKey ::
        S.Sequence seq => (Int -> a -> a -> a) -> seq (Int,a) -> FM a
    fromSeqWithKey = fromSeqWithKeyUsingInsertSeqWithKey
    
    insertWithKey :: (Int -> a -> a -> a) -> Int -> a -> FM a -> FM a
    insertWithKey = insertWithKeyUsingInsertWith
    
    insertSeqWith ::
        S.Sequence seq => (a -> a -> a) -> seq (Int,a) -> FM a -> FM a
    insertSeqWith = insertSeqWithUsingInsertWith
    
    insertSeqWithKey ::
        S.Sequence seq =>
          (Int -> a -> a -> a) -> seq (Int,a) -> FM a -> FM a
    insertSeqWithKey = insertSeqWithKeyUsingInsertWithKey
    

    Found in Data.Edison.Assoc.StandardMap from the package EdisonCore
    foldl1' f   m      = L.foldl1' f   (DM.elems m)
    unsafeFromOrdSeq   = DM.fromAscList . S.toList
    unsafeAppend       = DM.union
    filterLT k         = fst . DM.split k
    filterGT k         = snd . DM.split k
    filterLE k m       = let (lt, mx, _ ) = DM.splitLookup k m in maybe lt (\x -> insert k x lt) mx
    filterGE k m       = let (_ , mx, gt) = DM.splitLookup k m in maybe gt (\x -> insert k x gt) mx
    partitionLT_GE k m = let (lt, mx, gt) = DM.splitLookup k m in (lt, maybe gt (\x -> insert k x gt) mx)
    partitionLE_GT k m = let (lt, mx, gt) = DM.splitLookup k m in (maybe lt (\x -> insert k x lt) mx, gt)
    partitionLT_GT     = DM.split
    fromSeqWith    f s = DM.fromListWith    f (S.toList s)
    fromSeqWithKey f s = DM.fromListWithKey f (S.toList s)
    insertWith         = DM.insertWith
    insertWithKey      = insertWithKeyUsingInsertWith
    insertSeqWith      = insertSeqWithUsingInsertWith
    insertSeqWithKey   = insertSeqWithKeyUsingInsertWithKey
    unionl             = DM.union
    unionr             = flip DM.union
    unionWith          = DM.unionWith
    unionSeqWith       = unionSeqWithUsingReduce
    

    Found in Data.Edison.Assoc.TernaryTrie from the package EdisonCore
    -- FiniteMapX
    
    fromSeqWith = fromSeqWithUsingInsertSeqWith
    
    fromSeqWithKey = fromSeqWithKeyUsingInsertSeqWithKey
    
    insertWith f k v
      = addToFM k (\vem ->
          case vem of
              Nothing -> Just v
              Just ve -> Just (f ve v))
    
    insertWithKey = insertWithKeyUsingInsertWith
    
    insertSeqWith = insertSeqWithUsingInsertWith
    
    insertSeqWithKey = insertSeqWithKeyUsingInsertWithKey
    
    unionl = union
    unionr = flip union
    

    insertWithKeyUsingInsertWith See 4 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    strict n@E = n
    strict n@(I _ _ m) = strict m `seq` n
    
    strictWith _ n@E = n
    strictWith f n@(I _ a m) = f a `seq` strictWith f m `seq` n
    
    
    -- defaults
    
    deleteSeq = deleteSeqUsingFoldr
    insertWith = insertWithUsingLookupM
    insertSeqWith = insertSeqWithUsingInsertWith
    insertWithKey = insertWithKeyUsingInsertWith
    insertSeqWithKey = insertSeqWithKeyUsingInsertWithKey
    unionWith = unionWithUsingInsertWith
    unionSeqWith = unionSeqWithUsingFoldr
    fromSeqWith = fromSeqWithUsingInsertSeqWith
    fromSeqWithKey = fromSeqWithKeyUsingInsertSeqWithKey
    

    Found in Data.Edison.Assoc.PatriciaLoMap from the package EdisonCore
    lookupAll :: S.Sequence seq => Int -> FM a -> seq a
    lookupAll = lookupAllUsingLookupM
    
    lookupWithDefault :: a -> Int -> FM a -> a
    lookupWithDefault = lookupWithDefaultUsingLookupM
    
    elements :: S.Sequence seq => FM a -> seq a
    elements = elementsUsingFold
    
    fromSeqWithKey ::
        S.Sequence seq => (Int -> a -> a -> a) -> seq (Int,a) -> FM a
    fromSeqWithKey = fromSeqWithKeyUsingInsertSeqWithKey
    
    insertWithKey :: (Int -> a -> a -> a) -> Int -> a -> FM a -> FM a
    insertWithKey = insertWithKeyUsingInsertWith
    
    insertSeqWith ::
        S.Sequence seq => (a -> a -> a) -> seq (Int,a) -> FM a -> FM a
    insertSeqWith = insertSeqWithUsingInsertWith
    

    Found in Data.Edison.Assoc.StandardMap from the package EdisonCore
    foldr1' f   m      = L.foldr1' f   (DM.elems m)
    foldl1' f   m      = L.foldl1' f   (DM.elems m)
    unsafeFromOrdSeq   = DM.fromAscList . S.toList
    unsafeAppend       = DM.union
    filterLT k         = fst . DM.split k
    filterGT k         = snd . DM.split k
    filterLE k m       = let (lt, mx, _ ) = DM.splitLookup k m in maybe lt (\x -> insert k x lt) mx
    filterGE k m       = let (_ , mx, gt) = DM.splitLookup k m in maybe gt (\x -> insert k x gt) mx
    partitionLT_GE k m = let (lt, mx, gt) = DM.splitLookup k m in (lt, maybe gt (\x -> insert k x gt) mx)
    partitionLE_GT k m = let (lt, mx, gt) = DM.splitLookup k m in (maybe lt (\x -> insert k x lt) mx, gt)
    partitionLT_GT     = DM.split
    fromSeqWith    f s = DM.fromListWith    f (S.toList s)
    fromSeqWithKey f s = DM.fromListWithKey f (S.toList s)
    insertWith         = DM.insertWith
    insertWithKey      = insertWithKeyUsingInsertWith
    insertSeqWith      = insertSeqWithUsingInsertWith
    insertSeqWithKey   = insertSeqWithKeyUsingInsertWithKey
    unionl             = DM.union
    unionr             = flip DM.union
    unionWith          = DM.unionWith
    

    Found in Data.Edison.Assoc.TernaryTrie from the package EdisonCore
    -- FiniteMapX
    
    fromSeqWith = fromSeqWithUsingInsertSeqWith
    
    fromSeqWithKey = fromSeqWithKeyUsingInsertSeqWithKey
    
    insertWith f k v
      = addToFM k (\vem ->
          case vem of
              Nothing -> Just v
              Just ve -> Just (f ve v))
    
    insertWithKey = insertWithKeyUsingInsertWith
    
    insertSeqWith = insertSeqWithUsingInsertWith
    
    insertSeqWithKey = insertSeqWithKeyUsingInsertWithKey
    

    insertWithUsingLookupM See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    foldlWithKey' f x   = foldlWithKeyFM' f x . mergeSortFM
    toOrdSeq            = toSeq . mergeSortFM
    
    
    strict n@E = n
    strict n@(I _ _ m) = strict m `seq` n
    
    strictWith _ n@E = n
    strictWith f n@(I _ a m) = f a `seq` strictWith f m `seq` n
    
    
    -- defaults
    
    deleteSeq = deleteSeqUsingFoldr
    insertWith = insertWithUsingLookupM
    insertSeqWith = insertSeqWithUsingInsertWith
    insertWithKey = insertWithKeyUsingInsertWith
    insertSeqWithKey = insertSeqWithKeyUsingInsertWithKey
    unionWith = unionWithUsingInsertWith
    unionSeqWith = unionSeqWithUsingFoldr
    

    intersectionWithKeyUsingLookupM See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    fromSeqWith = fromSeqWithUsingInsertSeqWith
    fromSeqWithKey = fromSeqWithKeyUsingInsertSeqWithKey
    intersectionWith = intersectionWithUsingLookupM
    difference = differenceUsingDelete
    properSubset = properSubsetUsingSubset
    subset = subsetUsingMember
    properSubmapBy = properSubmapByUsingSubmapBy
    submapBy = submapByUsingLookupM
    sameMapBy = sameMapByUsingSubmapBy
    properSubmap = A.properSubmap
    submap = A.submap
    sameMap = A.sameMap
    unionWithKey = unionWithKeyUsingInsertWithKey
    unionSeqWithKey = unionSeqWithKeyUsingFoldr
    intersectionWithKey = intersectionWithKeyUsingLookupM
    
    -- instance declarations
    
    instance Eq k  => A.AssocX (FM k) k where
      {empty = empty; singleton = singleton; fromSeq = fromSeq; insert = insert;
    

    intersectionWithUsingLookupM See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    strictWith f n@(I _ a m) = f a `seq` strictWith f m `seq` n
    
    
    -- defaults
    
    deleteSeq = deleteSeqUsingFoldr
    insertWith = insertWithUsingLookupM
    insertSeqWith = insertSeqWithUsingInsertWith
    insertWithKey = insertWithKeyUsingInsertWith
    insertSeqWithKey = insertSeqWithKeyUsingInsertWithKey
    unionWith = unionWithUsingInsertWith
    unionSeqWith = unionSeqWithUsingFoldr
    fromSeqWith = fromSeqWithUsingInsertSeqWith
    fromSeqWithKey = fromSeqWithKeyUsingInsertSeqWithKey
    intersectionWith = intersectionWithUsingLookupM
    difference = differenceUsingDelete
    properSubset = properSubsetUsingSubset
    subset = subsetUsingMember
    properSubmapBy = properSubmapByUsingSubmapBy
    submapBy = submapByUsingLookupM
    

    keysUsingFoldWithKey See 3 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.PatriciaLoMap from the package EdisonCore
        S.Sequence seq =>
          (Int -> a -> a -> a) -> seq (Int,a) -> FM a -> FM a
    insertSeqWithKey = insertSeqWithKeyUsingInsertWithKey
    
    adjustAll :: (a -> a) -> Int -> FM a -> FM a
    adjustAll = adjust
    
    unionSeqWith :: S.Sequence seq => (a -> a -> a) -> seq (FM a) -> FM a
    unionSeqWith = unionSeqWithUsingReduce
    
    toSeq :: S.Sequence seq => FM a -> seq (Int,a)
    toSeq = toSeqUsingFoldWithKey
    
    keys :: S.Sequence seq => FM a -> seq Int
    keys = keysUsingFoldWithKey
    
    unionSeqWithKey ::
        S.Sequence seq => (Int -> a -> a -> a) -> seq (FM a) -> FM a
    unionSeqWithKey = unionSeqWithKeyUsingReduce
    

    Found in Data.Edison.Assoc.StandardMap from the package EdisonCore
    unionWith          = DM.unionWith
    unionSeqWith       = unionSeqWithUsingReduce
    intersectionWith   = DM.intersectionWith
    difference         = DM.difference
    properSubset       = DM.isProperSubmapOfBy (\_ _ -> True)
    subset             = DM.isSubmapOfBy (\_ _ -> True)
    properSubmapBy     = DM.isProperSubmapOfBy
    submapBy           = DM.isSubmapOfBy
    sameMapBy          = sameMapByUsingOrdLists
    properSubmap       = A.properSubmap
    submap             = A.submap
    sameMap            = A.sameMap
    
    toSeq              = toSeqUsingFoldWithKey
    keys               = keysUsingFoldWithKey
    mapWithKey         = DM.mapWithKey
    foldWithKey        = DM.foldrWithKey
    foldWithKey' f x m = L.foldl' (\b (k,a) -> f k a b) x (DM.toList m)
    filterWithKey      = DM.filterWithKey
    partitionWithKey   = DM.partitionWithKey
    

    Found in Data.Edison.Assoc.TernaryTrie from the package EdisonCore
                 && subsetEqFMB rx ry
    
    
    submapBy = submapByUsingLookupM
    properSubmapBy = properSubmapByUsingSubmapBy
    sameMapBy = sameMapByUsingSubmapBy
    properSubmap = A.properSubmap
    submap = A.submap
    sameMap = A.sameMap
    
    -- Assoc
    
    toSeq = toSeqUsingFoldWithKey
    
    keys = keysUsingFoldWithKey
    
    mapWithKey f
      = mapKVFM (\k mv -> case mv of
              Nothing -> Nothing
              Just v  -> Just (f k v))
    

    lookupAllUsingLookupM See 3 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.PatriciaLoMap from the package EdisonCore
    unionSeq :: S.Sequence seq => seq (FM a) -> FM a
    unionSeq = unionSeqUsingReduce
    
    deleteAll :: Int -> FM a -> FM a
    deleteAll = delete
    
    deleteSeq :: S.Sequence seq => seq Int -> FM a -> FM a
    deleteSeq = deleteSeqUsingFoldr
    
    count :: Int -> FM a -> Int
    count = countUsingMember
    
    lookupAll :: S.Sequence seq => Int -> FM a -> seq a
    lookupAll = lookupAllUsingLookupM
    
    lookupWithDefault :: a -> Int -> FM a -> a
    lookupWithDefault = lookupWithDefaultUsingLookupM
    
    elements :: S.Sequence seq => FM a -> seq a
    

    Found in Data.Edison.Assoc.StandardMap from the package EdisonCore
    fromSeq            = fromSeqUsingInsertSeq
    insert             = DM.insert
    insertSeq          = insertSeqUsingFoldr
    union              = DM.union
    unionSeq           = DM.unions . S.toList
    delete             = DM.delete
    deleteAll          = DM.delete -- by finite map property
    deleteSeq          = deleteSeqUsingFoldr
    null               = DM.null
    size               = DM.size
    member             = DM.member
    count              = countUsingMember
    lookup k m         = maybe (error (moduleName ++ ".lookup: failed")) id (DM.lookup k m)
    lookupM k m        = maybe (fail (moduleName ++ ".lookupM: failed")) return (DM.lookup k m)
    lookupAll          = lookupAllUsingLookupM
    lookupWithDefault  = DM.findWithDefault
    lookupAndDelete    = lookupAndDeleteDefault
    lookupAndDeleteM   = lookupAndDeleteMDefault
    lookupAndDeleteAll = lookupAndDeleteAllDefault
    adjust             = DM.adjust
    

    Found in Data.Edison.Assoc.TernaryTrie from the package EdisonCore
    count = countUsingMember
    
    lookup m k = runIdentity (lookupM m k)
    
    lookupM [] (FM Nothing _)
      = fail "TernaryTrie.lookup: lookup failed"
    lookupM [] (FM (Just v) _)
      = return v
    lookupM xs (FM _ fmb)
      = case  lookupFMB xs fmb  of
            Nothing -> fail "TernaryTrie.lookup: lookup failed"
            Just v  -> return v
    
    lookupAll = lookupAllUsingLookupM
    
    lookupAndDelete =
        lookupAndDelFromFM
          (error "TernaryTrie.lookupAndDelete: lookup failed")
          (,)
    

    lookupAndDeleteAllDefault See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.StandardMap from the package EdisonCore
    unionSeq           = DM.unions . S.toList
    delete             = DM.delete
    deleteAll          = DM.delete -- by finite map property
    deleteSeq          = deleteSeqUsingFoldr
    null               = DM.null
    size               = DM.size
    member             = DM.member
    count              = countUsingMember
    lookup k m         = maybe (error (moduleName ++ ".lookup: failed")) id (DM.lookup k m)
    lookupM k m        = maybe (fail (moduleName ++ ".lookupM: failed")) return (DM.lookup k m)
    lookupAll          = lookupAllUsingLookupM
    lookupWithDefault  = DM.findWithDefault
    lookupAndDelete    = lookupAndDeleteDefault
    lookupAndDeleteM   = lookupAndDeleteMDefault
    lookupAndDeleteAll = lookupAndDeleteAllDefault
    adjust             = DM.adjust
    adjustAll          = DM.adjust
    adjustOrInsert     = adjustOrInsertUsingMember
    adjustAllOrInsert  = adjustOrInsertUsingMember
    adjustOrDelete     = DM.update
    

    lookupAndDeleteDefault See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.StandardMap from the package EdisonCore
    insertSeq          = insertSeqUsingFoldr
    union              = DM.union
    unionSeq           = DM.unions . S.toList
    delete             = DM.delete
    deleteAll          = DM.delete -- by finite map property
    deleteSeq          = deleteSeqUsingFoldr
    null               = DM.null
    size               = DM.size
    member             = DM.member
    count              = countUsingMember
    lookup k m         = maybe (error (moduleName ++ ".lookup: failed")) id (DM.lookup k m)
    lookupM k m        = maybe (fail (moduleName ++ ".lookupM: failed")) return (DM.lookup k m)
    lookupAll          = lookupAllUsingLookupM
    lookupWithDefault  = DM.findWithDefault
    lookupAndDelete    = lookupAndDeleteDefault
    lookupAndDeleteM   = lookupAndDeleteMDefault
    lookupAndDeleteAll = lookupAndDeleteAllDefault
    adjust             = DM.adjust
    adjustAll          = DM.adjust
    adjustOrInsert     = adjustOrInsertUsingMember
    

    lookupAndDeleteMDefault See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.StandardMap from the package EdisonCore
    union              = DM.union
    unionSeq           = DM.unions . S.toList
    delete             = DM.delete
    deleteAll          = DM.delete -- by finite map property
    deleteSeq          = deleteSeqUsingFoldr
    null               = DM.null
    size               = DM.size
    member             = DM.member
    count              = countUsingMember
    lookup k m         = maybe (error (moduleName ++ ".lookup: failed")) id (DM.lookup k m)
    lookupM k m        = maybe (fail (moduleName ++ ".lookupM: failed")) return (DM.lookup k m)
    lookupAll          = lookupAllUsingLookupM
    lookupWithDefault  = DM.findWithDefault
    lookupAndDelete    = lookupAndDeleteDefault
    lookupAndDeleteM   = lookupAndDeleteMDefault
    lookupAndDeleteAll = lookupAndDeleteAllDefault
    adjust             = DM.adjust
    adjustAll          = DM.adjust
    adjustOrInsert     = adjustOrInsertUsingMember
    adjustAllOrInsert  = adjustOrInsertUsingMember
    

    lookupWithDefaultUsingLookupM See 2 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.PatriciaLoMap from the package EdisonCore
    deleteAll :: Int -> FM a -> FM a
    deleteAll = delete
    
    deleteSeq :: S.Sequence seq => seq Int -> FM a -> FM a
    deleteSeq = deleteSeqUsingFoldr
    
    count :: Int -> FM a -> Int
    count = countUsingMember
    
    lookupAll :: S.Sequence seq => Int -> FM a -> seq a
    lookupAll = lookupAllUsingLookupM
    
    lookupWithDefault :: a -> Int -> FM a -> a
    lookupWithDefault = lookupWithDefaultUsingLookupM
    
    elements :: S.Sequence seq => FM a -> seq a
    elements = elementsUsingFold
    
    fromSeqWithKey ::
    

    Found in Data.Edison.Assoc.TernaryTrie from the package EdisonCore
          (error "TernaryTrie.lookupAndDelete: lookup failed")
          (,)
    
    lookupAndDeleteM =
        lookupAndDelFromFM
          (fail  "TernaryTrie.lookupAndDeleteM: lookup failed")
          (\w m -> return (w,m))
    
    lookupAndDeleteAll k m =
        lookupAndDelFromFM
          (S.empty,m)
          (\w m' -> (S.singleton w,m'))
          k m
    
    lookupWithDefault = lookupWithDefaultUsingLookupM
    
    adjust f k
      = addToFM k (\mv -> case mv of
                            Nothing -> mv
                            Just v  -> Just (f v))
    

    maxElemUsingMaxView See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.PatriciaLoMap from the package EdisonCore
    minElem :: FM a -> a
    minElem = minElemUsingMinView
    
    minElemWithKey :: FM a -> (Int,a)
    minElemWithKey = minElemWithKeyUsingMinViewWithKey
    
    deleteMin :: FM a -> FM a
    deleteMin = deleteMinUsingMinView
    
    unsafeInsertMin :: Int -> a -> FM a -> FM a
    unsafeInsertMin = insert
    
    maxElem :: FM a -> a
    maxElem = maxElemUsingMaxView
    
    deleteMax :: FM a -> FM a
    deleteMax = deleteMaxUsingMaxView
    
    maxElemWithKey :: FM a -> (Int,a)
    

    maxElemWithKeyUsingMaxViewWithKey See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.PatriciaLoMap from the package EdisonCore
    deleteMin :: FM a -> FM a
    deleteMin = deleteMinUsingMinView
    
    unsafeInsertMin :: Int -> a -> FM a -> FM a
    unsafeInsertMin = insert
    
    maxElem :: FM a -> a
    maxElem = maxElemUsingMaxView
    
    deleteMax :: FM a -> FM a
    deleteMax = deleteMaxUsingMaxView
    
    maxElemWithKey :: FM a -> (Int,a)
    maxElemWithKey = maxElemWithKeyUsingMaxViewWithKey
    
    unsafeInsertMax :: Int -> a -> FM a -> FM a
    unsafeInsertMax = insert
    
    foldr :: (a -> b -> b) -> b -> FM a -> b
    

    memberUsingLookupM See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.TernaryTrie from the package EdisonCore
    deleteAll = delete
    
    deleteSeq = deleteSeqUsingFoldr
    
    null = nullFM
    
    size (FM k fmb)
        | isNothing k = fmb_size fmb 0
        | otherwise   = fmb_size fmb 1
        where fmb_size E k = k
              fmb_size (I _ _ Nothing l (FMB' m) r) k = fmb_size l $ fmb_size m $ fmb_size r k
              fmb_size (I _ _ _ l (FMB' m) r ) k      = fmb_size l $ fmb_size m $ fmb_size r $! k+1
    
    
    member = memberUsingLookupM
    
    count = countUsingMember
    
    lookup m k = runIdentity (lookupM m k)
    

    minElemUsingMinView See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.PatriciaLoMap from the package EdisonCore
    maxView :: Monad m => FM a -> m (a, FM a)
    maxView fm =
      case ordListFM_rev fm of
         [] -> fail $ moduleName++".maxView: empty map"
         ((k,x):_) -> return (x,delete k fm)
    
    maxViewWithKey :: Monad m => FM a -> m ((Int, a), FM a)
    maxViewWithKey fm =
       case ordListFM_rev fm of
         [] -> fail $ moduleName++".maxViewWithKey: empty map"
         ((k,x):_) -> return ((k,x),delete k fm)
    
    minElem :: FM a -> a
    minElem = minElemUsingMinView
    
    minElemWithKey :: FM a -> (Int,a)
    minElemWithKey = minElemWithKeyUsingMinViewWithKey
    
    deleteMin :: FM a -> FM a
    

    minElemWithKeyUsingMinViewWithKey See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.PatriciaLoMap from the package EdisonCore
      case ordListFM_rev fm of
         [] -> fail $ moduleName++".maxView: empty map"
         ((k,x):_) -> return (x,delete k fm)
    
    maxViewWithKey :: Monad m => FM a -> m ((Int, a), FM a)
    maxViewWithKey fm =
       case ordListFM_rev fm of
         [] -> fail $ moduleName++".maxViewWithKey: empty map"
         ((k,x):_) -> return ((k,x),delete k fm)
    
    minElem :: FM a -> a
    minElem = minElemUsingMinView
    
    minElemWithKey :: FM a -> (Int,a)
    minElemWithKey = minElemWithKeyUsingMinViewWithKey
    
    deleteMin :: FM a -> FM a
    deleteMin = deleteMinUsingMinView
    
    unsafeInsertMin :: Int -> a -> FM a -> FM a
    

    nullUsingElements No usage example found for this symbol :( Collapse [-]
    partitionUsingFilter See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.TernaryTrie from the package EdisonCore
    -}
    
    
    
    -- FIXME, undestand this code to strictify it
    foldr1' = foldr1
    foldl1' :: (b -> b -> b) -> FM k b -> b
    foldl1' = foldl1
    
    
    filter p = mapVFM (\mv -> case mv of
                                Nothing -> mv
                                Just v  -> if p v then mv else Nothing)
    
    partition = partitionUsingFilter
    
    elements = elementsUsingFold
    
    strict z@(FM _ fmb) = strictFMB fmb `seq` z
     where strictFMB n@E = n
    

    properSubmapByUsingSubmapBy See 3 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    deleteSeq = deleteSeqUsingFoldr
    insertWith = insertWithUsingLookupM
    insertSeqWith = insertSeqWithUsingInsertWith
    insertWithKey = insertWithKeyUsingInsertWith
    insertSeqWithKey = insertSeqWithKeyUsingInsertWithKey
    unionWith = unionWithUsingInsertWith
    unionSeqWith = unionSeqWithUsingFoldr
    fromSeqWith = fromSeqWithUsingInsertSeqWith
    fromSeqWithKey = fromSeqWithKeyUsingInsertSeqWithKey
    intersectionWith = intersectionWithUsingLookupM
    difference = differenceUsingDelete
    properSubset = properSubsetUsingSubset
    subset = subsetUsingMember
    properSubmapBy = properSubmapByUsingSubmapBy
    submapBy = submapByUsingLookupM
    sameMapBy = sameMapByUsingSubmapBy
    properSubmap = A.properSubmap
    submap = A.submap
    sameMap = A.sameMap
    

    Found in Data.Edison.Assoc.PatriciaLoMap from the package EdisonCore
    subset' E E = EQ
    subset' E _ = LT
    
    subset :: FM a -> FM b -> Bool
    subset s@(B p m s0 s1) (B q n t0 t1)
      | m < n    = False
      | m > n    = matchPrefix p q n && (if zeroBit p n then subset s t0
                                                         else subset s t1)
      | otherwise = (p == q) && subset s0 t0 && subset s1 t1
    subset (B _ _ _ _) _ = False
    subset (L k _) t = member k t
    subset E _ = True
    
    properSubmapBy :: (a -> a -> Bool) -> FM a -> FM a -> Bool
    properSubmapBy = properSubmapByUsingSubmapBy
    
    submapBy :: (a -> a -> Bool) -> FM a -> FM a -> Bool
    submapBy = submapByUsingLookupM
    
    sameMapBy :: (a -> a -> Bool) -> FM a -> FM a -> Bool
    

    Found in Data.Edison.Assoc.TernaryTrie from the package EdisonCore
            = let (vy, ly, FMB' my, ry) = splayFMB kx fmby
              in    subsetEqM vx vy
                 && subsetEqFMB lx ly
                 && subsetEqFMB mx my
                 && subsetEqFMB rx ry
          | otherwise
            = let (vx, lx, FMB' mx, rx) = splayFMB ky fmbx
              in    subsetEqM vx vy
                 && subsetEqFMB lx ly
                 && subsetEqFMB mx my
                 && subsetEqFMB rx ry
    
    
    submapBy = submapByUsingLookupM
    properSubmapBy = properSubmapByUsingSubmapBy
    sameMapBy = sameMapByUsingSubmapBy
    properSubmap = A.properSubmap
    submap = A.submap
    sameMap = A.sameMap
    

    properSubsetUsingSubset See 2 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    -- defaults
    
    deleteSeq = deleteSeqUsingFoldr
    insertWith = insertWithUsingLookupM
    insertSeqWith = insertSeqWithUsingInsertWith
    insertWithKey = insertWithKeyUsingInsertWith
    insertSeqWithKey = insertSeqWithKeyUsingInsertWithKey
    unionWith = unionWithUsingInsertWith
    unionSeqWith = unionSeqWithUsingFoldr
    fromSeqWith = fromSeqWithUsingInsertSeqWith
    fromSeqWithKey = fromSeqWithKeyUsingInsertSeqWithKey
    intersectionWith = intersectionWithUsingLookupM
    difference = differenceUsingDelete
    properSubset = properSubsetUsingSubset
    subset = subsetUsingMember
    properSubmapBy = properSubmapByUsingSubmapBy
    submapBy = submapByUsingLookupM
    sameMapBy = sameMapByUsingSubmapBy
    properSubmap = A.properSubmap
    

    Found in Data.Edison.Assoc.TernaryTrie from the package EdisonCore
    unionl = union
    unionr = flip union
    
    unionWith f = unionWithKey (const f)
    
    unionSeqWith = unionSeqWithUsingReduce
    
    intersectionWith f = intersectionWithKey (const f)
    
    difference mx my
      = mergeVFM (\v1 v2 -> case v2 of
                  Nothing -> v1
                  Just _  -> Nothing) mx my
    
    properSubset = properSubsetUsingSubset
    
    subset (FM nx fmbx) (FM ny fmby)
      = subsetEqM nx ny && subsetEqFMB fmbx fmby
      where
        subsetEqM Nothing _ = True
    

    readsPrecUsingFromList See 3 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    instance Eq k => Functor (FM k) where
      fmap =  map
    
    instance (Eq k,Eq a) => Eq (FM k a) where
      (==) = sameMap
    
    instance (Ord k, Ord a) => Ord (FM k a) where
      compare = compareUsingToOrdList
    
    instance (Eq k,Show k,Show a) => Show (FM k a) where
      showsPrec = showsPrecUsingToList
    
    instance (Eq k,Read k,Read a) => Read (FM k a) where
      readsPrec = readsPrecUsingFromList
    
    instance (Eq k,Arbitrary k,Arbitrary a) => Arbitrary (FM k a) where
       arbitrary = do (xs::[(k,a)]) <- arbitrary
                      return (Prelude.foldr (uncurry insert) empty xs)
    

    Found in Data.Edison.Assoc.PatriciaLoMap from the package EdisonCore
       foldrWithKey = foldrWithKey; foldrWithKey' = foldrWithKey';
       foldlWithKey = foldlWithKey; foldlWithKey' = foldlWithKey';
       toOrdSeq = toOrdSeq}
    
    instance A.OrdFiniteMapX FM Int
    instance A.OrdFiniteMap FM Int
    
    instance Functor FM where
      fmap = map
    
    instance (Show a) => Show (FM a) where
      showsPrec = showsPrecUsingToList
    
    instance (Read a) => Read (FM a) where
      readsPrec = readsPrecUsingFromList
    
    instance (Eq a) => Eq (FM a) where
      (==) = sameMap
    
    instance (Ord a) => Ord (FM a) where
    

    Found in Data.Edison.Assoc.TernaryTrie from the package EdisonCore
       foldlWithKey = foldlWithKey; foldlWithKey' = foldlWithKey';
       toOrdSeq = toOrdSeq}
    
    instance Ord k => A.OrdFiniteMapX (FM k) [k]
    instance Ord k => A.OrdFiniteMap (FM k) [k]
    
    
    instance Ord k => Functor (FM k) where
      fmap = map
    
    instance (Ord k, Show k, Show a) => Show (FM k a) where
      showsPrec = showsPrecUsingToList
    
    instance (Ord k, Read k, Read a) => Read (FM k a) where
      readsPrec = readsPrecUsingFromList
    
    instance (Ord k, Eq a) => Eq (FM k a) where
      (==) = sameMap
    
    instance (Ord k, Ord a) => Ord (FM k a) where
    

    readsPrecUsingUnsafeFromOrdSeq No usage example found for this symbol :( Collapse [-]
    sameMapByUsingOrdLists See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.StandardMap from the package EdisonCore
    insertWith         = DM.insertWith
    insertWithKey      = insertWithKeyUsingInsertWith
    insertSeqWith      = insertSeqWithUsingInsertWith
    insertSeqWithKey   = insertSeqWithKeyUsingInsertWithKey
    unionl             = DM.union
    unionr             = flip DM.union
    unionWith          = DM.unionWith
    unionSeqWith       = unionSeqWithUsingReduce
    intersectionWith   = DM.intersectionWith
    difference         = DM.difference
    properSubset       = DM.isProperSubmapOfBy (\_ _ -> True)
    subset             = DM.isSubmapOfBy (\_ _ -> True)
    properSubmapBy     = DM.isProperSubmapOfBy
    submapBy           = DM.isSubmapOfBy
    sameMapBy          = sameMapByUsingOrdLists
    properSubmap       = A.properSubmap
    submap             = A.submap
    sameMap            = A.sameMap
    
    toSeq              = toSeqUsingFoldWithKey
    

    sameMapByUsingSubmapBy See 3 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    insertWith = insertWithUsingLookupM
    insertSeqWith = insertSeqWithUsingInsertWith
    insertWithKey = insertWithKeyUsingInsertWith
    insertSeqWithKey = insertSeqWithKeyUsingInsertWithKey
    unionWith = unionWithUsingInsertWith
    unionSeqWith = unionSeqWithUsingFoldr
    fromSeqWith = fromSeqWithUsingInsertSeqWith
    fromSeqWithKey = fromSeqWithKeyUsingInsertSeqWithKey
    intersectionWith = intersectionWithUsingLookupM
    difference = differenceUsingDelete
    properSubset = properSubsetUsingSubset
    subset = subsetUsingMember
    properSubmapBy = properSubmapByUsingSubmapBy
    submapBy = submapByUsingLookupM
    sameMapBy = sameMapByUsingSubmapBy
    properSubmap = A.properSubmap
    submap = A.submap
    sameMap = A.sameMap
    unionWithKey = unionWithKeyUsingInsertWithKey
    unionSeqWithKey = unionSeqWithKeyUsingFoldr
    

    Found in Data.Edison.Assoc.PatriciaLoMap from the package EdisonCore
      | m > n    = matchPrefix p q n && (if zeroBit p n then subset s t0
                                                         else subset s t1)
      | otherwise = (p == q) && subset s0 t0 && subset s1 t1
    subset (B _ _ _ _) _ = False
    subset (L k _) t = member k t
    subset E _ = True
    
    properSubmapBy :: (a -> a -> Bool) -> FM a -> FM a -> Bool
    properSubmapBy = properSubmapByUsingSubmapBy
    
    submapBy :: (a -> a -> Bool) -> FM a -> FM a -> Bool
    submapBy = submapByUsingLookupM
    
    sameMapBy :: (a -> a -> Bool) -> FM a -> FM a -> Bool
    sameMapBy = sameMapByUsingSubmapBy
    
    properSubmap :: (Eq a) => FM a -> FM a -> Bool
    properSubmap = A.properSubmap
    
    submap :: (Eq a) => FM a -> FM a -> Bool
    

    Found in Data.Edison.Assoc.TernaryTrie from the package EdisonCore
              in    subsetEqM vx vy
                 && subsetEqFMB lx ly
                 && subsetEqFMB mx my
                 && subsetEqFMB rx ry
          | otherwise
            = let (vx, lx, FMB' mx, rx) = splayFMB ky fmbx
              in    subsetEqM vx vy
                 && subsetEqFMB lx ly
                 && subsetEqFMB mx my
                 && subsetEqFMB rx ry
    
    
    submapBy = submapByUsingLookupM
    properSubmapBy = properSubmapByUsingSubmapBy
    sameMapBy = sameMapByUsingSubmapBy
    properSubmap = A.properSubmap
    submap = A.submap
    sameMap = A.sameMap
    
    -- Assoc
    

    showsPrecUsingToList See 3 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
       intersectionWithKey = intersectionWithKey}
    
    instance Ord k => A.OrdFiniteMap (FM k) k
    
    instance Eq k => Functor (FM k) where
      fmap =  map
    
    instance (Eq k,Eq a) => Eq (FM k a) where
      (==) = sameMap
    
    instance (Ord k, Ord a) => Ord (FM k a) where
      compare = compareUsingToOrdList
    
    instance (Eq k,Show k,Show a) => Show (FM k a) where
      showsPrec = showsPrecUsingToList
    
    instance (Eq k,Read k,Read a) => Read (FM k a) where
      readsPrec = readsPrecUsingFromList
    
    instance (Eq k,Arbitrary k,Arbitrary a) => Arbitrary (FM k a) where
    

    Found in Data.Edison.Assoc.PatriciaLoMap from the package EdisonCore
    instance A.OrdAssoc FM Int where
      {minViewWithKey = minViewWithKey; minElemWithKey = minElemWithKey;
       maxViewWithKey = maxViewWithKey; maxElemWithKey = maxElemWithKey;
       foldrWithKey = foldrWithKey; foldrWithKey' = foldrWithKey';
       foldlWithKey = foldlWithKey; foldlWithKey' = foldlWithKey';
       toOrdSeq = toOrdSeq}
    
    instance A.OrdFiniteMapX FM Int
    instance A.OrdFiniteMap FM Int
    
    instance Functor FM where
      fmap = map
    
    instance (Show a) => Show (FM a) where
      showsPrec = showsPrecUsingToList
    
    instance (Read a) => Read (FM a) where
      readsPrec = readsPrecUsingFromList
    
    instance (Eq a) => Eq (FM a) where
    

    Found in Data.Edison.Assoc.TernaryTrie from the package EdisonCore
      {minViewWithKey = minViewWithKey; minElemWithKey = minElemWithKey;
       maxViewWithKey = maxViewWithKey; maxElemWithKey = maxElemWithKey;
       foldrWithKey = foldrWithKey; foldrWithKey' = foldrWithKey';
       foldlWithKey = foldlWithKey; foldlWithKey' = foldlWithKey';
       toOrdSeq = toOrdSeq}
    
    instance Ord k => A.OrdFiniteMapX (FM k) [k]
    instance Ord k => A.OrdFiniteMap (FM k) [k]
    
    
    instance Ord k => Functor (FM k) where
      fmap = map
    
    instance (Ord k, Show k, Show a) => Show (FM k a) where
      showsPrec = showsPrecUsingToList
    
    instance (Ord k, Read k, Read a) => Read (FM k a) where
      readsPrec = readsPrecUsingFromList
    
    instance (Ord k, Eq a) => Eq (FM k a) where
    

    showsPrecUsingToOrdList No usage example found for this symbol :( Collapse [-]
    singletonUsingInsert No usage example found for this symbol :( Collapse [-]
    submapByUsingLookupM See 3 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    deleteSeq = deleteSeqUsingFoldr
    insertWith = insertWithUsingLookupM
    insertSeqWith = insertSeqWithUsingInsertWith
    insertWithKey = insertWithKeyUsingInsertWith
    insertSeqWithKey = insertSeqWithKeyUsingInsertWithKey
    unionWith = unionWithUsingInsertWith
    unionSeqWith = unionSeqWithUsingFoldr
    fromSeqWith = fromSeqWithUsingInsertSeqWith
    fromSeqWithKey = fromSeqWithKeyUsingInsertSeqWithKey
    intersectionWith = intersectionWithUsingLookupM
    difference = differenceUsingDelete
    properSubset = properSubsetUsingSubset
    subset = subsetUsingMember
    properSubmapBy = properSubmapByUsingSubmapBy
    submapBy = submapByUsingLookupM
    sameMapBy = sameMapByUsingSubmapBy
    properSubmap = A.properSubmap
    submap = A.submap
    sameMap = A.sameMap
    unionWithKey = unionWithKeyUsingInsertWithKey
    

    Found in Data.Edison.Assoc.PatriciaLoMap from the package EdisonCore
    subset :: FM a -> FM b -> Bool
    subset s@(B p m s0 s1) (B q n t0 t1)
      | m < n    = False
      | m > n    = matchPrefix p q n && (if zeroBit p n then subset s t0
                                                         else subset s t1)
      | otherwise = (p == q) && subset s0 t0 && subset s1 t1
    subset (B _ _ _ _) _ = False
    subset (L k _) t = member k t
    subset E _ = True
    
    properSubmapBy :: (a -> a -> Bool) -> FM a -> FM a -> Bool
    properSubmapBy = properSubmapByUsingSubmapBy
    
    submapBy :: (a -> a -> Bool) -> FM a -> FM a -> Bool
    submapBy = submapByUsingLookupM
    
    sameMapBy :: (a -> a -> Bool) -> FM a -> FM a -> Bool
    sameMapBy = sameMapByUsingSubmapBy
    
    properSubmap :: (Eq a) => FM a -> FM a -> Bool
    

    Found in Data.Edison.Assoc.TernaryTrie from the package EdisonCore
          | sizex >= sizey
            = let (vy, ly, FMB' my, ry) = splayFMB kx fmby
              in    subsetEqM vx vy
                 && subsetEqFMB lx ly
                 && subsetEqFMB mx my
                 && subsetEqFMB rx ry
          | otherwise
            = let (vx, lx, FMB' mx, rx) = splayFMB ky fmbx
              in    subsetEqM vx vy
                 && subsetEqFMB lx ly
                 && subsetEqFMB mx my
                 && subsetEqFMB rx ry
    
    
    submapBy = submapByUsingLookupM
    properSubmapBy = properSubmapByUsingSubmapBy
    sameMapBy = sameMapByUsingSubmapBy
    properSubmap = A.properSubmap
    submap = A.submap
    sameMap = A.sameMap
    

    subsetUsingMember See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    -- defaults
    
    deleteSeq = deleteSeqUsingFoldr
    insertWith = insertWithUsingLookupM
    insertSeqWith = insertSeqWithUsingInsertWith
    insertWithKey = insertWithKeyUsingInsertWith
    insertSeqWithKey = insertSeqWithKeyUsingInsertWithKey
    unionWith = unionWithUsingInsertWith
    unionSeqWith = unionSeqWithUsingFoldr
    fromSeqWith = fromSeqWithUsingInsertSeqWith
    fromSeqWithKey = fromSeqWithKeyUsingInsertSeqWithKey
    intersectionWith = intersectionWithUsingLookupM
    difference = differenceUsingDelete
    properSubset = properSubsetUsingSubset
    subset = subsetUsingMember
    properSubmapBy = properSubmapByUsingSubmapBy
    submapBy = submapByUsingLookupM
    sameMapBy = sameMapByUsingSubmapBy
    properSubmap = A.properSubmap
    submap = A.submap
    

    toOrdSeqUsingFoldrWithKey See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.TernaryTrie from the package EdisonCore
    filterGE :: Ord k => [k] -> FM k a -> FM k a
    filterGE []     fm          = fm
    filterGE (k:ks) (FM _ fmb) = FM Nothing (filterG_FMB (\k mv m r -> mkVBalancedFMB k mv E (FMB' m) r) k ks fmb)
    
    --FIXME do better...
    partitionLT_GE :: Ord k => [k] -> FM k a -> (FM k a,FM k a)
    partitionLT_GE ks fm = (filterLT ks fm, filterGE ks fm)
    
    partitionLE_GT :: Ord k => [k] -> FM k a -> (FM k a,FM k a)
    partitionLE_GT ks fm = (filterLE ks fm, filterGT ks fm)
    
    partitionLT_GT :: Ord k => [k] -> FM k a -> (FM k a,FM k a)
    partitionLT_GT ks fm = (filterLT ks fm, filterGT ks fm)
    
    toOrdSeq = toOrdSeqUsingFoldrWithKey
    
    -- instance declarations
    
    instance Ord k  => A.AssocX (FM k) [k] where
      {empty = empty; singleton = singleton; fromSeq = fromSeq; insert = insert;
    

    toSeqUsingFoldWithKey See 3 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.PatriciaLoMap from the package EdisonCore
    insertSeqWith = insertSeqWithUsingInsertWith
    
    insertSeqWithKey ::
        S.Sequence seq =>
          (Int -> a -> a -> a) -> seq (Int,a) -> FM a -> FM a
    insertSeqWithKey = insertSeqWithKeyUsingInsertWithKey
    
    adjustAll :: (a -> a) -> Int -> FM a -> FM a
    adjustAll = adjust
    
    unionSeqWith :: S.Sequence seq => (a -> a -> a) -> seq (FM a) -> FM a
    unionSeqWith = unionSeqWithUsingReduce
    
    toSeq :: S.Sequence seq => FM a -> seq (Int,a)
    toSeq = toSeqUsingFoldWithKey
    
    keys :: S.Sequence seq => FM a -> seq Int
    keys = keysUsingFoldWithKey
    
    unionSeqWithKey ::
    

    Found in Data.Edison.Assoc.StandardMap from the package EdisonCore
    unionr             = flip DM.union
    unionWith          = DM.unionWith
    unionSeqWith       = unionSeqWithUsingReduce
    intersectionWith   = DM.intersectionWith
    difference         = DM.difference
    properSubset       = DM.isProperSubmapOfBy (\_ _ -> True)
    subset             = DM.isSubmapOfBy (\_ _ -> True)
    properSubmapBy     = DM.isProperSubmapOfBy
    submapBy           = DM.isSubmapOfBy
    sameMapBy          = sameMapByUsingOrdLists
    properSubmap       = A.properSubmap
    submap             = A.submap
    sameMap            = A.sameMap
    
    toSeq              = toSeqUsingFoldWithKey
    keys               = keysUsingFoldWithKey
    mapWithKey         = DM.mapWithKey
    foldWithKey        = DM.foldrWithKey
    foldWithKey' f x m = L.foldl' (\b (k,a) -> f k a b) x (DM.toList m)
    filterWithKey      = DM.filterWithKey
    

    Found in Data.Edison.Assoc.TernaryTrie from the package EdisonCore
                 && subsetEqFMB lx ly
                 && subsetEqFMB mx my
                 && subsetEqFMB rx ry
    
    
    submapBy = submapByUsingLookupM
    properSubmapBy = properSubmapByUsingSubmapBy
    sameMapBy = sameMapByUsingSubmapBy
    properSubmap = A.properSubmap
    submap = A.submap
    sameMap = A.sameMap
    
    -- Assoc
    
    toSeq = toSeqUsingFoldWithKey
    
    keys = keysUsingFoldWithKey
    
    mapWithKey f
      = mapKVFM (\k mv -> case mv of
    

    unionSeqUsingReduce See 2 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.PatriciaLoMap from the package EdisonCore
    partitionLE_GT k fm = (filterLE k fm,filterGT k fm)
    
    partitionLT_GT :: Int -> FM a -> (FM a,FM a)
    partitionLT_GT k fm = (filterLT k fm,filterGT k fm)
    
    toOrdSeq :: S.Sequence seq => FM a -> seq (Int,a)
    toOrdSeq = L.foldr S.lcons S.empty . ordListFM
    
    -- defaults
    
    insertSeq :: S.Sequence seq => seq (Int,a) -> FM a -> FM a
    insertSeq = insertSeqUsingFoldr
    
    unionSeq :: S.Sequence seq => seq (FM a) -> FM a
    unionSeq = unionSeqUsingReduce
    
    deleteAll :: Int -> FM a -> FM a
    deleteAll = delete
    
    deleteSeq :: S.Sequence seq => seq Int -> FM a -> FM a
    

    Found in Data.Edison.Assoc.TernaryTrie from the package EdisonCore
    empty = FM Nothing E
    
    singleton [] v = FM (Just v) E
    singleton xs v = FM Nothing (listToFMB xs (\_ -> Just v))
    
    fromSeq = fromSeqUsingInsertSeq
    
    insert k v fm = addToFM k (\_ -> Just v) fm
    
    insertSeq = insertSeqUsingFoldr
    
    union = mergeVFM mplus
    
    unionSeq = unionSeqUsingReduce
    
    delete k fm = delFromFM k fm
    
    deleteAll = delete
    

    unionSeqWithKeyUsingFoldr See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    unionSeqWith = unionSeqWithUsingFoldr
    fromSeqWith = fromSeqWithUsingInsertSeqWith
    fromSeqWithKey = fromSeqWithKeyUsingInsertSeqWithKey
    intersectionWith = intersectionWithUsingLookupM
    difference = differenceUsingDelete
    properSubset = properSubsetUsingSubset
    subset = subsetUsingMember
    properSubmapBy = properSubmapByUsingSubmapBy
    submapBy = submapByUsingLookupM
    sameMapBy = sameMapByUsingSubmapBy
    properSubmap = A.properSubmap
    submap = A.submap
    sameMap = A.sameMap
    unionWithKey = unionWithKeyUsingInsertWithKey
    unionSeqWithKey = unionSeqWithKeyUsingFoldr
    intersectionWithKey = intersectionWithKeyUsingLookupM
    
    -- instance declarations
    
    instance Eq k  => A.AssocX (FM k) k where
    

    unionSeqWithKeyUsingReduce See 3 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.PatriciaLoMap from the package EdisonCore
    adjustAll :: (a -> a) -> Int -> FM a -> FM a
    adjustAll = adjust
    
    unionSeqWith :: S.Sequence seq => (a -> a -> a) -> seq (FM a) -> FM a
    unionSeqWith = unionSeqWithUsingReduce
    
    toSeq :: S.Sequence seq => FM a -> seq (Int,a)
    toSeq = toSeqUsingFoldWithKey
    
    keys :: S.Sequence seq => FM a -> seq Int
    keys = keysUsingFoldWithKey
    
    unionSeqWithKey ::
        S.Sequence seq => (Int -> a -> a -> a) -> seq (FM a) -> FM a
    unionSeqWithKey = unionSeqWithKeyUsingReduce
    
    -- instance declarations
    
    instance A.AssocX FM Int where
      {empty = empty; singleton = singleton; fromSeq = fromSeq; insert = insert;
    

    Found in Data.Edison.Assoc.StandardMap from the package EdisonCore
                            then fail (moduleName ++ ".minViewWithKey: failed")
                            else return (DM.deleteFindMin m)
    minElemWithKey     = DM.findMin
    maxViewWithKey m   = if DM.null m
                            then fail (moduleName ++ ".maxViewWithKey: failed")
                            else return (DM.deleteFindMax m)
    maxElemWithKey     = DM.findMax
    foldrWithKey        = DM.foldrWithKey
    foldrWithKey' f x m = L.foldr' (\(k,a) b -> f k a b) x (DM.toAscList m)
    foldlWithKey  f x m = L.foldl  (\b (k,a) -> f b k a) x (DM.toAscList m)
    foldlWithKey' f x m = L.foldl' (\b (k,a) -> f b k a) x (DM.toAscList m)
    toOrdSeq           = S.fromList . DM.toAscList
    
    unionWithKey       = DM.unionWithKey
    unionSeqWithKey    = unionSeqWithKeyUsingReduce
    intersectionWithKey = DM.intersectionWithKey
    
    
    instance Ord k => A.AssocX (FM k) k where
      {empty = empty; singleton = singleton; fromSeq = fromSeq; insert = insert;
    

    Found in Data.Edison.Assoc.TernaryTrie from the package EdisonCore
    partitionWithKey f m
      = (filterWithKey f m, filterWithKey (\k v -> not (f k v)) m)
    
    -- FiniteMap
    
    unionWithKey f
      = mergeKVFM (\k v1m v2m ->
        case v1m of
            Nothing -> v2m
            Just v1 ->
                case v2m of
                Nothing -> v1m
                Just v2 -> Just (f k v1 v2))
    
    unionSeqWithKey = unionSeqWithKeyUsingReduce
    
    intersectionWithKey f
      = mergeKVFM (\k v1m v2m ->
        case v1m of
            Nothing -> Nothing
    

    unionSeqWithUsingFoldr See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    strict n@(I _ _ m) = strict m `seq` n
    
    strictWith _ n@E = n
    strictWith f n@(I _ a m) = f a `seq` strictWith f m `seq` n
    
    
    -- defaults
    
    deleteSeq = deleteSeqUsingFoldr
    insertWith = insertWithUsingLookupM
    insertSeqWith = insertSeqWithUsingInsertWith
    insertWithKey = insertWithKeyUsingInsertWith
    insertSeqWithKey = insertSeqWithKeyUsingInsertWithKey
    unionWith = unionWithUsingInsertWith
    unionSeqWith = unionSeqWithUsingFoldr
    fromSeqWith = fromSeqWithUsingInsertSeqWith
    fromSeqWithKey = fromSeqWithKeyUsingInsertSeqWithKey
    intersectionWith = intersectionWithUsingLookupM
    difference = differenceUsingDelete
    properSubset = properSubsetUsingSubset
    

    unionSeqWithUsingReduce See 3 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.PatriciaLoMap from the package EdisonCore
    insertSeqWith ::
        S.Sequence seq => (a -> a -> a) -> seq (Int,a) -> FM a -> FM a
    insertSeqWith = insertSeqWithUsingInsertWith
    
    insertSeqWithKey ::
        S.Sequence seq =>
          (Int -> a -> a -> a) -> seq (Int,a) -> FM a -> FM a
    insertSeqWithKey = insertSeqWithKeyUsingInsertWithKey
    
    adjustAll :: (a -> a) -> Int -> FM a -> FM a
    adjustAll = adjust
    
    unionSeqWith :: S.Sequence seq => (a -> a -> a) -> seq (FM a) -> FM a
    unionSeqWith = unionSeqWithUsingReduce
    
    toSeq :: S.Sequence seq => FM a -> seq (Int,a)
    toSeq = toSeqUsingFoldWithKey
    
    keys :: S.Sequence seq => FM a -> seq Int
    

    Found in Data.Edison.Assoc.StandardMap from the package EdisonCore
    filterLE k m       = let (lt, mx, _ ) = DM.splitLookup k m in maybe lt (\x -> insert k x lt) mx
    filterGE k m       = let (_ , mx, gt) = DM.splitLookup k m in maybe gt (\x -> insert k x gt) mx
    partitionLT_GE k m = let (lt, mx, gt) = DM.splitLookup k m in (lt, maybe gt (\x -> insert k x gt) mx)
    partitionLE_GT k m = let (lt, mx, gt) = DM.splitLookup k m in (maybe lt (\x -> insert k x lt) mx, gt)
    partitionLT_GT     = DM.split
    fromSeqWith    f s = DM.fromListWith    f (S.toList s)
    fromSeqWithKey f s = DM.fromListWithKey f (S.toList s)
    insertWith         = DM.insertWith
    insertWithKey      = insertWithKeyUsingInsertWith
    insertSeqWith      = insertSeqWithUsingInsertWith
    insertSeqWithKey   = insertSeqWithKeyUsingInsertWithKey
    unionl             = DM.union
    unionr             = flip DM.union
    unionWith          = DM.unionWith
    unionSeqWith       = unionSeqWithUsingReduce
    intersectionWith   = DM.intersectionWith
    difference         = DM.difference
    properSubset       = DM.isProperSubmapOfBy (\_ _ -> True)
    subset             = DM.isSubmapOfBy (\_ _ -> True)
    properSubmapBy     = DM.isProperSubmapOfBy
    

    Found in Data.Edison.Assoc.TernaryTrie from the package EdisonCore
              Nothing -> Just v
              Just ve -> Just (f ve v))
    
    insertWithKey = insertWithKeyUsingInsertWith
    
    insertSeqWith = insertSeqWithUsingInsertWith
    
    insertSeqWithKey = insertSeqWithKeyUsingInsertWithKey
    
    unionl = union
    unionr = flip union
    
    unionWith f = unionWithKey (const f)
    
    unionSeqWith = unionSeqWithUsingReduce
    
    intersectionWith f = intersectionWithKey (const f)
    
    difference mx my
      = mergeVFM (\v1 v2 -> case v2 of
    

    unionWithKeyUsingInsertWithKey See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    unionWith = unionWithUsingInsertWith
    unionSeqWith = unionSeqWithUsingFoldr
    fromSeqWith = fromSeqWithUsingInsertSeqWith
    fromSeqWithKey = fromSeqWithKeyUsingInsertSeqWithKey
    intersectionWith = intersectionWithUsingLookupM
    difference = differenceUsingDelete
    properSubset = properSubsetUsingSubset
    subset = subsetUsingMember
    properSubmapBy = properSubmapByUsingSubmapBy
    submapBy = submapByUsingLookupM
    sameMapBy = sameMapByUsingSubmapBy
    properSubmap = A.properSubmap
    submap = A.submap
    sameMap = A.sameMap
    unionWithKey = unionWithKeyUsingInsertWithKey
    unionSeqWithKey = unionSeqWithKeyUsingFoldr
    intersectionWithKey = intersectionWithKeyUsingLookupM
    
    -- instance declarations
    

    unionWithUsingInsertWith See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    strict n@E = n
    strict n@(I _ _ m) = strict m `seq` n
    
    strictWith _ n@E = n
    strictWith f n@(I _ a m) = f a `seq` strictWith f m `seq` n
    
    
    -- defaults
    
    deleteSeq = deleteSeqUsingFoldr
    insertWith = insertWithUsingLookupM
    insertSeqWith = insertSeqWithUsingInsertWith
    insertWithKey = insertWithKeyUsingInsertWith
    insertSeqWithKey = insertSeqWithKeyUsingInsertWithKey
    unionWith = unionWithUsingInsertWith
    unionSeqWith = unionSeqWithUsingFoldr
    fromSeqWith = fromSeqWithUsingInsertSeqWith
    fromSeqWithKey = fromSeqWithKeyUsingInsertSeqWithKey
    intersectionWith = intersectionWithUsingLookupM
    difference = differenceUsingDelete