{-# LANGUAGE DeriveDataTypeable #-}
{- |
Module      :  ./Common/OrderedMap.hs
Description :  ordered maps (these keep insertion order)
Copyright   :  (c)  Klaus Luettich and Uni Bremen 2005
License     :  GPLv2 or higher, see LICENSE.txt

Maintainer  :  Christian.Maeder@dfki.de
Stability   :  provisional
Portability :  portable

Ordered maps (these keep insertion order)

ordered maps keep the ordering if converted from a list and of all
insert operations which are implemented; toList uses the
insertion\/conversion order for the creation of the new list

-}

module Common.OrderedMap
  ( OMap
  , ElemWOrd (..)
  , null
  , lookup
  , insert
  , map, mapWithKey
  , update
  , filter, filterWithKey
  , partition, partitionWithKey
  , fromList, toList
  , keys, elems
  ) where

import Prelude hiding (lookup, map, filter, null)

import Data.Data
import Data.Ord
import qualified Data.List as List
import qualified Data.Map as Map
import qualified Control.Monad.Fail as Fail

data ElemWOrd a = EWOrd
  { ElemWOrd a -> Int
order :: Int
  , ElemWOrd a -> a
ele :: a }
  deriving (Int -> ElemWOrd a -> ShowS
[ElemWOrd a] -> ShowS
ElemWOrd a -> String
(Int -> ElemWOrd a -> ShowS)
-> (ElemWOrd a -> String)
-> ([ElemWOrd a] -> ShowS)
-> Show (ElemWOrd a)
forall a. Show a => Int -> ElemWOrd a -> ShowS
forall a. Show a => [ElemWOrd a] -> ShowS
forall a. Show a => ElemWOrd a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ElemWOrd a] -> ShowS
$cshowList :: forall a. Show a => [ElemWOrd a] -> ShowS
show :: ElemWOrd a -> String
$cshow :: forall a. Show a => ElemWOrd a -> String
showsPrec :: Int -> ElemWOrd a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> ElemWOrd a -> ShowS
Show, Typeable, Typeable (ElemWOrd a)
Constr
DataType
Typeable (ElemWOrd a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ElemWOrd a -> c (ElemWOrd a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ElemWOrd a))
-> (ElemWOrd a -> Constr)
-> (ElemWOrd a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ElemWOrd a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ElemWOrd a)))
-> ((forall b. Data b => b -> b) -> ElemWOrd a -> ElemWOrd a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ElemWOrd a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ElemWOrd a -> r)
-> (forall u. (forall d. Data d => d -> u) -> ElemWOrd a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ElemWOrd a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ElemWOrd a -> m (ElemWOrd a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ElemWOrd a -> m (ElemWOrd a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ElemWOrd a -> m (ElemWOrd a))
-> Data (ElemWOrd a)
ElemWOrd a -> Constr
ElemWOrd a -> DataType
(forall d. Data d => c (t d)) -> Maybe (c (ElemWOrd a))
(forall b. Data b => b -> b) -> ElemWOrd a -> ElemWOrd a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ElemWOrd a -> c (ElemWOrd a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ElemWOrd a)
forall a. Data a => Typeable (ElemWOrd a)
forall a. Data a => ElemWOrd a -> Constr
forall a. Data a => ElemWOrd a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> ElemWOrd a -> ElemWOrd a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> ElemWOrd a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> ElemWOrd a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ElemWOrd a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ElemWOrd a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> ElemWOrd a -> m (ElemWOrd a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ElemWOrd a -> m (ElemWOrd a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ElemWOrd a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ElemWOrd a -> c (ElemWOrd a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ElemWOrd a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ElemWOrd a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ElemWOrd a -> u
forall u. (forall d. Data d => d -> u) -> ElemWOrd a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ElemWOrd a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ElemWOrd a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ElemWOrd a -> m (ElemWOrd a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ElemWOrd a -> m (ElemWOrd a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ElemWOrd a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ElemWOrd a -> c (ElemWOrd a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ElemWOrd a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ElemWOrd a))
$cEWOrd :: Constr
$tElemWOrd :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> ElemWOrd a -> m (ElemWOrd a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ElemWOrd a -> m (ElemWOrd a)
gmapMp :: (forall d. Data d => d -> m d) -> ElemWOrd a -> m (ElemWOrd a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ElemWOrd a -> m (ElemWOrd a)
gmapM :: (forall d. Data d => d -> m d) -> ElemWOrd a -> m (ElemWOrd a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> ElemWOrd a -> m (ElemWOrd a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> ElemWOrd a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> ElemWOrd a -> u
gmapQ :: (forall d. Data d => d -> u) -> ElemWOrd a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> ElemWOrd a -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ElemWOrd a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ElemWOrd a -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ElemWOrd a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ElemWOrd a -> r
gmapT :: (forall b. Data b => b -> b) -> ElemWOrd a -> ElemWOrd a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> ElemWOrd a -> ElemWOrd a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ElemWOrd a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ElemWOrd a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (ElemWOrd a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ElemWOrd a))
dataTypeOf :: ElemWOrd a -> DataType
$cdataTypeOf :: forall a. Data a => ElemWOrd a -> DataType
toConstr :: ElemWOrd a -> Constr
$ctoConstr :: forall a. Data a => ElemWOrd a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ElemWOrd a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ElemWOrd a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ElemWOrd a -> c (ElemWOrd a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ElemWOrd a -> c (ElemWOrd a)
$cp1Data :: forall a. Data a => Typeable (ElemWOrd a)
Data)

instance Ord a => Eq (ElemWOrd a) where
    x :: ElemWOrd a
x == :: ElemWOrd a -> ElemWOrd a -> Bool
== y :: ElemWOrd a
y = ElemWOrd a -> ElemWOrd a -> Ordering
forall a. Ord a => a -> a -> Ordering
compare ElemWOrd a
x ElemWOrd a
y Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
== Ordering
EQ

instance Ord a => Ord (ElemWOrd a) where
    compare :: ElemWOrd a -> ElemWOrd a -> Ordering
compare = (ElemWOrd a -> a) -> ElemWOrd a -> ElemWOrd a -> Ordering
forall a b. Ord a => (b -> a) -> b -> b -> Ordering
comparing ElemWOrd a -> a
forall a. ElemWOrd a -> a
ele

type OMap a b = Map.Map a (ElemWOrd b)

null :: OMap k a -> Bool
null :: OMap k a -> Bool
null = OMap k a -> Bool
forall k a. Map k a -> Bool
Map.null

lookup :: (Fail.MonadFail m, Ord k) => k -> OMap k a -> m a
lookup :: k -> OMap k a -> m a
lookup k :: k
k = m a -> (ElemWOrd a -> m a) -> Maybe (ElemWOrd a) -> m a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (String -> m a
forall (m :: * -> *) a. MonadFail m => String -> m a
Fail.fail "Common.OrderedMap.lookup")
  (a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> m a) -> (ElemWOrd a -> a) -> ElemWOrd a -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ElemWOrd a -> a
forall a. ElemWOrd a -> a
ele) (Maybe (ElemWOrd a) -> m a)
-> (OMap k a -> Maybe (ElemWOrd a)) -> OMap k a -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k -> OMap k a -> Maybe (ElemWOrd a)
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup k
k

insert :: Ord k => k -> a -> OMap k a -> OMap k a
insert :: k -> a -> OMap k a -> OMap k a
insert k :: k
k e :: a
e m :: OMap k a
m = (ElemWOrd a -> ElemWOrd a -> ElemWOrd a)
-> k -> ElemWOrd a -> OMap k a -> OMap k a
forall k a. Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
Map.insertWith (\ ne :: ElemWOrd a
ne oe :: ElemWOrd a
oe -> ElemWOrd a
oe {ele :: a
ele = ElemWOrd a -> a
forall a. ElemWOrd a -> a
ele ElemWOrd a
ne})
               k
k (Int -> a -> ElemWOrd a
forall a. Int -> a -> ElemWOrd a
EWOrd (Int -> Int
forall a. Enum a => a -> a
succ (Int -> Int) -> Int -> Int
forall a b. (a -> b) -> a -> b
$ OMap k a -> Int
forall k a. Map k a -> Int
Map.size OMap k a
m) a
e) OMap k a
m

update :: Ord k => (a -> Maybe a) -> k -> OMap k a -> OMap k a
update :: (a -> Maybe a) -> k -> OMap k a -> OMap k a
update = (k -> a -> Maybe a) -> k -> OMap k a -> OMap k a
forall k a.
Ord k =>
(k -> a -> Maybe a) -> k -> OMap k a -> OMap k a
updateWithKey ((k -> a -> Maybe a) -> k -> OMap k a -> OMap k a)
-> ((a -> Maybe a) -> k -> a -> Maybe a)
-> (a -> Maybe a)
-> k
-> OMap k a
-> OMap k a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Maybe a) -> k -> a -> Maybe a
forall a b. a -> b -> a
const

updateWithKey :: Ord k => (k -> a -> Maybe a) -> k -> OMap k a -> OMap k a
updateWithKey :: (k -> a -> Maybe a) -> k -> OMap k a -> OMap k a
updateWithKey f :: k -> a -> Maybe a
f =
    (k -> ElemWOrd a -> Maybe (ElemWOrd a))
-> k -> OMap k a -> OMap k a
forall k a. Ord k => (k -> a -> Maybe a) -> k -> Map k a -> Map k a
Map.updateWithKey ((k -> ElemWOrd a -> Maybe (ElemWOrd a))
 -> k -> OMap k a -> OMap k a)
-> (k -> ElemWOrd a -> Maybe (ElemWOrd a))
-> k
-> OMap k a
-> OMap k a
forall a b. (a -> b) -> a -> b
$ \ k1 :: k
k1 e :: ElemWOrd a
e -> case k -> a -> Maybe a
f k
k1 (ElemWOrd a -> a
forall a. ElemWOrd a -> a
ele ElemWOrd a
e) of
                                         Nothing -> Maybe (ElemWOrd a)
forall a. Maybe a
Nothing
                                         Just x :: a
x -> ElemWOrd a -> Maybe (ElemWOrd a)
forall a. a -> Maybe a
Just ElemWOrd a
e {ele :: a
ele = a
x}
filter :: Ord k => (a -> Bool) -> OMap k a -> OMap k a
filter :: (a -> Bool) -> OMap k a -> OMap k a
filter = (k -> a -> Bool) -> OMap k a -> OMap k a
forall k a. Ord k => (k -> a -> Bool) -> OMap k a -> OMap k a
filterWithKey ((k -> a -> Bool) -> OMap k a -> OMap k a)
-> ((a -> Bool) -> k -> a -> Bool)
-> (a -> Bool)
-> OMap k a
-> OMap k a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Bool) -> k -> a -> Bool
forall a b. a -> b -> a
const

filterWithKey :: Ord k => (k -> a -> Bool) -> OMap k a -> OMap k a
filterWithKey :: (k -> a -> Bool) -> OMap k a -> OMap k a
filterWithKey p :: k -> a -> Bool
p = (k -> ElemWOrd a -> Bool) -> OMap k a -> OMap k a
forall k a. (k -> a -> Bool) -> Map k a -> Map k a
Map.filterWithKey (\ k :: k
k -> k -> a -> Bool
p k
k (a -> Bool) -> (ElemWOrd a -> a) -> ElemWOrd a -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ElemWOrd a -> a
forall a. ElemWOrd a -> a
ele)

map :: Ord k => (a -> b) -> OMap k a -> OMap k b
map :: (a -> b) -> OMap k a -> OMap k b
map = (k -> a -> b) -> OMap k a -> OMap k b
forall k a b. (k -> a -> b) -> OMap k a -> OMap k b
mapWithKey ((k -> a -> b) -> OMap k a -> OMap k b)
-> ((a -> b) -> k -> a -> b) -> (a -> b) -> OMap k a -> OMap k b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> b) -> k -> a -> b
forall a b. a -> b -> a
const

mapWithKey :: (k -> a -> b) -> OMap k a -> OMap k b
mapWithKey :: (k -> a -> b) -> OMap k a -> OMap k b
mapWithKey f :: k -> a -> b
f = (k -> ElemWOrd a -> ElemWOrd b) -> OMap k a -> OMap k b
forall k a b. (k -> a -> b) -> Map k a -> Map k b
Map.mapWithKey ( \ k :: k
k x :: ElemWOrd a
x -> ElemWOrd a
x {ele :: b
ele = k -> a -> b
f k
k (ElemWOrd a -> a
forall a. ElemWOrd a -> a
ele ElemWOrd a
x)})

partition :: Ord k => (a -> Bool) -> OMap k a -> (OMap k a, OMap k a)
partition :: (a -> Bool) -> OMap k a -> (OMap k a, OMap k a)
partition = (k -> a -> Bool) -> OMap k a -> (OMap k a, OMap k a)
forall k a.
Ord k =>
(k -> a -> Bool) -> OMap k a -> (OMap k a, OMap k a)
partitionWithKey ((k -> a -> Bool) -> OMap k a -> (OMap k a, OMap k a))
-> ((a -> Bool) -> k -> a -> Bool)
-> (a -> Bool)
-> OMap k a
-> (OMap k a, OMap k a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Bool) -> k -> a -> Bool
forall a b. a -> b -> a
const

partitionWithKey :: Ord k => (k -> a -> Bool) -> OMap k a
                 -> (OMap k a, OMap k a)
partitionWithKey :: (k -> a -> Bool) -> OMap k a -> (OMap k a, OMap k a)
partitionWithKey p :: k -> a -> Bool
p = (k -> ElemWOrd a -> Bool) -> OMap k a -> (OMap k a, OMap k a)
forall k a. (k -> a -> Bool) -> Map k a -> (Map k a, Map k a)
Map.partitionWithKey (\ k :: k
k -> k -> a -> Bool
p k
k (a -> Bool) -> (ElemWOrd a -> a) -> ElemWOrd a -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ElemWOrd a -> a
forall a. ElemWOrd a -> a
ele)

fromList :: Ord k => [(k, a)] -> OMap k a
fromList :: [(k, a)] -> OMap k a
fromList = (OMap k a -> (k, a) -> OMap k a)
-> OMap k a -> [(k, a)] -> OMap k a
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
List.foldl OMap k a -> (k, a) -> OMap k a
forall k a. Ord k => OMap k a -> (k, a) -> OMap k a
ins OMap k a
forall k a. Map k a
Map.empty
    where ins :: OMap k a -> (k, a) -> OMap k a
ins m :: OMap k a
m (k :: k
k, e :: a
e) = k -> a -> OMap k a -> OMap k a
forall k a. Ord k => k -> a -> OMap k a -> OMap k a
insert k
k a
e OMap k a
m

toList :: Ord k => OMap k a -> [(k, a)]
toList :: OMap k a -> [(k, a)]
toList = ((k, ElemWOrd a) -> (k, a)) -> [(k, ElemWOrd a)] -> [(k, a)]
forall a b. (a -> b) -> [a] -> [b]
List.map (\ (k :: k
k, e :: ElemWOrd a
e) -> (k
k, ElemWOrd a -> a
forall a. ElemWOrd a -> a
ele ElemWOrd a
e))
  ([(k, ElemWOrd a)] -> [(k, a)])
-> (OMap k a -> [(k, ElemWOrd a)]) -> OMap k a -> [(k, a)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((k, ElemWOrd a) -> (k, ElemWOrd a) -> Ordering)
-> [(k, ElemWOrd a)] -> [(k, ElemWOrd a)]
forall a. (a -> a -> Ordering) -> [a] -> [a]
List.sortBy (((k, ElemWOrd a) -> Int)
-> (k, ElemWOrd a) -> (k, ElemWOrd a) -> Ordering
forall a b. Ord a => (b -> a) -> b -> b -> Ordering
comparing (((k, ElemWOrd a) -> Int)
 -> (k, ElemWOrd a) -> (k, ElemWOrd a) -> Ordering)
-> ((k, ElemWOrd a) -> Int)
-> (k, ElemWOrd a)
-> (k, ElemWOrd a)
-> Ordering
forall a b. (a -> b) -> a -> b
$ ElemWOrd a -> Int
forall a. ElemWOrd a -> Int
order (ElemWOrd a -> Int)
-> ((k, ElemWOrd a) -> ElemWOrd a) -> (k, ElemWOrd a) -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (k, ElemWOrd a) -> ElemWOrd a
forall a b. (a, b) -> b
snd)
  ([(k, ElemWOrd a)] -> [(k, ElemWOrd a)])
-> (OMap k a -> [(k, ElemWOrd a)]) -> OMap k a -> [(k, ElemWOrd a)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. OMap k a -> [(k, ElemWOrd a)]
forall k a. Map k a -> [(k, a)]
Map.toList

keys :: Ord k => OMap k a -> [k]
keys :: OMap k a -> [k]
keys = ((k, a) -> k) -> [(k, a)] -> [k]
forall a b. (a -> b) -> [a] -> [b]
List.map (k, a) -> k
forall a b. (a, b) -> a
fst ([(k, a)] -> [k]) -> (OMap k a -> [(k, a)]) -> OMap k a -> [k]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. OMap k a -> [(k, a)]
forall k a. Ord k => OMap k a -> [(k, a)]
toList

elems :: Ord k => OMap k a -> [a]
elems :: OMap k a -> [a]
elems = ((k, a) -> a) -> [(k, a)] -> [a]
forall a b. (a -> b) -> [a] -> [b]
List.map (k, a) -> a
forall a b. (a, b) -> b
snd ([(k, a)] -> [a]) -> (OMap k a -> [(k, a)]) -> OMap k a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. OMap k a -> [(k, a)]
forall k a. Ord k => OMap k a -> [(k, a)]
toList