Data.Edison.Seq.BinaryRandList: exported symbols usage examples

Symbols

  • adjust See 8 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    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;
       insertSeq = insertSeq; union = union; unionSeq = unionSeq;
       delete = delete; deleteAll = deleteAll; deleteSeq = deleteSeq;
       null = null; size = size; member = member; count = count;
       lookup = lookup; lookupM = lookupM; lookupAll = lookupAll;
       lookupAndDelete = lookupAndDelete; lookupAndDeleteM = lookupAndDeleteM;
       lookupAndDeleteAll = lookupAndDeleteAll;
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
       adjustAllOrInsert = adjustAllOrInsert;
       adjustOrDelete = adjustOrDelete; adjustOrDeleteAll = adjustOrDeleteAll;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       filter = filter; partition = partition; elements = elements;
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    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;
       insertSeq = insertSeq; union = union; unionSeq = unionSeq;
       delete = delete; deleteAll = deleteAll; deleteSeq = deleteSeq;
       null = null; size = size; member = member; count = count;
       lookup = lookup; lookupM = lookupM; lookupAll = lookupAll;
       lookupAndDelete = lookupAndDelete; lookupAndDeleteM = lookupAndDeleteM;
       lookupAndDeleteAll = lookupAndDeleteAll;
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
       adjustAllOrInsert = adjustAllOrInsert;
       adjustOrDelete = adjustOrDelete; adjustOrDeleteAll = adjustOrDeleteAll;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       filter = filter; partition = partition; elements = elements;
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
          Just (z,m') -> (S.singleton z,m')
    
    
    lookupWithDefault d _ E = d
    lookupWithDefault d key (I k x m) | key == k = x
                                      | otherwise = lookupWithDefault d key m
    
    elements E = S.empty
    elements (I k x m) = S.lcons x (elements (delete k m))
    
    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)
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
       case lookupAndDeleteM key m of
          Nothing     -> (S.empty,m)
          Just (z,m') -> (S.singleton z,m')
    
    
    lookupWithDefault d _ E = d
    lookupWithDefault d key (I k x m) | key == k = x
                                      | otherwise = lookupWithDefault d key m
    
    elements E = S.empty
    elements (I k x m) = S.lcons x (elements (delete k m))
    
    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)
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    lookupAndDeleteAll key m =
       case lookupAndDeleteM key m of
          Nothing     -> (S.empty,m)
          Just (z,m') -> (S.singleton z,m')
    
    
    lookupWithDefault d _ E = d
    lookupWithDefault d key (I k x m) | key == k = x
                                      | otherwise = lookupWithDefault d key m
    
    elements E = S.empty
    elements (I k x m) = S.lcons x (elements (delete k m))
    
    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
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    lookupAndDeleteAll key m =
       case lookupAndDeleteM key m of
          Nothing     -> (S.empty,m)
          Just (z,m') -> (S.singleton z,m')
    
    
    lookupWithDefault d _ E = d
    lookupWithDefault d key (I k x m) | key == k = x
                                      | otherwise = lookupWithDefault d key m
    
    elements E = S.empty
    elements (I k x m) = S.lcons x (elements (delete k m))
    
    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
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    delete        :: Eq k => k -> FM k a -> FM k a
    deleteAll     :: Eq k => k -> FM k a -> FM k a
    deleteSeq     :: (Eq k,S.Sequence seq) => seq k -> FM k a -> FM k a
    null          :: Eq k => FM k a -> Bool
    size          :: Eq k => FM k a -> Int
    member        :: Eq k => k -> FM k a -> Bool
    count         :: Eq k => k -> FM k a -> Int
    lookup        :: Eq k => k -> FM k a -> a
    lookupM       :: (Eq k, Monad rm) => k -> FM k a -> rm a
    lookupAll     :: (Eq k,S.Sequence seq) => k -> FM k a -> seq a
    lookupAndDelete    :: Eq k => k -> FM k a -> (a,FM k a)
    lookupAndDeleteM   :: (Eq k,Monad rm)   => k -> FM k a -> rm (a,FM k a)
    lookupAndDeleteAll :: (Eq k,S.Sequence seq) => k -> FM k a -> (seq a,FM k a)
    lookupWithDefault  :: Eq k => a -> k -> FM k a -> a
    adjust             :: Eq k => (a -> a) -> k -> FM k a -> FM k a
    adjustAll          :: Eq k => (a -> a) -> k -> FM k a -> FM k a
    adjustOrInsert     :: Eq k => (a -> a) -> a -> k -> FM k a -> FM k a
    adjustAllOrInsert  :: Eq k => (a -> a) -> a -> k -> FM k a -> FM k a
    adjustOrDelete     :: Eq k => (a -> Maybe a) -> k -> FM k a -> FM k a
    adjustOrDeleteAll  :: Eq k => (a -> Maybe a) -> k -> FM k a -> FM k a
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    --   Duplicates are removed conceptually, but not physically.  The first
    --   occurrence of a given key is the one that is considered to be in the map.
    --
    --   The list type is mildly customized to prevent boxing the pairs.
    
    module Data.Edison.Assoc.AssocList (
        -- * Type of simple association lists
        FM, -- instance of Assoc(X), FiniteMap(X)
            -- also instance of Functor
    
        -- * AssocX operations
        empty,singleton,fromSeq,insert,insertSeq,union,unionSeq,delete,deleteAll,
        deleteSeq,null,size,member,count,lookup,lookupM,lookupAll,
        lookupAndDelete,lookupAndDeleteM,lookupAndDeleteAll,
        lookupWithDefault,adjust,adjustAll,adjustOrInsert,adjustAllOrInsert,
        adjustOrDelete,adjustOrDeleteAll,strict,strictWith,
        map,fold,fold',fold1,fold1',filter,partition,elements,structuralInvariant,
    
        -- * OrdAssocX operations
        minView, minElem, deleteMin, unsafeInsertMin, maxView, maxElem, deleteMax,
    

    append No usage example found for this symbol :( Collapse [-]
    concat No usage example found for this symbol :( Collapse [-]
    concatMap No usage example found for this symbol :( Collapse [-]
    copy No usage example found for this symbol :( Collapse [-]
    drop No usage example found for this symbol :( Collapse [-]
    dropWhile No usage example found for this symbol :( Collapse [-]
    empty See 13 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    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)
    
    instance (Eq k,CoArbitrary k,CoArbitrary a) => CoArbitrary (FM k a) where
       coarbitrary E = variant 0
       coarbitrary (I k a m) = variant 1 . coarbitrary k
                             . coarbitrary a . coarbitrary m
    
    
    instance Eq k => Semigroup (FM k a) where
       (<>) = union
    instance Eq k => Monoid (FM k a) where
       mempty  = empty
       mappend = (SG.<>)
       mconcat = unionSeq
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    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)
    
    instance (Eq k,CoArbitrary k,CoArbitrary a) => CoArbitrary (FM k a) where
       coarbitrary E = variant 0
       coarbitrary (I k a m) = variant 1 . coarbitrary k
                             . coarbitrary a . coarbitrary m
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    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;
       insertSeq = insertSeq; union = union; unionSeq = unionSeq;
       delete = delete; deleteAll = deleteAll; deleteSeq = deleteSeq;
       null = null; size = size; member = member; count = count;
       lookup = lookup; lookupM = lookupM; lookupAll = lookupAll;
       lookupAndDelete = lookupAndDelete; lookupAndDeleteM = lookupAndDeleteM;
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    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;
       insertSeq = insertSeq; union = union; unionSeq = unionSeq;
       delete = delete; deleteAll = deleteAll; deleteSeq = deleteSeq;
       null = null; size = size; member = member; count = count;
       lookup = lookup; lookupM = lookupM; lookupAll = lookupAll;
       lookupAndDelete = lookupAndDelete; lookupAndDeleteM = lookupAndDeleteM;
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    filter _ E = E
    filter p (I k x m) | p x = I k x (filter p (delete k m))
                       | otherwise = filter p (delete k m)
    
    partition _ E = (E, E)
    partition p (I k x m)
        | p x       = (I k x m1,m2)
        | otherwise = (m1,I k x m2)
      where (m1,m2) = partition p (delete k m)
    
    
    toSeq E = S.empty
    toSeq (I k x m) = S.lcons (k,x) (toSeq (delete k m))
    
    keys E = S.empty
    keys (I k _ m) = S.lcons k (keys (delete k m))
    
    mapWithKey _ E = E
    mapWithKey f (I k x m) = I k (f k x) (mapWithKey f m)
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    fold1' _ E = error "AssocList.fold1': empty map"
    fold1' f (I k x m) = fold' f x (delete k m)
    
    filter _ E = E
    filter p (I k x m) | p x = I k x (filter p (delete k m))
                       | otherwise = filter p (delete k m)
    
    partition _ E = (E, E)
    partition p (I k x m)
        | p x       = (I k x m1,m2)
        | otherwise = (m1,I k x m2)
      where (m1,m2) = partition p (delete k m)
    
    
    toSeq E = S.empty
    toSeq (I k x m) = S.lcons (k,x) (toSeq (delete k m))
    
    keys E = S.empty
    keys (I k _ m) = S.lcons k (keys (delete k m))
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
       | key == k  = return (x,delete k m)
       | otherwise = lookupAndDeleteM key m >>=
                        \ (z, m') -> return (z, I k x m')
    
    lookupAndDeleteAll key m =
       case lookupAndDeleteM key m of
          Nothing     -> (S.empty,m)
          Just (z,m') -> (S.singleton z,m')
    
    
    lookupWithDefault d _ E = d
    lookupWithDefault d key (I k x m) | key == k = x
                                      | otherwise = lookupWithDefault d key m
    
    elements E = S.empty
    elements (I k x m) = S.lcons x (elements (delete k m))
    
    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)
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    lookupAll _ E = S.empty
    lookupAll key (I k x m) | key == k  = S.singleton x
                            | otherwise = lookupAll key m
    
    lookupAndDelete key m = runIdentity (lookupAndDeleteM key m)
    
    lookupAndDeleteM _ E = fail "AssocList.lookupAndDeleteM: lookup failed"
    lookupAndDeleteM key (I k x m)
       | key == k  = return (x,delete k m)
       | otherwise = lookupAndDeleteM key m >>=
                        \ (z, m') -> return (z, I k x m')
    
    lookupAndDeleteAll key m =
       case lookupAndDeleteM key m of
          Nothing     -> (S.empty,m)
          Just (z,m') -> (S.singleton z,m')
    
    
    lookupWithDefault d _ E = d
    lookupWithDefault d key (I k x m) | key == k = x
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    member _ E = False
    member key (I k _ m) = key == k || member key m
    
    count _ E = 0
    count key (I k _ m) | key == k  = 1
                        | otherwise = count key m
    
    lookup key m = runIdentity (lookupM key m)
    
    lookupM _ E = fail "AssocList.lookup: lookup failed"
    lookupM key (I k x m) | key == k  = return x
                          | otherwise = lookupM key m
    
    lookupAll _ E = S.empty
    lookupAll key (I k x m) | key == k  = S.singleton x
                            | otherwise = lookupAll key m
    
    lookupAndDelete key m = runIdentity (lookupAndDeleteM key m)
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    dropWhileFM p o@(I k _ m)
       | p k       = dropWhileFM p m
       | otherwise = o
    
    spanFM :: (k -> Bool) -> FM k a -> (FM k a,FM k a)
    spanFM _ E = (E,E)
    spanFM p o@(I k a m)
       | p k       = let (x,y) = spanFM p m in (I k a x,y)
       | otherwise = (E,o)
    
    
    ---------------------------------------------------
    -- interface functions
    
    empty = E
    singleton k x = I k x E
    insert = I
    insertSeq kxs m = S.foldr uinsert m kxs
    fromSeq = S.foldr uinsert E
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    uinsert (k,x) = I k x
    
    
    -- left biased merge.
    mergeFM :: (Ord t) => FM t t1 -> FM t t1 -> FM t t1
    mergeFM E m = m
    mergeFM m E = m
    mergeFM o1@(I k1 a1 m1) o2@(I k2 a2 m2) =
      case compare k1 k2 of
          LT -> I k1 a1 (mergeFM m1 o2)
          GT -> I k2 a2 (mergeFM o1 m2)
          EQ -> I k1 a1 (mergeFM m1 m2)
    
    toRandList :: FM t t1 -> RL.Seq (FM t t1)
    toRandList E = RL.empty
    toRandList (I k a m) = RL.lcons (I k a E) (toRandList m)
    
    mergeSortFM :: (Ord t) => FM t t1 -> FM t t1
    mergeSortFM m = RL.reducer mergeFM E (toRandList m)
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    import Prelude hiding (null,map,lookup,foldr,foldl,foldr1,foldl1,filter)
    import qualified Prelude
    import Data.Monoid
    import Data.Semigroup as SG
    import Control.Monad.Identity
    import qualified Data.Edison.Assoc as A
    import qualified Data.Edison.Seq as S
    import qualified Data.Edison.Seq.BinaryRandList as RL
    import Data.Edison.Assoc.Defaults
    import Test.QuickCheck (Arbitrary(..), CoArbitrary(..), variant)
    
    -- signatures for exported functions
    moduleName    :: String
    empty         :: Eq k => FM k a
    singleton     :: Eq k => k -> a -> FM k a
    fromSeq       :: (Eq k,S.Sequence seq) => seq (k,a) -> FM k a
    insert        :: Eq k => k -> a -> FM k a -> FM k a
    insertSeq     :: (Eq k,S.Sequence seq) => seq (k,a) -> FM k a -> FM k a
    union         :: Eq k => FM k a -> FM k a -> FM k a
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    --
    --   This module implements finite maps as simple association lists.
    --
    --   Duplicates are removed conceptually, but not physically.  The first
    --   occurrence of a given key is the one that is considered to be in the map.
    --
    --   The list type is mildly customized to prevent boxing the pairs.
    
    module Data.Edison.Assoc.AssocList (
        -- * Type of simple association lists
        FM, -- instance of Assoc(X), FiniteMap(X)
            -- also instance of Functor
    
        -- * AssocX operations
        empty,singleton,fromSeq,insert,insertSeq,union,unionSeq,delete,deleteAll,
        deleteSeq,null,size,member,count,lookup,lookupM,lookupAll,
        lookupAndDelete,lookupAndDeleteM,lookupAndDeleteAll,
        lookupWithDefault,adjust,adjustAll,adjustOrInsert,adjustAllOrInsert,
        adjustOrDelete,adjustOrDeleteAll,strict,strictWith,
        map,fold,fold',fold1,fold1',filter,partition,elements,structuralInvariant,
    

    filter See 9 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    instance Eq k  => A.AssocX (FM k) k where
      {empty = empty; singleton = singleton; fromSeq = fromSeq; insert = insert;
       insertSeq = insertSeq; union = union; unionSeq = unionSeq;
       delete = delete; deleteAll = deleteAll; deleteSeq = deleteSeq;
       null = null; size = size; member = member; count = count;
       lookup = lookup; lookupM = lookupM; lookupAll = lookupAll;
       lookupAndDelete = lookupAndDelete; lookupAndDeleteM = lookupAndDeleteM;
       lookupAndDeleteAll = lookupAndDeleteAll;
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
       adjustAllOrInsert = adjustAllOrInsert;
       adjustOrDelete = adjustOrDelete; adjustOrDeleteAll = adjustOrDeleteAll;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       filter = filter; partition = partition; elements = elements;
       strict = strict; strictWith = strictWith;
       structuralInvariant = structuralInvariant; instanceName _ = moduleName}
    
    instance Ord k => A.OrdAssocX (FM k) k where
      {minView = minView; minElem = minElem; deleteMin = deleteMin;
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    instance Eq k  => A.AssocX (FM k) k where
      {empty = empty; singleton = singleton; fromSeq = fromSeq; insert = insert;
       insertSeq = insertSeq; union = union; unionSeq = unionSeq;
       delete = delete; deleteAll = deleteAll; deleteSeq = deleteSeq;
       null = null; size = size; member = member; count = count;
       lookup = lookup; lookupM = lookupM; lookupAll = lookupAll;
       lookupAndDelete = lookupAndDelete; lookupAndDeleteM = lookupAndDeleteM;
       lookupAndDeleteAll = lookupAndDeleteAll;
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
       adjustAllOrInsert = adjustAllOrInsert;
       adjustOrDelete = adjustOrDelete; adjustOrDeleteAll = adjustOrDeleteAll;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       filter = filter; partition = partition; elements = elements;
       strict = strict; strictWith = strictWith;
       structuralInvariant = structuralInvariant; instanceName _ = moduleName}
    
    instance Ord k => A.OrdAssocX (FM k) k where
      {minView = minView; minElem = minElem; deleteMin = deleteMin;
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    fold _ c E = c
    fold f c (I k x m) = fold f (f x c) (delete k m)
    
    fold' _ c E = c
    fold' f c (I k x m) = c `seq` fold' f (f x c) (delete k m)
    
    fold1 _ E = error "AssocList.fold1: empty map"
    fold1 f (I k x m) = fold f x (delete k m)
    
    fold1' _ E = error "AssocList.fold1': empty map"
    fold1' f (I k x m) = fold' f x (delete k m)
    
    filter _ E = E
    filter p (I k x m) | p x = I k x (filter p (delete k m))
                       | otherwise = filter p (delete k m)
    
    partition _ E = (E, E)
    partition p (I k x m)
        | p x       = (I k x m1,m2)
        | otherwise = (m1,I k x m2)
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    fold _ c E = c
    fold f c (I k x m) = fold f (f x c) (delete k m)
    
    fold' _ c E = c
    fold' f c (I k x m) = c `seq` fold' f (f x c) (delete k m)
    
    fold1 _ E = error "AssocList.fold1: empty map"
    fold1 f (I k x m) = fold f x (delete k m)
    
    fold1' _ E = error "AssocList.fold1': empty map"
    fold1' f (I k x m) = fold' f x (delete k m)
    
    filter _ E = E
    filter p (I k x m) | p x = I k x (filter p (delete k m))
                       | otherwise = filter p (delete k m)
    
    partition _ E = (E, E)
    partition p (I k x m)
        | p x       = (I k x m1,m2)
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    fold _ c E = c
    fold f c (I k x m) = fold f (f x c) (delete k m)
    
    fold' _ c E = c
    fold' f c (I k x m) = c `seq` fold' f (f x c) (delete k m)
    
    fold1 _ E = error "AssocList.fold1: empty map"
    fold1 f (I k x m) = fold f x (delete k m)
    
    fold1' _ E = error "AssocList.fold1': empty map"
    fold1' f (I k x m) = fold' f x (delete k m)
    
    filter _ E = E
    filter p (I k x m) | p x = I k x (filter p (delete k m))
                       | otherwise = filter p (delete k m)
    
    partition _ E = (E, E)
    partition p (I k x m)
        | p x       = (I k x m1,m2)
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    map f (I k x m) = I k (f x) (map f m)
    
    fold _ c E = c
    fold f c (I k x m) = fold f (f x c) (delete k m)
    
    fold' _ c E = c
    fold' f c (I k x m) = c `seq` fold' f (f x c) (delete k m)
    
    fold1 _ E = error "AssocList.fold1: empty map"
    fold1 f (I k x m) = fold f x (delete k m)
    
    fold1' _ E = error "AssocList.fold1': empty map"
    fold1' f (I k x m) = fold' f x (delete k m)
    
    filter _ E = E
    filter p (I k x m) | p x = I k x (filter p (delete k m))
                       | otherwise = filter p (delete k m)
    
    partition _ E = (E, E)
    partition p (I k x m)
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    lookupWithDefault  :: Eq k => a -> k -> FM k a -> a
    adjust             :: Eq k => (a -> a) -> k -> FM k a -> FM k a
    adjustAll          :: Eq k => (a -> a) -> k -> FM k a -> FM k a
    adjustOrInsert     :: Eq k => (a -> a) -> a -> k -> FM k a -> FM k a
    adjustAllOrInsert  :: Eq k => (a -> a) -> a -> k -> FM k a -> FM k a
    adjustOrDelete     :: Eq k => (a -> Maybe a) -> k -> FM k a -> FM k a
    adjustOrDeleteAll  :: Eq k => (a -> Maybe a) -> k -> FM k a -> FM k a
    strict             :: FM k a -> FM k a
    strictWith         :: (a -> b) -> FM k a -> FM k a
    map           :: Eq k => (a -> b) -> FM k a -> FM k b
    fold          :: Eq k => (a -> b -> b) -> b -> FM k a -> b
    fold1         :: Eq k => (a -> a -> a) -> FM k a -> a
    fold'         :: Eq k => (a -> b -> b) -> b -> FM k a -> b
    fold1'        :: Eq k => (a -> a -> a) -> FM k a -> a
    filter        :: Eq k => (a -> Bool) -> FM k a -> FM k a
    partition     :: Eq k => (a -> Bool) -> FM k a -> (FM k a, FM k a)
    elements      :: (Eq k,S.Sequence seq) => FM k a -> seq a
    
    fromSeqWith      :: (Eq k,S.Sequence seq) =>
                            (a -> a -> a) -> seq (k,a) -> FM k a
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
        -- * FiniteMapX operations
        fromSeqWith,fromSeqWithKey,insertWith,insertWithKey,insertSeqWith,
        insertSeqWithKey,unionl,unionr,unionWith,unionSeqWith,intersectionWith,
        difference,properSubset,subset,properSubmapBy,submapBy,sameMapBy,
        properSubmap,submap,sameMap,
    
        -- * FiniteMap operations
        unionWithKey,unionSeqWithKey,intersectionWithKey,
    
        -- * Documentation
        moduleName
    ) where
    
    import Prelude hiding (null,map,lookup,foldr,foldl,foldr1,foldl1,filter)
    import qualified Prelude
    import Data.Monoid
    import Data.Semigroup as SG
    import Control.Monad.Identity
    import qualified Data.Edison.Assoc as A
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    --
    --   The list type is mildly customized to prevent boxing the pairs.
    
    module Data.Edison.Assoc.AssocList (
        -- * Type of simple association lists
        FM, -- instance of Assoc(X), FiniteMap(X)
            -- also instance of Functor
    
        -- * AssocX operations
        empty,singleton,fromSeq,insert,insertSeq,union,unionSeq,delete,deleteAll,
        deleteSeq,null,size,member,count,lookup,lookupM,lookupAll,
        lookupAndDelete,lookupAndDeleteM,lookupAndDeleteAll,
        lookupWithDefault,adjust,adjustAll,adjustOrInsert,adjustAllOrInsert,
        adjustOrDelete,adjustOrDeleteAll,strict,strictWith,
        map,fold,fold',fold1,fold1',filter,partition,elements,structuralInvariant,
    
        -- * OrdAssocX operations
        minView, minElem, deleteMin, unsafeInsertMin, maxView, maxElem, deleteMax,
        unsafeInsertMax, foldr, foldr', foldl, foldl', foldr1, foldr1',
        foldl1, foldl1', unsafeFromOrdSeq, unsafeAppend,
    

    fold See 8 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    -- instance declarations
    
    instance Eq k  => A.AssocX (FM k) k where
      {empty = empty; singleton = singleton; fromSeq = fromSeq; insert = insert;
       insertSeq = insertSeq; union = union; unionSeq = unionSeq;
       delete = delete; deleteAll = deleteAll; deleteSeq = deleteSeq;
       null = null; size = size; member = member; count = count;
       lookup = lookup; lookupM = lookupM; lookupAll = lookupAll;
       lookupAndDelete = lookupAndDelete; lookupAndDeleteM = lookupAndDeleteM;
       lookupAndDeleteAll = lookupAndDeleteAll;
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
       adjustAllOrInsert = adjustAllOrInsert;
       adjustOrDelete = adjustOrDelete; adjustOrDeleteAll = adjustOrDeleteAll;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       filter = filter; partition = partition; elements = elements;
       strict = strict; strictWith = strictWith;
       structuralInvariant = structuralInvariant; instanceName _ = moduleName}
    
    instance Ord k => A.OrdAssocX (FM k) k where
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    -- instance declarations
    
    instance Eq k  => A.AssocX (FM k) k where
      {empty = empty; singleton = singleton; fromSeq = fromSeq; insert = insert;
       insertSeq = insertSeq; union = union; unionSeq = unionSeq;
       delete = delete; deleteAll = deleteAll; deleteSeq = deleteSeq;
       null = null; size = size; member = member; count = count;
       lookup = lookup; lookupM = lookupM; lookupAll = lookupAll;
       lookupAndDelete = lookupAndDelete; lookupAndDeleteM = lookupAndDeleteM;
       lookupAndDeleteAll = lookupAndDeleteAll;
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
       adjustAllOrInsert = adjustAllOrInsert;
       adjustOrDelete = adjustOrDelete; adjustOrDeleteAll = adjustOrDeleteAll;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       filter = filter; partition = partition; elements = elements;
       strict = strict; strictWith = strictWith;
       structuralInvariant = structuralInvariant; instanceName _ = moduleName}
    
    instance Ord k => A.OrdAssocX (FM k) k where
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    adjustOrDelete = adjustOrDeleteDefault
    adjustOrDeleteAll = adjustOrDeleteAllDefault
    
    map _ E = E
    map f (I k x m) = I k (f x) (map f m)
    
    fold _ c E = c
    fold f c (I k x m) = fold f (f x c) (delete k m)
    
    fold' _ c E = c
    fold' f c (I k x m) = c `seq` fold' f (f x c) (delete k m)
    
    fold1 _ E = error "AssocList.fold1: empty map"
    fold1 f (I k x m) = fold f x (delete k m)
    
    fold1' _ E = error "AssocList.fold1': empty map"
    fold1' f (I k x m) = fold' f x (delete k m)
    
    filter _ E = E
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    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
    fold f c (I k x m) = fold f (f x c) (delete k m)
    
    fold' _ c E = c
    fold' f c (I k x m) = c `seq` fold' f (f x c) (delete k m)
    
    fold1 _ E = error "AssocList.fold1: empty map"
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    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
    fold f c (I k x m) = fold f (f x c) (delete k m)
    
    fold' _ c E = c
    fold' f c (I k x m) = c `seq` fold' f (f x c) (delete k m)
    
    fold1 _ E = error "AssocList.fold1: empty map"
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    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
    fold f c (I k x m) = fold f (f x c) (delete k m)
    
    fold' _ c E = c
    fold' f c (I k x m) = c `seq` fold' f (f x c) (delete k m)
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    lookupAll     :: (Eq k,S.Sequence seq) => k -> FM k a -> seq a
    lookupAndDelete    :: Eq k => k -> FM k a -> (a,FM k a)
    lookupAndDeleteM   :: (Eq k,Monad rm)   => k -> FM k a -> rm (a,FM k a)
    lookupAndDeleteAll :: (Eq k,S.Sequence seq) => k -> FM k a -> (seq a,FM k a)
    lookupWithDefault  :: Eq k => a -> k -> FM k a -> a
    adjust             :: Eq k => (a -> a) -> k -> FM k a -> FM k a
    adjustAll          :: Eq k => (a -> a) -> k -> FM k a -> FM k a
    adjustOrInsert     :: Eq k => (a -> a) -> a -> k -> FM k a -> FM k a
    adjustAllOrInsert  :: Eq k => (a -> a) -> a -> k -> FM k a -> FM k a
    adjustOrDelete     :: Eq k => (a -> Maybe a) -> k -> FM k a -> FM k a
    adjustOrDeleteAll  :: Eq k => (a -> Maybe a) -> k -> FM k a -> FM k a
    strict             :: FM k a -> FM k a
    strictWith         :: (a -> b) -> FM k a -> FM k a
    map           :: Eq k => (a -> b) -> FM k a -> FM k b
    fold          :: Eq k => (a -> b -> b) -> b -> FM k a -> b
    fold1         :: Eq k => (a -> a -> a) -> FM k a -> a
    fold'         :: Eq k => (a -> b -> b) -> b -> FM k a -> b
    fold1'        :: Eq k => (a -> a -> a) -> FM k a -> a
    filter        :: Eq k => (a -> Bool) -> FM k a -> FM k a
    partition     :: Eq k => (a -> Bool) -> FM k a -> (FM k a, FM k a)
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    --
    --   The list type is mildly customized to prevent boxing the pairs.
    
    module Data.Edison.Assoc.AssocList (
        -- * Type of simple association lists
        FM, -- instance of Assoc(X), FiniteMap(X)
            -- also instance of Functor
    
        -- * AssocX operations
        empty,singleton,fromSeq,insert,insertSeq,union,unionSeq,delete,deleteAll,
        deleteSeq,null,size,member,count,lookup,lookupM,lookupAll,
        lookupAndDelete,lookupAndDeleteM,lookupAndDeleteAll,
        lookupWithDefault,adjust,adjustAll,adjustOrInsert,adjustAllOrInsert,
        adjustOrDelete,adjustOrDeleteAll,strict,strictWith,
        map,fold,fold',fold1,fold1',filter,partition,elements,structuralInvariant,
    
        -- * OrdAssocX operations
        minView, minElem, deleteMin, unsafeInsertMin, maxView, maxElem, deleteMax,
        unsafeInsertMax, foldr, foldr', foldl, foldl', foldr1, foldr1',
        foldl1, foldl1', unsafeFromOrdSeq, unsafeAppend,
    

    fold' See 8 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    -- instance declarations
    
    instance Eq k  => A.AssocX (FM k) k where
      {empty = empty; singleton = singleton; fromSeq = fromSeq; insert = insert;
       insertSeq = insertSeq; union = union; unionSeq = unionSeq;
       delete = delete; deleteAll = deleteAll; deleteSeq = deleteSeq;
       null = null; size = size; member = member; count = count;
       lookup = lookup; lookupM = lookupM; lookupAll = lookupAll;
       lookupAndDelete = lookupAndDelete; lookupAndDeleteM = lookupAndDeleteM;
       lookupAndDeleteAll = lookupAndDeleteAll;
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
       adjustAllOrInsert = adjustAllOrInsert;
       adjustOrDelete = adjustOrDelete; adjustOrDeleteAll = adjustOrDeleteAll;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       filter = filter; partition = partition; elements = elements;
       strict = strict; strictWith = strictWith;
       structuralInvariant = structuralInvariant; instanceName _ = moduleName}
    
    instance Ord k => A.OrdAssocX (FM k) k where
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    -- instance declarations
    
    instance Eq k  => A.AssocX (FM k) k where
      {empty = empty; singleton = singleton; fromSeq = fromSeq; insert = insert;
       insertSeq = insertSeq; union = union; unionSeq = unionSeq;
       delete = delete; deleteAll = deleteAll; deleteSeq = deleteSeq;
       null = null; size = size; member = member; count = count;
       lookup = lookup; lookupM = lookupM; lookupAll = lookupAll;
       lookupAndDelete = lookupAndDelete; lookupAndDeleteM = lookupAndDeleteM;
       lookupAndDeleteAll = lookupAndDeleteAll;
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
       adjustAllOrInsert = adjustAllOrInsert;
       adjustOrDelete = adjustOrDelete; adjustOrDeleteAll = adjustOrDeleteAll;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       filter = filter; partition = partition; elements = elements;
       strict = strict; strictWith = strictWith;
       structuralInvariant = structuralInvariant; instanceName _ = moduleName}
    
    instance Ord k => A.OrdAssocX (FM k) k where
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    map _ E = E
    map f (I k x m) = I k (f x) (map f m)
    
    fold _ c E = c
    fold f c (I k x m) = fold f (f x c) (delete k m)
    
    fold' _ c E = c
    fold' f c (I k x m) = c `seq` fold' f (f x c) (delete k m)
    
    fold1 _ E = error "AssocList.fold1: empty map"
    fold1 f (I k x m) = fold f x (delete k m)
    
    fold1' _ E = error "AssocList.fold1': empty map"
    fold1' f (I k x m) = fold' f x (delete k m)
    
    filter _ E = E
    filter p (I k x m) | p x = I k x (filter p (delete k m))
                       | otherwise = filter p (delete k m)
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
        | 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
    fold f c (I k x m) = fold f (f x c) (delete k m)
    
    fold' _ c E = c
    fold' f c (I k x m) = c `seq` fold' f (f x c) (delete k m)
    
    fold1 _ E = error "AssocList.fold1: empty map"
    fold1 f (I k x m) = fold f x (delete k m)
    
    fold1' _ E = error "AssocList.fold1': empty map"
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
        | 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
    fold f c (I k x m) = fold f (f x c) (delete k m)
    
    fold' _ c E = c
    fold' f c (I k x m) = c `seq` fold' f (f x c) (delete k m)
    
    fold1 _ E = error "AssocList.fold1: empty map"
    fold1 f (I k x m) = fold f x (delete k m)
    
    fold1' _ E = error "AssocList.fold1': empty map"
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
        | 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
    fold f c (I k x m) = fold f (f x c) (delete k m)
    
    fold' _ c E = c
    fold' f c (I k x m) = c `seq` fold' f (f x c) (delete k m)
    
    fold1 _ E = error "AssocList.fold1: empty map"
    fold1 f (I k x m) = fold f x (delete k m)
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    lookupAndDeleteM   :: (Eq k,Monad rm)   => k -> FM k a -> rm (a,FM k a)
    lookupAndDeleteAll :: (Eq k,S.Sequence seq) => k -> FM k a -> (seq a,FM k a)
    lookupWithDefault  :: Eq k => a -> k -> FM k a -> a
    adjust             :: Eq k => (a -> a) -> k -> FM k a -> FM k a
    adjustAll          :: Eq k => (a -> a) -> k -> FM k a -> FM k a
    adjustOrInsert     :: Eq k => (a -> a) -> a -> k -> FM k a -> FM k a
    adjustAllOrInsert  :: Eq k => (a -> a) -> a -> k -> FM k a -> FM k a
    adjustOrDelete     :: Eq k => (a -> Maybe a) -> k -> FM k a -> FM k a
    adjustOrDeleteAll  :: Eq k => (a -> Maybe a) -> k -> FM k a -> FM k a
    strict             :: FM k a -> FM k a
    strictWith         :: (a -> b) -> FM k a -> FM k a
    map           :: Eq k => (a -> b) -> FM k a -> FM k b
    fold          :: Eq k => (a -> b -> b) -> b -> FM k a -> b
    fold1         :: Eq k => (a -> a -> a) -> FM k a -> a
    fold'         :: Eq k => (a -> b -> b) -> b -> FM k a -> b
    fold1'        :: Eq k => (a -> a -> a) -> FM k a -> a
    filter        :: Eq k => (a -> Bool) -> FM k a -> FM k a
    partition     :: Eq k => (a -> Bool) -> FM k a -> (FM k a, FM k a)
    elements      :: (Eq k,S.Sequence seq) => FM k a -> seq a
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    --
    --   The list type is mildly customized to prevent boxing the pairs.
    
    module Data.Edison.Assoc.AssocList (
        -- * Type of simple association lists
        FM, -- instance of Assoc(X), FiniteMap(X)
            -- also instance of Functor
    
        -- * AssocX operations
        empty,singleton,fromSeq,insert,insertSeq,union,unionSeq,delete,deleteAll,
        deleteSeq,null,size,member,count,lookup,lookupM,lookupAll,
        lookupAndDelete,lookupAndDeleteM,lookupAndDeleteAll,
        lookupWithDefault,adjust,adjustAll,adjustOrInsert,adjustAllOrInsert,
        adjustOrDelete,adjustOrDeleteAll,strict,strictWith,
        map,fold,fold',fold1,fold1',filter,partition,elements,structuralInvariant,
    
        -- * OrdAssocX operations
        minView, minElem, deleteMin, unsafeInsertMin, maxView, maxElem, deleteMax,
        unsafeInsertMax, foldr, foldr', foldl, foldl', foldr1, foldr1',
        foldl1, foldl1', unsafeFromOrdSeq, unsafeAppend,
    

    fold1 See 6 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    -- instance declarations
    
    instance Eq k  => A.AssocX (FM k) k where
      {empty = empty; singleton = singleton; fromSeq = fromSeq; insert = insert;
       insertSeq = insertSeq; union = union; unionSeq = unionSeq;
       delete = delete; deleteAll = deleteAll; deleteSeq = deleteSeq;
       null = null; size = size; member = member; count = count;
       lookup = lookup; lookupM = lookupM; lookupAll = lookupAll;
       lookupAndDelete = lookupAndDelete; lookupAndDeleteM = lookupAndDeleteM;
       lookupAndDeleteAll = lookupAndDeleteAll;
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
       adjustAllOrInsert = adjustAllOrInsert;
       adjustOrDelete = adjustOrDelete; adjustOrDeleteAll = adjustOrDeleteAll;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       filter = filter; partition = partition; elements = elements;
       strict = strict; strictWith = strictWith;
       structuralInvariant = structuralInvariant; instanceName _ = moduleName}
    
    instance Ord k => A.OrdAssocX (FM k) k where
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    -- instance declarations
    
    instance Eq k  => A.AssocX (FM k) k where
      {empty = empty; singleton = singleton; fromSeq = fromSeq; insert = insert;
       insertSeq = insertSeq; union = union; unionSeq = unionSeq;
       delete = delete; deleteAll = deleteAll; deleteSeq = deleteSeq;
       null = null; size = size; member = member; count = count;
       lookup = lookup; lookupM = lookupM; lookupAll = lookupAll;
       lookupAndDelete = lookupAndDelete; lookupAndDeleteM = lookupAndDeleteM;
       lookupAndDeleteAll = lookupAndDeleteAll;
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
       adjustAllOrInsert = adjustAllOrInsert;
       adjustOrDelete = adjustOrDelete; adjustOrDeleteAll = adjustOrDeleteAll;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       filter = filter; partition = partition; elements = elements;
       strict = strict; strictWith = strictWith;
       structuralInvariant = structuralInvariant; instanceName _ = moduleName}
    
    instance Ord k => A.OrdAssocX (FM k) k where
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    adjustOrDelete = adjustOrDeleteDefault
    adjustOrDeleteAll = adjustOrDeleteAllDefault
    
    map _ E = E
    map f (I k x m) = I k (f x) (map f m)
    
    fold _ c E = c
    fold f c (I k x m) = fold f (f x c) (delete k m)
    
    fold' _ c E = c
    fold' f c (I k x m) = c `seq` fold' f (f x c) (delete k m)
    
    fold1 _ E = error "AssocList.fold1: empty map"
    fold1 f (I k x m) = fold f x (delete k m)
    
    fold1' _ E = error "AssocList.fold1': empty map"
    fold1' f (I k x m) = fold' f x (delete k m)
    
    filter _ E = E
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    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
    fold f c (I k x m) = fold f (f x c) (delete k m)
    
    fold' _ c E = c
    fold' f c (I k x m) = c `seq` fold' f (f x c) (delete k m)
    
    fold1 _ E = error "AssocList.fold1: empty map"
    fold1 f (I k x m) = fold f x (delete k m)
    
    fold1' _ E = error "AssocList.fold1': empty map"
    fold1' f (I k x m) = fold' f x (delete k m)
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    lookupAndDelete    :: Eq k => k -> FM k a -> (a,FM k a)
    lookupAndDeleteM   :: (Eq k,Monad rm)   => k -> FM k a -> rm (a,FM k a)
    lookupAndDeleteAll :: (Eq k,S.Sequence seq) => k -> FM k a -> (seq a,FM k a)
    lookupWithDefault  :: Eq k => a -> k -> FM k a -> a
    adjust             :: Eq k => (a -> a) -> k -> FM k a -> FM k a
    adjustAll          :: Eq k => (a -> a) -> k -> FM k a -> FM k a
    adjustOrInsert     :: Eq k => (a -> a) -> a -> k -> FM k a -> FM k a
    adjustAllOrInsert  :: Eq k => (a -> a) -> a -> k -> FM k a -> FM k a
    adjustOrDelete     :: Eq k => (a -> Maybe a) -> k -> FM k a -> FM k a
    adjustOrDeleteAll  :: Eq k => (a -> Maybe a) -> k -> FM k a -> FM k a
    strict             :: FM k a -> FM k a
    strictWith         :: (a -> b) -> FM k a -> FM k a
    map           :: Eq k => (a -> b) -> FM k a -> FM k b
    fold          :: Eq k => (a -> b -> b) -> b -> FM k a -> b
    fold1         :: Eq k => (a -> a -> a) -> FM k a -> a
    fold'         :: Eq k => (a -> b -> b) -> b -> FM k a -> b
    fold1'        :: Eq k => (a -> a -> a) -> FM k a -> a
    filter        :: Eq k => (a -> Bool) -> FM k a -> FM k a
    partition     :: Eq k => (a -> Bool) -> FM k a -> (FM k a, FM k a)
    elements      :: (Eq k,S.Sequence seq) => FM k a -> seq a
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    --
    --   The list type is mildly customized to prevent boxing the pairs.
    
    module Data.Edison.Assoc.AssocList (
        -- * Type of simple association lists
        FM, -- instance of Assoc(X), FiniteMap(X)
            -- also instance of Functor
    
        -- * AssocX operations
        empty,singleton,fromSeq,insert,insertSeq,union,unionSeq,delete,deleteAll,
        deleteSeq,null,size,member,count,lookup,lookupM,lookupAll,
        lookupAndDelete,lookupAndDeleteM,lookupAndDeleteAll,
        lookupWithDefault,adjust,adjustAll,adjustOrInsert,adjustAllOrInsert,
        adjustOrDelete,adjustOrDeleteAll,strict,strictWith,
        map,fold,fold',fold1,fold1',filter,partition,elements,structuralInvariant,
    
        -- * OrdAssocX operations
        minView, minElem, deleteMin, unsafeInsertMin, maxView, maxElem, deleteMax,
        unsafeInsertMax, foldr, foldr', foldl, foldl', foldr1, foldr1',
        foldl1, foldl1', unsafeFromOrdSeq, unsafeAppend,
    

    fold1' See 6 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    -- instance declarations
    
    instance Eq k  => A.AssocX (FM k) k where
      {empty = empty; singleton = singleton; fromSeq = fromSeq; insert = insert;
       insertSeq = insertSeq; union = union; unionSeq = unionSeq;
       delete = delete; deleteAll = deleteAll; deleteSeq = deleteSeq;
       null = null; size = size; member = member; count = count;
       lookup = lookup; lookupM = lookupM; lookupAll = lookupAll;
       lookupAndDelete = lookupAndDelete; lookupAndDeleteM = lookupAndDeleteM;
       lookupAndDeleteAll = lookupAndDeleteAll;
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
       adjustAllOrInsert = adjustAllOrInsert;
       adjustOrDelete = adjustOrDelete; adjustOrDeleteAll = adjustOrDeleteAll;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       filter = filter; partition = partition; elements = elements;
       strict = strict; strictWith = strictWith;
       structuralInvariant = structuralInvariant; instanceName _ = moduleName}
    
    instance Ord k => A.OrdAssocX (FM k) k where
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    -- instance declarations
    
    instance Eq k  => A.AssocX (FM k) k where
      {empty = empty; singleton = singleton; fromSeq = fromSeq; insert = insert;
       insertSeq = insertSeq; union = union; unionSeq = unionSeq;
       delete = delete; deleteAll = deleteAll; deleteSeq = deleteSeq;
       null = null; size = size; member = member; count = count;
       lookup = lookup; lookupM = lookupM; lookupAll = lookupAll;
       lookupAndDelete = lookupAndDelete; lookupAndDeleteM = lookupAndDeleteM;
       lookupAndDeleteAll = lookupAndDeleteAll;
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
       adjustAllOrInsert = adjustAllOrInsert;
       adjustOrDelete = adjustOrDelete; adjustOrDeleteAll = adjustOrDeleteAll;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       filter = filter; partition = partition; elements = elements;
       strict = strict; strictWith = strictWith;
       structuralInvariant = structuralInvariant; instanceName _ = moduleName}
    
    instance Ord k => A.OrdAssocX (FM k) k where
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    map _ E = E
    map f (I k x m) = I k (f x) (map f m)
    
    fold _ c E = c
    fold f c (I k x m) = fold f (f x c) (delete k m)
    
    fold' _ c E = c
    fold' f c (I k x m) = c `seq` fold' f (f x c) (delete k m)
    
    fold1 _ E = error "AssocList.fold1: empty map"
    fold1 f (I k x m) = fold f x (delete k m)
    
    fold1' _ E = error "AssocList.fold1': empty map"
    fold1' f (I k x m) = fold' f x (delete k m)
    
    filter _ E = E
    filter p (I k x m) | p x = I k x (filter p (delete k m))
                       | otherwise = filter p (delete k m)
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    adjustOrDeleteAll = adjustOrDeleteAllDefault
    
    map _ E = E
    map f (I k x m) = I k (f x) (map f m)
    
    fold _ c E = c
    fold f c (I k x m) = fold f (f x c) (delete k m)
    
    fold' _ c E = c
    fold' f c (I k x m) = c `seq` fold' f (f x c) (delete k m)
    
    fold1 _ E = error "AssocList.fold1: empty map"
    fold1 f (I k x m) = fold f x (delete k m)
    
    fold1' _ E = error "AssocList.fold1': empty map"
    fold1' f (I k x m) = fold' f x (delete k m)
    
    filter _ E = E
    filter p (I k x m) | p x = I k x (filter p (delete k m))
                       | otherwise = filter p (delete k m)
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    lookupAndDeleteAll :: (Eq k,S.Sequence seq) => k -> FM k a -> (seq a,FM k a)
    lookupWithDefault  :: Eq k => a -> k -> FM k a -> a
    adjust             :: Eq k => (a -> a) -> k -> FM k a -> FM k a
    adjustAll          :: Eq k => (a -> a) -> k -> FM k a -> FM k a
    adjustOrInsert     :: Eq k => (a -> a) -> a -> k -> FM k a -> FM k a
    adjustAllOrInsert  :: Eq k => (a -> a) -> a -> k -> FM k a -> FM k a
    adjustOrDelete     :: Eq k => (a -> Maybe a) -> k -> FM k a -> FM k a
    adjustOrDeleteAll  :: Eq k => (a -> Maybe a) -> k -> FM k a -> FM k a
    strict             :: FM k a -> FM k a
    strictWith         :: (a -> b) -> FM k a -> FM k a
    map           :: Eq k => (a -> b) -> FM k a -> FM k b
    fold          :: Eq k => (a -> b -> b) -> b -> FM k a -> b
    fold1         :: Eq k => (a -> a -> a) -> FM k a -> a
    fold'         :: Eq k => (a -> b -> b) -> b -> FM k a -> b
    fold1'        :: Eq k => (a -> a -> a) -> FM k a -> a
    filter        :: Eq k => (a -> Bool) -> FM k a -> FM k a
    partition     :: Eq k => (a -> Bool) -> FM k a -> (FM k a, FM k a)
    elements      :: (Eq k,S.Sequence seq) => FM k a -> seq a
    
    fromSeqWith      :: (Eq k,S.Sequence seq) =>
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    --
    --   The list type is mildly customized to prevent boxing the pairs.
    
    module Data.Edison.Assoc.AssocList (
        -- * Type of simple association lists
        FM, -- instance of Assoc(X), FiniteMap(X)
            -- also instance of Functor
    
        -- * AssocX operations
        empty,singleton,fromSeq,insert,insertSeq,union,unionSeq,delete,deleteAll,
        deleteSeq,null,size,member,count,lookup,lookupM,lookupAll,
        lookupAndDelete,lookupAndDeleteM,lookupAndDeleteAll,
        lookupWithDefault,adjust,adjustAll,adjustOrInsert,adjustAllOrInsert,
        adjustOrDelete,adjustOrDeleteAll,strict,strictWith,
        map,fold,fold',fold1,fold1',filter,partition,elements,structuralInvariant,
    
        -- * OrdAssocX operations
        minView, minElem, deleteMin, unsafeInsertMin, maxView, maxElem, deleteMax,
        unsafeInsertMax, foldr, foldr', foldl, foldl', foldr1, foldr1',
        foldl1, foldl1', unsafeFromOrdSeq, unsafeAppend,
    

    foldl See 6 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
       lookupAndDeleteAll = lookupAndDeleteAll;
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
       adjustAllOrInsert = adjustAllOrInsert;
       adjustOrDelete = adjustOrDelete; adjustOrDeleteAll = adjustOrDeleteAll;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       filter = filter; partition = partition; elements = elements;
       strict = strict; strictWith = strictWith;
       structuralInvariant = structuralInvariant; instanceName _ = moduleName}
    
    instance Ord k => A.OrdAssocX (FM k) k where
      {minView = minView; minElem = minElem; deleteMin = deleteMin;
       unsafeInsertMin = unsafeInsertMin; maxView = maxView; maxElem = maxElem;
       deleteMax = deleteMax; unsafeInsertMax = unsafeInsertMax;
       foldr = foldr; foldr' = foldr'; foldl = foldl; foldl' = foldl';
       foldr1 = foldr1; foldr1' = foldr1'; foldl1 = foldl1; foldl1' = foldl1';
       unsafeFromOrdSeq = unsafeFromOrdSeq; unsafeAppend = unsafeAppend;
       filterLT = filterLT; filterGT = filterGT; filterLE = filterLE;
       filterGE = filterGE; partitionLT_GE = partitionLT_GE;
       partitionLE_GT = partitionLE_GT; partitionLT_GT = partitionLT_GT}
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
       lookupAndDeleteAll = lookupAndDeleteAll;
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
       adjustAllOrInsert = adjustAllOrInsert;
       adjustOrDelete = adjustOrDelete; adjustOrDeleteAll = adjustOrDeleteAll;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       filter = filter; partition = partition; elements = elements;
       strict = strict; strictWith = strictWith;
       structuralInvariant = structuralInvariant; instanceName _ = moduleName}
    
    instance Ord k => A.OrdAssocX (FM k) k where
      {minView = minView; minElem = minElem; deleteMin = deleteMin;
       unsafeInsertMin = unsafeInsertMin; maxView = maxView; maxElem = maxElem;
       deleteMax = deleteMax; unsafeInsertMax = unsafeInsertMax;
       foldr = foldr; foldr' = foldr'; foldl = foldl; foldl' = foldl';
       foldr1 = foldr1; foldr1' = foldr1'; foldl1 = foldl1; foldl1' = foldl1';
       unsafeFromOrdSeq = unsafeFromOrdSeq; unsafeAppend = unsafeAppend;
       filterLT = filterLT; filterGT = filterGT; filterLE = filterLE;
       filterGE = filterGE; partitionLT_GE = partitionLT_GE;
       partitionLE_GT = partitionLE_GT; partitionLT_GT = partitionLT_GT}
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    foldr  f z m = foldrFM  f z (mergeSortFM m)
    foldr' f z m = foldrFM' f z (mergeSortFM m)
    
    foldr1 f m =
      case mergeSortFM m of
        E -> error $ moduleName++".foldlr1: empty map"
        n -> foldr1FM f n
    
    foldr1' f m =
      case mergeSortFM m of
        E -> error $ moduleName++".foldlr1': empty map"
        n -> foldr1FM' f n
    
    foldl  f x m = foldlFM  f x (mergeSortFM m)
    foldl' f x m = foldlFM' f x (mergeSortFM m)
    
    foldl1 f m =
      case mergeSortFM m of
        E -> error $ moduleName++".foldl1: empty map"
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    unionSeqWithKey  :: (Eq k,S.Sequence seq) =>
                            (k -> a -> a -> a) -> seq (FM k a) -> FM k a
    intersectionWithKey :: Eq k => (k -> a -> b -> c) -> FM k a -> FM k b -> FM k c
    
    minView          :: (Ord k,Monad m) => FM k a -> m (a,FM k a)
    minElem          :: Ord k => FM k a -> a
    deleteMin        :: Ord k => FM k a -> FM k a
    unsafeInsertMin  :: Ord k => k -> a -> FM k a -> FM k a
    maxView          :: (Ord k,Monad m) => FM k a -> m (a,FM k a)
    maxElem          :: Ord k => FM k a -> a
    deleteMax        :: Ord k => FM k a -> FM k a
    unsafeInsertMax  :: Ord k => k -> a -> FM k a -> FM k a
    foldr            :: Ord k => (a -> b -> b) -> b -> FM k a -> b
    foldr1           :: Ord k => (a -> a -> a) -> FM k a -> a
    foldl            :: Ord k => (b -> a -> b) -> b -> FM k a -> b
    foldl1           :: Ord k => (a -> a -> a) -> FM k a -> a
    foldr'           :: Ord k => (a -> b -> b) -> b -> FM k a -> b
    foldr1'          :: Ord k => (a -> a -> a) -> FM k a -> a
    foldl'           :: Ord k => (b -> a -> b) -> b -> FM k a -> b
    foldl1'          :: Ord k => (a -> a -> a) -> FM k a -> a
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
        -- * FiniteMapX operations
        fromSeqWith,fromSeqWithKey,insertWith,insertWithKey,insertSeqWith,
        insertSeqWithKey,unionl,unionr,unionWith,unionSeqWith,intersectionWith,
        difference,properSubset,subset,properSubmapBy,submapBy,sameMapBy,
        properSubmap,submap,sameMap,
    
        -- * FiniteMap operations
        unionWithKey,unionSeqWithKey,intersectionWithKey,
    
        -- * Documentation
        moduleName
    ) where
    
    import Prelude hiding (null,map,lookup,foldr,foldl,foldr1,foldl1,filter)
    import qualified Prelude
    import Data.Monoid
    import Data.Semigroup as SG
    import Control.Monad.Identity
    import qualified Data.Edison.Assoc as A
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
        -- * Type of simple association lists
        FM, -- instance of Assoc(X), FiniteMap(X)
            -- also instance of Functor
    
        -- * AssocX operations
        empty,singleton,fromSeq,insert,insertSeq,union,unionSeq,delete,deleteAll,
        deleteSeq,null,size,member,count,lookup,lookupM,lookupAll,
        lookupAndDelete,lookupAndDeleteM,lookupAndDeleteAll,
        lookupWithDefault,adjust,adjustAll,adjustOrInsert,adjustAllOrInsert,
        adjustOrDelete,adjustOrDeleteAll,strict,strictWith,
        map,fold,fold',fold1,fold1',filter,partition,elements,structuralInvariant,
    
        -- * OrdAssocX operations
        minView, minElem, deleteMin, unsafeInsertMin, maxView, maxElem, deleteMax,
        unsafeInsertMax, foldr, foldr', foldl, foldl', foldr1, foldr1',
        foldl1, foldl1', unsafeFromOrdSeq, unsafeAppend,
        filterLT, filterLE, filterGT, filterGE,
        partitionLT_GE, partitionLE_GT, partitionLT_GT,
    
        -- * Assoc operations
    

    foldl' See 5 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
       lookupAndDeleteAll = lookupAndDeleteAll;
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
       adjustAllOrInsert = adjustAllOrInsert;
       adjustOrDelete = adjustOrDelete; adjustOrDeleteAll = adjustOrDeleteAll;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       filter = filter; partition = partition; elements = elements;
       strict = strict; strictWith = strictWith;
       structuralInvariant = structuralInvariant; instanceName _ = moduleName}
    
    instance Ord k => A.OrdAssocX (FM k) k where
      {minView = minView; minElem = minElem; deleteMin = deleteMin;
       unsafeInsertMin = unsafeInsertMin; maxView = maxView; maxElem = maxElem;
       deleteMax = deleteMax; unsafeInsertMax = unsafeInsertMax;
       foldr = foldr; foldr' = foldr'; foldl = foldl; foldl' = foldl';
       foldr1 = foldr1; foldr1' = foldr1'; foldl1 = foldl1; foldl1' = foldl1';
       unsafeFromOrdSeq = unsafeFromOrdSeq; unsafeAppend = unsafeAppend;
       filterLT = filterLT; filterGT = filterGT; filterLE = filterLE;
       filterGE = filterGE; partitionLT_GE = partitionLT_GE;
       partitionLE_GT = partitionLE_GT; partitionLT_GT = partitionLT_GT}
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
       lookupAndDeleteAll = lookupAndDeleteAll;
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
       adjustAllOrInsert = adjustAllOrInsert;
       adjustOrDelete = adjustOrDelete; adjustOrDeleteAll = adjustOrDeleteAll;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       filter = filter; partition = partition; elements = elements;
       strict = strict; strictWith = strictWith;
       structuralInvariant = structuralInvariant; instanceName _ = moduleName}
    
    instance Ord k => A.OrdAssocX (FM k) k where
      {minView = minView; minElem = minElem; deleteMin = deleteMin;
       unsafeInsertMin = unsafeInsertMin; maxView = maxView; maxElem = maxElem;
       deleteMax = deleteMax; unsafeInsertMax = unsafeInsertMax;
       foldr = foldr; foldr' = foldr'; foldl = foldl; foldl' = foldl';
       foldr1 = foldr1; foldr1' = foldr1'; foldl1 = foldl1; foldl1' = foldl1';
       unsafeFromOrdSeq = unsafeFromOrdSeq; unsafeAppend = unsafeAppend;
       filterLT = filterLT; filterGT = filterGT; filterLE = filterLE;
       filterGE = filterGE; partitionLT_GE = partitionLT_GE;
       partitionLE_GT = partitionLE_GT; partitionLT_GT = partitionLT_GT}
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    foldr  f z m = foldrFM  f z (mergeSortFM m)
    foldr' f z m = foldrFM' f z (mergeSortFM m)
    
    foldr1 f m =
      case mergeSortFM m of
        E -> error $ moduleName++".foldlr1: empty map"
        n -> foldr1FM f n
    
    foldr1' f m =
      case mergeSortFM m of
        E -> error $ moduleName++".foldlr1': empty map"
        n -> foldr1FM' f n
    
    foldl  f x m = foldlFM  f x (mergeSortFM m)
    foldl' f x m = foldlFM' f x (mergeSortFM m)
    
    foldl1 f m =
      case mergeSortFM m of
        E -> error $ moduleName++".foldl1: empty map"
        I k a n -> foldlFM f a (delete k n)
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    minView          :: (Ord k,Monad m) => FM k a -> m (a,FM k a)
    minElem          :: Ord k => FM k a -> a
    deleteMin        :: Ord k => FM k a -> FM k a
    unsafeInsertMin  :: Ord k => k -> a -> FM k a -> FM k a
    maxView          :: (Ord k,Monad m) => FM k a -> m (a,FM k a)
    maxElem          :: Ord k => FM k a -> a
    deleteMax        :: Ord k => FM k a -> FM k a
    unsafeInsertMax  :: Ord k => k -> a -> FM k a -> FM k a
    foldr            :: Ord k => (a -> b -> b) -> b -> FM k a -> b
    foldr1           :: Ord k => (a -> a -> a) -> FM k a -> a
    foldl            :: Ord k => (b -> a -> b) -> b -> FM k a -> b
    foldl1           :: Ord k => (a -> a -> a) -> FM k a -> a
    foldr'           :: Ord k => (a -> b -> b) -> b -> FM k a -> b
    foldr1'          :: Ord k => (a -> a -> a) -> FM k a -> a
    foldl'           :: Ord k => (b -> a -> b) -> b -> FM k a -> b
    foldl1'          :: Ord k => (a -> a -> a) -> FM k a -> a
    unsafeFromOrdSeq :: (Ord k,S.Sequence seq) => seq (k,a) -> FM k a
    unsafeAppend     :: Ord k => FM k a -> FM k a -> FM k a
    filterLT         :: Ord k => k -> FM k a -> FM k a
    filterLE         :: Ord k => k -> FM k a -> FM k a
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
        -- * Type of simple association lists
        FM, -- instance of Assoc(X), FiniteMap(X)
            -- also instance of Functor
    
        -- * AssocX operations
        empty,singleton,fromSeq,insert,insertSeq,union,unionSeq,delete,deleteAll,
        deleteSeq,null,size,member,count,lookup,lookupM,lookupAll,
        lookupAndDelete,lookupAndDeleteM,lookupAndDeleteAll,
        lookupWithDefault,adjust,adjustAll,adjustOrInsert,adjustAllOrInsert,
        adjustOrDelete,adjustOrDeleteAll,strict,strictWith,
        map,fold,fold',fold1,fold1',filter,partition,elements,structuralInvariant,
    
        -- * OrdAssocX operations
        minView, minElem, deleteMin, unsafeInsertMin, maxView, maxElem, deleteMax,
        unsafeInsertMax, foldr, foldr', foldl, foldl', foldr1, foldr1',
        foldl1, foldl1', unsafeFromOrdSeq, unsafeAppend,
        filterLT, filterLE, filterGT, filterGE,
        partitionLT_GE, partitionLE_GT, partitionLT_GT,
    
        -- * Assoc operations
    

    foldl1 See 6 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
       adjustAllOrInsert = adjustAllOrInsert;
       adjustOrDelete = adjustOrDelete; adjustOrDeleteAll = adjustOrDeleteAll;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       filter = filter; partition = partition; elements = elements;
       strict = strict; strictWith = strictWith;
       structuralInvariant = structuralInvariant; instanceName _ = moduleName}
    
    instance Ord k => A.OrdAssocX (FM k) k where
      {minView = minView; minElem = minElem; deleteMin = deleteMin;
       unsafeInsertMin = unsafeInsertMin; maxView = maxView; maxElem = maxElem;
       deleteMax = deleteMax; unsafeInsertMax = unsafeInsertMax;
       foldr = foldr; foldr' = foldr'; foldl = foldl; foldl' = foldl';
       foldr1 = foldr1; foldr1' = foldr1'; foldl1 = foldl1; foldl1' = foldl1';
       unsafeFromOrdSeq = unsafeFromOrdSeq; unsafeAppend = unsafeAppend;
       filterLT = filterLT; filterGT = filterGT; filterLE = filterLE;
       filterGE = filterGE; partitionLT_GE = partitionLT_GE;
       partitionLE_GT = partitionLE_GT; partitionLT_GT = partitionLT_GT}
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
       adjustAllOrInsert = adjustAllOrInsert;
       adjustOrDelete = adjustOrDelete; adjustOrDeleteAll = adjustOrDeleteAll;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       filter = filter; partition = partition; elements = elements;
       strict = strict; strictWith = strictWith;
       structuralInvariant = structuralInvariant; instanceName _ = moduleName}
    
    instance Ord k => A.OrdAssocX (FM k) k where
      {minView = minView; minElem = minElem; deleteMin = deleteMin;
       unsafeInsertMin = unsafeInsertMin; maxView = maxView; maxElem = maxElem;
       deleteMax = deleteMax; unsafeInsertMax = unsafeInsertMax;
       foldr = foldr; foldr' = foldr'; foldl = foldl; foldl' = foldl';
       foldr1 = foldr1; foldr1' = foldr1'; foldl1 = foldl1; foldl1' = foldl1';
       unsafeFromOrdSeq = unsafeFromOrdSeq; unsafeAppend = unsafeAppend;
       filterLT = filterLT; filterGT = filterGT; filterLE = filterLE;
       filterGE = filterGE; partitionLT_GE = partitionLT_GE;
       partitionLE_GT = partitionLE_GT; partitionLT_GT = partitionLT_GT}
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    foldr1 f m =
      case mergeSortFM m of
        E -> error $ moduleName++".foldlr1: empty map"
        n -> foldr1FM f n
    
    foldr1' f m =
      case mergeSortFM m of
        E -> error $ moduleName++".foldlr1': empty map"
        n -> foldr1FM' f n
    
    foldl  f x m = foldlFM  f x (mergeSortFM m)
    foldl' f x m = foldlFM' f x (mergeSortFM m)
    
    foldl1 f m =
      case mergeSortFM m of
        E -> error $ moduleName++".foldl1: empty map"
        I k a n -> foldlFM f a (delete k n)
    
    foldl1' f m =
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
                            (k -> a -> a -> a) -> seq (FM k a) -> FM k a
    intersectionWithKey :: Eq k => (k -> a -> b -> c) -> FM k a -> FM k b -> FM k c
    
    minView          :: (Ord k,Monad m) => FM k a -> m (a,FM k a)
    minElem          :: Ord k => FM k a -> a
    deleteMin        :: Ord k => FM k a -> FM k a
    unsafeInsertMin  :: Ord k => k -> a -> FM k a -> FM k a
    maxView          :: (Ord k,Monad m) => FM k a -> m (a,FM k a)
    maxElem          :: Ord k => FM k a -> a
    deleteMax        :: Ord k => FM k a -> FM k a
    unsafeInsertMax  :: Ord k => k -> a -> FM k a -> FM k a
    foldr            :: Ord k => (a -> b -> b) -> b -> FM k a -> b
    foldr1           :: Ord k => (a -> a -> a) -> FM k a -> a
    foldl            :: Ord k => (b -> a -> b) -> b -> FM k a -> b
    foldl1           :: Ord k => (a -> a -> a) -> FM k a -> a
    foldr'           :: Ord k => (a -> b -> b) -> b -> FM k a -> b
    foldr1'          :: Ord k => (a -> a -> a) -> FM k a -> a
    foldl'           :: Ord k => (b -> a -> b) -> b -> FM k a -> b
    foldl1'          :: Ord k => (a -> a -> a) -> FM k a -> a
    unsafeFromOrdSeq :: (Ord k,S.Sequence seq) => seq (k,a) -> FM k a
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
        -- * FiniteMapX operations
        fromSeqWith,fromSeqWithKey,insertWith,insertWithKey,insertSeqWith,
        insertSeqWithKey,unionl,unionr,unionWith,unionSeqWith,intersectionWith,
        difference,properSubset,subset,properSubmapBy,submapBy,sameMapBy,
        properSubmap,submap,sameMap,
    
        -- * FiniteMap operations
        unionWithKey,unionSeqWithKey,intersectionWithKey,
    
        -- * Documentation
        moduleName
    ) where
    
    import Prelude hiding (null,map,lookup,foldr,foldl,foldr1,foldl1,filter)
    import qualified Prelude
    import Data.Monoid
    import Data.Semigroup as SG
    import Control.Monad.Identity
    import qualified Data.Edison.Assoc as A
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
        FM, -- instance of Assoc(X), FiniteMap(X)
            -- also instance of Functor
    
        -- * AssocX operations
        empty,singleton,fromSeq,insert,insertSeq,union,unionSeq,delete,deleteAll,
        deleteSeq,null,size,member,count,lookup,lookupM,lookupAll,
        lookupAndDelete,lookupAndDeleteM,lookupAndDeleteAll,
        lookupWithDefault,adjust,adjustAll,adjustOrInsert,adjustAllOrInsert,
        adjustOrDelete,adjustOrDeleteAll,strict,strictWith,
        map,fold,fold',fold1,fold1',filter,partition,elements,structuralInvariant,
    
        -- * OrdAssocX operations
        minView, minElem, deleteMin, unsafeInsertMin, maxView, maxElem, deleteMax,
        unsafeInsertMax, foldr, foldr', foldl, foldl', foldr1, foldr1',
        foldl1, foldl1', unsafeFromOrdSeq, unsafeAppend,
        filterLT, filterLE, filterGT, filterGE,
        partitionLT_GE, partitionLE_GT, partitionLT_GT,
    
        -- * Assoc operations
        toSeq,keys,mapWithKey,foldWithKey,foldWithKey',filterWithKey,partitionWithKey,
    

    foldl1' See 5 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
       adjustAllOrInsert = adjustAllOrInsert;
       adjustOrDelete = adjustOrDelete; adjustOrDeleteAll = adjustOrDeleteAll;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       filter = filter; partition = partition; elements = elements;
       strict = strict; strictWith = strictWith;
       structuralInvariant = structuralInvariant; instanceName _ = moduleName}
    
    instance Ord k => A.OrdAssocX (FM k) k where
      {minView = minView; minElem = minElem; deleteMin = deleteMin;
       unsafeInsertMin = unsafeInsertMin; maxView = maxView; maxElem = maxElem;
       deleteMax = deleteMax; unsafeInsertMax = unsafeInsertMax;
       foldr = foldr; foldr' = foldr'; foldl = foldl; foldl' = foldl';
       foldr1 = foldr1; foldr1' = foldr1'; foldl1 = foldl1; foldl1' = foldl1';
       unsafeFromOrdSeq = unsafeFromOrdSeq; unsafeAppend = unsafeAppend;
       filterLT = filterLT; filterGT = filterGT; filterLE = filterLE;
       filterGE = filterGE; partitionLT_GE = partitionLT_GE;
       partitionLE_GT = partitionLE_GT; partitionLT_GT = partitionLT_GT}
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
       adjustAllOrInsert = adjustAllOrInsert;
       adjustOrDelete = adjustOrDelete; adjustOrDeleteAll = adjustOrDeleteAll;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       filter = filter; partition = partition; elements = elements;
       strict = strict; strictWith = strictWith;
       structuralInvariant = structuralInvariant; instanceName _ = moduleName}
    
    instance Ord k => A.OrdAssocX (FM k) k where
      {minView = minView; minElem = minElem; deleteMin = deleteMin;
       unsafeInsertMin = unsafeInsertMin; maxView = maxView; maxElem = maxElem;
       deleteMax = deleteMax; unsafeInsertMax = unsafeInsertMax;
       foldr = foldr; foldr' = foldr'; foldl = foldl; foldl' = foldl';
       foldr1 = foldr1; foldr1' = foldr1'; foldl1 = foldl1; foldl1' = foldl1';
       unsafeFromOrdSeq = unsafeFromOrdSeq; unsafeAppend = unsafeAppend;
       filterLT = filterLT; filterGT = filterGT; filterLE = filterLE;
       filterGE = filterGE; partitionLT_GE = partitionLT_GE;
       partitionLE_GT = partitionLE_GT; partitionLT_GT = partitionLT_GT}
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    foldr1' f m =
      case mergeSortFM m of
        E -> error $ moduleName++".foldlr1': empty map"
        n -> foldr1FM' f n
    
    foldl  f x m = foldlFM  f x (mergeSortFM m)
    foldl' f x m = foldlFM' f x (mergeSortFM m)
    
    foldl1 f m =
      case mergeSortFM m of
        E -> error $ moduleName++".foldl1: empty map"
        I k a n -> foldlFM f a (delete k n)
    
    foldl1' f m =
      case mergeSortFM m of
        E -> error $ moduleName++".foldl1': empty map"
        I k a n -> foldlFM' f a (delete k n)
    
    unsafeFromOrdSeq   = fromSeq
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    minElem          :: Ord k => FM k a -> a
    deleteMin        :: Ord k => FM k a -> FM k a
    unsafeInsertMin  :: Ord k => k -> a -> FM k a -> FM k a
    maxView          :: (Ord k,Monad m) => FM k a -> m (a,FM k a)
    maxElem          :: Ord k => FM k a -> a
    deleteMax        :: Ord k => FM k a -> FM k a
    unsafeInsertMax  :: Ord k => k -> a -> FM k a -> FM k a
    foldr            :: Ord k => (a -> b -> b) -> b -> FM k a -> b
    foldr1           :: Ord k => (a -> a -> a) -> FM k a -> a
    foldl            :: Ord k => (b -> a -> b) -> b -> FM k a -> b
    foldl1           :: Ord k => (a -> a -> a) -> FM k a -> a
    foldr'           :: Ord k => (a -> b -> b) -> b -> FM k a -> b
    foldr1'          :: Ord k => (a -> a -> a) -> FM k a -> a
    foldl'           :: Ord k => (b -> a -> b) -> b -> FM k a -> b
    foldl1'          :: Ord k => (a -> a -> a) -> FM k a -> a
    unsafeFromOrdSeq :: (Ord k,S.Sequence seq) => seq (k,a) -> FM k a
    unsafeAppend     :: Ord k => FM k a -> FM k a -> FM k a
    filterLT         :: Ord k => k -> FM k a -> FM k a
    filterLE         :: Ord k => k -> FM k a -> FM k a
    filterGT         :: Ord k => k -> FM k a -> FM k a
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
        FM, -- instance of Assoc(X), FiniteMap(X)
            -- also instance of Functor
    
        -- * AssocX operations
        empty,singleton,fromSeq,insert,insertSeq,union,unionSeq,delete,deleteAll,
        deleteSeq,null,size,member,count,lookup,lookupM,lookupAll,
        lookupAndDelete,lookupAndDeleteM,lookupAndDeleteAll,
        lookupWithDefault,adjust,adjustAll,adjustOrInsert,adjustAllOrInsert,
        adjustOrDelete,adjustOrDeleteAll,strict,strictWith,
        map,fold,fold',fold1,fold1',filter,partition,elements,structuralInvariant,
    
        -- * OrdAssocX operations
        minView, minElem, deleteMin, unsafeInsertMin, maxView, maxElem, deleteMax,
        unsafeInsertMax, foldr, foldr', foldl, foldl', foldr1, foldr1',
        foldl1, foldl1', unsafeFromOrdSeq, unsafeAppend,
        filterLT, filterLE, filterGT, filterGE,
        partitionLT_GE, partitionLE_GT, partitionLT_GT,
    
        -- * Assoc operations
        toSeq,keys,mapWithKey,foldWithKey,foldWithKey',filterWithKey,partitionWithKey,
    

    foldlWithIndex No usage example found for this symbol :( Collapse [-]
    foldlWithIndex' No usage example found for this symbol :( Collapse [-]
    foldr See 10 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    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)
    
    instance (Eq k,CoArbitrary k,CoArbitrary a) => CoArbitrary (FM k a) where
       coarbitrary E = variant 0
       coarbitrary (I k a m) = variant 1 . coarbitrary k
                             . coarbitrary a . coarbitrary m
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
       lookupAndDeleteAll = lookupAndDeleteAll;
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
       adjustAllOrInsert = adjustAllOrInsert;
       adjustOrDelete = adjustOrDelete; adjustOrDeleteAll = adjustOrDeleteAll;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       filter = filter; partition = partition; elements = elements;
       strict = strict; strictWith = strictWith;
       structuralInvariant = structuralInvariant; instanceName _ = moduleName}
    
    instance Ord k => A.OrdAssocX (FM k) k where
      {minView = minView; minElem = minElem; deleteMin = deleteMin;
       unsafeInsertMin = unsafeInsertMin; maxView = maxView; maxElem = maxElem;
       deleteMax = deleteMax; unsafeInsertMax = unsafeInsertMax;
       foldr = foldr; foldr' = foldr'; foldl = foldl; foldl' = foldl';
       foldr1 = foldr1; foldr1' = foldr1'; foldl1 = foldl1; foldl1' = foldl1';
       unsafeFromOrdSeq = unsafeFromOrdSeq; unsafeAppend = unsafeAppend;
       filterLT = filterLT; filterGT = filterGT; filterLE = filterLE;
       filterGE = filterGE; partitionLT_GE = partitionLT_GE;
       partitionLE_GT = partitionLE_GT; partitionLT_GT = partitionLT_GT}
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
       lookupAndDeleteAll = lookupAndDeleteAll;
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
       adjustAllOrInsert = adjustAllOrInsert;
       adjustOrDelete = adjustOrDelete; adjustOrDeleteAll = adjustOrDeleteAll;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       filter = filter; partition = partition; elements = elements;
       strict = strict; strictWith = strictWith;
       structuralInvariant = structuralInvariant; instanceName _ = moduleName}
    
    instance Ord k => A.OrdAssocX (FM k) k where
      {minView = minView; minElem = minElem; deleteMin = deleteMin;
       unsafeInsertMin = unsafeInsertMin; maxView = maxView; maxElem = maxElem;
       deleteMax = deleteMax; unsafeInsertMax = unsafeInsertMax;
       foldr = foldr; foldr' = foldr'; foldl = foldl; foldl' = foldl';
       foldr1 = foldr1; foldr1' = foldr1'; foldl1 = foldl1; foldl1' = foldl1';
       unsafeFromOrdSeq = unsafeFromOrdSeq; unsafeAppend = unsafeAppend;
       filterLT = filterLT; filterGT = filterGT; filterLE = filterLE;
       filterGE = filterGE; partitionLT_GE = partitionLT_GE;
       partitionLE_GT = partitionLE_GT; partitionLT_GT = partitionLT_GT}
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    unsafeInsertMin  = insert
    
    maxView E = fail (moduleName++".maxView: empty map")
    maxView n@(I k a m) = let (k',x) = findMax k a m in return (x,delete k' n)
    
    maxElem E = error (moduleName++".maxElem: empty map")
    maxElem (I k a m) = let (_,x) = findMax k a m in x
    
    deleteMax E = error (moduleName++".deleteMax: empty map")
    deleteMax n@(I k a m) = let (k',_) = findMax k a m in delete k' n
    
    unsafeInsertMax = insert
    
    foldr  f z m = foldrFM  f z (mergeSortFM m)
    foldr' f z m = foldrFM' f z (mergeSortFM m)
    
    foldr1 f m =
      case mergeSortFM m of
        E -> error $ moduleName++".foldlr1: empty map"
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    ---------------------------------------------------
    -- interface functions
    
    empty = E
    singleton k x = I k x E
    insert = I
    insertSeq kxs m = S.foldr uinsert m kxs
    fromSeq = S.foldr uinsert E
    
    union m E = m
    union E m = m
    union (I k x m1) m2 = I k x (union m1 m2)
    
    unionSeq = S.foldr union E
    
    deleteAll _ E = E
    deleteAll key (I k x m) | key == k  = deleteAll key m
                            | otherwise = I k x (deleteAll key m)
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    spanFM :: (k -> Bool) -> FM k a -> (FM k a,FM k a)
    spanFM _ E = (E,E)
    spanFM p o@(I k a m)
       | p k       = let (x,y) = spanFM p m in (I k a x,y)
       | otherwise = (E,o)
    
    
    ---------------------------------------------------
    -- interface functions
    
    empty = E
    singleton k x = I k x E
    insert = I
    insertSeq kxs m = S.foldr uinsert m kxs
    fromSeq = S.foldr uinsert E
    
    union m E = m
    union E m = m
    union (I k x m1) m2 = I k x (union m1 m2)
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    spanFM :: (k -> Bool) -> FM k a -> (FM k a,FM k a)
    spanFM _ E = (E,E)
    spanFM p o@(I k a m)
       | p k       = let (x,y) = spanFM p m in (I k a x,y)
       | otherwise = (E,o)
    
    
    ---------------------------------------------------
    -- interface functions
    
    empty = E
    singleton k x = I k x E
    insert = I
    insertSeq kxs m = S.foldr uinsert m kxs
    fromSeq = S.foldr uinsert E
    
    union m E = m
    union E m = m
    union (I k x m1) m2 = I k x (union m1 m2)
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    unionWithKey     :: Eq k => (k -> a -> a -> a) -> FM k a -> FM k a -> FM k a
    unionSeqWithKey  :: (Eq k,S.Sequence seq) =>
                            (k -> a -> a -> a) -> seq (FM k a) -> FM k a
    intersectionWithKey :: Eq k => (k -> a -> b -> c) -> FM k a -> FM k b -> FM k c
    
    minView          :: (Ord k,Monad m) => FM k a -> m (a,FM k a)
    minElem          :: Ord k => FM k a -> a
    deleteMin        :: Ord k => FM k a -> FM k a
    unsafeInsertMin  :: Ord k => k -> a -> FM k a -> FM k a
    maxView          :: (Ord k,Monad m) => FM k a -> m (a,FM k a)
    maxElem          :: Ord k => FM k a -> a
    deleteMax        :: Ord k => FM k a -> FM k a
    unsafeInsertMax  :: Ord k => k -> a -> FM k a -> FM k a
    foldr            :: Ord k => (a -> b -> b) -> b -> FM k a -> b
    foldr1           :: Ord k => (a -> a -> a) -> FM k a -> a
    foldl            :: Ord k => (b -> a -> b) -> b -> FM k a -> b
    foldl1           :: Ord k => (a -> a -> a) -> FM k a -> a
    foldr'           :: Ord k => (a -> b -> b) -> b -> FM k a -> b
    foldr1'          :: Ord k => (a -> a -> a) -> FM k a -> a
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
        -- * FiniteMapX operations
        fromSeqWith,fromSeqWithKey,insertWith,insertWithKey,insertSeqWith,
        insertSeqWithKey,unionl,unionr,unionWith,unionSeqWith,intersectionWith,
        difference,properSubset,subset,properSubmapBy,submapBy,sameMapBy,
        properSubmap,submap,sameMap,
    
        -- * FiniteMap operations
        unionWithKey,unionSeqWithKey,intersectionWithKey,
    
        -- * Documentation
        moduleName
    ) where
    
    import Prelude hiding (null,map,lookup,foldr,foldl,foldr1,foldl1,filter)
    import qualified Prelude
    import Data.Monoid
    import Data.Semigroup as SG
    import Control.Monad.Identity
    import qualified Data.Edison.Assoc as A
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
        -- * Type of simple association lists
        FM, -- instance of Assoc(X), FiniteMap(X)
            -- also instance of Functor
    
        -- * AssocX operations
        empty,singleton,fromSeq,insert,insertSeq,union,unionSeq,delete,deleteAll,
        deleteSeq,null,size,member,count,lookup,lookupM,lookupAll,
        lookupAndDelete,lookupAndDeleteM,lookupAndDeleteAll,
        lookupWithDefault,adjust,adjustAll,adjustOrInsert,adjustAllOrInsert,
        adjustOrDelete,adjustOrDeleteAll,strict,strictWith,
        map,fold,fold',fold1,fold1',filter,partition,elements,structuralInvariant,
    
        -- * OrdAssocX operations
        minView, minElem, deleteMin, unsafeInsertMin, maxView, maxElem, deleteMax,
        unsafeInsertMax, foldr, foldr', foldl, foldl', foldr1, foldr1',
        foldl1, foldl1', unsafeFromOrdSeq, unsafeAppend,
        filterLT, filterLE, filterGT, filterGE,
        partitionLT_GE, partitionLE_GT, partitionLT_GT,
    
        -- * Assoc operations
    

    foldr' See 5 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
       lookupAndDeleteAll = lookupAndDeleteAll;
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
       adjustAllOrInsert = adjustAllOrInsert;
       adjustOrDelete = adjustOrDelete; adjustOrDeleteAll = adjustOrDeleteAll;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       filter = filter; partition = partition; elements = elements;
       strict = strict; strictWith = strictWith;
       structuralInvariant = structuralInvariant; instanceName _ = moduleName}
    
    instance Ord k => A.OrdAssocX (FM k) k where
      {minView = minView; minElem = minElem; deleteMin = deleteMin;
       unsafeInsertMin = unsafeInsertMin; maxView = maxView; maxElem = maxElem;
       deleteMax = deleteMax; unsafeInsertMax = unsafeInsertMax;
       foldr = foldr; foldr' = foldr'; foldl = foldl; foldl' = foldl';
       foldr1 = foldr1; foldr1' = foldr1'; foldl1 = foldl1; foldl1' = foldl1';
       unsafeFromOrdSeq = unsafeFromOrdSeq; unsafeAppend = unsafeAppend;
       filterLT = filterLT; filterGT = filterGT; filterLE = filterLE;
       filterGE = filterGE; partitionLT_GE = partitionLT_GE;
       partitionLE_GT = partitionLE_GT; partitionLT_GT = partitionLT_GT}
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
       lookupAndDeleteAll = lookupAndDeleteAll;
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
       adjustAllOrInsert = adjustAllOrInsert;
       adjustOrDelete = adjustOrDelete; adjustOrDeleteAll = adjustOrDeleteAll;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       filter = filter; partition = partition; elements = elements;
       strict = strict; strictWith = strictWith;
       structuralInvariant = structuralInvariant; instanceName _ = moduleName}
    
    instance Ord k => A.OrdAssocX (FM k) k where
      {minView = minView; minElem = minElem; deleteMin = deleteMin;
       unsafeInsertMin = unsafeInsertMin; maxView = maxView; maxElem = maxElem;
       deleteMax = deleteMax; unsafeInsertMax = unsafeInsertMax;
       foldr = foldr; foldr' = foldr'; foldl = foldl; foldl' = foldl';
       foldr1 = foldr1; foldr1' = foldr1'; foldl1 = foldl1; foldl1' = foldl1';
       unsafeFromOrdSeq = unsafeFromOrdSeq; unsafeAppend = unsafeAppend;
       filterLT = filterLT; filterGT = filterGT; filterLE = filterLE;
       filterGE = filterGE; partitionLT_GE = partitionLT_GE;
       partitionLE_GT = partitionLE_GT; partitionLT_GT = partitionLT_GT}
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    unsafeInsertMin  = insert
    
    maxView E = fail (moduleName++".maxView: empty map")
    maxView n@(I k a m) = let (k',x) = findMax k a m in return (x,delete k' n)
    
    maxElem E = error (moduleName++".maxElem: empty map")
    maxElem (I k a m) = let (_,x) = findMax k a m in x
    
    deleteMax E = error (moduleName++".deleteMax: empty map")
    deleteMax n@(I k a m) = let (k',_) = findMax k a m in delete k' n
    
    unsafeInsertMax = insert
    
    foldr  f z m = foldrFM  f z (mergeSortFM m)
    foldr' f z m = foldrFM' f z (mergeSortFM m)
    
    foldr1 f m =
      case mergeSortFM m of
        E -> error $ moduleName++".foldlr1: empty map"
        n -> foldr1FM f n
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    intersectionWithKey :: Eq k => (k -> a -> b -> c) -> FM k a -> FM k b -> FM k c
    
    minView          :: (Ord k,Monad m) => FM k a -> m (a,FM k a)
    minElem          :: Ord k => FM k a -> a
    deleteMin        :: Ord k => FM k a -> FM k a
    unsafeInsertMin  :: Ord k => k -> a -> FM k a -> FM k a
    maxView          :: (Ord k,Monad m) => FM k a -> m (a,FM k a)
    maxElem          :: Ord k => FM k a -> a
    deleteMax        :: Ord k => FM k a -> FM k a
    unsafeInsertMax  :: Ord k => k -> a -> FM k a -> FM k a
    foldr            :: Ord k => (a -> b -> b) -> b -> FM k a -> b
    foldr1           :: Ord k => (a -> a -> a) -> FM k a -> a
    foldl            :: Ord k => (b -> a -> b) -> b -> FM k a -> b
    foldl1           :: Ord k => (a -> a -> a) -> FM k a -> a
    foldr'           :: Ord k => (a -> b -> b) -> b -> FM k a -> b
    foldr1'          :: Ord k => (a -> a -> a) -> FM k a -> a
    foldl'           :: Ord k => (b -> a -> b) -> b -> FM k a -> b
    foldl1'          :: Ord k => (a -> a -> a) -> FM k a -> a
    unsafeFromOrdSeq :: (Ord k,S.Sequence seq) => seq (k,a) -> FM k a
    unsafeAppend     :: Ord k => FM k a -> FM k a -> FM k a
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
        -- * Type of simple association lists
        FM, -- instance of Assoc(X), FiniteMap(X)
            -- also instance of Functor
    
        -- * AssocX operations
        empty,singleton,fromSeq,insert,insertSeq,union,unionSeq,delete,deleteAll,
        deleteSeq,null,size,member,count,lookup,lookupM,lookupAll,
        lookupAndDelete,lookupAndDeleteM,lookupAndDeleteAll,
        lookupWithDefault,adjust,adjustAll,adjustOrInsert,adjustAllOrInsert,
        adjustOrDelete,adjustOrDeleteAll,strict,strictWith,
        map,fold,fold',fold1,fold1',filter,partition,elements,structuralInvariant,
    
        -- * OrdAssocX operations
        minView, minElem, deleteMin, unsafeInsertMin, maxView, maxElem, deleteMax,
        unsafeInsertMax, foldr, foldr', foldl, foldl', foldr1, foldr1',
        foldl1, foldl1', unsafeFromOrdSeq, unsafeAppend,
        filterLT, filterLE, filterGT, filterGE,
        partitionLT_GE, partitionLE_GT, partitionLT_GT,
    
        -- * Assoc operations
    

    foldr1 See 6 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
       adjustAllOrInsert = adjustAllOrInsert;
       adjustOrDelete = adjustOrDelete; adjustOrDeleteAll = adjustOrDeleteAll;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       filter = filter; partition = partition; elements = elements;
       strict = strict; strictWith = strictWith;
       structuralInvariant = structuralInvariant; instanceName _ = moduleName}
    
    instance Ord k => A.OrdAssocX (FM k) k where
      {minView = minView; minElem = minElem; deleteMin = deleteMin;
       unsafeInsertMin = unsafeInsertMin; maxView = maxView; maxElem = maxElem;
       deleteMax = deleteMax; unsafeInsertMax = unsafeInsertMax;
       foldr = foldr; foldr' = foldr'; foldl = foldl; foldl' = foldl';
       foldr1 = foldr1; foldr1' = foldr1'; foldl1 = foldl1; foldl1' = foldl1';
       unsafeFromOrdSeq = unsafeFromOrdSeq; unsafeAppend = unsafeAppend;
       filterLT = filterLT; filterGT = filterGT; filterLE = filterLE;
       filterGE = filterGE; partitionLT_GE = partitionLT_GE;
       partitionLE_GT = partitionLE_GT; partitionLT_GT = partitionLT_GT}
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
       adjustAllOrInsert = adjustAllOrInsert;
       adjustOrDelete = adjustOrDelete; adjustOrDeleteAll = adjustOrDeleteAll;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       filter = filter; partition = partition; elements = elements;
       strict = strict; strictWith = strictWith;
       structuralInvariant = structuralInvariant; instanceName _ = moduleName}
    
    instance Ord k => A.OrdAssocX (FM k) k where
      {minView = minView; minElem = minElem; deleteMin = deleteMin;
       unsafeInsertMin = unsafeInsertMin; maxView = maxView; maxElem = maxElem;
       deleteMax = deleteMax; unsafeInsertMax = unsafeInsertMax;
       foldr = foldr; foldr' = foldr'; foldl = foldl; foldl' = foldl';
       foldr1 = foldr1; foldr1' = foldr1'; foldl1 = foldl1; foldl1' = foldl1';
       unsafeFromOrdSeq = unsafeFromOrdSeq; unsafeAppend = unsafeAppend;
       filterLT = filterLT; filterGT = filterGT; filterLE = filterLE;
       filterGE = filterGE; partitionLT_GE = partitionLT_GE;
       partitionLE_GT = partitionLE_GT; partitionLT_GT = partitionLT_GT}
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    maxView E = fail (moduleName++".maxView: empty map")
    maxView n@(I k a m) = let (k',x) = findMax k a m in return (x,delete k' n)
    
    maxElem E = error (moduleName++".maxElem: empty map")
    maxElem (I k a m) = let (_,x) = findMax k a m in x
    
    deleteMax E = error (moduleName++".deleteMax: empty map")
    deleteMax n@(I k a m) = let (k',_) = findMax k a m in delete k' n
    
    unsafeInsertMax = insert
    
    foldr  f z m = foldrFM  f z (mergeSortFM m)
    foldr' f z m = foldrFM' f z (mergeSortFM m)
    
    foldr1 f m =
      case mergeSortFM m of
        E -> error $ moduleName++".foldlr1: empty map"
        n -> foldr1FM f n
    
    foldr1' f m =
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    unionWithKey     :: Eq k => (k -> a -> a -> a) -> FM k a -> FM k a -> FM k a
    unionSeqWithKey  :: (Eq k,S.Sequence seq) =>
                            (k -> a -> a -> a) -> seq (FM k a) -> FM k a
    intersectionWithKey :: Eq k => (k -> a -> b -> c) -> FM k a -> FM k b -> FM k c
    
    minView          :: (Ord k,Monad m) => FM k a -> m (a,FM k a)
    minElem          :: Ord k => FM k a -> a
    deleteMin        :: Ord k => FM k a -> FM k a
    unsafeInsertMin  :: Ord k => k -> a -> FM k a -> FM k a
    maxView          :: (Ord k,Monad m) => FM k a -> m (a,FM k a)
    maxElem          :: Ord k => FM k a -> a
    deleteMax        :: Ord k => FM k a -> FM k a
    unsafeInsertMax  :: Ord k => k -> a -> FM k a -> FM k a
    foldr            :: Ord k => (a -> b -> b) -> b -> FM k a -> b
    foldr1           :: Ord k => (a -> a -> a) -> FM k a -> a
    foldl            :: Ord k => (b -> a -> b) -> b -> FM k a -> b
    foldl1           :: Ord k => (a -> a -> a) -> FM k a -> a
    foldr'           :: Ord k => (a -> b -> b) -> b -> FM k a -> b
    foldr1'          :: Ord k => (a -> a -> a) -> FM k a -> a
    foldl'           :: Ord k => (b -> a -> b) -> b -> FM k a -> b
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
        -- * FiniteMapX operations
        fromSeqWith,fromSeqWithKey,insertWith,insertWithKey,insertSeqWith,
        insertSeqWithKey,unionl,unionr,unionWith,unionSeqWith,intersectionWith,
        difference,properSubset,subset,properSubmapBy,submapBy,sameMapBy,
        properSubmap,submap,sameMap,
    
        -- * FiniteMap operations
        unionWithKey,unionSeqWithKey,intersectionWithKey,
    
        -- * Documentation
        moduleName
    ) where
    
    import Prelude hiding (null,map,lookup,foldr,foldl,foldr1,foldl1,filter)
    import qualified Prelude
    import Data.Monoid
    import Data.Semigroup as SG
    import Control.Monad.Identity
    import qualified Data.Edison.Assoc as A
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
        -- * Type of simple association lists
        FM, -- instance of Assoc(X), FiniteMap(X)
            -- also instance of Functor
    
        -- * AssocX operations
        empty,singleton,fromSeq,insert,insertSeq,union,unionSeq,delete,deleteAll,
        deleteSeq,null,size,member,count,lookup,lookupM,lookupAll,
        lookupAndDelete,lookupAndDeleteM,lookupAndDeleteAll,
        lookupWithDefault,adjust,adjustAll,adjustOrInsert,adjustAllOrInsert,
        adjustOrDelete,adjustOrDeleteAll,strict,strictWith,
        map,fold,fold',fold1,fold1',filter,partition,elements,structuralInvariant,
    
        -- * OrdAssocX operations
        minView, minElem, deleteMin, unsafeInsertMin, maxView, maxElem, deleteMax,
        unsafeInsertMax, foldr, foldr', foldl, foldl', foldr1, foldr1',
        foldl1, foldl1', unsafeFromOrdSeq, unsafeAppend,
        filterLT, filterLE, filterGT, filterGE,
        partitionLT_GE, partitionLE_GT, partitionLT_GT,
    
        -- * Assoc operations
    

    foldr1' See 5 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
       adjustAllOrInsert = adjustAllOrInsert;
       adjustOrDelete = adjustOrDelete; adjustOrDeleteAll = adjustOrDeleteAll;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       filter = filter; partition = partition; elements = elements;
       strict = strict; strictWith = strictWith;
       structuralInvariant = structuralInvariant; instanceName _ = moduleName}
    
    instance Ord k => A.OrdAssocX (FM k) k where
      {minView = minView; minElem = minElem; deleteMin = deleteMin;
       unsafeInsertMin = unsafeInsertMin; maxView = maxView; maxElem = maxElem;
       deleteMax = deleteMax; unsafeInsertMax = unsafeInsertMax;
       foldr = foldr; foldr' = foldr'; foldl = foldl; foldl' = foldl';
       foldr1 = foldr1; foldr1' = foldr1'; foldl1 = foldl1; foldl1' = foldl1';
       unsafeFromOrdSeq = unsafeFromOrdSeq; unsafeAppend = unsafeAppend;
       filterLT = filterLT; filterGT = filterGT; filterLE = filterLE;
       filterGE = filterGE; partitionLT_GE = partitionLT_GE;
       partitionLE_GT = partitionLE_GT; partitionLT_GT = partitionLT_GT}
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
       adjustAllOrInsert = adjustAllOrInsert;
       adjustOrDelete = adjustOrDelete; adjustOrDeleteAll = adjustOrDeleteAll;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       filter = filter; partition = partition; elements = elements;
       strict = strict; strictWith = strictWith;
       structuralInvariant = structuralInvariant; instanceName _ = moduleName}
    
    instance Ord k => A.OrdAssocX (FM k) k where
      {minView = minView; minElem = minElem; deleteMin = deleteMin;
       unsafeInsertMin = unsafeInsertMin; maxView = maxView; maxElem = maxElem;
       deleteMax = deleteMax; unsafeInsertMax = unsafeInsertMax;
       foldr = foldr; foldr' = foldr'; foldl = foldl; foldl' = foldl';
       foldr1 = foldr1; foldr1' = foldr1'; foldl1 = foldl1; foldl1' = foldl1';
       unsafeFromOrdSeq = unsafeFromOrdSeq; unsafeAppend = unsafeAppend;
       filterLT = filterLT; filterGT = filterGT; filterLE = filterLE;
       filterGE = filterGE; partitionLT_GE = partitionLT_GE;
       partitionLE_GT = partitionLE_GT; partitionLT_GT = partitionLT_GT}
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    deleteMax E = error (moduleName++".deleteMax: empty map")
    deleteMax n@(I k a m) = let (k',_) = findMax k a m in delete k' n
    
    unsafeInsertMax = insert
    
    foldr  f z m = foldrFM  f z (mergeSortFM m)
    foldr' f z m = foldrFM' f z (mergeSortFM m)
    
    foldr1 f m =
      case mergeSortFM m of
        E -> error $ moduleName++".foldlr1: empty map"
        n -> foldr1FM f n
    
    foldr1' f m =
      case mergeSortFM m of
        E -> error $ moduleName++".foldlr1': empty map"
        n -> foldr1FM' f n
    
    foldl  f x m = foldlFM  f x (mergeSortFM m)
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    minView          :: (Ord k,Monad m) => FM k a -> m (a,FM k a)
    minElem          :: Ord k => FM k a -> a
    deleteMin        :: Ord k => FM k a -> FM k a
    unsafeInsertMin  :: Ord k => k -> a -> FM k a -> FM k a
    maxView          :: (Ord k,Monad m) => FM k a -> m (a,FM k a)
    maxElem          :: Ord k => FM k a -> a
    deleteMax        :: Ord k => FM k a -> FM k a
    unsafeInsertMax  :: Ord k => k -> a -> FM k a -> FM k a
    foldr            :: Ord k => (a -> b -> b) -> b -> FM k a -> b
    foldr1           :: Ord k => (a -> a -> a) -> FM k a -> a
    foldl            :: Ord k => (b -> a -> b) -> b -> FM k a -> b
    foldl1           :: Ord k => (a -> a -> a) -> FM k a -> a
    foldr'           :: Ord k => (a -> b -> b) -> b -> FM k a -> b
    foldr1'          :: Ord k => (a -> a -> a) -> FM k a -> a
    foldl'           :: Ord k => (b -> a -> b) -> b -> FM k a -> b
    foldl1'          :: Ord k => (a -> a -> a) -> FM k a -> a
    unsafeFromOrdSeq :: (Ord k,S.Sequence seq) => seq (k,a) -> FM k a
    unsafeAppend     :: Ord k => FM k a -> FM k a -> FM k a
    filterLT         :: Ord k => k -> FM k a -> FM k a
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
        -- * Type of simple association lists
        FM, -- instance of Assoc(X), FiniteMap(X)
            -- also instance of Functor
    
        -- * AssocX operations
        empty,singleton,fromSeq,insert,insertSeq,union,unionSeq,delete,deleteAll,
        deleteSeq,null,size,member,count,lookup,lookupM,lookupAll,
        lookupAndDelete,lookupAndDeleteM,lookupAndDeleteAll,
        lookupWithDefault,adjust,adjustAll,adjustOrInsert,adjustAllOrInsert,
        adjustOrDelete,adjustOrDeleteAll,strict,strictWith,
        map,fold,fold',fold1,fold1',filter,partition,elements,structuralInvariant,
    
        -- * OrdAssocX operations
        minView, minElem, deleteMin, unsafeInsertMin, maxView, maxElem, deleteMax,
        unsafeInsertMax, foldr, foldr', foldl, foldl', foldr1, foldr1',
        foldl1, foldl1', unsafeFromOrdSeq, unsafeAppend,
        filterLT, filterLE, filterGT, filterGE,
        partitionLT_GE, partitionLE_GT, partitionLT_GT,
    
        -- * Assoc operations
    

    foldrWithIndex No usage example found for this symbol :( Collapse [-]
    foldrWithIndex' No usage example found for this symbol :( Collapse [-]
    fromList No usage example found for this symbol :( Collapse [-]
    inBounds No usage example found for this symbol :( Collapse [-]
    lcons See 4 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    filter p (I k x m) | p x = I k x (filter p (delete k m))
                       | otherwise = filter p (delete k m)
    
    partition _ E = (E, E)
    partition p (I k x m)
        | p x       = (I k x m1,m2)
        | otherwise = (m1,I k x m2)
      where (m1,m2) = partition p (delete k m)
    
    
    toSeq E = S.empty
    toSeq (I k x m) = S.lcons (k,x) (toSeq (delete k m))
    
    keys E = S.empty
    keys (I k _ m) = S.lcons k (keys (delete k m))
    
    mapWithKey _ E = E
    mapWithKey f (I k x m) = I k (f k x) (mapWithKey f m)
    
    foldWithKey _ c E = c
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    fold1' f (I k x m) = fold' f x (delete k m)
    
    filter _ E = E
    filter p (I k x m) | p x = I k x (filter p (delete k m))
                       | otherwise = filter p (delete k m)
    
    partition _ E = (E, E)
    partition p (I k x m)
        | p x       = (I k x m1,m2)
        | otherwise = (m1,I k x m2)
      where (m1,m2) = partition p (delete k m)
    
    
    toSeq E = S.empty
    toSeq (I k x m) = S.lcons (k,x) (toSeq (delete k m))
    
    keys E = S.empty
    keys (I k _ m) = S.lcons k (keys (delete k m))
    
    mapWithKey _ E = E
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
       | otherwise = lookupAndDeleteM key m >>=
                        \ (z, m') -> return (z, I k x m')
    
    lookupAndDeleteAll key m =
       case lookupAndDeleteM key m of
          Nothing     -> (S.empty,m)
          Just (z,m') -> (S.singleton z,m')
    
    
    lookupWithDefault d _ E = d
    lookupWithDefault d key (I k x m) | key == k = x
                                      | otherwise = lookupWithDefault d key m
    
    elements E = S.empty
    elements (I k x m) = S.lcons x (elements (delete k m))
    
    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)
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    -- left biased merge.
    mergeFM :: (Ord t) => FM t t1 -> FM t t1 -> FM t t1
    mergeFM E m = m
    mergeFM m E = m
    mergeFM o1@(I k1 a1 m1) o2@(I k2 a2 m2) =
      case compare k1 k2 of
          LT -> I k1 a1 (mergeFM m1 o2)
          GT -> I k2 a2 (mergeFM o1 m2)
          EQ -> I k1 a1 (mergeFM m1 m2)
    
    toRandList :: FM t t1 -> RL.Seq (FM t t1)
    toRandList E = RL.empty
    toRandList (I k a m) = RL.lcons (I k a E) (toRandList m)
    
    mergeSortFM :: (Ord t) => FM t t1 -> FM t t1
    mergeSortFM m = RL.reducer mergeFM E (toRandList m)
    
    foldrFM :: Eq k => (a -> b -> b) -> b -> FM k a -> b
    

    lhead No usage example found for this symbol :( Collapse [-]
    lheadM No usage example found for this symbol :( Collapse [-]
    lookup See 6 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    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;
       insertSeq = insertSeq; union = union; unionSeq = unionSeq;
       delete = delete; deleteAll = deleteAll; deleteSeq = deleteSeq;
       null = null; size = size; member = member; count = count;
       lookup = lookup; lookupM = lookupM; lookupAll = lookupAll;
       lookupAndDelete = lookupAndDelete; lookupAndDeleteM = lookupAndDeleteM;
       lookupAndDeleteAll = lookupAndDeleteAll;
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
       adjustAllOrInsert = adjustAllOrInsert;
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    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;
       insertSeq = insertSeq; union = union; unionSeq = unionSeq;
       delete = delete; deleteAll = deleteAll; deleteSeq = deleteSeq;
       null = null; size = size; member = member; count = count;
       lookup = lookup; lookupM = lookupM; lookupAll = lookupAll;
       lookupAndDelete = lookupAndDelete; lookupAndDeleteM = lookupAndDeleteM;
       lookupAndDeleteAll = lookupAndDeleteAll;
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
       adjustAllOrInsert = adjustAllOrInsert;
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    null E = True
    null (I _ _ _) = False
    
    size E = 0
    size (I k _ m) = 1 + size (delete k m)
    
    member _ E = False
    member key (I k _ m) = key == k || member key m
    
    count _ E = 0
    count key (I k _ m) | key == k  = 1
                        | otherwise = count key m
    
    lookup key m = runIdentity (lookupM key m)
    
    lookupM _ E = fail "AssocList.lookup: lookup failed"
    lookupM key (I k x m) | key == k  = return x
                          | otherwise = lookupM key m
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    empty         :: Eq k => FM k a
    singleton     :: Eq k => k -> a -> FM k a
    fromSeq       :: (Eq k,S.Sequence seq) => seq (k,a) -> FM k a
    insert        :: Eq k => k -> a -> FM k a -> FM k a
    insertSeq     :: (Eq k,S.Sequence seq) => seq (k,a) -> FM k a -> FM k a
    union         :: Eq k => FM k a -> FM k a -> FM k a
    unionSeq      :: (Eq k,S.Sequence seq) => seq (FM k a) -> FM k a
    delete        :: Eq k => k -> FM k a -> FM k a
    deleteAll     :: Eq k => k -> FM k a -> FM k a
    deleteSeq     :: (Eq k,S.Sequence seq) => seq k -> FM k a -> FM k a
    null          :: Eq k => FM k a -> Bool
    size          :: Eq k => FM k a -> Int
    member        :: Eq k => k -> FM k a -> Bool
    count         :: Eq k => k -> FM k a -> Int
    lookup        :: Eq k => k -> FM k a -> a
    lookupM       :: (Eq k, Monad rm) => k -> FM k a -> rm a
    lookupAll     :: (Eq k,S.Sequence seq) => k -> FM k a -> seq a
    lookupAndDelete    :: Eq k => k -> FM k a -> (a,FM k a)
    lookupAndDeleteM   :: (Eq k,Monad rm)   => k -> FM k a -> rm (a,FM k a)
    lookupAndDeleteAll :: (Eq k,S.Sequence seq) => k -> FM k a -> (seq a,FM k a)
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
        -- * FiniteMapX operations
        fromSeqWith,fromSeqWithKey,insertWith,insertWithKey,insertSeqWith,
        insertSeqWithKey,unionl,unionr,unionWith,unionSeqWith,intersectionWith,
        difference,properSubset,subset,properSubmapBy,submapBy,sameMapBy,
        properSubmap,submap,sameMap,
    
        -- * FiniteMap operations
        unionWithKey,unionSeqWithKey,intersectionWithKey,
    
        -- * Documentation
        moduleName
    ) where
    
    import Prelude hiding (null,map,lookup,foldr,foldl,foldr1,foldl1,filter)
    import qualified Prelude
    import Data.Monoid
    import Data.Semigroup as SG
    import Control.Monad.Identity
    import qualified Data.Edison.Assoc as A
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    --   This module implements finite maps as simple association lists.
    --
    --   Duplicates are removed conceptually, but not physically.  The first
    --   occurrence of a given key is the one that is considered to be in the map.
    --
    --   The list type is mildly customized to prevent boxing the pairs.
    
    module Data.Edison.Assoc.AssocList (
        -- * Type of simple association lists
        FM, -- instance of Assoc(X), FiniteMap(X)
            -- also instance of Functor
    
        -- * AssocX operations
        empty,singleton,fromSeq,insert,insertSeq,union,unionSeq,delete,deleteAll,
        deleteSeq,null,size,member,count,lookup,lookupM,lookupAll,
        lookupAndDelete,lookupAndDeleteM,lookupAndDeleteAll,
        lookupWithDefault,adjust,adjustAll,adjustOrInsert,adjustAllOrInsert,
        adjustOrDelete,adjustOrDeleteAll,strict,strictWith,
        map,fold,fold',fold1,fold1',filter,partition,elements,structuralInvariant,
    

    lookupM See 8 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    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;
       insertSeq = insertSeq; union = union; unionSeq = unionSeq;
       delete = delete; deleteAll = deleteAll; deleteSeq = deleteSeq;
       null = null; size = size; member = member; count = count;
       lookup = lookup; lookupM = lookupM; lookupAll = lookupAll;
       lookupAndDelete = lookupAndDelete; lookupAndDeleteM = lookupAndDeleteM;
       lookupAndDeleteAll = lookupAndDeleteAll;
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
       adjustAllOrInsert = adjustAllOrInsert;
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    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;
       insertSeq = insertSeq; union = union; unionSeq = unionSeq;
       delete = delete; deleteAll = deleteAll; deleteSeq = deleteSeq;
       null = null; size = size; member = member; count = count;
       lookup = lookup; lookupM = lookupM; lookupAll = lookupAll;
       lookupAndDelete = lookupAndDelete; lookupAndDeleteM = lookupAndDeleteM;
       lookupAndDeleteAll = lookupAndDeleteAll;
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
       adjustAllOrInsert = adjustAllOrInsert;
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    size E = 0
    size (I k _ m) = 1 + size (delete k m)
    
    member _ E = False
    member key (I k _ m) = key == k || member key m
    
    count _ E = 0
    count key (I k _ m) | key == k  = 1
                        | otherwise = count key m
    
    lookup key m = runIdentity (lookupM key m)
    
    lookupM _ E = fail "AssocList.lookup: lookup failed"
    lookupM key (I k x m) | key == k  = return x
                          | otherwise = lookupM key m
    
    lookupAll _ E = S.empty
    lookupAll key (I k x m) | key == k  = S.singleton x
                            | otherwise = lookupAll key m
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    size E = 0
    size (I k _ m) = 1 + size (delete k m)
    
    member _ E = False
    member key (I k _ m) = key == k || member key m
    
    count _ E = 0
    count key (I k _ m) | key == k  = 1
                        | otherwise = count key m
    
    lookup key m = runIdentity (lookupM key m)
    
    lookupM _ E = fail "AssocList.lookup: lookup failed"
    lookupM key (I k x m) | key == k  = return x
                          | otherwise = lookupM key m
    
    lookupAll _ E = S.empty
    lookupAll key (I k x m) | key == k  = S.singleton x
                            | otherwise = lookupAll key m
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    null (I _ _ _) = False
    
    size E = 0
    size (I k _ m) = 1 + size (delete k m)
    
    member _ E = False
    member key (I k _ m) = key == k || member key m
    
    count _ E = 0
    count key (I k _ m) | key == k  = 1
                        | otherwise = count key m
    
    lookup key m = runIdentity (lookupM key m)
    
    lookupM _ E = fail "AssocList.lookup: lookup failed"
    lookupM key (I k x m) | key == k  = return x
                          | otherwise = lookupM key m
    
    lookupAll _ E = S.empty
    lookupAll key (I k x m) | key == k  = S.singleton x
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    null E = True
    null (I _ _ _) = False
    
    size E = 0
    size (I k _ m) = 1 + size (delete k m)
    
    member _ E = False
    member key (I k _ m) = key == k || member key m
    
    count _ E = 0
    count key (I k _ m) | key == k  = 1
                        | otherwise = count key m
    
    lookup key m = runIdentity (lookupM key m)
    
    lookupM _ E = fail "AssocList.lookup: lookup failed"
    lookupM key (I k x m) | key == k  = return x
                          | otherwise = lookupM key m
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    singleton     :: Eq k => k -> a -> FM k a
    fromSeq       :: (Eq k,S.Sequence seq) => seq (k,a) -> FM k a
    insert        :: Eq k => k -> a -> FM k a -> FM k a
    insertSeq     :: (Eq k,S.Sequence seq) => seq (k,a) -> FM k a -> FM k a
    union         :: Eq k => FM k a -> FM k a -> FM k a
    unionSeq      :: (Eq k,S.Sequence seq) => seq (FM k a) -> FM k a
    delete        :: Eq k => k -> FM k a -> FM k a
    deleteAll     :: Eq k => k -> FM k a -> FM k a
    deleteSeq     :: (Eq k,S.Sequence seq) => seq k -> FM k a -> FM k a
    null          :: Eq k => FM k a -> Bool
    size          :: Eq k => FM k a -> Int
    member        :: Eq k => k -> FM k a -> Bool
    count         :: Eq k => k -> FM k a -> Int
    lookup        :: Eq k => k -> FM k a -> a
    lookupM       :: (Eq k, Monad rm) => k -> FM k a -> rm a
    lookupAll     :: (Eq k,S.Sequence seq) => k -> FM k a -> seq a
    lookupAndDelete    :: Eq k => k -> FM k a -> (a,FM k a)
    lookupAndDeleteM   :: (Eq k,Monad rm)   => k -> FM k a -> rm (a,FM k a)
    lookupAndDeleteAll :: (Eq k,S.Sequence seq) => k -> FM k a -> (seq a,FM k a)
    lookupWithDefault  :: Eq k => a -> k -> FM k a -> a
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    --   This module implements finite maps as simple association lists.
    --
    --   Duplicates are removed conceptually, but not physically.  The first
    --   occurrence of a given key is the one that is considered to be in the map.
    --
    --   The list type is mildly customized to prevent boxing the pairs.
    
    module Data.Edison.Assoc.AssocList (
        -- * Type of simple association lists
        FM, -- instance of Assoc(X), FiniteMap(X)
            -- also instance of Functor
    
        -- * AssocX operations
        empty,singleton,fromSeq,insert,insertSeq,union,unionSeq,delete,deleteAll,
        deleteSeq,null,size,member,count,lookup,lookupM,lookupAll,
        lookupAndDelete,lookupAndDeleteM,lookupAndDeleteAll,
        lookupWithDefault,adjust,adjustAll,adjustOrInsert,adjustAllOrInsert,
        adjustOrDelete,adjustOrDeleteAll,strict,strictWith,
        map,fold,fold',fold1,fold1',filter,partition,elements,structuralInvariant,
    

    lookupWithDefault See 7 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    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;
       insertSeq = insertSeq; union = union; unionSeq = unionSeq;
       delete = delete; deleteAll = deleteAll; deleteSeq = deleteSeq;
       null = null; size = size; member = member; count = count;
       lookup = lookup; lookupM = lookupM; lookupAll = lookupAll;
       lookupAndDelete = lookupAndDelete; lookupAndDeleteM = lookupAndDeleteM;
       lookupAndDeleteAll = lookupAndDeleteAll;
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
       adjustAllOrInsert = adjustAllOrInsert;
       adjustOrDelete = adjustOrDelete; adjustOrDeleteAll = adjustOrDeleteAll;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       filter = filter; partition = partition; elements = elements;
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    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;
       insertSeq = insertSeq; union = union; unionSeq = unionSeq;
       delete = delete; deleteAll = deleteAll; deleteSeq = deleteSeq;
       null = null; size = size; member = member; count = count;
       lookup = lookup; lookupM = lookupM; lookupAll = lookupAll;
       lookupAndDelete = lookupAndDelete; lookupAndDeleteM = lookupAndDeleteM;
       lookupAndDeleteAll = lookupAndDeleteAll;
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
       adjustAllOrInsert = adjustAllOrInsert;
       adjustOrDelete = adjustOrDelete; adjustOrDeleteAll = adjustOrDeleteAll;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       filter = filter; partition = partition; elements = elements;
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    lookupAndDeleteM _ E = fail "AssocList.lookupAndDeleteM: lookup failed"
    lookupAndDeleteM key (I k x m)
       | key == k  = return (x,delete k m)
       | otherwise = lookupAndDeleteM key m >>=
                        \ (z, m') -> return (z, I k x m')
    
    lookupAndDeleteAll key m =
       case lookupAndDeleteM key m of
          Nothing     -> (S.empty,m)
          Just (z,m') -> (S.singleton z,m')
    
    
    lookupWithDefault d _ E = d
    lookupWithDefault d key (I k x m) | key == k = x
                                      | otherwise = lookupWithDefault d key m
    
    elements E = S.empty
    elements (I k x m) = S.lcons x (elements (delete k m))
    
    adjust _ _ E = E
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    lookupAndDeleteM _ E = fail "AssocList.lookupAndDeleteM: lookup failed"
    lookupAndDeleteM key (I k x m)
       | key == k  = return (x,delete k m)
       | otherwise = lookupAndDeleteM key m >>=
                        \ (z, m') -> return (z, I k x m')
    
    lookupAndDeleteAll key m =
       case lookupAndDeleteM key m of
          Nothing     -> (S.empty,m)
          Just (z,m') -> (S.singleton z,m')
    
    
    lookupWithDefault d _ E = d
    lookupWithDefault d key (I k x m) | key == k = x
                                      | otherwise = lookupWithDefault d key m
    
    elements E = S.empty
    elements (I k x m) = S.lcons x (elements (delete k m))
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    lookupAndDelete key m = runIdentity (lookupAndDeleteM key m)
    
    lookupAndDeleteM _ E = fail "AssocList.lookupAndDeleteM: lookup failed"
    lookupAndDeleteM key (I k x m)
       | key == k  = return (x,delete k m)
       | otherwise = lookupAndDeleteM key m >>=
                        \ (z, m') -> return (z, I k x m')
    
    lookupAndDeleteAll key m =
       case lookupAndDeleteM key m of
          Nothing     -> (S.empty,m)
          Just (z,m') -> (S.singleton z,m')
    
    
    lookupWithDefault d _ E = d
    lookupWithDefault d key (I k x m) | key == k = x
                                      | otherwise = lookupWithDefault d key m
    
    elements E = S.empty
    elements (I k x m) = S.lcons x (elements (delete k m))
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    unionSeq      :: (Eq k,S.Sequence seq) => seq (FM k a) -> FM k a
    delete        :: Eq k => k -> FM k a -> FM k a
    deleteAll     :: Eq k => k -> FM k a -> FM k a
    deleteSeq     :: (Eq k,S.Sequence seq) => seq k -> FM k a -> FM k a
    null          :: Eq k => FM k a -> Bool
    size          :: Eq k => FM k a -> Int
    member        :: Eq k => k -> FM k a -> Bool
    count         :: Eq k => k -> FM k a -> Int
    lookup        :: Eq k => k -> FM k a -> a
    lookupM       :: (Eq k, Monad rm) => k -> FM k a -> rm a
    lookupAll     :: (Eq k,S.Sequence seq) => k -> FM k a -> seq a
    lookupAndDelete    :: Eq k => k -> FM k a -> (a,FM k a)
    lookupAndDeleteM   :: (Eq k,Monad rm)   => k -> FM k a -> rm (a,FM k a)
    lookupAndDeleteAll :: (Eq k,S.Sequence seq) => k -> FM k a -> (seq a,FM k a)
    lookupWithDefault  :: Eq k => a -> k -> FM k a -> a
    adjust             :: Eq k => (a -> a) -> k -> FM k a -> FM k a
    adjustAll          :: Eq k => (a -> a) -> k -> FM k a -> FM k a
    adjustOrInsert     :: Eq k => (a -> a) -> a -> k -> FM k a -> FM k a
    adjustAllOrInsert  :: Eq k => (a -> a) -> a -> k -> FM k a -> FM k a
    adjustOrDelete     :: Eq k => (a -> Maybe a) -> k -> FM k a -> FM k a
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    --   Duplicates are removed conceptually, but not physically.  The first
    --   occurrence of a given key is the one that is considered to be in the map.
    --
    --   The list type is mildly customized to prevent boxing the pairs.
    
    module Data.Edison.Assoc.AssocList (
        -- * Type of simple association lists
        FM, -- instance of Assoc(X), FiniteMap(X)
            -- also instance of Functor
    
        -- * AssocX operations
        empty,singleton,fromSeq,insert,insertSeq,union,unionSeq,delete,deleteAll,
        deleteSeq,null,size,member,count,lookup,lookupM,lookupAll,
        lookupAndDelete,lookupAndDeleteM,lookupAndDeleteAll,
        lookupWithDefault,adjust,adjustAll,adjustOrInsert,adjustAllOrInsert,
        adjustOrDelete,adjustOrDeleteAll,strict,strictWith,
        map,fold,fold',fold1,fold1',filter,partition,elements,structuralInvariant,
    
        -- * OrdAssocX operations
        minView, minElem, deleteMin, unsafeInsertMin, maxView, maxElem, deleteMax,
    

    ltail No usage example found for this symbol :( Collapse [-]
    ltailM No usage example found for this symbol :( Collapse [-]
    lview No usage example found for this symbol :( Collapse [-]
    map See 7 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    instance Ord k => A.OrdAssoc (FM k) k where
      {minViewWithKey = minViewWithKey; minElemWithKey = minElemWithKey;
       maxViewWithKey = maxViewWithKey; maxElemWithKey = maxElemWithKey;
       foldrWithKey = foldrWithKey; foldrWithKey' = foldrWithKey';
       foldlWithKey = foldlWithKey; foldlWithKey' = foldlWithKey';
       toOrdSeq = toOrdSeq}
    
    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
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    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
    fold f c (I k x m) = fold f (f x c) (delete k m)
    
    fold' _ c E = c
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    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
    fold f c (I k x m) = fold f (f x c) (delete k m)
    
    fold' _ c E = c
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
                           | 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
    fold f c (I k x m) = fold f (f x c) (delete k m)
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    lookupM       :: (Eq k, Monad rm) => k -> FM k a -> rm a
    lookupAll     :: (Eq k,S.Sequence seq) => k -> FM k a -> seq a
    lookupAndDelete    :: Eq k => k -> FM k a -> (a,FM k a)
    lookupAndDeleteM   :: (Eq k,Monad rm)   => k -> FM k a -> rm (a,FM k a)
    lookupAndDeleteAll :: (Eq k,S.Sequence seq) => k -> FM k a -> (seq a,FM k a)
    lookupWithDefault  :: Eq k => a -> k -> FM k a -> a
    adjust             :: Eq k => (a -> a) -> k -> FM k a -> FM k a
    adjustAll          :: Eq k => (a -> a) -> k -> FM k a -> FM k a
    adjustOrInsert     :: Eq k => (a -> a) -> a -> k -> FM k a -> FM k a
    adjustAllOrInsert  :: Eq k => (a -> a) -> a -> k -> FM k a -> FM k a
    adjustOrDelete     :: Eq k => (a -> Maybe a) -> k -> FM k a -> FM k a
    adjustOrDeleteAll  :: Eq k => (a -> Maybe a) -> k -> FM k a -> FM k a
    strict             :: FM k a -> FM k a
    strictWith         :: (a -> b) -> FM k a -> FM k a
    map           :: Eq k => (a -> b) -> FM k a -> FM k b
    fold          :: Eq k => (a -> b -> b) -> b -> FM k a -> b
    fold1         :: Eq k => (a -> a -> a) -> FM k a -> a
    fold'         :: Eq k => (a -> b -> b) -> b -> FM k a -> b
    fold1'        :: Eq k => (a -> a -> a) -> FM k a -> a
    filter        :: Eq k => (a -> Bool) -> FM k a -> FM k a
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
        -- * FiniteMapX operations
        fromSeqWith,fromSeqWithKey,insertWith,insertWithKey,insertSeqWith,
        insertSeqWithKey,unionl,unionr,unionWith,unionSeqWith,intersectionWith,
        difference,properSubset,subset,properSubmapBy,submapBy,sameMapBy,
        properSubmap,submap,sameMap,
    
        -- * FiniteMap operations
        unionWithKey,unionSeqWithKey,intersectionWithKey,
    
        -- * Documentation
        moduleName
    ) where
    
    import Prelude hiding (null,map,lookup,foldr,foldl,foldr1,foldl1,filter)
    import qualified Prelude
    import Data.Monoid
    import Data.Semigroup as SG
    import Control.Monad.Identity
    import qualified Data.Edison.Assoc as A
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    --
    --   The list type is mildly customized to prevent boxing the pairs.
    
    module Data.Edison.Assoc.AssocList (
        -- * Type of simple association lists
        FM, -- instance of Assoc(X), FiniteMap(X)
            -- also instance of Functor
    
        -- * AssocX operations
        empty,singleton,fromSeq,insert,insertSeq,union,unionSeq,delete,deleteAll,
        deleteSeq,null,size,member,count,lookup,lookupM,lookupAll,
        lookupAndDelete,lookupAndDeleteM,lookupAndDeleteAll,
        lookupWithDefault,adjust,adjustAll,adjustOrInsert,adjustAllOrInsert,
        adjustOrDelete,adjustOrDeleteAll,strict,strictWith,
        map,fold,fold',fold1,fold1',filter,partition,elements,structuralInvariant,
    
        -- * OrdAssocX operations
        minView, minElem, deleteMin, unsafeInsertMin, maxView, maxElem, deleteMax,
        unsafeInsertMax, foldr, foldr', foldl, foldl', foldr1, foldr1',
        foldl1, foldl1', unsafeFromOrdSeq, unsafeAppend,
    

    mapWithIndex No usage example found for this symbol :( Collapse [-]
    moduleName See 18 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
      {empty = empty; singleton = singleton; fromSeq = fromSeq; insert = insert;
       insertSeq = insertSeq; union = union; unionSeq = unionSeq;
       delete = delete; deleteAll = deleteAll; deleteSeq = deleteSeq;
       null = null; size = size; member = member; count = count;
       lookup = lookup; lookupM = lookupM; lookupAll = lookupAll;
       lookupAndDelete = lookupAndDelete; lookupAndDeleteM = lookupAndDeleteM;
       lookupAndDeleteAll = lookupAndDeleteAll;
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
       adjustAllOrInsert = adjustAllOrInsert;
       adjustOrDelete = adjustOrDelete; adjustOrDeleteAll = adjustOrDeleteAll;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       filter = filter; partition = partition; elements = elements;
       strict = strict; strictWith = strictWith;
       structuralInvariant = structuralInvariant; instanceName _ = moduleName}
    
    instance Ord k => A.OrdAssocX (FM k) k where
      {minView = minView; minElem = minElem; deleteMin = deleteMin;
       unsafeInsertMin = unsafeInsertMin; maxView = maxView; maxElem = maxElem;
       deleteMax = deleteMax; unsafeInsertMax = unsafeInsertMax;
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    filterGE k         = dropWhileFM (<k)  . mergeSortFM
    partitionLT_GE k   = spanFM (<k)  . mergeSortFM
    partitionLE_GT k   = spanFM (<=k) . mergeSortFM
    partitionLT_GT k   = (\(x,y) -> (x,delete k y)) . spanFM (<k)  . mergeSortFM
    
    minViewWithKey E   = fail $ moduleName++".minViewWithKey: empty map"
    minViewWithKey n@(I k a m) = let (k',x) = findMin k a m in return ((k',x),delete k' n)
    
    minElemWithKey E   = error $ moduleName++".minElemWithKey: empty map"
    minElemWithKey (I k a m) = findMin k a m
    
    maxViewWithKey E   = fail $ moduleName++".maxViewWithKey: empty map"
    maxViewWithKey n@(I k a m) = let (k',x) = findMax k a m in return ((k',x),delete k' n)
    
    maxElemWithKey E   = error $ moduleName++".maxElemWithKey: empty map"
    maxElemWithKey (I k a m) = findMax k a m
    
    foldrWithKey  f z   = foldrWithKeyFM  f z . mergeSortFM
    foldrWithKey' f z   = foldrWithKeyFM' f z . mergeSortFM
    foldlWithKey  f x   = foldlWithKeyFM  f x . mergeSortFM
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    filterLT k         = takeWhileFM (<k)  . mergeSortFM
    filterLE k         = takeWhileFM (<=k) . mergeSortFM
    filterGT k         = dropWhileFM (<=k) . mergeSortFM
    filterGE k         = dropWhileFM (<k)  . mergeSortFM
    partitionLT_GE k   = spanFM (<k)  . mergeSortFM
    partitionLE_GT k   = spanFM (<=k) . mergeSortFM
    partitionLT_GT k   = (\(x,y) -> (x,delete k y)) . spanFM (<k)  . mergeSortFM
    
    minViewWithKey E   = fail $ moduleName++".minViewWithKey: empty map"
    minViewWithKey n@(I k a m) = let (k',x) = findMin k a m in return ((k',x),delete k' n)
    
    minElemWithKey E   = error $ moduleName++".minElemWithKey: empty map"
    minElemWithKey (I k a m) = findMin k a m
    
    maxViewWithKey E   = fail $ moduleName++".maxViewWithKey: empty map"
    maxViewWithKey n@(I k a m) = let (k',x) = findMax k a m in return ((k',x),delete k' n)
    
    maxElemWithKey E   = error $ moduleName++".maxElemWithKey: empty map"
    maxElemWithKey (I k a m) = findMax k a m
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    unsafeFromOrdSeq   = fromSeq
    unsafeAppend       = union
    filterLT k         = takeWhileFM (<k)  . mergeSortFM
    filterLE k         = takeWhileFM (<=k) . mergeSortFM
    filterGT k         = dropWhileFM (<=k) . mergeSortFM
    filterGE k         = dropWhileFM (<k)  . mergeSortFM
    partitionLT_GE k   = spanFM (<k)  . mergeSortFM
    partitionLE_GT k   = spanFM (<=k) . mergeSortFM
    partitionLT_GT k   = (\(x,y) -> (x,delete k y)) . spanFM (<k)  . mergeSortFM
    
    minViewWithKey E   = fail $ moduleName++".minViewWithKey: empty map"
    minViewWithKey n@(I k a m) = let (k',x) = findMin k a m in return ((k',x),delete k' n)
    
    minElemWithKey E   = error $ moduleName++".minElemWithKey: empty map"
    minElemWithKey (I k a m) = findMin k a m
    
    maxViewWithKey E   = fail $ moduleName++".maxViewWithKey: empty map"
    maxViewWithKey n@(I k a m) = let (k',x) = findMax k a m in return ((k',x),delete k' n)
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
      case mergeSortFM m of
        E -> error $ moduleName++".foldl1': empty map"
        I k a n -> foldlFM' f a (delete k n)
    
    unsafeFromOrdSeq   = fromSeq
    unsafeAppend       = union
    filterLT k         = takeWhileFM (<k)  . mergeSortFM
    filterLE k         = takeWhileFM (<=k) . mergeSortFM
    filterGT k         = dropWhileFM (<=k) . mergeSortFM
    filterGE k         = dropWhileFM (<k)  . mergeSortFM
    partitionLT_GE k   = spanFM (<k)  . mergeSortFM
    partitionLE_GT k   = spanFM (<=k) . mergeSortFM
    partitionLT_GT k   = (\(x,y) -> (x,delete k y)) . spanFM (<k)  . mergeSortFM
    
    minViewWithKey E   = fail $ moduleName++".minViewWithKey: empty map"
    minViewWithKey n@(I k a m) = let (k',x) = findMin k a m in return ((k',x),delete k' n)
    
    minElemWithKey E   = error $ moduleName++".minElemWithKey: empty map"
    minElemWithKey (I k a m) = findMin k a m
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
      case mergeSortFM m of
        E -> error $ moduleName++".foldlr1': empty map"
        n -> foldr1FM' f n
    
    foldl  f x m = foldlFM  f x (mergeSortFM m)
    foldl' f x m = foldlFM' f x (mergeSortFM m)
    
    foldl1 f m =
      case mergeSortFM m of
        E -> error $ moduleName++".foldl1: empty map"
        I k a n -> foldlFM f a (delete k n)
    
    foldl1' f m =
      case mergeSortFM m of
        E -> error $ moduleName++".foldl1': empty map"
        I k a n -> foldlFM' f a (delete k n)
    
    unsafeFromOrdSeq   = fromSeq
    unsafeAppend       = union
    filterLT k         = takeWhileFM (<k)  . mergeSortFM
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
      case mergeSortFM m of
        E -> error $ moduleName++".foldlr1: empty map"
        n -> foldr1FM f n
    
    foldr1' f m =
      case mergeSortFM m of
        E -> error $ moduleName++".foldlr1': empty map"
        n -> foldr1FM' f n
    
    foldl  f x m = foldlFM  f x (mergeSortFM m)
    foldl' f x m = foldlFM' f x (mergeSortFM m)
    
    foldl1 f m =
      case mergeSortFM m of
        E -> error $ moduleName++".foldl1: empty map"
        I k a n -> foldlFM f a (delete k n)
    
    foldl1' f m =
      case mergeSortFM m of
        E -> error $ moduleName++".foldl1': empty map"
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    deleteMax n@(I k a m) = let (k',_) = findMax k a m in delete k' n
    
    unsafeInsertMax = insert
    
    foldr  f z m = foldrFM  f z (mergeSortFM m)
    foldr' f z m = foldrFM' f z (mergeSortFM m)
    
    foldr1 f m =
      case mergeSortFM m of
        E -> error $ moduleName++".foldlr1: empty map"
        n -> foldr1FM f n
    
    foldr1' f m =
      case mergeSortFM m of
        E -> error $ moduleName++".foldlr1': empty map"
        n -> foldr1FM' f n
    
    foldl  f x m = foldlFM  f x (mergeSortFM m)
    foldl' f x m = foldlFM' f x (mergeSortFM m)
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    maxElem E = error (moduleName++".maxElem: empty map")
    maxElem (I k a m) = let (_,x) = findMax k a m in x
    
    deleteMax E = error (moduleName++".deleteMax: empty map")
    deleteMax n@(I k a m) = let (k',_) = findMax k a m in delete k' n
    
    unsafeInsertMax = insert
    
    foldr  f z m = foldrFM  f z (mergeSortFM m)
    foldr' f z m = foldrFM' f z (mergeSortFM m)
    
    foldr1 f m =
      case mergeSortFM m of
        E -> error $ moduleName++".foldlr1: empty map"
        n -> foldr1FM f n
    
    foldr1' f m =
      case mergeSortFM m of
        E -> error $ moduleName++".foldlr1': empty map"
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    minElem E = error (moduleName++".minElem: empty map")
    minElem (I k a m) = let (_,x) = findMin k a m in x
    
    deleteMin E = error (moduleName++".deleteMin: empty map")
    deleteMin n@(I k a m) = let (k',_) = findMin k a m in delete k' n
    
    unsafeInsertMin  = insert
    
    maxView E = fail (moduleName++".maxView: empty map")
    maxView n@(I k a m) = let (k',x) = findMax k a m in return (x,delete k' n)
    
    maxElem E = error (moduleName++".maxElem: empty map")
    maxElem (I k a m) = let (_,x) = findMax k a m in x
    
    deleteMax E = error (moduleName++".deleteMax: empty map")
    deleteMax n@(I k a m) = let (k',_) = findMax k a m in delete k' n
    
    unsafeInsertMax = insert
    
    foldr  f z m = foldrFM  f z (mergeSortFM m)
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    minView E = fail (moduleName++".minView: empty map")
    minView n@(I k a m) = let (k',x) = findMin k a m in return (x,delete k' n)
    
    minElem E = error (moduleName++".minElem: empty map")
    minElem (I k a m) = let (_,x) = findMin k a m in x
    
    deleteMin E = error (moduleName++".deleteMin: empty map")
    deleteMin n@(I k a m) = let (k',_) = findMin k a m in delete k' n
    
    unsafeInsertMin  = insert
    
    maxView E = fail (moduleName++".maxView: empty map")
    maxView n@(I k a m) = let (k',x) = findMax k a m in return (x,delete k' n)
    
    maxElem E = error (moduleName++".maxElem: empty map")
    maxElem (I k a m) = let (_,x) = findMax k a m in x
    
    deleteMax E = error (moduleName++".deleteMax: empty map")
    deleteMax n@(I k a m) = let (k',_) = findMax k a m in delete k' n
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
            | k > k0    = findMax k  a  (delete k m)
            | otherwise = findMax k0 a0 (delete k m)
    
    minView E = fail (moduleName++".minView: empty map")
    minView n@(I k a m) = let (k',x) = findMin k a m in return (x,delete k' n)
    
    minElem E = error (moduleName++".minElem: empty map")
    minElem (I k a m) = let (_,x) = findMin k a m in x
    
    deleteMin E = error (moduleName++".deleteMin: empty map")
    deleteMin n@(I k a m) = let (k',_) = findMin k a m in delete k' n
    
    unsafeInsertMin  = insert
    
    maxView E = fail (moduleName++".maxView: empty map")
    maxView n@(I k a m) = let (k',x) = findMax k a m in return (x,delete k' n)
    
    maxElem E = error (moduleName++".maxElem: empty map")
    maxElem (I k a m) = let (_,x) = findMax k a m in x
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
            | otherwise = findMin k0 a0 (delete k m)
    
    findMax ::( Ord t) => t -> t1 -> FM t t1 -> (t, t1)
    findMax k0 x E = (k0,x)
    findMax k0 a0 (I k a m)
            | k > k0    = findMax k  a  (delete k m)
            | otherwise = findMax k0 a0 (delete k m)
    
    minView E = fail (moduleName++".minView: empty map")
    minView n@(I k a m) = let (k',x) = findMin k a m in return (x,delete k' n)
    
    minElem E = error (moduleName++".minElem: empty map")
    minElem (I k a m) = let (_,x) = findMin k a m in x
    
    deleteMin E = error (moduleName++".deleteMin: empty map")
    deleteMin n@(I k a m) = let (k',_) = findMin k a m in delete k' n
    
    unsafeInsertMin  = insert
    
    maxView E = fail (moduleName++".maxView: empty map")
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    findMin k0 x E = (k0,x)
    findMin k0 a0 (I k a m)
            | k < k0    = findMin k  a  (delete k m)
            | otherwise = findMin k0 a0 (delete k m)
    
    findMax ::( Ord t) => t -> t1 -> FM t t1 -> (t, t1)
    findMax k0 x E = (k0,x)
    findMax k0 a0 (I k a m)
            | k > k0    = findMax k  a  (delete k m)
            | otherwise = findMax k0 a0 (delete k m)
    
    minView E = fail (moduleName++".minView: empty map")
    minView n@(I k a m) = let (k',x) = findMin k a m in return (x,delete k' n)
    
    minElem E = error (moduleName++".minElem: empty map")
    minElem (I k a m) = let (_,x) = findMin k a m in x
    
    deleteMin E = error (moduleName++".deleteMin: empty map")
    deleteMin n@(I k a m) = let (k',_) = findMin k a m in delete k' n
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    findMin :: (Ord t) => t -> t1 -> FM t t1 -> (t, t1)
    findMin k0 x E = (k0,x)
    findMin k0 a0 (I k a m)
            | k < k0    = findMin k  a  (delete k m)
            | otherwise = findMin k0 a0 (delete k m)
    
    findMax ::( Ord t) => t -> t1 -> FM t t1 -> (t, t1)
    findMax k0 x E = (k0,x)
    findMax k0 a0 (I k a m)
            | k > k0    = findMax k  a  (delete k m)
            | otherwise = findMax k0 a0 (delete k m)
    
    minView E = fail (moduleName++".minView: empty map")
    minView n@(I k a m) = let (k',x) = findMin k a m in return (x,delete k' n)
    
    minElem E = error (moduleName++".minElem: empty map")
    minElem (I k a m) = let (_,x) = findMin k a m in x
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    partitionLE_GT   :: Ord k => k -> FM k a -> (FM k a,FM k a)
    partitionLT_GT   :: Ord k => k -> FM k a -> (FM k a,FM k a)
    
    minViewWithKey    :: (Ord k,Monad m) => FM k a -> m ((k, a), FM k a)
    minElemWithKey    :: Ord k => FM k a -> (k,a)
    maxViewWithKey    :: (Ord k,Monad m) => FM k a -> m ((k, a), FM k a)
    maxElemWithKey    :: Ord k => FM k a -> (k,a)
    foldrWithKey      :: Ord k => (k -> a -> b -> b) -> b -> FM k a -> b
    foldlWithKey      :: Ord k => (b -> k -> a -> b) -> b -> FM k a -> b
    foldrWithKey'     :: Ord k => (k -> a -> b -> b) -> b -> FM k a -> b
    foldlWithKey'     :: Ord k => (b -> k -> a -> b) -> b -> FM k a -> b
    toOrdSeq          :: (Ord k,S.Sequence seq) => FM k a -> seq (k,a)
    
    
    moduleName = "Data.Edison.Assoc.AssocList"
    
    
    data FM k a = E | I k a (FM k a)
    
    -- no invariants
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    ) where
    
    import Prelude hiding (null,map,lookup,foldr,foldl,foldr1,foldl1,filter)
    import qualified Prelude
    import Data.Monoid
    import Data.Semigroup as SG
    import Control.Monad.Identity
    import qualified Data.Edison.Assoc as A
    import qualified Data.Edison.Seq as S
    import qualified Data.Edison.Seq.BinaryRandList as RL
    import Data.Edison.Assoc.Defaults
    import Test.QuickCheck (Arbitrary(..), CoArbitrary(..), variant)
    
    -- signatures for exported functions
    moduleName    :: String
    empty         :: Eq k => FM k a
    singleton     :: Eq k => k -> a -> FM k a
    fromSeq       :: (Eq k,S.Sequence seq) => seq (k,a) -> FM k a
    insert        :: Eq k => k -> a -> FM k a -> FM k a
    insertSeq     :: (Eq k,S.Sequence seq) => seq (k,a) -> FM k a -> FM k a
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
        -- * OrdAssoc operations
        minViewWithKey, minElemWithKey, maxViewWithKey, maxElemWithKey,
        foldrWithKey, foldrWithKey', foldlWithKey, foldlWithKey', toOrdSeq,
    
        -- * FiniteMapX operations
        fromSeqWith,fromSeqWithKey,insertWith,insertWithKey,insertSeqWith,
        insertSeqWithKey,unionl,unionr,unionWith,unionSeqWith,intersectionWith,
        difference,properSubset,subset,properSubmapBy,submapBy,sameMapBy,
        properSubmap,submap,sameMap,
    
        -- * FiniteMap operations
        unionWithKey,unionSeqWithKey,intersectionWithKey,
    
        -- * Documentation
        moduleName
    ) where
    
    import Prelude hiding (null,map,lookup,foldr,foldl,foldr1,foldl1,filter)
    import qualified Prelude
    import Data.Monoid
    

    null See 7 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    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;
       insertSeq = insertSeq; union = union; unionSeq = unionSeq;
       delete = delete; deleteAll = deleteAll; deleteSeq = deleteSeq;
       null = null; size = size; member = member; count = count;
       lookup = lookup; lookupM = lookupM; lookupAll = lookupAll;
       lookupAndDelete = lookupAndDelete; lookupAndDeleteM = lookupAndDeleteM;
       lookupAndDeleteAll = lookupAndDeleteAll;
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    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;
       insertSeq = insertSeq; union = union; unionSeq = unionSeq;
       delete = delete; deleteAll = deleteAll; deleteSeq = deleteSeq;
       null = null; size = size; member = member; count = count;
       lookup = lookup; lookupM = lookupM; lookupAll = lookupAll;
       lookupAndDelete = lookupAndDelete; lookupAndDeleteM = lookupAndDeleteM;
       lookupAndDeleteAll = lookupAndDeleteAll;
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    union m E = m
    union E m = m
    union (I k x m1) m2 = I k x (union m1 m2)
    
    unionSeq = S.foldr union E
    
    deleteAll _ E = E
    deleteAll key (I k x m) | key == k  = deleteAll key m
                            | otherwise = I k x (deleteAll key m)
    
    delete = deleteAll
    
    null E = True
    null (I _ _ _) = False
    
    size E = 0
    size (I k _ m) = 1 + size (delete k m)
    
    member _ E = False
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    fromSeq = S.foldr uinsert E
    
    union m E = m
    union E m = m
    union (I k x m1) m2 = I k x (union m1 m2)
    
    unionSeq = S.foldr union E
    
    deleteAll _ E = E
    deleteAll key (I k x m) | key == k  = deleteAll key m
                            | otherwise = I k x (deleteAll key m)
    
    delete = deleteAll
    
    null E = True
    null (I _ _ _) = False
    
    size E = 0
    size (I k _ m) = 1 + size (delete k m)
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    import Test.QuickCheck (Arbitrary(..), CoArbitrary(..), variant)
    
    -- signatures for exported functions
    moduleName    :: String
    empty         :: Eq k => FM k a
    singleton     :: Eq k => k -> a -> FM k a
    fromSeq       :: (Eq k,S.Sequence seq) => seq (k,a) -> FM k a
    insert        :: Eq k => k -> a -> FM k a -> FM k a
    insertSeq     :: (Eq k,S.Sequence seq) => seq (k,a) -> FM k a -> FM k a
    union         :: Eq k => FM k a -> FM k a -> FM k a
    unionSeq      :: (Eq k,S.Sequence seq) => seq (FM k a) -> FM k a
    delete        :: Eq k => k -> FM k a -> FM k a
    deleteAll     :: Eq k => k -> FM k a -> FM k a
    deleteSeq     :: (Eq k,S.Sequence seq) => seq k -> FM k a -> FM k a
    null          :: Eq k => FM k a -> Bool
    size          :: Eq k => FM k a -> Int
    member        :: Eq k => k -> FM k a -> Bool
    count         :: Eq k => k -> FM k a -> Int
    lookup        :: Eq k => k -> FM k a -> a
    lookupM       :: (Eq k, Monad rm) => k -> FM k a -> rm a
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
        -- * FiniteMapX operations
        fromSeqWith,fromSeqWithKey,insertWith,insertWithKey,insertSeqWith,
        insertSeqWithKey,unionl,unionr,unionWith,unionSeqWith,intersectionWith,
        difference,properSubset,subset,properSubmapBy,submapBy,sameMapBy,
        properSubmap,submap,sameMap,
    
        -- * FiniteMap operations
        unionWithKey,unionSeqWithKey,intersectionWithKey,
    
        -- * Documentation
        moduleName
    ) where
    
    import Prelude hiding (null,map,lookup,foldr,foldl,foldr1,foldl1,filter)
    import qualified Prelude
    import Data.Monoid
    import Data.Semigroup as SG
    import Control.Monad.Identity
    import qualified Data.Edison.Assoc as A
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    --   This module implements finite maps as simple association lists.
    --
    --   Duplicates are removed conceptually, but not physically.  The first
    --   occurrence of a given key is the one that is considered to be in the map.
    --
    --   The list type is mildly customized to prevent boxing the pairs.
    
    module Data.Edison.Assoc.AssocList (
        -- * Type of simple association lists
        FM, -- instance of Assoc(X), FiniteMap(X)
            -- also instance of Functor
    
        -- * AssocX operations
        empty,singleton,fromSeq,insert,insertSeq,union,unionSeq,delete,deleteAll,
        deleteSeq,null,size,member,count,lookup,lookupM,lookupAll,
        lookupAndDelete,lookupAndDeleteM,lookupAndDeleteAll,
        lookupWithDefault,adjust,adjustAll,adjustOrInsert,adjustAllOrInsert,
        adjustOrDelete,adjustOrDeleteAll,strict,strictWith,
        map,fold,fold',fold1,fold1',filter,partition,elements,structuralInvariant,
    

    partition See 7 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    instance Eq k  => A.AssocX (FM k) k where
      {empty = empty; singleton = singleton; fromSeq = fromSeq; insert = insert;
       insertSeq = insertSeq; union = union; unionSeq = unionSeq;
       delete = delete; deleteAll = deleteAll; deleteSeq = deleteSeq;
       null = null; size = size; member = member; count = count;
       lookup = lookup; lookupM = lookupM; lookupAll = lookupAll;
       lookupAndDelete = lookupAndDelete; lookupAndDeleteM = lookupAndDeleteM;
       lookupAndDeleteAll = lookupAndDeleteAll;
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
       adjustAllOrInsert = adjustAllOrInsert;
       adjustOrDelete = adjustOrDelete; adjustOrDeleteAll = adjustOrDeleteAll;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       filter = filter; partition = partition; elements = elements;
       strict = strict; strictWith = strictWith;
       structuralInvariant = structuralInvariant; instanceName _ = moduleName}
    
    instance Ord k => A.OrdAssocX (FM k) k where
      {minView = minView; minElem = minElem; deleteMin = deleteMin;
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    instance Eq k  => A.AssocX (FM k) k where
      {empty = empty; singleton = singleton; fromSeq = fromSeq; insert = insert;
       insertSeq = insertSeq; union = union; unionSeq = unionSeq;
       delete = delete; deleteAll = deleteAll; deleteSeq = deleteSeq;
       null = null; size = size; member = member; count = count;
       lookup = lookup; lookupM = lookupM; lookupAll = lookupAll;
       lookupAndDelete = lookupAndDelete; lookupAndDeleteM = lookupAndDeleteM;
       lookupAndDeleteAll = lookupAndDeleteAll;
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
       adjustAllOrInsert = adjustAllOrInsert;
       adjustOrDelete = adjustOrDelete; adjustOrDeleteAll = adjustOrDeleteAll;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       filter = filter; partition = partition; elements = elements;
       strict = strict; strictWith = strictWith;
       structuralInvariant = structuralInvariant; instanceName _ = moduleName}
    
    instance Ord k => A.OrdAssocX (FM k) k where
      {minView = minView; minElem = minElem; deleteMin = deleteMin;
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    fold1 _ E = error "AssocList.fold1: empty map"
    fold1 f (I k x m) = fold f x (delete k m)
    
    fold1' _ E = error "AssocList.fold1': empty map"
    fold1' f (I k x m) = fold' f x (delete k m)
    
    filter _ E = E
    filter p (I k x m) | p x = I k x (filter p (delete k m))
                       | otherwise = filter p (delete k m)
    
    partition _ E = (E, E)
    partition p (I k x m)
        | p x       = (I k x m1,m2)
        | otherwise = (m1,I k x m2)
      where (m1,m2) = partition p (delete k m)
    
    
    toSeq E = S.empty
    toSeq (I k x m) = S.lcons (k,x) (toSeq (delete k m))
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    fold' _ c E = c
    fold' f c (I k x m) = c `seq` fold' f (f x c) (delete k m)
    
    fold1 _ E = error "AssocList.fold1: empty map"
    fold1 f (I k x m) = fold f x (delete k m)
    
    fold1' _ E = error "AssocList.fold1': empty map"
    fold1' f (I k x m) = fold' f x (delete k m)
    
    filter _ E = E
    filter p (I k x m) | p x = I k x (filter p (delete k m))
                       | otherwise = filter p (delete k m)
    
    partition _ E = (E, E)
    partition p (I k x m)
        | p x       = (I k x m1,m2)
        | otherwise = (m1,I k x m2)
      where (m1,m2) = partition p (delete k m)
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    fold' _ c E = c
    fold' f c (I k x m) = c `seq` fold' f (f x c) (delete k m)
    
    fold1 _ E = error "AssocList.fold1: empty map"
    fold1 f (I k x m) = fold f x (delete k m)
    
    fold1' _ E = error "AssocList.fold1': empty map"
    fold1' f (I k x m) = fold' f x (delete k m)
    
    filter _ E = E
    filter p (I k x m) | p x = I k x (filter p (delete k m))
                       | otherwise = filter p (delete k m)
    
    partition _ E = (E, E)
    partition p (I k x m)
        | p x       = (I k x m1,m2)
        | otherwise = (m1,I k x m2)
      where (m1,m2) = partition p (delete k m)
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    adjust             :: Eq k => (a -> a) -> k -> FM k a -> FM k a
    adjustAll          :: Eq k => (a -> a) -> k -> FM k a -> FM k a
    adjustOrInsert     :: Eq k => (a -> a) -> a -> k -> FM k a -> FM k a
    adjustAllOrInsert  :: Eq k => (a -> a) -> a -> k -> FM k a -> FM k a
    adjustOrDelete     :: Eq k => (a -> Maybe a) -> k -> FM k a -> FM k a
    adjustOrDeleteAll  :: Eq k => (a -> Maybe a) -> k -> FM k a -> FM k a
    strict             :: FM k a -> FM k a
    strictWith         :: (a -> b) -> FM k a -> FM k a
    map           :: Eq k => (a -> b) -> FM k a -> FM k b
    fold          :: Eq k => (a -> b -> b) -> b -> FM k a -> b
    fold1         :: Eq k => (a -> a -> a) -> FM k a -> a
    fold'         :: Eq k => (a -> b -> b) -> b -> FM k a -> b
    fold1'        :: Eq k => (a -> a -> a) -> FM k a -> a
    filter        :: Eq k => (a -> Bool) -> FM k a -> FM k a
    partition     :: Eq k => (a -> Bool) -> FM k a -> (FM k a, FM k a)
    elements      :: (Eq k,S.Sequence seq) => FM k a -> seq a
    
    fromSeqWith      :: (Eq k,S.Sequence seq) =>
                            (a -> a -> a) -> seq (k,a) -> FM k a
    fromSeqWithKey   :: (Eq k,S.Sequence seq) => (k -> a -> a -> a) -> seq (k,a) -> FM k a
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    --
    --   The list type is mildly customized to prevent boxing the pairs.
    
    module Data.Edison.Assoc.AssocList (
        -- * Type of simple association lists
        FM, -- instance of Assoc(X), FiniteMap(X)
            -- also instance of Functor
    
        -- * AssocX operations
        empty,singleton,fromSeq,insert,insertSeq,union,unionSeq,delete,deleteAll,
        deleteSeq,null,size,member,count,lookup,lookupM,lookupAll,
        lookupAndDelete,lookupAndDeleteM,lookupAndDeleteAll,
        lookupWithDefault,adjust,adjustAll,adjustOrInsert,adjustAllOrInsert,
        adjustOrDelete,adjustOrDeleteAll,strict,strictWith,
        map,fold,fold',fold1,fold1',filter,partition,elements,structuralInvariant,
    
        -- * OrdAssocX operations
        minView, minElem, deleteMin, unsafeInsertMin, maxView, maxElem, deleteMax,
        unsafeInsertMax, foldr, foldr', foldl, foldl', foldr1, foldr1',
        foldl1, foldl1', unsafeFromOrdSeq, unsafeAppend,
    

    rcons No usage example found for this symbol :( Collapse [-]
    reduce1 No usage example found for this symbol :( Collapse [-]
    reduce1' No usage example found for this symbol :( Collapse [-]
    reducel No usage example found for this symbol :( Collapse [-]
    reducel' No usage example found for this symbol :( Collapse [-]
    reducer See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    mergeFM :: (Ord t) => FM t t1 -> FM t t1 -> FM t t1
    mergeFM E m = m
    mergeFM m E = m
    mergeFM o1@(I k1 a1 m1) o2@(I k2 a2 m2) =
      case compare k1 k2 of
          LT -> I k1 a1 (mergeFM m1 o2)
          GT -> I k2 a2 (mergeFM o1 m2)
          EQ -> I k1 a1 (mergeFM m1 m2)
    
    toRandList :: FM t t1 -> RL.Seq (FM t t1)
    toRandList E = RL.empty
    toRandList (I k a m) = RL.lcons (I k a E) (toRandList m)
    
    mergeSortFM :: (Ord t) => FM t t1 -> FM t t1
    mergeSortFM m = RL.reducer mergeFM E (toRandList m)
    
    foldrFM :: Eq k => (a -> b -> b) -> b -> FM k a -> b
    foldrFM _ z E = z
    foldrFM f z (I k a m) = f a (foldrFM f z (delete k m))
    

    reducer' No usage example found for this symbol :( Collapse [-]
    reverse No usage example found for this symbol :( Collapse [-]
    reverseOnto No usage example found for this symbol :( Collapse [-]
    rhead No usage example found for this symbol :( Collapse [-]
    rheadM No usage example found for this symbol :( Collapse [-]
    rtail No usage example found for this symbol :( Collapse [-]
    rtailM No usage example found for this symbol :( Collapse [-]
    rview No usage example found for this symbol :( Collapse [-]
    singleton See 8 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    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;
       insertSeq = insertSeq; union = union; unionSeq = unionSeq;
       delete = delete; deleteAll = deleteAll; deleteSeq = deleteSeq;
       null = null; size = size; member = member; count = count;
       lookup = lookup; lookupM = lookupM; lookupAll = lookupAll;
       lookupAndDelete = lookupAndDelete; lookupAndDeleteM = lookupAndDeleteM;
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    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;
       insertSeq = insertSeq; union = union; unionSeq = unionSeq;
       delete = delete; deleteAll = deleteAll; deleteSeq = deleteSeq;
       null = null; size = size; member = member; count = count;
       lookup = lookup; lookupM = lookupM; lookupAll = lookupAll;
       lookupAndDelete = lookupAndDelete; lookupAndDeleteM = lookupAndDeleteM;
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    lookupWithDefault d _ E = d
    lookupWithDefault d key (I k x m) | key == k = x
                                      | otherwise = lookupWithDefault d key m
    
    elements E = S.empty
    elements (I k x m) = S.lcons x (elements (delete k m))
    
    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
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    lookupAll key (I k x m) | key == k  = S.singleton x
                            | otherwise = lookupAll key m
    
    lookupAndDelete key m = runIdentity (lookupAndDeleteM key m)
    
    lookupAndDeleteM _ E = fail "AssocList.lookupAndDeleteM: lookup failed"
    lookupAndDeleteM key (I k x m)
       | key == k  = return (x,delete k m)
       | otherwise = lookupAndDeleteM key m >>=
                        \ (z, m') -> return (z, I k x m')
    
    lookupAndDeleteAll key m =
       case lookupAndDeleteM key m of
          Nothing     -> (S.empty,m)
          Just (z,m') -> (S.singleton z,m')
    
    
    lookupWithDefault d _ E = d
    lookupWithDefault d key (I k x m) | key == k = x
                                      | otherwise = lookupWithDefault d key m
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    member _ E = False
    member key (I k _ m) = key == k || member key m
    
    count _ E = 0
    count key (I k _ m) | key == k  = 1
                        | otherwise = count key m
    
    lookup key m = runIdentity (lookupM key m)
    
    lookupM _ E = fail "AssocList.lookup: lookup failed"
    lookupM key (I k x m) | key == k  = return x
                          | otherwise = lookupM key m
    
    lookupAll _ E = S.empty
    lookupAll key (I k x m) | key == k  = S.singleton x
                            | otherwise = lookupAll key m
    
    lookupAndDelete key m = runIdentity (lookupAndDeleteM key m)
    
    lookupAndDeleteM _ E = fail "AssocList.lookupAndDeleteM: lookup failed"
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
       | p k       = dropWhileFM p m
       | otherwise = o
    
    spanFM :: (k -> Bool) -> FM k a -> (FM k a,FM k a)
    spanFM _ E = (E,E)
    spanFM p o@(I k a m)
       | p k       = let (x,y) = spanFM p m in (I k a x,y)
       | otherwise = (E,o)
    
    
    ---------------------------------------------------
    -- interface functions
    
    empty = E
    singleton k x = I k x E
    insert = I
    insertSeq kxs m = S.foldr uinsert m kxs
    fromSeq = S.foldr uinsert E
    
    union m E = m
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    import Prelude hiding (null,map,lookup,foldr,foldl,foldr1,foldl1,filter)
    import qualified Prelude
    import Data.Monoid
    import Data.Semigroup as SG
    import Control.Monad.Identity
    import qualified Data.Edison.Assoc as A
    import qualified Data.Edison.Seq as S
    import qualified Data.Edison.Seq.BinaryRandList as RL
    import Data.Edison.Assoc.Defaults
    import Test.QuickCheck (Arbitrary(..), CoArbitrary(..), variant)
    
    -- signatures for exported functions
    moduleName    :: String
    empty         :: Eq k => FM k a
    singleton     :: Eq k => k -> a -> FM k a
    fromSeq       :: (Eq k,S.Sequence seq) => seq (k,a) -> FM k a
    insert        :: Eq k => k -> a -> FM k a -> FM k a
    insertSeq     :: (Eq k,S.Sequence seq) => seq (k,a) -> FM k a -> FM k a
    union         :: Eq k => FM k a -> FM k a -> FM k a
    unionSeq      :: (Eq k,S.Sequence seq) => seq (FM k a) -> FM k a
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    --
    --   This module implements finite maps as simple association lists.
    --
    --   Duplicates are removed conceptually, but not physically.  The first
    --   occurrence of a given key is the one that is considered to be in the map.
    --
    --   The list type is mildly customized to prevent boxing the pairs.
    
    module Data.Edison.Assoc.AssocList (
        -- * Type of simple association lists
        FM, -- instance of Assoc(X), FiniteMap(X)
            -- also instance of Functor
    
        -- * AssocX operations
        empty,singleton,fromSeq,insert,insertSeq,union,unionSeq,delete,deleteAll,
        deleteSeq,null,size,member,count,lookup,lookupM,lookupAll,
        lookupAndDelete,lookupAndDeleteM,lookupAndDeleteAll,
        lookupWithDefault,adjust,adjustAll,adjustOrInsert,adjustAllOrInsert,
        adjustOrDelete,adjustOrDeleteAll,strict,strictWith,
        map,fold,fold',fold1,fold1',filter,partition,elements,structuralInvariant,
    

    size See 7 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    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;
       insertSeq = insertSeq; union = union; unionSeq = unionSeq;
       delete = delete; deleteAll = deleteAll; deleteSeq = deleteSeq;
       null = null; size = size; member = member; count = count;
       lookup = lookup; lookupM = lookupM; lookupAll = lookupAll;
       lookupAndDelete = lookupAndDelete; lookupAndDeleteM = lookupAndDeleteM;
       lookupAndDeleteAll = lookupAndDeleteAll;
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    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;
       insertSeq = insertSeq; union = union; unionSeq = unionSeq;
       delete = delete; deleteAll = deleteAll; deleteSeq = deleteSeq;
       null = null; size = size; member = member; count = count;
       lookup = lookup; lookupM = lookupM; lookupAll = lookupAll;
       lookupAndDelete = lookupAndDelete; lookupAndDeleteM = lookupAndDeleteM;
       lookupAndDeleteAll = lookupAndDeleteAll;
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    union (I k x m1) m2 = I k x (union m1 m2)
    
    unionSeq = S.foldr union E
    
    deleteAll _ E = E
    deleteAll key (I k x m) | key == k  = deleteAll key m
                            | otherwise = I k x (deleteAll key m)
    
    delete = deleteAll
    
    null E = True
    null (I _ _ _) = False
    
    size E = 0
    size (I k _ m) = 1 + size (delete k m)
    
    member _ E = False
    member key (I k _ m) = key == k || member key m
    
    count _ E = 0
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    union (I k x m1) m2 = I k x (union m1 m2)
    
    unionSeq = S.foldr union E
    
    deleteAll _ E = E
    deleteAll key (I k x m) | key == k  = deleteAll key m
                            | otherwise = I k x (deleteAll key m)
    
    delete = deleteAll
    
    null E = True
    null (I _ _ _) = False
    
    size E = 0
    size (I k _ m) = 1 + size (delete k m)
    
    member _ E = False
    member key (I k _ m) = key == k || member key m
    
    count _ E = 0
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    union E m = m
    union (I k x m1) m2 = I k x (union m1 m2)
    
    unionSeq = S.foldr union E
    
    deleteAll _ E = E
    deleteAll key (I k x m) | key == k  = deleteAll key m
                            | otherwise = I k x (deleteAll key m)
    
    delete = deleteAll
    
    null E = True
    null (I _ _ _) = False
    
    size E = 0
    size (I k _ m) = 1 + size (delete k m)
    
    member _ E = False
    member key (I k _ m) = key == k || member key m
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    -- signatures for exported functions
    moduleName    :: String
    empty         :: Eq k => FM k a
    singleton     :: Eq k => k -> a -> FM k a
    fromSeq       :: (Eq k,S.Sequence seq) => seq (k,a) -> FM k a
    insert        :: Eq k => k -> a -> FM k a -> FM k a
    insertSeq     :: (Eq k,S.Sequence seq) => seq (k,a) -> FM k a -> FM k a
    union         :: Eq k => FM k a -> FM k a -> FM k a
    unionSeq      :: (Eq k,S.Sequence seq) => seq (FM k a) -> FM k a
    delete        :: Eq k => k -> FM k a -> FM k a
    deleteAll     :: Eq k => k -> FM k a -> FM k a
    deleteSeq     :: (Eq k,S.Sequence seq) => seq k -> FM k a -> FM k a
    null          :: Eq k => FM k a -> Bool
    size          :: Eq k => FM k a -> Int
    member        :: Eq k => k -> FM k a -> Bool
    count         :: Eq k => k -> FM k a -> Int
    lookup        :: Eq k => k -> FM k a -> a
    lookupM       :: (Eq k, Monad rm) => k -> FM k a -> rm a
    lookupAll     :: (Eq k,S.Sequence seq) => k -> FM k a -> seq a
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    --   This module implements finite maps as simple association lists.
    --
    --   Duplicates are removed conceptually, but not physically.  The first
    --   occurrence of a given key is the one that is considered to be in the map.
    --
    --   The list type is mildly customized to prevent boxing the pairs.
    
    module Data.Edison.Assoc.AssocList (
        -- * Type of simple association lists
        FM, -- instance of Assoc(X), FiniteMap(X)
            -- also instance of Functor
    
        -- * AssocX operations
        empty,singleton,fromSeq,insert,insertSeq,union,unionSeq,delete,deleteAll,
        deleteSeq,null,size,member,count,lookup,lookupM,lookupAll,
        lookupAndDelete,lookupAndDeleteM,lookupAndDeleteAll,
        lookupWithDefault,adjust,adjustAll,adjustOrInsert,adjustAllOrInsert,
        adjustOrDelete,adjustOrDeleteAll,strict,strictWith,
        map,fold,fold',fold1,fold1',filter,partition,elements,structuralInvariant,
    

    splitAt No usage example found for this symbol :( Collapse [-]
    splitWhile No usage example found for this symbol :( Collapse [-]
    strict See 7 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    instance Eq k  => A.AssocX (FM k) k where
      {empty = empty; singleton = singleton; fromSeq = fromSeq; insert = insert;
       insertSeq = insertSeq; union = union; unionSeq = unionSeq;
       delete = delete; deleteAll = deleteAll; deleteSeq = deleteSeq;
       null = null; size = size; member = member; count = count;
       lookup = lookup; lookupM = lookupM; lookupAll = lookupAll;
       lookupAndDelete = lookupAndDelete; lookupAndDeleteM = lookupAndDeleteM;
       lookupAndDeleteAll = lookupAndDeleteAll;
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
       adjustAllOrInsert = adjustAllOrInsert;
       adjustOrDelete = adjustOrDelete; adjustOrDeleteAll = adjustOrDeleteAll;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       filter = filter; partition = partition; elements = elements;
       strict = strict; strictWith = strictWith;
       structuralInvariant = structuralInvariant; instanceName _ = moduleName}
    
    instance Ord k => A.OrdAssocX (FM k) k where
      {minView = minView; minElem = minElem; deleteMin = deleteMin;
       unsafeInsertMin = unsafeInsertMin; maxView = maxView; maxElem = maxElem;
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    instance Eq k  => A.AssocX (FM k) k where
      {empty = empty; singleton = singleton; fromSeq = fromSeq; insert = insert;
       insertSeq = insertSeq; union = union; unionSeq = unionSeq;
       delete = delete; deleteAll = deleteAll; deleteSeq = deleteSeq;
       null = null; size = size; member = member; count = count;
       lookup = lookup; lookupM = lookupM; lookupAll = lookupAll;
       lookupAndDelete = lookupAndDelete; lookupAndDeleteM = lookupAndDeleteM;
       lookupAndDeleteAll = lookupAndDeleteAll;
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
       adjustAllOrInsert = adjustAllOrInsert;
       adjustOrDelete = adjustOrDelete; adjustOrDeleteAll = adjustOrDeleteAll;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       filter = filter; partition = partition; elements = elements;
       strict = strict; strictWith = strictWith;
       structuralInvariant = structuralInvariant; instanceName _ = moduleName}
    
    instance Ord k => A.OrdAssocX (FM k) k where
      {minView = minView; minElem = minElem; deleteMin = deleteMin;
       unsafeInsertMin = unsafeInsertMin; maxView = maxView; maxElem = maxElem;
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    maxViewWithKey E   = fail $ moduleName++".maxViewWithKey: empty map"
    maxViewWithKey n@(I k a m) = let (k',x) = findMax k a m in return ((k',x),delete k' n)
    
    maxElemWithKey E   = error $ moduleName++".maxElemWithKey: empty map"
    maxElemWithKey (I k a m) = findMax k a m
    
    foldrWithKey  f z   = foldrWithKeyFM  f z . mergeSortFM
    foldrWithKey' f z   = foldrWithKeyFM' f z . mergeSortFM
    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
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    maxViewWithKey E   = fail $ moduleName++".maxViewWithKey: empty map"
    maxViewWithKey n@(I k a m) = let (k',x) = findMax k a m in return ((k',x),delete k' n)
    
    maxElemWithKey E   = error $ moduleName++".maxElemWithKey: empty map"
    maxElemWithKey (I k a m) = findMax k a m
    
    foldrWithKey  f z   = foldrWithKeyFM  f z . mergeSortFM
    foldrWithKey' f z   = foldrWithKeyFM' f z . mergeSortFM
    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
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    maxViewWithKey E   = fail $ moduleName++".maxViewWithKey: empty map"
    maxViewWithKey n@(I k a m) = let (k',x) = findMax k a m in return ((k',x),delete k' n)
    
    maxElemWithKey E   = error $ moduleName++".maxElemWithKey: empty map"
    maxElemWithKey (I k a m) = findMax k a m
    
    foldrWithKey  f z   = foldrWithKeyFM  f z . mergeSortFM
    foldrWithKey' f z   = foldrWithKeyFM' f z . mergeSortFM
    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
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    count         :: Eq k => k -> FM k a -> Int
    lookup        :: Eq k => k -> FM k a -> a
    lookupM       :: (Eq k, Monad rm) => k -> FM k a -> rm a
    lookupAll     :: (Eq k,S.Sequence seq) => k -> FM k a -> seq a
    lookupAndDelete    :: Eq k => k -> FM k a -> (a,FM k a)
    lookupAndDeleteM   :: (Eq k,Monad rm)   => k -> FM k a -> rm (a,FM k a)
    lookupAndDeleteAll :: (Eq k,S.Sequence seq) => k -> FM k a -> (seq a,FM k a)
    lookupWithDefault  :: Eq k => a -> k -> FM k a -> a
    adjust             :: Eq k => (a -> a) -> k -> FM k a -> FM k a
    adjustAll          :: Eq k => (a -> a) -> k -> FM k a -> FM k a
    adjustOrInsert     :: Eq k => (a -> a) -> a -> k -> FM k a -> FM k a
    adjustAllOrInsert  :: Eq k => (a -> a) -> a -> k -> FM k a -> FM k a
    adjustOrDelete     :: Eq k => (a -> Maybe a) -> k -> FM k a -> FM k a
    adjustOrDeleteAll  :: Eq k => (a -> Maybe a) -> k -> FM k a -> FM k a
    strict             :: FM k a -> FM k a
    strictWith         :: (a -> b) -> FM k a -> FM k a
    map           :: Eq k => (a -> b) -> FM k a -> FM k b
    fold          :: Eq k => (a -> b -> b) -> b -> FM k a -> b
    fold1         :: Eq k => (a -> a -> a) -> FM k a -> a
    fold'         :: Eq k => (a -> b -> b) -> b -> FM k a -> b
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    --   occurrence of a given key is the one that is considered to be in the map.
    --
    --   The list type is mildly customized to prevent boxing the pairs.
    
    module Data.Edison.Assoc.AssocList (
        -- * Type of simple association lists
        FM, -- instance of Assoc(X), FiniteMap(X)
            -- also instance of Functor
    
        -- * AssocX operations
        empty,singleton,fromSeq,insert,insertSeq,union,unionSeq,delete,deleteAll,
        deleteSeq,null,size,member,count,lookup,lookupM,lookupAll,
        lookupAndDelete,lookupAndDeleteM,lookupAndDeleteAll,
        lookupWithDefault,adjust,adjustAll,adjustOrInsert,adjustAllOrInsert,
        adjustOrDelete,adjustOrDeleteAll,strict,strictWith,
        map,fold,fold',fold1,fold1',filter,partition,elements,structuralInvariant,
    
        -- * OrdAssocX operations
        minView, minElem, deleteMin, unsafeInsertMin, maxView, maxElem, deleteMax,
        unsafeInsertMax, foldr, foldr', foldl, foldl', foldr1, foldr1',
    

    strictWith See 7 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    instance Eq k  => A.AssocX (FM k) k where
      {empty = empty; singleton = singleton; fromSeq = fromSeq; insert = insert;
       insertSeq = insertSeq; union = union; unionSeq = unionSeq;
       delete = delete; deleteAll = deleteAll; deleteSeq = deleteSeq;
       null = null; size = size; member = member; count = count;
       lookup = lookup; lookupM = lookupM; lookupAll = lookupAll;
       lookupAndDelete = lookupAndDelete; lookupAndDeleteM = lookupAndDeleteM;
       lookupAndDeleteAll = lookupAndDeleteAll;
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
       adjustAllOrInsert = adjustAllOrInsert;
       adjustOrDelete = adjustOrDelete; adjustOrDeleteAll = adjustOrDeleteAll;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       filter = filter; partition = partition; elements = elements;
       strict = strict; strictWith = strictWith;
       structuralInvariant = structuralInvariant; instanceName _ = moduleName}
    
    instance Ord k => A.OrdAssocX (FM k) k where
      {minView = minView; minElem = minElem; deleteMin = deleteMin;
       unsafeInsertMin = unsafeInsertMin; maxView = maxView; maxElem = maxElem;
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    instance Eq k  => A.AssocX (FM k) k where
      {empty = empty; singleton = singleton; fromSeq = fromSeq; insert = insert;
       insertSeq = insertSeq; union = union; unionSeq = unionSeq;
       delete = delete; deleteAll = deleteAll; deleteSeq = deleteSeq;
       null = null; size = size; member = member; count = count;
       lookup = lookup; lookupM = lookupM; lookupAll = lookupAll;
       lookupAndDelete = lookupAndDelete; lookupAndDeleteM = lookupAndDeleteM;
       lookupAndDeleteAll = lookupAndDeleteAll;
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
       adjustAllOrInsert = adjustAllOrInsert;
       adjustOrDelete = adjustOrDelete; adjustOrDeleteAll = adjustOrDeleteAll;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       filter = filter; partition = partition; elements = elements;
       strict = strict; strictWith = strictWith;
       structuralInvariant = structuralInvariant; instanceName _ = moduleName}
    
    instance Ord k => A.OrdAssocX (FM k) k where
      {minView = minView; minElem = minElem; deleteMin = deleteMin;
       unsafeInsertMin = unsafeInsertMin; maxView = maxView; maxElem = maxElem;
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    maxElemWithKey E   = error $ moduleName++".maxElemWithKey: empty map"
    maxElemWithKey (I k a m) = findMax k a m
    
    foldrWithKey  f z   = foldrWithKeyFM  f z . mergeSortFM
    foldrWithKey' f z   = foldrWithKeyFM' f z . mergeSortFM
    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
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    maxElemWithKey E   = error $ moduleName++".maxElemWithKey: empty map"
    maxElemWithKey (I k a m) = findMax k a m
    
    foldrWithKey  f z   = foldrWithKeyFM  f z . mergeSortFM
    foldrWithKey' f z   = foldrWithKeyFM' f z . mergeSortFM
    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
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    maxElemWithKey E   = error $ moduleName++".maxElemWithKey: empty map"
    maxElemWithKey (I k a m) = findMax k a m
    
    foldrWithKey  f z   = foldrWithKeyFM  f z . mergeSortFM
    foldrWithKey' f z   = foldrWithKeyFM' f z . mergeSortFM
    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
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    lookup        :: Eq k => k -> FM k a -> a
    lookupM       :: (Eq k, Monad rm) => k -> FM k a -> rm a
    lookupAll     :: (Eq k,S.Sequence seq) => k -> FM k a -> seq a
    lookupAndDelete    :: Eq k => k -> FM k a -> (a,FM k a)
    lookupAndDeleteM   :: (Eq k,Monad rm)   => k -> FM k a -> rm (a,FM k a)
    lookupAndDeleteAll :: (Eq k,S.Sequence seq) => k -> FM k a -> (seq a,FM k a)
    lookupWithDefault  :: Eq k => a -> k -> FM k a -> a
    adjust             :: Eq k => (a -> a) -> k -> FM k a -> FM k a
    adjustAll          :: Eq k => (a -> a) -> k -> FM k a -> FM k a
    adjustOrInsert     :: Eq k => (a -> a) -> a -> k -> FM k a -> FM k a
    adjustAllOrInsert  :: Eq k => (a -> a) -> a -> k -> FM k a -> FM k a
    adjustOrDelete     :: Eq k => (a -> Maybe a) -> k -> FM k a -> FM k a
    adjustOrDeleteAll  :: Eq k => (a -> Maybe a) -> k -> FM k a -> FM k a
    strict             :: FM k a -> FM k a
    strictWith         :: (a -> b) -> FM k a -> FM k a
    map           :: Eq k => (a -> b) -> FM k a -> FM k b
    fold          :: Eq k => (a -> b -> b) -> b -> FM k a -> b
    fold1         :: Eq k => (a -> a -> a) -> FM k a -> a
    fold'         :: Eq k => (a -> b -> b) -> b -> FM k a -> b
    fold1'        :: Eq k => (a -> a -> a) -> FM k a -> a
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    --   occurrence of a given key is the one that is considered to be in the map.
    --
    --   The list type is mildly customized to prevent boxing the pairs.
    
    module Data.Edison.Assoc.AssocList (
        -- * Type of simple association lists
        FM, -- instance of Assoc(X), FiniteMap(X)
            -- also instance of Functor
    
        -- * AssocX operations
        empty,singleton,fromSeq,insert,insertSeq,union,unionSeq,delete,deleteAll,
        deleteSeq,null,size,member,count,lookup,lookupM,lookupAll,
        lookupAndDelete,lookupAndDeleteM,lookupAndDeleteAll,
        lookupWithDefault,adjust,adjustAll,adjustOrInsert,adjustAllOrInsert,
        adjustOrDelete,adjustOrDeleteAll,strict,strictWith,
        map,fold,fold',fold1,fold1',filter,partition,elements,structuralInvariant,
    
        -- * OrdAssocX operations
        minView, minElem, deleteMin, unsafeInsertMin, maxView, maxElem, deleteMax,
        unsafeInsertMax, foldr, foldr', foldl, foldl', foldr1, foldr1',
    

    structuralInvariant See 5 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
      {empty = empty; singleton = singleton; fromSeq = fromSeq; insert = insert;
       insertSeq = insertSeq; union = union; unionSeq = unionSeq;
       delete = delete; deleteAll = deleteAll; deleteSeq = deleteSeq;
       null = null; size = size; member = member; count = count;
       lookup = lookup; lookupM = lookupM; lookupAll = lookupAll;
       lookupAndDelete = lookupAndDelete; lookupAndDeleteM = lookupAndDeleteM;
       lookupAndDeleteAll = lookupAndDeleteAll;
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
       adjustAllOrInsert = adjustAllOrInsert;
       adjustOrDelete = adjustOrDelete; adjustOrDeleteAll = adjustOrDeleteAll;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       filter = filter; partition = partition; elements = elements;
       strict = strict; strictWith = strictWith;
       structuralInvariant = structuralInvariant; instanceName _ = moduleName}
    
    instance Ord k => A.OrdAssocX (FM k) k where
      {minView = minView; minElem = minElem; deleteMin = deleteMin;
       unsafeInsertMin = unsafeInsertMin; maxView = maxView; maxElem = maxElem;
       deleteMax = deleteMax; unsafeInsertMax = unsafeInsertMax;
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
      {empty = empty; singleton = singleton; fromSeq = fromSeq; insert = insert;
       insertSeq = insertSeq; union = union; unionSeq = unionSeq;
       delete = delete; deleteAll = deleteAll; deleteSeq = deleteSeq;
       null = null; size = size; member = member; count = count;
       lookup = lookup; lookupM = lookupM; lookupAll = lookupAll;
       lookupAndDelete = lookupAndDelete; lookupAndDeleteM = lookupAndDeleteM;
       lookupAndDeleteAll = lookupAndDeleteAll;
       lookupWithDefault = lookupWithDefault; adjust = adjust;
       adjustAll = adjustAll; adjustOrInsert = adjustOrInsert;
       adjustAllOrInsert = adjustAllOrInsert;
       adjustOrDelete = adjustOrDelete; adjustOrDeleteAll = adjustOrDeleteAll;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       filter = filter; partition = partition; elements = elements;
       strict = strict; strictWith = strictWith;
       structuralInvariant = structuralInvariant; instanceName _ = moduleName}
    
    instance Ord k => A.OrdAssocX (FM k) k where
      {minView = minView; minElem = minElem; deleteMin = deleteMin;
       unsafeInsertMin = unsafeInsertMin; maxView = maxView; maxElem = maxElem;
       deleteMax = deleteMax; unsafeInsertMax = unsafeInsertMax;
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    foldrWithKey      :: Ord k => (k -> a -> b -> b) -> b -> FM k a -> b
    foldlWithKey      :: Ord k => (b -> k -> a -> b) -> b -> FM k a -> b
    foldrWithKey'     :: Ord k => (k -> a -> b -> b) -> b -> FM k a -> b
    foldlWithKey'     :: Ord k => (b -> k -> a -> b) -> b -> FM k a -> b
    toOrdSeq          :: (Ord k,S.Sequence seq) => FM k a -> seq (k,a)
    
    
    moduleName = "Data.Edison.Assoc.AssocList"
    
    
    data FM k a = E | I k a (FM k a)
    
    -- no invariants
    structuralInvariant :: Eq k => FM k a -> Bool
    structuralInvariant = const True
    
    ---------------------------------------
    -- some unexported utility functions
    
    -- uncurried insert.
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    maxElemWithKey    :: Ord k => FM k a -> (k,a)
    foldrWithKey      :: Ord k => (k -> a -> b -> b) -> b -> FM k a -> b
    foldlWithKey      :: Ord k => (b -> k -> a -> b) -> b -> FM k a -> b
    foldrWithKey'     :: Ord k => (k -> a -> b -> b) -> b -> FM k a -> b
    foldlWithKey'     :: Ord k => (b -> k -> a -> b) -> b -> FM k a -> b
    toOrdSeq          :: (Ord k,S.Sequence seq) => FM k a -> seq (k,a)
    
    
    moduleName = "Data.Edison.Assoc.AssocList"
    
    
    data FM k a = E | I k a (FM k a)
    
    -- no invariants
    structuralInvariant :: Eq k => FM k a -> Bool
    structuralInvariant = const True
    
    ---------------------------------------
    -- some unexported utility functions
    

    Found in Data.Edison.Assoc.AssocList from the package EdisonCore
    --
    --   The list type is mildly customized to prevent boxing the pairs.
    
    module Data.Edison.Assoc.AssocList (
        -- * Type of simple association lists
        FM, -- instance of Assoc(X), FiniteMap(X)
            -- also instance of Functor
    
        -- * AssocX operations
        empty,singleton,fromSeq,insert,insertSeq,union,unionSeq,delete,deleteAll,
        deleteSeq,null,size,member,count,lookup,lookupM,lookupAll,
        lookupAndDelete,lookupAndDeleteM,lookupAndDeleteAll,
        lookupWithDefault,adjust,adjustAll,adjustOrInsert,adjustAllOrInsert,
        adjustOrDelete,adjustOrDeleteAll,strict,strictWith,
        map,fold,fold',fold1,fold1',filter,partition,elements,structuralInvariant,
    
        -- * OrdAssocX operations
        minView, minElem, deleteMin