EdisonCore-1.3.3.1: A library of efficient, purely-functional data structures (Core Implementations)
CopyrightCopyright (c) 1998 2008 Chris Okasaki
LicenseMIT; see COPYRIGHT file for terms and conditions
Maintainerrobdockins AT fastmail DOT fm
Stabilitystable
PortabilityGHC, Hugs (MPTC and FD)
Safe HaskellSafe-Inferred
LanguageHaskell2010

Data.Edison.Assoc.AssocList

Description

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.

Synopsis

Type of simple association lists

data FM k a Source #

Instances

Instances details
Eq k => Functor (FM k) Source # 
Instance details

Defined in Data.Edison.Assoc.AssocList

Methods

fmap :: (a -> b) -> FM k a -> FM k b #

(<$) :: a -> FM k b -> FM k a #

Eq k => Assoc (FM k) k Source # 
Instance details

Defined in Data.Edison.Assoc.AssocList

Methods

toSeq :: Sequence seq => FM k a -> seq (k, a) #

keys :: Sequence seq => FM k a -> seq k #

mapWithKey :: (k -> a -> b) -> FM k a -> FM k b #

foldWithKey :: (k -> a -> b -> b) -> b -> FM k a -> b #

foldWithKey' :: (k -> a -> b -> b) -> b -> FM k a -> b #

filterWithKey :: (k -> a -> Bool) -> FM k a -> FM k a #

partitionWithKey :: (k -> a -> Bool) -> FM k a -> (FM k a, FM k a) #

Eq k => AssocX (FM k) k Source # 
Instance details

Defined in Data.Edison.Assoc.AssocList

Methods

empty :: FM k a #

singleton :: k -> a -> FM k a #

fromSeq :: Sequence seq => seq (k, a) -> FM k a #

insert :: k -> a -> FM k a -> FM k a #

insertSeq :: Sequence seq => seq (k, a) -> FM k a -> FM k a #

union :: FM k a -> FM k a -> FM k a #

unionSeq :: Sequence seq => seq (FM k a) -> FM k a #

delete :: k -> FM k a -> FM k a #

deleteAll :: k -> FM k a -> FM k a #

deleteSeq :: Sequence seq => seq k -> FM k a -> FM k a #

null :: FM k a -> Bool #

size :: FM k a -> Int #

member :: k -> FM k a -> Bool #

count :: k -> FM k a -> Int #

lookup :: k -> FM k a -> a #

lookupM :: MonadFail rm => k -> FM k a -> rm a #

lookupAll :: Sequence seq => k -> FM k a -> seq a #

lookupAndDelete :: k -> FM k a -> (a, FM k a) #

lookupAndDeleteM :: MonadFail rm => k -> FM k a -> rm (a, FM k a) #

lookupAndDeleteAll :: Sequence seq => k -> FM k a -> (seq a, FM k a) #

lookupWithDefault :: a -> k -> FM k a -> a #

adjust :: (a -> a) -> k -> FM k a -> FM k a #

adjustAll :: (a -> a) -> k -> FM k a -> FM k a #

adjustOrInsert :: (a -> a) -> a -> k -> FM k a -> FM k a #

adjustAllOrInsert :: (a -> a) -> a -> k -> FM k a -> FM k a #

adjustOrDelete :: (a -> Maybe a) -> k -> FM k a -> FM k a #

adjustOrDeleteAll :: (a -> Maybe a) -> k -> FM k a -> FM k a #

fold :: (a -> b -> b) -> b -> FM k a -> b #

fold' :: (a -> b -> b) -> b -> FM k a -> b #

fold1 :: (a -> a -> a) -> FM k a -> a #

fold1' :: (a -> a -> a) -> FM k a -> a #

filter :: (a -> Bool) -> FM k a -> FM k a #

partition :: (a -> Bool) -> FM k a -> (FM k a, FM k a) #

elements :: Sequence seq => FM k a -> seq a #

strict :: FM k a -> FM k a #

strictWith :: (a -> b) -> FM k a -> FM k a #

structuralInvariant :: FM k a -> Bool #

instanceName :: FM k a -> String #

Eq k => FiniteMap (FM k) k Source # 
Instance details

Defined in Data.Edison.Assoc.AssocList

Methods

unionWithKey :: (k -> a -> a -> a) -> FM k a -> FM k a -> FM k a #

unionSeqWithKey :: Sequence seq => (k -> a -> a -> a) -> seq (FM k a) -> FM k a #

intersectionWithKey :: (k -> a -> b -> c) -> FM k a -> FM k b -> FM k c #

Eq k => FiniteMapX (FM k) k Source # 
Instance details

Defined in Data.Edison.Assoc.AssocList

Methods

fromSeqWith :: Sequence seq => (a -> a -> a) -> seq (k, a) -> FM k a #

fromSeqWithKey :: Sequence seq => (k -> a -> a -> a) -> seq (k, a) -> FM k a #

insertWith :: (a -> a -> a) -> k -> a -> FM k a -> FM k a #

insertWithKey :: (k -> a -> a -> a) -> k -> a -> FM k a -> FM k a #

insertSeqWith :: Sequence seq => (a -> a -> a) -> seq (k, a) -> FM k a -> FM k a #

insertSeqWithKey :: Sequence seq => (k -> a -> a -> a) -> seq (k, a) -> FM k a -> FM k a #

unionl :: FM k a -> FM k a -> FM k a #

unionr :: FM k a -> FM k a -> FM k a #

unionWith :: (a -> a -> a) -> FM k a -> FM k a -> FM k a #

unionSeqWith :: Sequence seq => (a -> a -> a) -> seq (FM k a) -> FM k a #

intersectionWith :: (a -> b -> c) -> FM k a -> FM k b -> FM k c #

difference :: FM k a -> FM k b -> FM k a #

properSubset :: FM k a -> FM k b -> Bool #

subset :: FM k a -> FM k b -> Bool #

submapBy :: (a -> a -> Bool) -> FM k a -> FM k a -> Bool #

properSubmapBy :: (a -> a -> Bool) -> FM k a -> FM k a -> Bool #

sameMapBy :: (a -> a -> Bool) -> FM k a -> FM k a -> Bool #

Ord k => OrdAssoc (FM k) k Source # 
Instance details

Defined in Data.Edison.Assoc.AssocList

Methods

minViewWithKey :: MonadFail rm => FM k a -> rm ((k, a), FM k a) #

minElemWithKey :: FM k a -> (k, a) #

maxViewWithKey :: MonadFail rm => FM k a -> rm ((k, a), FM k a) #

maxElemWithKey :: FM k a -> (k, a) #

foldrWithKey :: (k -> a -> b -> 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 #

foldlWithKey' :: (b -> k -> a -> b) -> b -> FM k a -> b #

toOrdSeq :: Sequence seq => FM k a -> seq (k, a) #

Ord k => OrdAssocX (FM k) k Source # 
Instance details

Defined in Data.Edison.Assoc.AssocList

Methods

minView :: MonadFail rm => FM k a -> rm (a, FM k a) #

minElem :: FM k a -> a #

deleteMin :: FM k a -> FM k a #

unsafeInsertMin :: k -> a -> FM k a -> FM k a #

maxView :: MonadFail rm => FM k a -> rm (a, FM k a) #

maxElem :: FM k a -> a #

deleteMax :: FM k a -> FM k a #

unsafeInsertMax :: k -> a -> FM k a -> FM k a #

foldr :: (a -> b -> b) -> b -> FM k a -> b #

foldr' :: (a -> b -> b) -> b -> FM k a -> b #

foldl :: (b -> a -> b) -> b -> FM k a -> b #

foldl' :: (b -> a -> b) -> b -> FM k a -> b #

foldr1 :: (a -> a -> a) -> FM k a -> a #

foldr1' :: (a -> a -> a) -> FM k a -> a #

foldl1 :: (a -> a -> a) -> FM k a -> a #

foldl1' :: (a -> a -> a) -> FM k a -> a #

unsafeFromOrdSeq :: Sequence seq => seq (k, a) -> FM k a #

unsafeAppend :: FM k a -> FM k a -> FM k a #

filterLT :: k -> FM k a -> FM k a #

filterLE :: k -> FM k a -> FM k a #

filterGT :: k -> FM k a -> FM k a #

filterGE :: k -> FM k a -> FM k a #

partitionLT_GE :: k -> FM k a -> (FM k a, FM k a) #

partitionLE_GT :: k -> FM k a -> (FM k a, FM k a) #

partitionLT_GT :: k -> FM k a -> (FM k a, FM k a) #

Ord k => OrdFiniteMap (FM k) k Source # 
Instance details

Defined in Data.Edison.Assoc.AssocList

Ord k => OrdFiniteMapX (FM k) k Source # 
Instance details

Defined in Data.Edison.Assoc.AssocList

(Eq k, Arbitrary k, Arbitrary a) => Arbitrary (FM k a) Source # 
Instance details

Defined in Data.Edison.Assoc.AssocList

Methods

arbitrary :: Gen (FM k a) #

shrink :: FM k a -> [FM k a] #

(Eq k, CoArbitrary k, CoArbitrary a) => CoArbitrary (FM k a) Source # 
Instance details

Defined in Data.Edison.Assoc.AssocList

Methods

coarbitrary :: FM k a -> Gen b -> Gen b #

Eq k => Monoid (FM k a) Source # 
Instance details

Defined in Data.Edison.Assoc.AssocList

Methods

mempty :: FM k a #

mappend :: FM k a -> FM k a -> FM k a #

mconcat :: [FM k a] -> FM k a #

Eq k => Semigroup (FM k a) Source # 
Instance details

Defined in Data.Edison.Assoc.AssocList

Methods

(<>) :: FM k a -> FM k a -> FM k a #

sconcat :: NonEmpty (FM k a) -> FM k a #

stimes :: Integral b => b -> FM k a -> FM k a #

(Eq k, Read k, Read a) => Read (FM k a) Source # 
Instance details

Defined in Data.Edison.Assoc.AssocList

Methods

readsPrec :: Int -> ReadS (FM k a) #

readList :: ReadS [FM k a] #

readPrec :: ReadPrec (FM k a) #

readListPrec :: ReadPrec [FM k a] #

(Eq k, Show k, Show a) => Show (FM k a) Source # 
Instance details

Defined in Data.Edison.Assoc.AssocList

Methods

showsPrec :: Int -> FM k a -> ShowS #

show :: FM k a -> String #

showList :: [FM k a] -> ShowS #

(Eq k, Eq a) => Eq (FM k a) Source # 
Instance details

Defined in Data.Edison.Assoc.AssocList

Methods

(==) :: FM k a -> FM k a -> Bool #

(/=) :: FM k a -> FM k a -> Bool #

(Ord k, Ord a) => Ord (FM k a) Source # 
Instance details

Defined in Data.Edison.Assoc.AssocList

Methods

compare :: FM k a -> FM k a -> Ordering #

(<) :: FM k a -> FM k a -> Bool #

(<=) :: FM k a -> FM k a -> Bool #

(>) :: FM k a -> FM k a -> Bool #

(>=) :: FM k a -> FM k a -> Bool #

max :: FM k a -> FM k a -> FM k a #

min :: FM k a -> FM k a -> FM k a #

AssocX operations

empty :: Eq k => FM k a Source #

singleton :: Eq k => k -> a -> FM k a Source #

fromSeq :: (Eq k, Sequence seq) => seq (k, a) -> FM k a Source #

insert :: Eq k => k -> a -> FM k a -> FM k a Source #

insertSeq :: (Eq k, Sequence seq) => seq (k, a) -> FM k a -> FM k a Source #

union :: Eq k => FM k a -> FM k a -> FM k a Source #

unionSeq :: (Eq k, Sequence seq) => seq (FM k a) -> FM k a Source #

delete :: Eq k => k -> FM k a -> FM k a Source #

deleteAll :: Eq k => k -> FM k a -> FM k a Source #

deleteSeq :: (Eq k, Sequence seq) => seq k -> FM k a -> FM k a Source #

null :: Eq k => FM k a -> Bool Source #

size :: Eq k => FM k a -> Int Source #

member :: Eq k => k -> FM k a -> Bool Source #

count :: Eq k => k -> FM k a -> Int Source #

lookup :: Eq k => k -> FM k a -> a Source #

lookupM :: (Eq k, MonadFail rm) => k -> FM k a -> rm a Source #

lookupAll :: (Eq k, Sequence seq) => k -> FM k a -> seq a Source #

lookupAndDelete :: Eq k => k -> FM k a -> (a, FM k a) Source #

lookupAndDeleteM :: (Eq k, MonadFail rm) => k -> FM k a -> rm (a, FM k a) Source #

lookupAndDeleteAll :: (Eq k, Sequence seq) => k -> FM k a -> (seq a, FM k a) Source #

lookupWithDefault :: Eq k => a -> k -> FM k a -> a Source #

adjust :: Eq k => (a -> a) -> k -> FM k a -> FM k a Source #

adjustAll :: Eq k => (a -> a) -> k -> FM k a -> FM k a Source #

adjustOrInsert :: Eq k => (a -> a) -> a -> k -> FM k a -> FM k a Source #

adjustAllOrInsert :: Eq k => (a -> a) -> a -> k -> FM k a -> FM k a Source #

adjustOrDelete :: Eq k => (a -> Maybe a) -> k -> FM k a -> FM k a Source #

adjustOrDeleteAll :: Eq k => (a -> Maybe a) -> k -> FM k a -> FM k a Source #

strict :: FM k a -> FM k a Source #

strictWith :: (a -> b) -> FM k a -> FM k a Source #

map :: Eq k => (a -> b) -> FM k a -> FM k b Source #

fold :: Eq k => (a -> b -> b) -> b -> FM k a -> b Source #

fold' :: Eq k => (a -> b -> b) -> b -> FM k a -> b Source #

fold1 :: Eq k => (a -> a -> a) -> FM k a -> a Source #

fold1' :: Eq k => (a -> a -> a) -> FM k a -> a Source #

filter :: Eq k => (a -> Bool) -> FM k a -> FM k a Source #

partition :: Eq k => (a -> Bool) -> FM k a -> (FM k a, FM k a) Source #

elements :: (Eq k, Sequence seq) => FM k a -> seq a Source #

OrdAssocX operations

minView :: (Ord k, MonadFail m) => FM k a -> m (a, FM k a) Source #

minElem :: Ord k => FM k a -> a Source #

deleteMin :: Ord k => FM k a -> FM k a Source #

unsafeInsertMin :: Ord k => k -> a -> FM k a -> FM k a Source #

maxView :: (Ord k, MonadFail m) => FM k a -> m (a, FM k a) Source #

maxElem :: Ord k => FM k a -> a Source #

deleteMax :: Ord k => FM k a -> FM k a Source #

unsafeInsertMax :: Ord k => k -> a -> FM k a -> FM k a Source #

foldr :: Ord k => (a -> b -> b) -> b -> FM k a -> b Source #

foldr' :: Ord k => (a -> b -> b) -> b -> FM k a -> b Source #

foldl :: Ord k => (b -> a -> b) -> b -> FM k a -> b Source #

foldl' :: Ord k => (b -> a -> b) -> b -> FM k a -> b Source #

foldr1 :: Ord k => (a -> a -> a) -> FM k a -> a Source #

foldr1' :: Ord k => (a -> a -> a) -> FM k a -> a Source #

foldl1 :: Ord k => (a -> a -> a) -> FM k a -> a Source #

foldl1' :: Ord k => (a -> a -> a) -> FM k a -> a Source #

unsafeFromOrdSeq :: (Ord k, Sequence seq) => seq (k, a) -> FM k a Source #

unsafeAppend :: Ord k => FM k a -> FM k a -> FM k a Source #

filterLT :: Ord k => k -> FM k a -> FM k a Source #

filterLE :: Ord k => k -> FM k a -> FM k a Source #

filterGT :: Ord k => k -> FM k a -> FM k a Source #

filterGE :: Ord k => k -> FM k a -> FM k a Source #

partitionLT_GE :: Ord k => k -> FM k a -> (FM k a, FM k a) Source #

partitionLE_GT :: Ord k => k -> FM k a -> (FM k a, FM k a) Source #

partitionLT_GT :: Ord k => k -> FM k a -> (FM k a, FM k a) Source #

Assoc operations

toSeq :: (Eq k, Sequence seq) => FM k a -> seq (k, a) Source #

keys :: (Eq k, Sequence seq) => FM k a -> seq k Source #

mapWithKey :: Eq k => (k -> a -> b) -> FM k a -> FM k b Source #

foldWithKey :: Eq k => (k -> a -> b -> b) -> b -> FM k a -> b Source #

foldWithKey' :: Eq k => (k -> a -> b -> b) -> b -> FM k a -> b Source #

filterWithKey :: Eq k => (k -> a -> Bool) -> FM k a -> FM k a Source #

partitionWithKey :: Eq k => (k -> a -> Bool) -> FM k a -> (FM k a, FM k a) Source #

OrdAssoc operations

minViewWithKey :: (Ord k, MonadFail m) => FM k a -> m ((k, a), FM k a) Source #

minElemWithKey :: Ord k => FM k a -> (k, a) Source #

maxViewWithKey :: (Ord k, MonadFail m) => FM k a -> m ((k, a), FM k a) Source #

maxElemWithKey :: Ord k => FM k a -> (k, a) Source #

foldrWithKey :: Ord k => (k -> a -> b -> b) -> b -> FM k a -> b Source #

foldrWithKey' :: Ord k => (k -> a -> b -> b) -> b -> FM k a -> b Source #

foldlWithKey :: Ord k => (b -> k -> a -> b) -> b -> FM k a -> b Source #

foldlWithKey' :: Ord k => (b -> k -> a -> b) -> b -> FM k a -> b Source #

toOrdSeq :: (Ord k, Sequence seq) => FM k a -> seq (k, a) Source #

FiniteMapX operations

fromSeqWith :: (Eq k, Sequence seq) => (a -> a -> a) -> seq (k, a) -> FM k a Source #

fromSeqWithKey :: (Eq k, Sequence seq) => (k -> a -> a -> a) -> seq (k, a) -> FM k a Source #

insertWith :: Eq k => (a -> a -> a) -> k -> a -> FM k a -> FM k a Source #

insertWithKey :: Eq k => (k -> a -> a -> a) -> k -> a -> FM k a -> FM k a Source #

insertSeqWith :: (Eq k, Sequence seq) => (a -> a -> a) -> seq (k, a) -> FM k a -> FM k a Source #

insertSeqWithKey :: (Eq k, Sequence seq) => (k -> a -> a -> a) -> seq (k, a) -> FM k a -> FM k a Source #

unionl :: Eq k => FM k a -> FM k a -> FM k a Source #

unionr :: Eq k => FM k a -> FM k a -> FM k a Source #

unionWith :: Eq k => (a -> a -> a) -> FM k a -> FM k a -> FM k a Source #

unionSeqWith :: (Eq k, Sequence seq) => (a -> a -> a) -> seq (FM k a) -> FM k a Source #

intersectionWith :: Eq k => (a -> b -> c) -> FM k a -> FM k b -> FM k c Source #

difference :: Eq k => FM k a -> FM k b -> FM k a Source #

properSubset :: Eq k => FM k a -> FM k b -> Bool Source #

subset :: Eq k => FM k a -> FM k b -> Bool Source #

properSubmapBy :: Eq k => (a -> a -> Bool) -> FM k a -> FM k a -> Bool Source #

submapBy :: Eq k => (a -> a -> Bool) -> FM k a -> FM k a -> Bool Source #

sameMapBy :: Eq k => (a -> a -> Bool) -> FM k a -> FM k a -> Bool Source #

properSubmap :: (Eq k, Eq a) => FM k a -> FM k a -> Bool Source #

submap :: (Eq k, Eq a) => FM k a -> FM k a -> Bool Source #

sameMap :: (Eq k, Eq a) => FM k a -> FM k a -> Bool Source #

FiniteMap operations

unionWithKey :: Eq k => (k -> a -> a -> a) -> FM k a -> FM k a -> FM k a Source #

unionSeqWithKey :: (Eq k, Sequence seq) => (k -> a -> a -> a) -> seq (FM k a) -> FM k a Source #

intersectionWithKey :: Eq k => (k -> a -> b -> c) -> FM k a -> FM k b -> FM k c Source #

Documentation