-- |
--   Module      :  Data.Edison.Assoc.AssocList
--   Copyright   :  Copyright (c) 2006, 2008 Robert Dockins
--   License     :  MIT; see COPYRIGHT file for terms and conditions
--
--   Maintainer  :  robdockins AT fastmail DOT fm
--   Stability   :  stable
--   Portability :  GHC, Hugs (MPTC and FD)
--
--   The standard library "Data.Map" repackaged as an Edison
--   associative collection.

module Data.Edison.Assoc.StandardMap (
    -- * Type of standard finite maps
    FM,

    -- * 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,

    -- * FiniteMapX operations
    fromSeqWith,fromSeqWithKey,insertWith,insertWithKey,insertSeqWith,
    insertSeqWithKey,unionl,unionr,unionWith,unionSeqWith,intersectionWith,
    difference,properSubset,subset,properSubmapBy,submapBy,sameMapBy,
    properSubmap,submap,sameMap,

    -- * 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,

    -- * OrdAssoc operations
    minViewWithKey, minElemWithKey, maxViewWithKey, maxElemWithKey,
    foldrWithKey, foldrWithKey', foldlWithKey, foldlWithKey', toOrdSeq,

    -- * FiniteMap operations
    unionWithKey,unionSeqWithKey,intersectionWithKey,

    -- * Documentation
    moduleName
) where

import Prelude hiding (null,map,lookup,foldr,foldl,foldr1,foldl1,foldl',filter)
import qualified Prelude
import qualified Control.Monad.Fail as Fail
import qualified Data.Edison.Assoc as A
import qualified Data.Edison.Seq as S
import qualified Data.Edison.Seq.ListSeq as L
import Data.Edison.Assoc.Defaults
import Data.Int
import Test.QuickCheck (Arbitrary(..), CoArbitrary(..))

import qualified Data.Map as DM

type FM = DM.Map

moduleName :: String
moduleName :: String
moduleName = String
"Data.Edison.Assoc.StandardMap"

empty             :: FM k a
singleton         :: Ord k => k -> a -> FM k a
fromSeq           :: (Ord k,S.Sequence seq) => seq (k,a) -> FM k a
insert            :: Ord k => k -> a -> FM k a -> FM k a
insertSeq         :: (Ord k,S.Sequence seq) => seq (k,a) -> FM k a -> FM k a
union             :: Ord k => FM k a -> FM k a -> FM k a
unionSeq          :: (Ord k,S.Sequence seq) => seq (FM k a) -> FM k a
delete            :: Ord k => k -> FM k a -> FM k a
deleteAll         :: Ord k => k -> FM k a -> FM k a
deleteSeq         :: (Ord k,S.Sequence seq) => seq k -> FM k a -> FM k a
null              :: FM k a -> Bool
size              :: FM k a -> Int
member            :: Ord k => k -> FM k a -> Bool
count             :: Ord k => k -> FM k a -> Int
lookup            :: Ord k => k -> FM k a -> a
lookupAll         :: (Ord k,S.Sequence seq) => k -> FM k a -> seq a
lookupM           :: (Ord k, Fail.MonadFail m) => k -> FM k a -> m a
lookupWithDefault :: Ord k => a -> k -> FM k a -> a
lookupAndDelete   :: Ord k => k -> FM k a -> (a, FM k a)
lookupAndDeleteM  :: (Ord k, Fail.MonadFail m) => k -> FM k a -> m (a, FM k a)
lookupAndDeleteAll :: (Ord k,S.Sequence seq) => k -> FM k a -> (seq a,FM k a)
adjust            :: Ord k => (a->a) -> k -> FM k a -> FM k a
adjustAll         :: Ord k => (a->a) -> k -> FM k a -> FM k a
adjustOrInsert    :: Ord k => (a -> a) -> a -> k -> FM k a -> FM k a
adjustAllOrInsert :: Ord k => (a -> a) -> a -> k -> FM k a -> FM k a
adjustOrDelete    :: Ord k => (a -> Maybe a) -> k -> FM k a -> FM k a
adjustOrDeleteAll :: Ord k => (a -> Maybe a) -> k -> FM k a -> FM k a
strict            :: Ord k => FM k a -> FM k a
strictWith        :: Ord k => (a -> b) -> FM k a -> FM k a
map               :: Ord k => (a -> b) -> FM k a -> FM k b
fold              :: Ord k => (a -> b -> b) -> b -> FM k a -> b
fold1             :: Ord k => (a -> a -> a) -> FM k a -> a
fold'             :: Ord k => (a -> b -> b) -> b -> FM k a -> b
fold1'            :: Ord k => (a -> a -> a) -> FM k a -> a
filter            :: Ord k => (a -> Bool) -> FM k a -> FM k a
partition         :: Ord k => (a -> Bool) -> FM k a -> (FM k a,FM k a)
elements          :: (Ord k,S.Sequence seq) => FM k a -> seq a

minView           :: (Ord k, Fail.MonadFail 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, Fail.MonadFail 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
foldl             :: Ord k => (b -> a -> b) -> b -> FM k a -> b
foldr1            :: Ord k => (a -> a -> a) -> FM k a -> a
foldl1            :: Ord k => (a -> a -> a) -> FM k a -> a
foldr'            :: Ord k => (a -> b -> b) -> b -> FM k a -> b
foldl'            :: Ord k => (b -> a -> b) -> b -> FM k a -> b
foldr1'           :: Ord k => (a -> a -> a) -> FM k a -> a
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
filterGT          :: Ord k => k -> FM k a -> FM k a
filterLE          :: Ord k => k -> FM k a -> FM k a
filterGE          :: Ord k => k -> FM k a -> FM k a
partitionLT_GE    :: Ord k => k -> FM k a -> (FM k a,FM k a)
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)

fromSeqWith       :: (Ord k,S.Sequence seq) => (a -> a -> a)
                         -> seq (k,a) -> FM k a
fromSeqWithKey    :: (Ord k,S.Sequence seq) => (k -> a -> a -> a)
                         -> seq (k,a) -> FM k a
insertWith        :: Ord k => (a -> a -> a) -> k -> a
                         -> FM k a -> FM k a
insertWithKey     :: Ord k => (k -> a -> a -> a) -> k -> a
                         -> FM k a -> FM k a
insertSeqWith     :: (Ord k,S.Sequence seq) => (a -> a -> a) -> seq (k,a)
                         -> FM k a -> FM k a
insertSeqWithKey  :: (Ord k,S.Sequence seq) => (k -> a -> a -> a) -> seq (k,a)
                         -> FM k a -> FM k a
unionl            :: Ord k => FM k a -> FM k a -> FM k a
unionr            :: Ord k => FM k a -> FM k a -> FM k a
unionWith         :: Ord k => (a -> a -> a) -> FM k a -> FM k a -> FM k a
unionSeqWith      :: (Ord k,S.Sequence seq) =>
                         (a -> a -> a) -> seq (FM k a) -> FM k a
intersectionWith  :: Ord k => (a -> b -> c) -> FM k a -> FM k b -> FM k c
difference        :: Ord k => FM k a -> FM k b -> FM k a
properSubset      :: Ord k => FM k a -> FM k b -> Bool
subset            :: Ord k => FM k a -> FM k b -> Bool
properSubmapBy    :: Ord k => (a -> a -> Bool) -> FM k a -> FM k a -> Bool
submapBy          :: Ord k => (a -> a -> Bool) -> FM k a -> FM k a -> Bool
sameMapBy         :: Ord k => (a -> a -> Bool) -> FM k a -> FM k a -> Bool
properSubmap      :: (Ord k,Eq a) => FM k a -> FM k a -> Bool
submap            :: (Ord k,Eq a) => FM k a -> FM k a -> Bool
sameMap           :: (Ord k,Eq a) => FM k a -> FM k a -> Bool

toSeq             :: (Ord k,S.Sequence seq) => FM k a -> seq (k,a)
keys              :: (Ord k,S.Sequence seq) => FM k a -> seq k
mapWithKey        :: Ord k => (k -> a -> b) -> FM k a -> FM k b
foldWithKey       :: Ord k => (k -> a -> b -> b) -> b -> FM k a -> b
foldWithKey'      :: Ord k => (k -> a -> b -> b) -> b -> FM k a -> b
filterWithKey     :: Ord k => (k -> a -> Bool) -> FM k a -> FM k a
partitionWithKey  :: Ord k => (k -> a -> Bool) -> FM k a -> (FM k a,FM k a)

minViewWithKey    :: (Ord k, Fail.MonadFail m) => FM k a -> m ((k, a), FM k a)
minElemWithKey    :: Ord k => FM k a -> (k,a)
maxViewWithKey    :: (Ord k, Fail.MonadFail m) => FM k a -> m ((k, a), FM k a)
maxElemWithKey    :: Ord k => FM k a -> (k,a)
foldrWithKey      :: (k -> a -> b -> b) -> b -> FM k a -> b
foldlWithKey      :: (b -> k -> a -> b) -> b -> FM k a -> b
foldrWithKey'     :: (k -> a -> b -> b) -> b -> FM k a -> b
foldlWithKey'     :: (b -> k -> a -> b) -> b -> FM k a -> b
toOrdSeq          :: (Ord k,S.Sequence seq) => FM k a -> seq (k,a)

unionWithKey      :: Ord k => (k -> a -> a -> a) -> FM k a -> FM k a -> FM k a
unionSeqWithKey   :: (Ord k,S.Sequence seq) => (k -> a -> a -> a)
                        -> seq (FM k a) -> FM k a
intersectionWithKey  :: Ord k => (k -> a -> b -> c) -> FM k a -> FM k b -> FM k c

structuralInvariant :: Ord k => FM k a -> Bool
structuralInvariant :: forall k a. Ord k => FM k a -> Bool
structuralInvariant = Map k a -> Bool
forall k a. Ord k => FM k a -> Bool
DM.valid


empty :: forall k a. FM k a
empty              = Map k a
forall k a. FM k a
DM.empty
singleton :: forall k a. Ord k => k -> a -> FM k a
singleton          = k -> a -> Map k a
forall k a. k -> a -> Map k a
DM.singleton
fromSeq :: forall k (seq :: * -> *) a.
(Ord k, Sequence seq) =>
seq (k, a) -> FM k a
fromSeq            = seq (k, a) -> Map k a
forall (m :: * -> *) k (seq :: * -> *) a.
(AssocX m k, Sequence seq) =>
seq (k, a) -> m a
fromSeqUsingInsertSeq
insert :: forall k a. Ord k => k -> a -> FM k a -> FM k a
insert             = k -> a -> Map k a -> Map k a
forall k a. Ord k => k -> a -> FM k a -> FM k a
DM.insert
insertSeq :: forall k (seq :: * -> *) a.
(Ord k, Sequence seq) =>
seq (k, a) -> FM k a -> FM k a
insertSeq          = seq (k, a) -> Map k a -> Map k a
forall (m :: * -> *) k (seq :: * -> *) a.
(AssocX m k, Sequence seq) =>
seq (k, a) -> m a -> m a
insertSeqUsingFoldr
union :: forall k a. Ord k => FM k a -> FM k a -> FM k a
union              = Map k a -> Map k a -> Map k a
forall k a. Ord k => FM k a -> FM k a -> FM k a
DM.union
unionSeq :: forall k (seq :: * -> *) a.
(Ord k, Sequence seq) =>
seq (FM k a) -> FM k a
unionSeq           = [Map k a] -> Map k a
forall (f :: * -> *) k a.
(Foldable f, Ord k) =>
f (Map k a) -> Map k a
DM.unions ([Map k a] -> Map k a)
-> (seq (Map k a) -> [Map k a]) -> seq (Map k a) -> Map k a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. seq (Map k a) -> [Map k a]
forall a. seq a -> [a]
forall (s :: * -> *) a. Sequence s => s a -> [a]
S.toList
delete :: forall k a. Ord k => k -> FM k a -> FM k a
delete             = k -> Map k a -> Map k a
forall k a. Ord k => k -> FM k a -> FM k a
DM.delete
deleteAll :: forall k a. Ord k => k -> FM k a -> FM k a
deleteAll          = k -> Map k a -> Map k a
forall k a. Ord k => k -> FM k a -> FM k a
DM.delete -- by finite map property
deleteSeq :: forall k (seq :: * -> *) a.
(Ord k, Sequence seq) =>
seq k -> FM k a -> FM k a
deleteSeq          = seq k -> Map k a -> Map k a
forall (m :: * -> *) k (seq :: * -> *) a.
(AssocX m k, Sequence seq) =>
seq k -> m a -> m a
deleteSeqUsingFoldr
null :: forall k a. FM k a -> Bool
null               = Map k a -> Bool
forall k a. FM k a -> Bool
DM.null
size :: forall k a. FM k a -> Int
size               = Map k a -> Int
forall k a. FM k a -> Int
DM.size
member :: forall k a. Ord k => k -> FM k a -> Bool
member             = k -> Map k a -> Bool
forall k a. Ord k => k -> FM k a -> Bool
DM.member
count :: forall k a. Ord k => k -> FM k a -> Int
count              = k -> Map k a -> Int
forall (m :: * -> *) k a. AssocX m k => k -> m a -> Int
countUsingMember
lookup :: forall k a. Ord k => k -> FM k a -> a
lookup k
k FM k a
m         = a -> (a -> a) -> Maybe a -> a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (String -> a
forall a. HasCallStack => String -> a
error (String
moduleName String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
".lookup: failed")) a -> a
forall a. a -> a
id (k -> FM k a -> Maybe a
forall k a. Ord k => k -> Map k a -> Maybe a
DM.lookup k
k FM k a
m)
lookupM :: forall k (m :: * -> *) a.
(Ord k, MonadFail m) =>
k -> FM k a -> m a
lookupM k
k FM k a
m        = m a -> (a -> m a) -> Maybe a -> m a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (String -> m a
forall a. String -> m a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
moduleName String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
".lookupM: failed")) a -> m a
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (k -> FM k a -> Maybe a
forall k a. Ord k => k -> Map k a -> Maybe a
DM.lookup k
k FM k a
m)
lookupAll :: forall k (seq :: * -> *) a.
(Ord k, Sequence seq) =>
k -> FM k a -> seq a
lookupAll          = k -> Map k a -> seq a
forall (m :: * -> *) k (seq :: * -> *) a.
(AssocX m k, Sequence seq) =>
k -> m a -> seq a
lookupAllUsingLookupM
lookupWithDefault :: forall k a. Ord k => a -> k -> FM k a -> a
lookupWithDefault  = a -> k -> Map k a -> a
forall k a. Ord k => a -> k -> FM k a -> a
DM.findWithDefault
lookupAndDelete :: forall k a. Ord k => k -> FM k a -> (a, FM k a)
lookupAndDelete    = k -> Map k a -> (a, Map k a)
forall (m :: * -> *) k a. AssocX m k => k -> m a -> (a, m a)
lookupAndDeleteDefault
lookupAndDeleteM :: forall k (m :: * -> *) a.
(Ord k, MonadFail m) =>
k -> FM k a -> m (a, FM k a)
lookupAndDeleteM   = k -> Map k a -> m (a, Map k a)
forall (rm :: * -> *) (m :: * -> *) k a.
(MonadFail rm, AssocX m k) =>
k -> m a -> rm (a, m a)
lookupAndDeleteMDefault
lookupAndDeleteAll :: forall k (seq :: * -> *) a.
(Ord k, Sequence seq) =>
k -> FM k a -> (seq a, FM k a)
lookupAndDeleteAll = k -> Map k a -> (seq a, Map k a)
forall (seq :: * -> *) (m :: * -> *) k a.
(Sequence seq, AssocX m k) =>
k -> m a -> (seq a, m a)
lookupAndDeleteAllDefault
adjust :: forall k a. Ord k => (a -> a) -> k -> FM k a -> FM k a
adjust             = (a -> a) -> k -> Map k a -> Map k a
forall k a. Ord k => (a -> a) -> k -> FM k a -> FM k a
DM.adjust
adjustAll :: forall k a. Ord k => (a -> a) -> k -> FM k a -> FM k a
adjustAll          = (a -> a) -> k -> Map k a -> Map k a
forall k a. Ord k => (a -> a) -> k -> FM k a -> FM k a
DM.adjust
adjustOrInsert :: forall k a. Ord k => (a -> a) -> a -> k -> FM k a -> FM k a
adjustOrInsert     = (a -> a) -> a -> k -> Map k a -> Map k a
forall (m :: * -> *) k a.
AssocX m k =>
(a -> a) -> a -> k -> m a -> m a
adjustOrInsertUsingMember
adjustAllOrInsert :: forall k a. Ord k => (a -> a) -> a -> k -> FM k a -> FM k a
adjustAllOrInsert  = (a -> a) -> a -> k -> Map k a -> Map k a
forall (m :: * -> *) k a.
AssocX m k =>
(a -> a) -> a -> k -> m a -> m a
adjustOrInsertUsingMember
adjustOrDelete :: forall k a. Ord k => (a -> Maybe a) -> k -> FM k a -> FM k a
adjustOrDelete     = (a -> Maybe a) -> k -> Map k a -> Map k a
forall k a. Ord k => (a -> Maybe a) -> k -> FM k a -> FM k a
DM.update
adjustOrDeleteAll :: forall k a. Ord k => (a -> Maybe a) -> k -> FM k a -> FM k a
adjustOrDeleteAll  = (a -> Maybe a) -> k -> Map k a -> Map k a
forall k a. Ord k => (a -> Maybe a) -> k -> FM k a -> FM k a
DM.update
strict :: forall k a. Ord k => FM k a -> FM k a
strict FM k a
xs          = (a -> () -> ()) -> () -> FM k a -> ()
forall a b k. (a -> b -> b) -> b -> Map k a -> b
DM.foldr ((() -> a -> ()) -> a -> () -> ()
forall a b c. (a -> b -> c) -> b -> a -> c
flip () -> a -> ()
forall a b. a -> b -> a
const) () FM k a
xs () -> FM k a -> FM k a
forall a b. a -> b -> b
`seq` FM k a
xs
strictWith :: forall k a b. Ord k => (a -> b) -> FM k a -> FM k a
strictWith a -> b
f FM k a
xs    = (a -> () -> ()) -> () -> FM k a -> ()
forall a b k. (a -> b -> b) -> b -> Map k a -> b
DM.foldr (\a
x ()
z -> a -> b
f a
x b -> () -> ()
forall a b. a -> b -> b
`seq` ()
z) () FM k a
xs () -> FM k a -> FM k a
forall a b. a -> b -> b
`seq` FM k a
xs
map :: forall k a b. Ord k => (a -> b) -> FM k a -> FM k b
map                = (a -> b) -> Map k a -> Map k b
forall a b. (a -> b) -> Map k a -> Map k b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap
fold :: forall k a b. Ord k => (a -> b -> b) -> b -> FM k a -> b
fold               = (a -> b -> b) -> b -> Map k a -> b
forall a b k. (a -> b -> b) -> b -> Map k a -> b
DM.foldr
fold' :: forall k a b. Ord k => (a -> b -> b) -> b -> FM k a -> b
fold' a -> b -> b
f b
x FM k a
xs       = (b -> a -> b) -> b -> [a] -> b
forall b a. (b -> a -> b) -> b -> [a] -> b
L.foldl' ((a -> b -> b) -> b -> a -> b
forall a b c. (a -> b -> c) -> b -> a -> c
flip a -> b -> b
f) b
x (FM k a -> [a]
forall k a. Map k a -> [a]
DM.elems FM k a
xs)
fold1 :: forall k a. Ord k => (a -> a -> a) -> FM k a -> a
fold1  a -> a -> a
f FM k a
xs        = (a -> a -> a) -> [a] -> a
forall a. (a -> a -> a) -> [a] -> a
L.foldr1 a -> a -> a
f (FM k a -> [a]
forall k a. Map k a -> [a]
DM.elems FM k a
xs)
fold1' :: forall k a. Ord k => (a -> a -> a) -> FM k a -> a
fold1' a -> a -> a
f FM k a
xs        = (a -> a -> a) -> [a] -> a
forall a. (a -> a -> a) -> [a] -> a
L.foldl1' ((a -> a -> a) -> a -> a -> a
forall a b c. (a -> b -> c) -> b -> a -> c
flip a -> a -> a
f) (FM k a -> [a]
forall k a. Map k a -> [a]
DM.elems FM k a
xs)
filter :: forall k a. Ord k => (a -> Bool) -> FM k a -> FM k a
filter             = (a -> Bool) -> Map k a -> Map k a
forall a k. (a -> Bool) -> Map k a -> Map k a
DM.filter
partition :: forall k a. Ord k => (a -> Bool) -> FM k a -> (FM k a, FM k a)
partition          = (a -> Bool) -> Map k a -> (Map k a, Map k a)
forall a k. (a -> Bool) -> Map k a -> (Map k a, Map k a)
DM.partition
elements :: forall k (seq :: * -> *) a.
(Ord k, Sequence seq) =>
FM k a -> seq a
elements           = Map k a -> seq a
forall (m :: * -> *) k (seq :: * -> *) a.
(AssocX m k, Sequence seq) =>
m a -> seq a
elementsUsingFold

minView :: forall k (m :: * -> *) a.
(Ord k, MonadFail m) =>
FM k a -> m (a, FM k a)
minView FM k a
m          = if FM k a -> Bool
forall k a. FM k a -> Bool
DM.null FM k a
m
                       then String -> m (a, FM k a)
forall a. String -> m a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
moduleName String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
".minView: failed")
                       else let ((k
_,a
x),FM k a
m') = FM k a -> ((k, a), FM k a)
forall k a. Map k a -> ((k, a), Map k a)
DM.deleteFindMin FM k a
m
                            in (a, FM k a) -> m (a, FM k a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (a
x,FM k a
m')
minElem :: forall k a. Ord k => FM k a -> a
minElem            = (k, a) -> a
forall a b. (a, b) -> b
snd ((k, a) -> a) -> (FM k a -> (k, a)) -> FM k a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FM k a -> (k, a)
forall k a. Map k a -> (k, a)
DM.findMin
deleteMin :: forall k a. Ord k => FM k a -> FM k a
deleteMin          = Map k a -> Map k a
forall k a. Map k a -> Map k a
DM.deleteMin
unsafeInsertMin :: forall k a. Ord k => k -> a -> FM k a -> FM k a
unsafeInsertMin    = k -> a -> Map k a -> Map k a
forall k a. Ord k => k -> a -> FM k a -> FM k a
DM.insert
maxView :: forall k (m :: * -> *) a.
(Ord k, MonadFail m) =>
FM k a -> m (a, FM k a)
maxView FM k a
m          = if FM k a -> Bool
forall k a. FM k a -> Bool
DM.null FM k a
m
                       then String -> m (a, FM k a)
forall a. String -> m a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
moduleName String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
".maxView: failed")
                       else let ((k
_,a
x),FM k a
m') = FM k a -> ((k, a), FM k a)
forall k a. Map k a -> ((k, a), Map k a)
DM.deleteFindMax FM k a
m
                            in (a, FM k a) -> m (a, FM k a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (a
x,FM k a
m')
maxElem :: forall k a. Ord k => FM k a -> a
maxElem            = (k, a) -> a
forall a b. (a, b) -> b
snd ((k, a) -> a) -> (FM k a -> (k, a)) -> FM k a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FM k a -> (k, a)
forall k a. Map k a -> (k, a)
DM.findMax
deleteMax :: forall k a. Ord k => FM k a -> FM k a
deleteMax          = Map k a -> Map k a
forall k a. Map k a -> Map k a
DM.deleteMax
unsafeInsertMax :: forall k a. Ord k => k -> a -> FM k a -> FM k a
unsafeInsertMax    = k -> a -> Map k a -> Map k a
forall k a. Ord k => k -> a -> FM k a -> FM k a
DM.insert
foldr :: forall k a b. Ord k => (a -> b -> b) -> b -> FM k a -> b
foldr   a -> b -> b
f b
x FM k a
m      = (a -> b -> b) -> b -> [a] -> b
forall a b. (a -> b -> b) -> b -> [a] -> b
L.foldr   a -> b -> b
f b
x (FM k a -> [a]
forall k a. Map k a -> [a]
DM.elems FM k a
m)
foldl :: forall k b a. Ord k => (b -> a -> b) -> b -> FM k a -> b
foldl   b -> a -> b
f b
x FM k a
m      = (b -> a -> b) -> b -> [a] -> b
forall b a. (b -> a -> b) -> b -> [a] -> b
L.foldl   b -> a -> b
f b
x (FM k a -> [a]
forall k a. Map k a -> [a]
DM.elems FM k a
m)
foldr1 :: forall k a. Ord k => (a -> a -> a) -> FM k a -> a
foldr1  a -> a -> a
f   FM k a
m      = (a -> a -> a) -> [a] -> a
forall a. (a -> a -> a) -> [a] -> a
L.foldr1  a -> a -> a
f   (FM k a -> [a]
forall k a. Map k a -> [a]
DM.elems FM k a
m)
foldl1 :: forall k a. Ord k => (a -> a -> a) -> FM k a -> a
foldl1  a -> a -> a
f   FM k a
m      = (a -> a -> a) -> [a] -> a
forall a. (a -> a -> a) -> [a] -> a
L.foldl1  a -> a -> a
f   (FM k a -> [a]
forall k a. Map k a -> [a]
DM.elems FM k a
m)
foldr' :: forall k a b. Ord k => (a -> b -> b) -> b -> FM k a -> b
foldr'  a -> b -> b
f b
x FM k a
m      = (a -> b -> b) -> b -> [a] -> b
forall a b. (a -> b -> b) -> b -> [a] -> b
L.foldr'  a -> b -> b
f b
x (FM k a -> [a]
forall k a. Map k a -> [a]
DM.elems FM k a
m)
foldl' :: forall k b a. Ord k => (b -> a -> b) -> b -> FM k a -> b
foldl'  b -> a -> b
f b
x FM k a
m      = (b -> a -> b) -> b -> [a] -> b
forall b a. (b -> a -> b) -> b -> [a] -> b
L.foldl'  b -> a -> b
f b
x (FM k a -> [a]
forall k a. Map k a -> [a]
DM.elems FM k a
m)
foldr1' :: forall k a. Ord k => (a -> a -> a) -> FM k a -> a
foldr1' a -> a -> a
f   FM k a
m      = (a -> a -> a) -> [a] -> a
forall a. (a -> a -> a) -> [a] -> a
L.foldr1' a -> a -> a
f   (FM k a -> [a]
forall k a. Map k a -> [a]
DM.elems FM k a
m)
foldl1' :: forall k a. Ord k => (a -> a -> a) -> FM k a -> a
foldl1' a -> a -> a
f   FM k a
m      = (a -> a -> a) -> [a] -> a
forall a. (a -> a -> a) -> [a] -> a
L.foldl1' a -> a -> a
f   (FM k a -> [a]
forall k a. Map k a -> [a]
DM.elems FM k a
m)
unsafeFromOrdSeq :: forall k (seq :: * -> *) a.
(Ord k, Sequence seq) =>
seq (k, a) -> FM k a
unsafeFromOrdSeq   = [(k, a)] -> Map k a
forall k a. Eq k => [(k, a)] -> Map k a
DM.fromAscList ([(k, a)] -> Map k a)
-> (seq (k, a) -> [(k, a)]) -> seq (k, a) -> Map k a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. seq (k, a) -> [(k, a)]
forall a. seq a -> [a]
forall (s :: * -> *) a. Sequence s => s a -> [a]
S.toList
unsafeAppend :: forall k a. Ord k => FM k a -> FM k a -> FM k a
unsafeAppend       = Map k a -> Map k a -> Map k a
forall k a. Ord k => FM k a -> FM k a -> FM k a
DM.union
filterLT :: forall k a. Ord k => k -> FM k a -> FM k a
filterLT k
k         = (FM k a, FM k a) -> FM k a
forall a b. (a, b) -> a
fst ((FM k a, FM k a) -> FM k a)
-> (FM k a -> (FM k a, FM k a)) -> FM k a -> FM k a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k -> FM k a -> (FM k a, FM k a)
forall k a. Ord k => k -> Map k a -> (Map k a, Map k a)
DM.split k
k
filterGT :: forall k a. Ord k => k -> FM k a -> FM k a
filterGT k
k         = (Map k a, Map k a) -> Map k a
forall a b. (a, b) -> b
snd ((Map k a, Map k a) -> Map k a)
-> (Map k a -> (Map k a, Map k a)) -> Map k a -> Map k a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k -> Map k a -> (Map k a, Map k a)
forall k a. Ord k => k -> Map k a -> (Map k a, Map k a)
DM.split k
k
filterLE :: forall k a. Ord k => k -> FM k a -> FM k a
filterLE k
k FM k a
m       = let (FM k a
lt, Maybe a
mx, FM k a
_ ) = k -> FM k a -> (FM k a, Maybe a, FM k a)
forall k a. Ord k => k -> Map k a -> (Map k a, Maybe a, Map k a)
DM.splitLookup k
k FM k a
m in FM k a -> (a -> FM k a) -> Maybe a -> FM k a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe FM k a
lt (\a
x -> k -> a -> FM k a -> FM k a
forall k a. Ord k => k -> a -> FM k a -> FM k a
insert k
k a
x FM k a
lt) Maybe a
mx
filterGE :: forall k a. Ord k => k -> FM k a -> FM k a
filterGE k
k FM k a
m       = let (FM k a
_ , Maybe a
mx, FM k a
gt) = k -> FM k a -> (FM k a, Maybe a, FM k a)
forall k a. Ord k => k -> Map k a -> (Map k a, Maybe a, Map k a)
DM.splitLookup k
k FM k a
m in FM k a -> (a -> FM k a) -> Maybe a -> FM k a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe FM k a
gt (\a
x -> k -> a -> FM k a -> FM k a
forall k a. Ord k => k -> a -> FM k a -> FM k a
insert k
k a
x FM k a
gt) Maybe a
mx
partitionLT_GE :: forall k a. Ord k => k -> Map k a -> (Map k a, Map k a)
partitionLT_GE k
k FM k a
m = let (FM k a
lt, Maybe a
mx, FM k a
gt) = k -> FM k a -> (FM k a, Maybe a, FM k a)
forall k a. Ord k => k -> Map k a -> (Map k a, Maybe a, Map k a)
DM.splitLookup k
k FM k a
m in (FM k a
lt, FM k a -> (a -> FM k a) -> Maybe a -> FM k a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe FM k a
gt (\a
x -> k -> a -> FM k a -> FM k a
forall k a. Ord k => k -> a -> FM k a -> FM k a
insert k
k a
x FM k a
gt) Maybe a
mx)
partitionLE_GT :: forall k a. Ord k => k -> Map k a -> (Map k a, Map k a)
partitionLE_GT k
k FM k a
m = let (FM k a
lt, Maybe a
mx, FM k a
gt) = k -> FM k a -> (FM k a, Maybe a, FM k a)
forall k a. Ord k => k -> Map k a -> (Map k a, Maybe a, Map k a)
DM.splitLookup k
k FM k a
m in (FM k a -> (a -> FM k a) -> Maybe a -> FM k a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe FM k a
lt (\a
x -> k -> a -> FM k a -> FM k a
forall k a. Ord k => k -> a -> FM k a -> FM k a
insert k
k a
x FM k a
lt) Maybe a
mx, FM k a
gt)
partitionLT_GT :: forall k a. Ord k => k -> Map k a -> (Map k a, Map k a)
partitionLT_GT     = k -> Map k a -> (Map k a, Map k a)
forall k a. Ord k => k -> Map k a -> (Map k a, Map k a)
DM.split
fromSeqWith :: forall k (seq :: * -> *) a.
(Ord k, Sequence seq) =>
(a -> a -> a) -> seq (k, a) -> FM k a
fromSeqWith    a -> a -> a
f seq (k, a)
s = (a -> a -> a) -> [(k, a)] -> Map k a
forall k a. Ord k => (a -> a -> a) -> [(k, a)] -> Map k a
DM.fromListWith    a -> a -> a
f (seq (k, a) -> [(k, a)]
forall a. seq a -> [a]
forall (s :: * -> *) a. Sequence s => s a -> [a]
S.toList seq (k, a)
s)
fromSeqWithKey :: forall k (seq :: * -> *) a.
(Ord k, Sequence seq) =>
(k -> a -> a -> a) -> seq (k, a) -> FM k a
fromSeqWithKey k -> a -> a -> a
f seq (k, a)
s = (k -> a -> a -> a) -> [(k, a)] -> Map k a
forall k a. Ord k => (k -> a -> a -> a) -> [(k, a)] -> Map k a
DM.fromListWithKey k -> a -> a -> a
f (seq (k, a) -> [(k, a)]
forall a. seq a -> [a]
forall (s :: * -> *) a. Sequence s => s a -> [a]
S.toList seq (k, a)
s)
insertWith :: forall k a. Ord k => (a -> a -> a) -> k -> a -> FM k a -> FM k a
insertWith         = (a -> a -> a) -> k -> a -> Map k a -> Map k a
forall k a. Ord k => (a -> a -> a) -> k -> a -> FM k a -> FM k a
DM.insertWith
insertWithKey :: forall k a.
Ord k =>
(k -> a -> a -> a) -> k -> a -> FM k a -> FM k a
insertWithKey      = (k -> a -> a -> a) -> k -> a -> Map k a -> Map k a
forall (m :: * -> *) k a.
FiniteMapX m k =>
(k -> a -> a -> a) -> k -> a -> m a -> m a
insertWithKeyUsingInsertWith
insertSeqWith :: forall k (seq :: * -> *) a.
(Ord k, Sequence seq) =>
(a -> a -> a) -> seq (k, a) -> FM k a -> FM k a
insertSeqWith      = (a -> a -> a) -> seq (k, a) -> Map k a -> Map k a
forall (m :: * -> *) k (seq :: * -> *) a.
(FiniteMapX m k, Sequence seq) =>
(a -> a -> a) -> seq (k, a) -> m a -> m a
insertSeqWithUsingInsertWith
insertSeqWithKey :: forall k (seq :: * -> *) a.
(Ord k, Sequence seq) =>
(k -> a -> a -> a) -> seq (k, a) -> FM k a -> FM k a
insertSeqWithKey   = (k -> a -> a -> a) -> seq (k, a) -> Map k a -> Map k a
forall (m :: * -> *) k (seq :: * -> *) a.
(FiniteMapX m k, Sequence seq) =>
(k -> a -> a -> a) -> seq (k, a) -> m a -> m a
insertSeqWithKeyUsingInsertWithKey
unionl :: forall k a. Ord k => FM k a -> FM k a -> FM k a
unionl             = Map k a -> Map k a -> Map k a
forall k a. Ord k => FM k a -> FM k a -> FM k a
DM.union
unionr :: forall k a. Ord k => FM k a -> FM k a -> FM k a
unionr             = (FM k a -> FM k a -> FM k a) -> FM k a -> FM k a -> FM k a
forall a b c. (a -> b -> c) -> b -> a -> c
flip FM k a -> FM k a -> FM k a
forall k a. Ord k => FM k a -> FM k a -> FM k a
DM.union
unionWith :: forall k a. Ord k => (a -> a -> a) -> FM k a -> FM k a -> FM k a
unionWith          = (a -> a -> a) -> Map k a -> Map k a -> Map k a
forall k a. Ord k => (a -> a -> a) -> FM k a -> FM k a -> FM k a
DM.unionWith
unionSeqWith :: forall k (seq :: * -> *) a.
(Ord k, Sequence seq) =>
(a -> a -> a) -> seq (FM k a) -> FM k a
unionSeqWith       = (a -> a -> a) -> seq (Map k a) -> Map k a
forall (m :: * -> *) k (seq :: * -> *) a.
(FiniteMapX m k, Sequence seq) =>
(a -> a -> a) -> seq (m a) -> m a
unionSeqWithUsingReduce
intersectionWith :: forall k a b c.
Ord k =>
(a -> b -> c) -> FM k a -> FM k b -> FM k c
intersectionWith   = (a -> b -> c) -> Map k a -> Map k b -> Map k c
forall k a b c.
Ord k =>
(a -> b -> c) -> FM k a -> FM k b -> FM k c
DM.intersectionWith
difference :: forall k a b. Ord k => FM k a -> FM k b -> FM k a
difference         = Map k a -> Map k b -> Map k a
forall k a b. Ord k => FM k a -> FM k b -> FM k a
DM.difference
properSubset :: forall k a b. Ord k => FM k a -> FM k b -> Bool
properSubset       = (a -> b -> Bool) -> Map k a -> Map k b -> Bool
forall k a b.
Ord k =>
(a -> b -> Bool) -> Map k a -> Map k b -> Bool
DM.isProperSubmapOfBy (\a
_ b
_ -> Bool
True)
subset :: forall k a b. Ord k => FM k a -> FM k b -> Bool
subset             = (a -> b -> Bool) -> Map k a -> Map k b -> Bool
forall k a b.
Ord k =>
(a -> b -> Bool) -> Map k a -> Map k b -> Bool
DM.isSubmapOfBy (\a
_ b
_ -> Bool
True)
properSubmapBy :: forall k a. Ord k => (a -> a -> Bool) -> FM k a -> FM k a -> Bool
properSubmapBy     = (a -> a -> Bool) -> Map k a -> Map k a -> Bool
forall k a b.
Ord k =>
(a -> b -> Bool) -> Map k a -> Map k b -> Bool
DM.isProperSubmapOfBy
submapBy :: forall k a. Ord k => (a -> a -> Bool) -> FM k a -> FM k a -> Bool
submapBy           = (a -> a -> Bool) -> Map k a -> Map k a -> Bool
forall k a b.
Ord k =>
(a -> b -> Bool) -> Map k a -> Map k b -> Bool
DM.isSubmapOfBy
sameMapBy :: forall k a. Ord k => (a -> a -> Bool) -> FM k a -> FM k a -> Bool
sameMapBy          = (a -> a -> Bool) -> Map k a -> Map k a -> Bool
forall (m :: * -> *) k a.
OrdFiniteMap m k =>
(a -> a -> Bool) -> m a -> m a -> Bool
sameMapByUsingOrdLists
properSubmap :: forall k a. (Ord k, Eq a) => FM k a -> FM k a -> Bool
properSubmap       = Map k a -> Map k a -> Bool
forall a (m :: * -> *) k.
(Eq a, FiniteMapX m k) =>
m a -> m a -> Bool
A.properSubmap
submap :: forall k a. (Ord k, Eq a) => FM k a -> FM k a -> Bool
submap             = Map k a -> Map k a -> Bool
forall a (m :: * -> *) k.
(Eq a, FiniteMapX m k) =>
m a -> m a -> Bool
A.submap
sameMap :: forall k a. (Ord k, Eq a) => FM k a -> FM k a -> Bool
sameMap            = Map k a -> Map k a -> Bool
forall a (m :: * -> *) k.
(Eq a, FiniteMapX m k) =>
m a -> m a -> Bool
A.sameMap

toSeq :: forall k (seq :: * -> *) a.
(Ord k, Sequence seq) =>
FM k a -> seq (k, a)
toSeq              = Map k a -> seq (k, a)
forall (m :: * -> *) k (seq :: * -> *) a.
(Assoc m k, Sequence seq) =>
m a -> seq (k, a)
toSeqUsingFoldWithKey
keys :: forall k (seq :: * -> *) a.
(Ord k, Sequence seq) =>
FM k a -> seq k
keys               = Map k a -> seq k
forall (m :: * -> *) k (seq :: * -> *) a.
(Assoc m k, Sequence seq) =>
m a -> seq k
keysUsingFoldWithKey
mapWithKey :: forall k a b. Ord k => (k -> a -> b) -> FM k a -> FM k b
mapWithKey         = (k -> a -> b) -> Map k a -> Map k b
forall k a b. (k -> a -> b) -> Map k a -> Map k b
DM.mapWithKey
foldWithKey :: forall k a b. Ord k => (k -> a -> b -> b) -> b -> FM k a -> b
foldWithKey        = (k -> a -> b -> b) -> b -> Map k a -> b
forall k a b. (k -> a -> b -> b) -> b -> Map k a -> b
DM.foldrWithKey
foldWithKey' :: forall k a b. Ord k => (k -> a -> b -> b) -> b -> FM k a -> b
foldWithKey' k -> a -> b -> b
f b
x FM k a
m = (b -> (k, a) -> b) -> b -> [(k, a)] -> b
forall b a. (b -> a -> b) -> b -> [a] -> b
L.foldl' (\b
b (k
k,a
a) -> k -> a -> b -> b
f k
k a
a b
b) b
x (FM k a -> [(k, a)]
forall k a. Map k a -> [(k, a)]
DM.toList FM k a
m)
filterWithKey :: forall k a. Ord k => (k -> a -> Bool) -> FM k a -> FM k a
filterWithKey      = (k -> a -> Bool) -> Map k a -> Map k a
forall k a. (k -> a -> Bool) -> Map k a -> Map k a
DM.filterWithKey
partitionWithKey :: forall k a. Ord k => (k -> a -> Bool) -> FM k a -> (FM k a, FM k a)
partitionWithKey   = (k -> a -> Bool) -> Map k a -> (Map k a, Map k a)
forall k a. (k -> a -> Bool) -> Map k a -> (Map k a, Map k a)
DM.partitionWithKey

minViewWithKey :: forall k (m :: * -> *) a.
(Ord k, MonadFail m) =>
FM k a -> m ((k, a), FM k a)
minViewWithKey FM k a
m   = if FM k a -> Bool
forall k a. FM k a -> Bool
DM.null FM k a
m
                        then String -> m ((k, a), FM k a)
forall a. String -> m a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
moduleName String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
".minViewWithKey: failed")
                        else ((k, a), FM k a) -> m ((k, a), FM k a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (FM k a -> ((k, a), FM k a)
forall k a. Map k a -> ((k, a), Map k a)
DM.deleteFindMin FM k a
m)
minElemWithKey :: forall k a. Ord k => FM k a -> (k, a)
minElemWithKey     = Map k a -> (k, a)
forall k a. Map k a -> (k, a)
DM.findMin
maxViewWithKey :: forall k (m :: * -> *) a.
(Ord k, MonadFail m) =>
FM k a -> m ((k, a), FM k a)
maxViewWithKey FM k a
m   = if FM k a -> Bool
forall k a. FM k a -> Bool
DM.null FM k a
m
                        then String -> m ((k, a), FM k a)
forall a. String -> m a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
moduleName String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
".maxViewWithKey: failed")
                        else ((k, a), FM k a) -> m ((k, a), FM k a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (FM k a -> ((k, a), FM k a)
forall k a. Map k a -> ((k, a), Map k a)
DM.deleteFindMax FM k a
m)
maxElemWithKey :: forall k a. Ord k => FM k a -> (k, a)
maxElemWithKey     = Map k a -> (k, a)
forall k a. Map k a -> (k, a)
DM.findMax
foldrWithKey :: forall k a b. (k -> a -> b -> b) -> b -> Map k a -> b
foldrWithKey        = (k -> a -> b -> b) -> b -> Map k a -> b
forall k a b. (k -> a -> b -> b) -> b -> Map k a -> b
DM.foldrWithKey
foldrWithKey' :: forall k a b. (k -> a -> b -> b) -> b -> Map k a -> b
foldrWithKey' k -> a -> b -> b
f b
x FM k a
m = ((k, a) -> b -> b) -> b -> [(k, a)] -> b
forall a b. (a -> b -> b) -> b -> [a] -> b
L.foldr' (\(k
k,a
a) b
b -> k -> a -> b -> b
f k
k a
a b
b) b
x (FM k a -> [(k, a)]
forall k a. Map k a -> [(k, a)]
DM.toAscList FM k a
m)
foldlWithKey :: forall b k a. (b -> k -> a -> b) -> b -> FM k a -> b
foldlWithKey  b -> k -> a -> b
f b
x FM k a
m = (b -> (k, a) -> b) -> b -> [(k, a)] -> b
forall b a. (b -> a -> b) -> b -> [a] -> b
L.foldl  (\b
b (k
k,a
a) -> b -> k -> a -> b
f b
b k
k a
a) b
x (FM k a -> [(k, a)]
forall k a. Map k a -> [(k, a)]
DM.toAscList FM k a
m)
foldlWithKey' :: forall b k a. (b -> k -> a -> b) -> b -> FM k a -> b
foldlWithKey' b -> k -> a -> b
f b
x FM k a
m = (b -> (k, a) -> b) -> b -> [(k, a)] -> b
forall b a. (b -> a -> b) -> b -> [a] -> b
L.foldl' (\b
b (k
k,a
a) -> b -> k -> a -> b
f b
b k
k a
a) b
x (FM k a -> [(k, a)]
forall k a. Map k a -> [(k, a)]
DM.toAscList FM k a
m)
toOrdSeq :: forall k (seq :: * -> *) a.
(Ord k, Sequence seq) =>
FM k a -> seq (k, a)
toOrdSeq           = [(k, a)] -> seq (k, a)
forall a. [a] -> seq a
forall (s :: * -> *) a. Sequence s => [a] -> s a
S.fromList ([(k, a)] -> seq (k, a))
-> (FM k a -> [(k, a)]) -> FM k a -> seq (k, a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FM k a -> [(k, a)]
forall k a. Map k a -> [(k, a)]
DM.toAscList

unionWithKey :: forall k a.
Ord k =>
(k -> a -> a -> a) -> FM k a -> FM k a -> FM k a
unionWithKey       = (k -> a -> a -> a) -> Map k a -> Map k a -> Map k a
forall k a.
Ord k =>
(k -> a -> a -> a) -> FM k a -> FM k a -> FM k a
DM.unionWithKey
unionSeqWithKey :: forall k (seq :: * -> *) a.
(Ord k, Sequence seq) =>
(k -> a -> a -> a) -> seq (FM k a) -> FM k a
unionSeqWithKey    = (k -> a -> a -> a) -> seq (Map k a) -> Map k a
forall (m :: * -> *) k (seq :: * -> *) a.
(FiniteMap m k, Sequence seq) =>
(k -> a -> a -> a) -> seq (m a) -> m a
unionSeqWithKeyUsingReduce
intersectionWithKey :: forall k a b c.
Ord k =>
(k -> a -> b -> c) -> FM k a -> FM k b -> FM k c
intersectionWithKey = (k -> a -> b -> c) -> Map k a -> Map k b -> Map k c
forall k a b c.
Ord k =>
(k -> a -> b -> c) -> FM k a -> FM k b -> FM k c
DM.intersectionWithKey


instance Ord k => A.AssocX (FM k) k where
  {empty :: forall a. FM k a
empty = FM k a
forall k a. FM k a
empty; singleton :: forall a. k -> a -> FM k a
singleton = k -> a -> FM k a
forall k a. Ord k => k -> a -> FM k a
singleton; fromSeq :: forall (seq :: * -> *) a. Sequence seq => seq (k, a) -> FM k a
fromSeq = seq (k, a) -> FM k a
forall k (seq :: * -> *) a.
(Ord k, Sequence seq) =>
seq (k, a) -> FM k a
fromSeq; insert :: forall a. k -> a -> FM k a -> FM k a
insert = k -> a -> FM k a -> FM k a
forall k a. Ord k => k -> a -> FM k a -> FM k a
insert;
   insertSeq :: forall (seq :: * -> *) a.
Sequence seq =>
seq (k, a) -> FM k a -> FM k a
insertSeq = seq (k, a) -> FM k a -> FM k a
forall k (seq :: * -> *) a.
(Ord k, Sequence seq) =>
seq (k, a) -> FM k a -> FM k a
insertSeq; union :: forall a. FM k a -> FM k a -> FM k a
union = FM k a -> FM k a -> FM k a
forall k a. Ord k => FM k a -> FM k a -> FM k a
union; unionSeq :: forall (seq :: * -> *) a. Sequence seq => seq (FM k a) -> FM k a
unionSeq = seq (FM k a) -> FM k a
forall k (seq :: * -> *) a.
(Ord k, Sequence seq) =>
seq (FM k a) -> FM k a
unionSeq;
   delete :: forall a. k -> FM k a -> FM k a
delete = k -> FM k a -> FM k a
forall k a. Ord k => k -> FM k a -> FM k a
delete; deleteAll :: forall a. k -> FM k a -> FM k a
deleteAll = k -> FM k a -> FM k a
forall k a. Ord k => k -> FM k a -> FM k a
deleteAll; deleteSeq :: forall (seq :: * -> *) a. Sequence seq => seq k -> FM k a -> FM k a
deleteSeq = seq k -> FM k a -> FM k a
forall k (seq :: * -> *) a.
(Ord k, Sequence seq) =>
seq k -> FM k a -> FM k a
deleteSeq;
   null :: forall a. FM k a -> Bool
null = FM k a -> Bool
forall k a. FM k a -> Bool
null; size :: forall a. FM k a -> Int
size = FM k a -> Int
forall k a. FM k a -> Int
size; member :: forall a. k -> FM k a -> Bool
member = k -> FM k a -> Bool
forall k a. Ord k => k -> FM k a -> Bool
member; count :: forall a. k -> FM k a -> Int
count = k -> FM k a -> Int
forall k a. Ord k => k -> FM k a -> Int
count;
   lookup :: forall a. k -> FM k a -> a
lookup = k -> FM k a -> a
forall k a. Ord k => k -> FM k a -> a
lookup; lookupM :: forall (rm :: * -> *) a. MonadFail rm => k -> FM k a -> rm a
lookupM = k -> FM k a -> rm a
forall k (m :: * -> *) a.
(Ord k, MonadFail m) =>
k -> FM k a -> m a
lookupM; lookupAll :: forall (seq :: * -> *) a. Sequence seq => k -> FM k a -> seq a
lookupAll = k -> FM k a -> seq a
forall k (seq :: * -> *) a.
(Ord k, Sequence seq) =>
k -> FM k a -> seq a
lookupAll;
   lookupAndDelete :: forall a. k -> FM k a -> (a, FM k a)
lookupAndDelete = k -> FM k a -> (a, FM k a)
forall k a. Ord k => k -> FM k a -> (a, FM k a)
lookupAndDelete; lookupAndDeleteM :: forall (rm :: * -> *) a.
MonadFail rm =>
k -> FM k a -> rm (a, FM k a)
lookupAndDeleteM = k -> FM k a -> rm (a, FM k a)
forall k (m :: * -> *) a.
(Ord k, MonadFail m) =>
k -> FM k a -> m (a, FM k a)
lookupAndDeleteM;
   lookupAndDeleteAll :: forall (seq :: * -> *) a.
Sequence seq =>
k -> FM k a -> (seq a, FM k a)
lookupAndDeleteAll = k -> FM k a -> (seq a, FM k a)
forall k (seq :: * -> *) a.
(Ord k, Sequence seq) =>
k -> FM k a -> (seq a, FM k a)
lookupAndDeleteAll;
   lookupWithDefault :: forall a. a -> k -> FM k a -> a
lookupWithDefault = a -> k -> FM k a -> a
forall k a. Ord k => a -> k -> FM k a -> a
lookupWithDefault; adjust :: forall a. (a -> a) -> k -> FM k a -> FM k a
adjust = (a -> a) -> k -> FM k a -> FM k a
forall k a. Ord k => (a -> a) -> k -> FM k a -> FM k a
adjust;
   adjustAll :: forall a. (a -> a) -> k -> FM k a -> FM k a
adjustAll = (a -> a) -> k -> FM k a -> FM k a
forall k a. Ord k => (a -> a) -> k -> FM k a -> FM k a
adjustAll; adjustOrInsert :: forall a. (a -> a) -> a -> k -> FM k a -> FM k a
adjustOrInsert = (a -> a) -> a -> k -> FM k a -> FM k a
forall k a. Ord k => (a -> a) -> a -> k -> FM k a -> FM k a
adjustOrInsert;
   adjustAllOrInsert :: forall a. (a -> a) -> a -> k -> FM k a -> FM k a
adjustAllOrInsert = (a -> a) -> a -> k -> FM k a -> FM k a
forall k a. Ord k => (a -> a) -> a -> k -> FM k a -> FM k a
adjustAllOrInsert;
   adjustOrDelete :: forall a. (a -> Maybe a) -> k -> FM k a -> FM k a
adjustOrDelete = (a -> Maybe a) -> k -> FM k a -> FM k a
forall k a. Ord k => (a -> Maybe a) -> k -> FM k a -> FM k a
adjustOrDelete; adjustOrDeleteAll :: forall a. (a -> Maybe a) -> k -> FM k a -> FM k a
adjustOrDeleteAll = (a -> Maybe a) -> k -> FM k a -> FM k a
forall k a. Ord k => (a -> Maybe a) -> k -> FM k a -> FM k a
adjustOrDeleteAll;
   fold :: forall a b. (a -> b -> b) -> b -> FM k a -> b
fold = (a -> b -> b) -> b -> FM k a -> b
forall k a b. Ord k => (a -> b -> b) -> b -> FM k a -> b
fold; fold' :: forall a b. (a -> b -> b) -> b -> FM k a -> b
fold' = (a -> b -> b) -> b -> FM k a -> b
forall k a b. Ord k => (a -> b -> b) -> b -> FM k a -> b
fold'; fold1 :: forall a. (a -> a -> a) -> FM k a -> a
fold1 = (a -> a -> a) -> FM k a -> a
forall k a. Ord k => (a -> a -> a) -> FM k a -> a
fold1; fold1' :: forall a. (a -> a -> a) -> FM k a -> a
fold1' = (a -> a -> a) -> FM k a -> a
forall k a. Ord k => (a -> a -> a) -> FM k a -> a
fold1';
   filter :: forall a. (a -> Bool) -> FM k a -> FM k a
filter = (a -> Bool) -> FM k a -> FM k a
forall k a. Ord k => (a -> Bool) -> FM k a -> FM k a
filter; partition :: forall a. (a -> Bool) -> FM k a -> (FM k a, FM k a)
partition = (a -> Bool) -> FM k a -> (FM k a, FM k a)
forall k a. Ord k => (a -> Bool) -> FM k a -> (FM k a, FM k a)
partition; elements :: forall (seq :: * -> *) a. Sequence seq => FM k a -> seq a
elements = FM k a -> seq a
forall k (seq :: * -> *) a.
(Ord k, Sequence seq) =>
FM k a -> seq a
elements;
   strict :: forall a. FM k a -> FM k a
strict = FM k a -> FM k a
forall k a. Ord k => FM k a -> FM k a
strict; strictWith :: forall a b. (a -> b) -> FM k a -> FM k a
strictWith = (a -> b) -> FM k a -> FM k a
forall k a b. Ord k => (a -> b) -> FM k a -> FM k a
strictWith;
   structuralInvariant :: forall a. FM k a -> Bool
structuralInvariant = FM k a -> Bool
forall k a. Ord k => FM k a -> Bool
structuralInvariant; instanceName :: forall a. FM k a -> String
instanceName FM k a
_ = String
moduleName}

instance Ord k => A.OrdAssocX (FM k) k where
  {minView :: forall (rm :: * -> *) a. MonadFail rm => FM k a -> rm (a, FM k a)
minView = FM k a -> rm (a, FM k a)
forall k (m :: * -> *) a.
(Ord k, MonadFail m) =>
FM k a -> m (a, FM k a)
minView; minElem :: forall a. FM k a -> a
minElem = FM k a -> a
forall k a. Ord k => FM k a -> a
minElem; deleteMin :: forall a. FM k a -> FM k a
deleteMin = FM k a -> FM k a
forall k a. Ord k => FM k a -> FM k a
deleteMin;
   unsafeInsertMin :: forall a. k -> a -> FM k a -> FM k a
unsafeInsertMin = k -> a -> FM k a -> FM k a
forall k a. Ord k => k -> a -> FM k a -> FM k a
unsafeInsertMin; maxView :: forall (rm :: * -> *) a. MonadFail rm => FM k a -> rm (a, FM k a)
maxView = FM k a -> rm (a, FM k a)
forall k (m :: * -> *) a.
(Ord k, MonadFail m) =>
FM k a -> m (a, FM k a)
maxView; maxElem :: forall a. FM k a -> a
maxElem = FM k a -> a
forall k a. Ord k => FM k a -> a
maxElem;
   deleteMax :: forall a. FM k a -> FM k a
deleteMax = FM k a -> FM k a
forall k a. Ord k => FM k a -> FM k a
deleteMax; unsafeInsertMax :: forall a. k -> a -> FM k a -> FM k a
unsafeInsertMax = k -> a -> FM k a -> FM k a
forall k a. Ord k => k -> a -> FM k a -> FM k a
unsafeInsertMax;
   foldr :: forall a b. (a -> b -> b) -> b -> FM k a -> b
foldr = (a -> b -> b) -> b -> FM k a -> b
forall k a b. Ord k => (a -> b -> b) -> b -> FM k a -> b
foldr; foldr' :: forall a b. (a -> b -> b) -> b -> FM k a -> b
foldr' = (a -> b -> b) -> b -> FM k a -> b
forall k a b. Ord k => (a -> b -> b) -> b -> FM k a -> b
foldr'; foldl :: forall b a. (b -> a -> b) -> b -> FM k a -> b
foldl = (b -> a -> b) -> b -> FM k a -> b
forall k b a. Ord k => (b -> a -> b) -> b -> FM k a -> b
foldl; foldl' :: forall b a. (b -> a -> b) -> b -> FM k a -> b
foldl' = (b -> a -> b) -> b -> FM k a -> b
forall k b a. Ord k => (b -> a -> b) -> b -> FM k a -> b
foldl';
   foldr1 :: forall a. (a -> a -> a) -> FM k a -> a
foldr1 = (a -> a -> a) -> FM k a -> a
forall k a. Ord k => (a -> a -> a) -> FM k a -> a
foldr1; foldr1' :: forall a. (a -> a -> a) -> FM k a -> a
foldr1' = (a -> a -> a) -> FM k a -> a
forall k a. Ord k => (a -> a -> a) -> FM k a -> a
foldr1'; foldl1 :: forall a. (a -> a -> a) -> FM k a -> a
foldl1 = (a -> a -> a) -> FM k a -> a
forall k a. Ord k => (a -> a -> a) -> FM k a -> a
foldl1; foldl1' :: forall a. (a -> a -> a) -> FM k a -> a
foldl1' = (a -> a -> a) -> FM k a -> a
forall k a. Ord k => (a -> a -> a) -> FM k a -> a
foldl1';
   unsafeFromOrdSeq :: forall (seq :: * -> *) a. Sequence seq => seq (k, a) -> FM k a
unsafeFromOrdSeq = seq (k, a) -> FM k a
forall k (seq :: * -> *) a.
(Ord k, Sequence seq) =>
seq (k, a) -> FM k a
unsafeFromOrdSeq; unsafeAppend :: forall a. FM k a -> FM k a -> FM k a
unsafeAppend = FM k a -> FM k a -> FM k a
forall k a. Ord k => FM k a -> FM k a -> FM k a
unsafeAppend;
   filterLT :: forall a. k -> FM k a -> FM k a
filterLT = k -> FM k a -> FM k a
forall k a. Ord k => k -> FM k a -> FM k a
filterLT; filterGT :: forall a. k -> FM k a -> FM k a
filterGT = k -> FM k a -> FM k a
forall k a. Ord k => k -> FM k a -> FM k a
filterGT; filterLE :: forall a. k -> FM k a -> FM k a
filterLE = k -> FM k a -> FM k a
forall k a. Ord k => k -> FM k a -> FM k a
filterLE;
   filterGE :: forall a. k -> FM k a -> FM k a
filterGE = k -> FM k a -> FM k a
forall k a. Ord k => k -> FM k a -> FM k a
filterGE; partitionLT_GE :: forall a. k -> FM k a -> (FM k a, FM k a)
partitionLT_GE = k -> FM k a -> (FM k a, FM k a)
forall k a. Ord k => k -> Map k a -> (Map k a, Map k a)
partitionLT_GE;
   partitionLE_GT :: forall a. k -> FM k a -> (FM k a, FM k a)
partitionLE_GT = k -> FM k a -> (FM k a, FM k a)
forall k a. Ord k => k -> Map k a -> (Map k a, Map k a)
partitionLE_GT; partitionLT_GT :: forall a. k -> FM k a -> (FM k a, FM k a)
partitionLT_GT = k -> FM k a -> (FM k a, FM k a)
forall k a. Ord k => k -> Map k a -> (Map k a, Map k a)
partitionLT_GT}

instance Ord k => A.FiniteMapX (FM k) k where
  {fromSeqWith :: forall (seq :: * -> *) a.
Sequence seq =>
(a -> a -> a) -> seq (k, a) -> FM k a
fromSeqWith = (a -> a -> a) -> seq (k, a) -> FM k a
forall k (seq :: * -> *) a.
(Ord k, Sequence seq) =>
(a -> a -> a) -> seq (k, a) -> FM k a
fromSeqWith; fromSeqWithKey :: forall (seq :: * -> *) a.
Sequence seq =>
(k -> a -> a -> a) -> seq (k, a) -> FM k a
fromSeqWithKey = (k -> a -> a -> a) -> seq (k, a) -> FM k a
forall k (seq :: * -> *) a.
(Ord k, Sequence seq) =>
(k -> a -> a -> a) -> seq (k, a) -> FM k a
fromSeqWithKey;
   insertWith :: forall a. (a -> a -> a) -> k -> a -> FM k a -> FM k a
insertWith = (a -> a -> a) -> k -> a -> FM k a -> FM k a
forall k a. Ord k => (a -> a -> a) -> k -> a -> FM k a -> FM k a
insertWith; insertWithKey :: forall a. (k -> a -> a -> a) -> k -> a -> FM k a -> FM k a
insertWithKey = (k -> a -> a -> a) -> k -> a -> FM k a -> FM k a
forall k a.
Ord k =>
(k -> a -> a -> a) -> k -> a -> FM k a -> FM k a
insertWithKey;
   insertSeqWith :: forall (seq :: * -> *) a.
Sequence seq =>
(a -> a -> a) -> seq (k, a) -> FM k a -> FM k a
insertSeqWith = (a -> a -> a) -> seq (k, a) -> FM k a -> FM k a
forall k (seq :: * -> *) a.
(Ord k, Sequence seq) =>
(a -> a -> a) -> seq (k, a) -> FM k a -> FM k a
insertSeqWith; insertSeqWithKey :: forall (seq :: * -> *) a.
Sequence seq =>
(k -> a -> a -> a) -> seq (k, a) -> FM k a -> FM k a
insertSeqWithKey = (k -> a -> a -> a) -> seq (k, a) -> FM k a -> FM k a
forall k (seq :: * -> *) a.
(Ord k, Sequence seq) =>
(k -> a -> a -> a) -> seq (k, a) -> FM k a -> FM k a
insertSeqWithKey;
   unionl :: forall a. FM k a -> FM k a -> FM k a
unionl = FM k a -> FM k a -> FM k a
forall k a. Ord k => FM k a -> FM k a -> FM k a
unionl; unionr :: forall a. FM k a -> FM k a -> FM k a
unionr = FM k a -> FM k a -> FM k a
forall k a. Ord k => FM k a -> FM k a -> FM k a
unionr; unionWith :: forall a. (a -> a -> a) -> FM k a -> FM k a -> FM k a
unionWith = (a -> a -> a) -> FM k a -> FM k a -> FM k a
forall k a. Ord k => (a -> a -> a) -> FM k a -> FM k a -> FM k a
unionWith;
   unionSeqWith :: forall (seq :: * -> *) a.
Sequence seq =>
(a -> a -> a) -> seq (FM k a) -> FM k a
unionSeqWith = (a -> a -> a) -> seq (FM k a) -> FM k a
forall k (seq :: * -> *) a.
(Ord k, Sequence seq) =>
(a -> a -> a) -> seq (FM k a) -> FM k a
unionSeqWith; intersectionWith :: forall a b c. (a -> b -> c) -> FM k a -> FM k b -> FM k c
intersectionWith = (a -> b -> c) -> FM k a -> FM k b -> FM k c
forall k a b c.
Ord k =>
(a -> b -> c) -> FM k a -> FM k b -> FM k c
intersectionWith;
   difference :: forall a b. FM k a -> FM k b -> FM k a
difference = FM k a -> FM k b -> FM k a
forall k a b. Ord k => FM k a -> FM k b -> FM k a
difference; properSubset :: forall a b. FM k a -> FM k b -> Bool
properSubset = FM k a -> FM k b -> Bool
forall k a b. Ord k => FM k a -> FM k b -> Bool
properSubset; subset :: forall a b. FM k a -> FM k b -> Bool
subset = FM k a -> FM k b -> Bool
forall k a b. Ord k => FM k a -> FM k b -> Bool
subset;
   properSubmapBy :: forall a. (a -> a -> Bool) -> FM k a -> FM k a -> Bool
properSubmapBy = (a -> a -> Bool) -> FM k a -> FM k a -> Bool
forall k a. Ord k => (a -> a -> Bool) -> FM k a -> FM k a -> Bool
properSubmapBy; submapBy :: forall a. (a -> a -> Bool) -> FM k a -> FM k a -> Bool
submapBy = (a -> a -> Bool) -> FM k a -> FM k a -> Bool
forall k a. Ord k => (a -> a -> Bool) -> FM k a -> FM k a -> Bool
submapBy;
   sameMapBy :: forall a. (a -> a -> Bool) -> FM k a -> FM k a -> Bool
sameMapBy = (a -> a -> Bool) -> FM k a -> FM k a -> Bool
forall k a. Ord k => (a -> a -> Bool) -> FM k a -> FM k a -> Bool
sameMapBy}

instance Ord k => A.OrdFiniteMapX (FM k) k

instance Ord k => A.Assoc (FM k) k where
  {toSeq :: forall (seq :: * -> *) a. Sequence seq => FM k a -> seq (k, a)
toSeq = FM k a -> seq (k, a)
forall k (seq :: * -> *) a.
(Ord k, Sequence seq) =>
FM k a -> seq (k, a)
toSeq; keys :: forall (seq :: * -> *) a. Sequence seq => FM k a -> seq k
keys = FM k a -> seq k
forall k (seq :: * -> *) a.
(Ord k, Sequence seq) =>
FM k a -> seq k
keys; mapWithKey :: forall a b. (k -> a -> b) -> FM k a -> FM k b
mapWithKey = (k -> a -> b) -> FM k a -> FM k b
forall k a b. Ord k => (k -> a -> b) -> FM k a -> FM k b
mapWithKey;
   foldWithKey :: forall a b. (k -> a -> b -> b) -> b -> FM k a -> b
foldWithKey = (k -> a -> b -> b) -> b -> FM k a -> b
forall k a b. Ord k => (k -> a -> b -> b) -> b -> FM k a -> b
foldWithKey; foldWithKey' :: forall a b. (k -> a -> b -> b) -> b -> FM k a -> b
foldWithKey' = (k -> a -> b -> b) -> b -> FM k a -> b
forall k a b. Ord k => (k -> a -> b -> b) -> b -> FM k a -> b
foldWithKey';
   filterWithKey :: forall a. (k -> a -> Bool) -> FM k a -> FM k a
filterWithKey = (k -> a -> Bool) -> FM k a -> FM k a
forall k a. Ord k => (k -> a -> Bool) -> FM k a -> FM k a
filterWithKey;
   partitionWithKey :: forall a. (k -> a -> Bool) -> FM k a -> (FM k a, FM k a)
partitionWithKey = (k -> a -> Bool) -> FM k a -> (FM k a, FM k a)
forall k a. Ord k => (k -> a -> Bool) -> FM k a -> (FM k a, FM k a)
partitionWithKey}

instance Ord k => A.OrdAssoc (FM k) k where
  {minViewWithKey :: forall (rm :: * -> *) a.
MonadFail rm =>
FM k a -> rm ((k, a), FM k a)
minViewWithKey = FM k a -> rm ((k, a), FM k a)
forall k (m :: * -> *) a.
(Ord k, MonadFail m) =>
FM k a -> m ((k, a), FM k a)
minViewWithKey; minElemWithKey :: forall a. FM k a -> (k, a)
minElemWithKey = FM k a -> (k, a)
forall k a. Ord k => FM k a -> (k, a)
minElemWithKey;
   maxViewWithKey :: forall (rm :: * -> *) a.
MonadFail rm =>
FM k a -> rm ((k, a), FM k a)
maxViewWithKey = FM k a -> rm ((k, a), FM k a)
forall k (m :: * -> *) a.
(Ord k, MonadFail m) =>
FM k a -> m ((k, a), FM k a)
maxViewWithKey; maxElemWithKey :: forall a. FM k a -> (k, a)
maxElemWithKey = FM k a -> (k, a)
forall k a. Ord k => FM k a -> (k, a)
maxElemWithKey;
   foldrWithKey :: forall a b. (k -> a -> b -> b) -> b -> FM k a -> b
foldrWithKey = (k -> a -> b -> b) -> b -> FM k a -> b
forall k a b. (k -> a -> b -> b) -> b -> Map k a -> b
foldrWithKey; foldrWithKey' :: forall a b. (k -> a -> b -> b) -> b -> FM k a -> b
foldrWithKey' = (k -> a -> b -> b) -> b -> FM k a -> b
forall k a b. (k -> a -> b -> b) -> b -> Map k a -> b
foldrWithKey';
   foldlWithKey :: forall b a. (b -> k -> a -> b) -> b -> FM k a -> b
foldlWithKey = (b -> k -> a -> b) -> b -> FM k a -> b
forall b k a. (b -> k -> a -> b) -> b -> FM k a -> b
foldlWithKey; foldlWithKey' :: forall b a. (b -> k -> a -> b) -> b -> FM k a -> b
foldlWithKey' = (b -> k -> a -> b) -> b -> FM k a -> b
forall b k a. (b -> k -> a -> b) -> b -> FM k a -> b
foldlWithKey';
   toOrdSeq :: forall (seq :: * -> *) a. Sequence seq => FM k a -> seq (k, a)
toOrdSeq = FM k a -> seq (k, a)
forall k (seq :: * -> *) a.
(Ord k, Sequence seq) =>
FM k a -> seq (k, a)
toOrdSeq}

instance Ord k => A.FiniteMap (FM k) k where
  {unionWithKey :: forall a. (k -> a -> a -> a) -> FM k a -> FM k a -> FM k a
unionWithKey = (k -> a -> a -> a) -> FM k a -> FM k a -> FM k a
forall k a.
Ord k =>
(k -> a -> a -> a) -> FM k a -> FM k a -> FM k a
unionWithKey; unionSeqWithKey :: forall (seq :: * -> *) a.
Sequence seq =>
(k -> a -> a -> a) -> seq (FM k a) -> FM k a
unionSeqWithKey = (k -> a -> a -> a) -> seq (FM k a) -> FM k a
forall k (seq :: * -> *) a.
(Ord k, Sequence seq) =>
(k -> a -> a -> a) -> seq (FM k a) -> FM k a
unionSeqWithKey;
   intersectionWithKey :: forall a b c. (k -> a -> b -> c) -> FM k a -> FM k b -> FM k c
intersectionWithKey = (k -> a -> b -> c) -> FM k a -> FM k b -> FM k c
forall k a b c.
Ord k =>
(k -> a -> b -> c) -> FM k a -> FM k b -> FM k c
intersectionWithKey}

instance Ord k => A.OrdFiniteMap (FM k) k