{-# LANGUAGE CPP #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE TupleSections #-}

module Data.Map.Ordered.Internal where

import Control.Monad (guard)
import Data.Data
import Data.Foldable (Foldable, foldl', foldMap)
import Data.Function (on)
import Data.Map (Map)
import Data.Map.Util
import Data.Monoid (Monoid(..))
#if MIN_VERSION_base(4,9,0)
import Data.Semigroup (Semigroup(..))
#endif
#if !(MIN_VERSION_base(4,8,0))
import Control.Applicative ((<$>))
import Data.Traversable
#endif
import Prelude hiding (filter, lookup, null)
import qualified Data.Map as M

data OMap k v = OMap !(Map k (Tag, v)) !(Map Tag (k, v))
	deriving (a -> OMap k b -> OMap k a
(a -> b) -> OMap k a -> OMap k b
(forall a b. (a -> b) -> OMap k a -> OMap k b)
-> (forall a b. a -> OMap k b -> OMap k a) -> Functor (OMap k)
forall a b. a -> OMap k b -> OMap k a
forall a b. (a -> b) -> OMap k a -> OMap k b
forall k a b. a -> OMap k b -> OMap k a
forall k a b. (a -> b) -> OMap k a -> OMap k b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> OMap k b -> OMap k a
$c<$ :: forall k a b. a -> OMap k b -> OMap k a
fmap :: (a -> b) -> OMap k a -> OMap k b
$cfmap :: forall k a b. (a -> b) -> OMap k a -> OMap k b
Functor, Typeable)

-- | Values are produced in insertion order, not key order.
instance Foldable (OMap k) where foldMap :: (a -> m) -> OMap k a -> m
foldMap a -> m
f (OMap Map k (Int, a)
_ Map Int (k, a)
kvs) = ((k, a) -> m) -> Map Int (k, a) -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (a -> m
f (a -> m) -> ((k, a) -> a) -> (k, a) -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (k, a) -> a
forall a b. (a, b) -> b
snd) Map Int (k, a)
kvs
instance (       Eq   k, Eq   v) => Eq   (OMap k v) where == :: OMap k v -> OMap k v -> Bool
(==)    = [(k, v)] -> [(k, v)] -> Bool
forall a. Eq a => a -> a -> Bool
(==)    ([(k, v)] -> [(k, v)] -> Bool)
-> (OMap k v -> [(k, v)]) -> OMap k v -> OMap k v -> Bool
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` OMap k v -> [(k, v)]
forall k v. OMap k v -> [(k, v)]
assocs
instance (       Ord  k, Ord  v) => Ord  (OMap k v) where compare :: OMap k v -> OMap k v -> Ordering
compare = [(k, v)] -> [(k, v)] -> Ordering
forall a. Ord a => a -> a -> Ordering
compare ([(k, v)] -> [(k, v)] -> Ordering)
-> (OMap k v -> [(k, v)]) -> OMap k v -> OMap k v -> Ordering
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` OMap k v -> [(k, v)]
forall k v. OMap k v -> [(k, v)]
assocs
instance (       Show k, Show v) => Show (OMap k v) where showsPrec :: Int -> OMap k v -> ShowS
showsPrec = (OMap k v -> [(k, v)]) -> Int -> OMap k v -> ShowS
forall a b. Show a => (b -> [a]) -> Int -> b -> ShowS
showsPrecList OMap k v -> [(k, v)]
forall k v. OMap k v -> [(k, v)]
assocs
instance (Ord k, Read k, Read v) => Read (OMap k v) where readsPrec :: Int -> ReadS (OMap k v)
readsPrec = ([(k, v)] -> OMap k v) -> Int -> ReadS (OMap k v)
forall a b. Read a => ([a] -> b) -> Int -> ReadS b
readsPrecList [(k, v)] -> OMap k v
forall k v. Ord k => [(k, v)] -> OMap k v
fromList

-- This instance preserves data abstraction at the cost of inefficiency.
-- We provide limited reflection services for the sake of data abstraction.
instance (Data k, Data a, Ord k) => Data (OMap k a) where
	gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OMap k a -> c (OMap k a)
gfoldl forall d b. Data d => c (d -> b) -> d -> c b
f forall g. g -> c g
z OMap k a
m   = ([(k, a)] -> OMap k a) -> c ([(k, a)] -> OMap k a)
forall g. g -> c g
z [(k, a)] -> OMap k a
forall k v. Ord k => [(k, v)] -> OMap k v
fromList c ([(k, a)] -> OMap k a) -> [(k, a)] -> c (OMap k a)
forall d b. Data d => c (d -> b) -> d -> c b
`f` OMap k a -> [(k, a)]
forall k v. OMap k v -> [(k, v)]
assocs OMap k a
m
	toConstr :: OMap k a -> Constr
toConstr OMap k a
_     = Constr
fromListConstr
	gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (OMap k a)
gunfold forall b r. Data b => c (b -> r) -> c r
k forall r. r -> c r
z Constr
c  = case Constr -> Int
constrIndex Constr
c of
		Int
1 -> c ([(k, a)] -> OMap k a) -> c (OMap k a)
forall b r. Data b => c (b -> r) -> c r
k (([(k, a)] -> OMap k a) -> c ([(k, a)] -> OMap k a)
forall r. r -> c r
z [(k, a)] -> OMap k a
forall k v. Ord k => [(k, v)] -> OMap k v
fromList)
		Int
_ -> String -> c (OMap k a)
forall a. HasCallStack => String -> a
error String
"gunfold"
	dataTypeOf :: OMap k a -> DataType
dataTypeOf OMap k a
_   = DataType
oMapDataType
	-- dataCast2 /must/ be eta-expanded in order to build on GHC 7.8.
	dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (OMap k a))
dataCast2 forall d e. (Data d, Data e) => c (t d e)
f    = c (t k a) -> Maybe (c (OMap k a))
forall k1 k2 k3 (c :: k1 -> *) (t :: k2 -> k3 -> k1)
       (t' :: k2 -> k3 -> k1) (a :: k2) (b :: k3).
(Typeable t, Typeable t') =>
c (t a b) -> Maybe (c (t' a b))
gcast2 c (t k a)
forall d e. (Data d, Data e) => c (t d e)
f

fromListConstr :: Constr
fromListConstr :: Constr
fromListConstr = DataType -> String -> [String] -> Fixity -> Constr
mkConstr DataType
oMapDataType String
"fromList" [] Fixity
Prefix

oMapDataType :: DataType
oMapDataType :: DataType
oMapDataType = String -> [Constr] -> DataType
mkDataType String
"Data.Map.Ordered.Map" [Constr
fromListConstr]

#if MIN_VERSION_base(4,9,0)
instance (Ord k, Semigroup v) => Semigroup (Bias L (OMap k v)) where
	Bias OMap k v
o <> :: Bias L (OMap k v) -> Bias L (OMap k v) -> Bias L (OMap k v)
<> Bias OMap k v
o' = OMap k v -> Bias L (OMap k v)
forall (dir :: IndexPreference) a. a -> Bias dir a
Bias ((k -> v -> v -> v) -> OMap k v -> OMap k v -> OMap k v
forall k v.
Ord k =>
(k -> v -> v -> v) -> OMap k v -> OMap k v -> OMap k v
unionWithL ((v -> v -> v) -> k -> v -> v -> v
forall a b. a -> b -> a
const v -> v -> v
forall a. Semigroup a => a -> a -> a
(<>)) OMap k v
o OMap k v
o')
instance (Ord k, Semigroup v) => Semigroup (Bias R (OMap k v)) where
	Bias OMap k v
o <> :: Bias R (OMap k v) -> Bias R (OMap k v) -> Bias R (OMap k v)
<> Bias OMap k v
o' = OMap k v -> Bias R (OMap k v)
forall (dir :: IndexPreference) a. a -> Bias dir a
Bias ((k -> v -> v -> v) -> OMap k v -> OMap k v -> OMap k v
forall k v.
Ord k =>
(k -> v -> v -> v) -> OMap k v -> OMap k v -> OMap k v
unionWithR ((v -> v -> v) -> k -> v -> v -> v
forall a b. a -> b -> a
const v -> v -> v
forall a. Semigroup a => a -> a -> a
(<>)) OMap k v
o OMap k v
o')
#endif

-- | Empty maps and map union. When combining two sets that share elements, the
-- indices of the left argument are preferred, and the values are combined with
-- 'mappend'.
--
-- See the asymptotics of 'unionWithL'.
instance (Ord k, Monoid v) => Monoid (Bias L (OMap k v)) where
	mempty :: Bias L (OMap k v)
mempty = OMap k v -> Bias L (OMap k v)
forall (dir :: IndexPreference) a. a -> Bias dir a
Bias OMap k v
forall k v. OMap k v
empty
	mappend :: Bias L (OMap k v) -> Bias L (OMap k v) -> Bias L (OMap k v)
mappend (Bias OMap k v
o) (Bias OMap k v
o') = OMap k v -> Bias L (OMap k v)
forall (dir :: IndexPreference) a. a -> Bias dir a
Bias ((k -> v -> v -> v) -> OMap k v -> OMap k v -> OMap k v
forall k v.
Ord k =>
(k -> v -> v -> v) -> OMap k v -> OMap k v -> OMap k v
unionWithL ((v -> v -> v) -> k -> v -> v -> v
forall a b. a -> b -> a
const v -> v -> v
forall a. Monoid a => a -> a -> a
mappend) OMap k v
o OMap k v
o')

-- | Empty maps and map union. When combining two sets that share elements, the
-- indices of the right argument are preferred, and the values are combined
-- with 'mappend'.
--
-- See the asymptotics of 'unionWithR'.
instance (Ord k, Monoid v) => Monoid (Bias R (OMap k v)) where
	mempty :: Bias R (OMap k v)
mempty = OMap k v -> Bias R (OMap k v)
forall (dir :: IndexPreference) a. a -> Bias dir a
Bias OMap k v
forall k v. OMap k v
empty
	mappend :: Bias R (OMap k v) -> Bias R (OMap k v) -> Bias R (OMap k v)
mappend (Bias OMap k v
o) (Bias OMap k v
o') = OMap k v -> Bias R (OMap k v)
forall (dir :: IndexPreference) a. a -> Bias dir a
Bias ((k -> v -> v -> v) -> OMap k v -> OMap k v -> OMap k v
forall k v.
Ord k =>
(k -> v -> v -> v) -> OMap k v -> OMap k v -> OMap k v
unionWithR ((v -> v -> v) -> k -> v -> v -> v
forall a b. a -> b -> a
const v -> v -> v
forall a. Monoid a => a -> a -> a
mappend) OMap k v
o OMap k v
o')

-- | Values are traversed in insertion order, not key order.
--
-- /O(n*log(n))/ where /n/ is the size of the map.
instance Ord k => Traversable (OMap k) where
	traverse :: (a -> f b) -> OMap k a -> f (OMap k b)
traverse a -> f b
f (OMap Map k (Int, a)
tvs Map Int (k, a)
kvs) = Map Int (k, b) -> OMap k b
forall k v. Ord k => Map Int (k, v) -> OMap k v
fromKV (Map Int (k, b) -> OMap k b) -> f (Map Int (k, b)) -> f (OMap k b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((k, a) -> f (k, b)) -> Map Int (k, a) -> f (Map Int (k, b))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (\(k
k,a
v) -> (,) k
k (b -> (k, b)) -> f b -> f (k, b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
f a
v) Map Int (k, a)
kvs

infixr 5 <|, |< -- copy :
infixl 5 >|, |>
infixr 6 <>|, |<> -- copy <>

(<|) , (|<) :: Ord k => (,)  k v -> OMap k v -> OMap k v
(>|) , (|>) :: Ord k => OMap k v -> (,)  k v -> OMap k v

-- | When a key occurs in both maps, prefer the value from the first map.
--
-- See asymptotics of 'unionWithR'.
(<>|) :: Ord k => OMap k v -> OMap k v -> OMap k v

-- | When a key occurs in both maps, prefer the value from the first map.
--
-- See asymptotics of 'unionWithL'.
(|<>) :: Ord k => OMap k v -> OMap k v -> OMap k v

(k
k, v
v) <| :: (k, v) -> OMap k v -> OMap k v
<| OMap Map k (Int, v)
tvs Map Int (k, v)
kvs = Map k (Int, v) -> Map Int (k, v) -> OMap k v
forall k v. Map k (Int, v) -> Map Int (k, v) -> OMap k v
OMap (k -> (Int, v) -> Map k (Int, v) -> Map k (Int, v)
forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert k
k (Int
t, v
v) Map k (Int, v)
tvs) (Int -> (k, v) -> Map Int (k, v) -> Map Int (k, v)
forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert Int
t (k
k, v
v) Map Int (k, v)
kvs) where
	t :: Int
t = Int -> ((Int, v) -> Int) -> Maybe (Int, v) -> Int
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Map Int (k, v) -> Int
forall a. Map Int a -> Int
nextLowerTag Map Int (k, v)
kvs) (Int, v) -> Int
forall a b. (a, b) -> a
fst (k -> Map k (Int, v) -> Maybe (Int, v)
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup k
k Map k (Int, v)
tvs)

(k
k, v
v) |< :: (k, v) -> OMap k v -> OMap k v
|< OMap k v
o = Map k (Int, v) -> Map Int (k, v) -> OMap k v
forall k v. Map k (Int, v) -> Map Int (k, v) -> OMap k v
OMap (k -> (Int, v) -> Map k (Int, v) -> Map k (Int, v)
forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert k
k (Int
t, v
v) Map k (Int, v)
tvs) (Int -> (k, v) -> Map Int (k, v) -> Map Int (k, v)
forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert Int
t (k
k, v
v) Map Int (k, v)
kvs) where
	t :: Int
t = Map Int (k, v) -> Int
forall a. Map Int a -> Int
nextLowerTag Map Int (k, v)
kvs
	OMap Map k (Int, v)
tvs Map Int (k, v)
kvs = k -> OMap k v -> OMap k v
forall k v. Ord k => k -> OMap k v -> OMap k v
delete k
k OMap k v
o

OMap k v
o >| :: OMap k v -> (k, v) -> OMap k v
>| (k
k, v
v) = Map k (Int, v) -> Map Int (k, v) -> OMap k v
forall k v. Map k (Int, v) -> Map Int (k, v) -> OMap k v
OMap (k -> (Int, v) -> Map k (Int, v) -> Map k (Int, v)
forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert k
k (Int
t, v
v) Map k (Int, v)
tvs) (Int -> (k, v) -> Map Int (k, v) -> Map Int (k, v)
forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert Int
t (k
k, v
v) Map Int (k, v)
kvs) where
	t :: Int
t = Map Int (k, v) -> Int
forall a. Map Int a -> Int
nextHigherTag Map Int (k, v)
kvs
	OMap Map k (Int, v)
tvs Map Int (k, v)
kvs = k -> OMap k v -> OMap k v
forall k v. Ord k => k -> OMap k v -> OMap k v
delete k
k OMap k v
o

OMap Map k (Int, v)
tvs Map Int (k, v)
kvs |> :: OMap k v -> (k, v) -> OMap k v
|> (k
k, v
v) = Map k (Int, v) -> Map Int (k, v) -> OMap k v
forall k v. Map k (Int, v) -> Map Int (k, v) -> OMap k v
OMap (k -> (Int, v) -> Map k (Int, v) -> Map k (Int, v)
forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert k
k (Int
t, v
v) Map k (Int, v)
tvs) (Int -> (k, v) -> Map Int (k, v) -> Map Int (k, v)
forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert Int
t (k
k, v
v) Map Int (k, v)
kvs) where
	t :: Int
t = Int -> ((Int, v) -> Int) -> Maybe (Int, v) -> Int
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Map Int (k, v) -> Int
forall a. Map Int a -> Int
nextHigherTag Map Int (k, v)
kvs) (Int, v) -> Int
forall a b. (a, b) -> a
fst (k -> Map k (Int, v) -> Maybe (Int, v)
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup k
k Map k (Int, v)
tvs)

<>| :: OMap k v -> OMap k v -> OMap k v
(<>|) = (k -> v -> v -> v) -> OMap k v -> OMap k v -> OMap k v
forall k v.
Ord k =>
(k -> v -> v -> v) -> OMap k v -> OMap k v -> OMap k v
unionWithR ((v -> v -> v) -> k -> v -> v -> v
forall a b. a -> b -> a
const v -> v -> v
forall a b. a -> b -> a
const)
|<> :: OMap k v -> OMap k v -> OMap k v
(|<>) = (k -> v -> v -> v) -> OMap k v -> OMap k v -> OMap k v
forall k v.
Ord k =>
(k -> v -> v -> v) -> OMap k v -> OMap k v -> OMap k v
unionWithL ((v -> v -> v) -> k -> v -> v -> v
forall a b. a -> b -> a
const v -> v -> v
forall a b. a -> b -> a
const)

-- | Take the union. The first 'OMap' \'s argument's indices are lower than the
-- second. If a key appears in both maps, the first argument's index takes
-- precedence, and the supplied function is used to combine the values.
--
-- /O(r*log(r))/ where /r/ is the size of the result
unionWithL :: Ord k => (k -> v -> v -> v) -> OMap k v -> OMap k v -> OMap k v
unionWithL :: (k -> v -> v -> v) -> OMap k v -> OMap k v -> OMap k v
unionWithL = (Int -> Int -> Int)
-> (k -> v -> v -> v) -> OMap k v -> OMap k v -> OMap k v
forall k v.
Ord k =>
(Int -> Int -> Int)
-> (k -> v -> v -> v) -> OMap k v -> OMap k v -> OMap k v
unionWithInternal (\Int
t Int
t' -> Int
t )

-- | Take the union. The first 'OMap' \'s argument's indices are lower than the
-- second. If a key appears in both maps, the second argument's index takes
-- precedence, and the supplied function is used to combine the values.
--
-- /O(r*log(r))/ where /r/ is the size of the result
unionWithR :: Ord k => (k -> v -> v -> v) -> OMap k v -> OMap k v -> OMap k v
unionWithR :: (k -> v -> v -> v) -> OMap k v -> OMap k v -> OMap k v
unionWithR = (Int -> Int -> Int)
-> (k -> v -> v -> v) -> OMap k v -> OMap k v -> OMap k v
forall k v.
Ord k =>
(Int -> Int -> Int)
-> (k -> v -> v -> v) -> OMap k v -> OMap k v -> OMap k v
unionWithInternal (\Int
t Int
t' -> Int
t')

unionWithInternal :: Ord k => (Tag -> Tag -> Tag) -> (k -> v -> v -> v) -> OMap k v -> OMap k v -> OMap k v
unionWithInternal :: (Int -> Int -> Int)
-> (k -> v -> v -> v) -> OMap k v -> OMap k v -> OMap k v
unionWithInternal Int -> Int -> Int
fT k -> v -> v -> v
fKV (OMap Map k (Int, v)
tvs Map Int (k, v)
kvs) (OMap Map k (Int, v)
tvs' Map Int (k, v)
kvs') = Map k (Int, v) -> OMap k v
forall k v. Ord k => Map k (Int, v) -> OMap k v
fromTV Map k (Int, v)
tvs'' where
	bump :: Int
bump  = case Map Int (k, v) -> Maybe Int
forall a. Map Int a -> Maybe Int
maxTag Map Int (k, v)
kvs  of
		Maybe Int
Nothing -> Int
0
		Just Int
k  -> -Int
kInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1
	bump' :: Int
bump' = case Map Int (k, v) -> Maybe Int
forall a. Map Int a -> Maybe Int
minTag Map Int (k, v)
kvs' of
		Maybe Int
Nothing -> Int
0
		Just Int
k  -> -Int
k
	tvs'' :: Map k (Int, v)
tvs'' = (k -> (Int, v) -> (Int, v) -> (Int, v))
-> Map k (Int, v) -> Map k (Int, v) -> Map k (Int, v)
forall k a.
Ord k =>
(k -> a -> a -> a) -> Map k a -> Map k a -> Map k a
M.unionWithKey (\k
k (Int
t,v
v) (Int
t',v
v') -> (Int -> Int -> Int
fT Int
t Int
t', k -> v -> v -> v
fKV k
k v
v v
v'))
		(((Int, v) -> (Int, v)) -> Map k (Int, v) -> Map k (Int, v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(Int
t,v
v) -> (Int
bump Int -> Int -> Int
forall a. Num a => a -> a -> a
+Int
t,v
v)) Map k (Int, v)
tvs )
		(((Int, v) -> (Int, v)) -> Map k (Int, v) -> Map k (Int, v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(Int
t,v
v) -> (Int
bump'Int -> Int -> Int
forall a. Num a => a -> a -> a
+Int
t,v
v)) Map k (Int, v)
tvs')

-- | @m \\\\ n@ deletes all the keys that exist in @n@ from @m@
--
-- /O(m*log(n))/ where /m/ is the size of the smaller map and /n/ is the size
-- of the larger map.
(\\) :: Ord k => OMap k v -> OMap k v' -> OMap k v
o :: OMap k v
o@(OMap Map k (Int, v)
tvs Map Int (k, v)
kvs) \\ :: OMap k v -> OMap k v' -> OMap k v
\\ o' :: OMap k v'
o'@(OMap Map k (Int, v')
tvs' Map Int (k, v')
kvs') = if OMap k v -> Int
forall k a. OMap k a -> Int
size OMap k v
o Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< OMap k v' -> Int
forall k a. OMap k a -> Int
size OMap k v'
o'
	then (k -> v -> Bool) -> OMap k v -> OMap k v
forall k v. Ord k => (k -> v -> Bool) -> OMap k v -> OMap k v
filter (Bool -> v -> Bool
forall a b. a -> b -> a
const (Bool -> v -> Bool) -> (k -> Bool) -> k -> v -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (k -> OMap k v' -> Bool
forall k v. Ord k => k -> OMap k v -> Bool
`notMember` OMap k v'
o')) OMap k v
o
	else (k -> OMap k v -> OMap k v) -> OMap k v -> [k] -> OMap k v
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr k -> OMap k v -> OMap k v
forall k v. Ord k => k -> OMap k v -> OMap k v
delete OMap k v
o (((k, v') -> k) -> [(k, v')] -> [k]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (k, v') -> k
forall a b. (a, b) -> a
fst (OMap k v' -> [(k, v')]
forall k v. OMap k v -> [(k, v)]
assocs OMap k v'
o'))

empty :: OMap k v
empty :: OMap k v
empty = Map k (Int, v) -> Map Int (k, v) -> OMap k v
forall k v. Map k (Int, v) -> Map Int (k, v) -> OMap k v
OMap Map k (Int, v)
forall k a. Map k a
M.empty Map Int (k, v)
forall k a. Map k a
M.empty

singleton :: (k, v) -> OMap k v
singleton :: (k, v) -> OMap k v
singleton kv :: (k, v)
kv@(k
k, v
v) = Map k (Int, v) -> Map Int (k, v) -> OMap k v
forall k v. Map k (Int, v) -> Map Int (k, v) -> OMap k v
OMap (k -> (Int, v) -> Map k (Int, v)
forall k a. k -> a -> Map k a
M.singleton k
k (Int
0, v
v)) (Int -> (k, v) -> Map Int (k, v)
forall k a. k -> a -> Map k a
M.singleton Int
0 (k, v)
kv)

-- | If a key appears multiple times, the first occurrence is used for ordering
-- and the last occurrence is used for its value. The library author welcomes
-- comments on whether this default is sane.
fromList :: Ord k => [(k, v)] -> OMap k v
fromList :: [(k, v)] -> OMap k v
fromList = (OMap k v -> (k, v) -> OMap k v)
-> OMap k v -> [(k, v)] -> OMap k v
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' OMap k v -> (k, v) -> OMap k v
forall k v. Ord k => OMap k v -> (k, v) -> OMap k v
(|>) OMap k v
forall k v. OMap k v
empty

null :: OMap k v -> Bool
null :: OMap k v -> Bool
null (OMap Map k (Int, v)
tvs Map Int (k, v)
_) = Map k (Int, v) -> Bool
forall k a. Map k a -> Bool
M.null Map k (Int, v)
tvs

size :: OMap k v -> Int
size :: OMap k v -> Int
size (OMap Map k (Int, v)
tvs Map Int (k, v)
_) = Map k (Int, v) -> Int
forall k a. Map k a -> Int
M.size Map k (Int, v)
tvs

member, notMember :: Ord k => k -> OMap k v -> Bool
member :: k -> OMap k v -> Bool
member    k
k (OMap Map k (Int, v)
tvs Map Int (k, v)
_) = k -> Map k (Int, v) -> Bool
forall k a. Ord k => k -> Map k a -> Bool
M.member    k
k Map k (Int, v)
tvs
notMember :: k -> OMap k v -> Bool
notMember k
k (OMap Map k (Int, v)
tvs Map Int (k, v)
_) = k -> Map k (Int, v) -> Bool
forall k a. Ord k => k -> Map k a -> Bool
M.notMember k
k Map k (Int, v)
tvs

lookup :: Ord k => k -> OMap k v -> Maybe v
lookup :: k -> OMap k v -> Maybe v
lookup k
k (OMap Map k (Int, v)
tvs Map Int (k, v)
_) = ((Int, v) -> v) -> Maybe (Int, v) -> Maybe v
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Int, v) -> v
forall a b. (a, b) -> b
snd (k -> Map k (Int, v) -> Maybe (Int, v)
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup k
k Map k (Int, v)
tvs)

-- The Ord constraint is for compatibility with older (<0.5) versions of
-- containers.
-- | @filter f m@ contains exactly the key-value pairs of @m@ that satisfy @f@,
-- without changing the order they appear
filter :: Ord k => (k -> v -> Bool) -> OMap k v -> OMap k v
filter :: (k -> v -> Bool) -> OMap k v -> OMap k v
filter k -> v -> Bool
f (OMap Map k (Int, v)
tvs Map Int (k, v)
kvs) = Map k (Int, v) -> Map Int (k, v) -> OMap k v
forall k v. Map k (Int, v) -> Map Int (k, v) -> OMap k v
OMap ((k -> (Int, v) -> Bool) -> Map k (Int, v) -> Map k (Int, v)
forall k a. (k -> a -> Bool) -> Map k a -> Map k a
M.filterWithKey (\k
k (Int
t, v
v) -> k -> v -> Bool
f k
k v
v) Map k (Int, v)
tvs)
                               ((Int -> (k, v) -> Bool) -> Map Int (k, v) -> Map Int (k, v)
forall k a. (k -> a -> Bool) -> Map k a -> Map k a
M.filterWithKey (\Int
t (k
k, v
v) -> k -> v -> Bool
f k
k v
v) Map Int (k, v)
kvs)

delete :: Ord k => k -> OMap k v -> OMap k v
delete :: k -> OMap k v -> OMap k v
delete k
k o :: OMap k v
o@(OMap Map k (Int, v)
tvs Map Int (k, v)
kvs) = case k -> Map k (Int, v) -> Maybe (Int, v)
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup k
k Map k (Int, v)
tvs of
	Maybe (Int, v)
Nothing     -> OMap k v
o
	Just (Int
t, v
_) -> Map k (Int, v) -> Map Int (k, v) -> OMap k v
forall k v. Map k (Int, v) -> Map Int (k, v) -> OMap k v
OMap (k -> Map k (Int, v) -> Map k (Int, v)
forall k a. Ord k => k -> Map k a -> Map k a
M.delete k
k Map k (Int, v)
tvs) (Int -> Map Int (k, v) -> Map Int (k, v)
forall k a. Ord k => k -> Map k a -> Map k a
M.delete Int
t Map Int (k, v)
kvs)

-- | Intersection. (The @/\\@ is intended to look a bit like the standard
-- mathematical notation for set intersection.)
--
-- See asymptotics of 'intersectionWith'.
(/\|) :: Ord k => OMap k v -> OMap k v' -> OMap k v
OMap k v
o /\| :: OMap k v -> OMap k v' -> OMap k v
/\| OMap k v'
o' = (k -> v' -> v -> v) -> OMap k v' -> OMap k v -> OMap k v
forall k v v' v''.
Ord k =>
(k -> v -> v' -> v'') -> OMap k v -> OMap k v' -> OMap k v''
intersectionWith (\k
k v'
v' v
v -> v
v) OMap k v'
o' OMap k v
o

-- | Intersection. (The @/\\@ is intended to look a bit like the standard
-- mathematical notation for set intersection.)
--
-- See asymptotics of 'intersectionWith'.
(|/\) :: Ord k => OMap k v -> OMap k v' -> OMap k v
OMap k v
o |/\ :: OMap k v -> OMap k v' -> OMap k v
|/\ OMap k v'
o' = (k -> v -> v' -> v) -> OMap k v -> OMap k v' -> OMap k v
forall k v v' v''.
Ord k =>
(k -> v -> v' -> v'') -> OMap k v -> OMap k v' -> OMap k v''
intersectionWith (\k
k v
v v'
v' -> v
v) OMap k v
o OMap k v'
o'

-- | Take the intersection. The first 'OMap' \'s argument's indices are used for
-- the result.
--
-- /O(m*log(n\/(m+1)) + r*log(r))/ where /m/ is the size of the smaller map, /n/
-- is the size of the larger map, and /r/ is the size of the result.
intersectionWith ::
	Ord k =>
	(k -> v -> v' -> v'') ->
	OMap k v -> OMap k v' -> OMap k v''
intersectionWith :: (k -> v -> v' -> v'') -> OMap k v -> OMap k v' -> OMap k v''
intersectionWith k -> v -> v' -> v''
f (OMap Map k (Int, v)
tvs Map Int (k, v)
kvs) (OMap Map k (Int, v')
tvs' Map Int (k, v')
kvs') = Map k (Int, v'') -> OMap k v''
forall k v. Ord k => Map k (Int, v) -> OMap k v
fromTV
	(Map k (Int, v'') -> OMap k v'') -> Map k (Int, v'') -> OMap k v''
forall a b. (a -> b) -> a -> b
$ (k -> (Int, v) -> (Int, v') -> (Int, v''))
-> Map k (Int, v) -> Map k (Int, v') -> Map k (Int, v'')
forall k a b c.
Ord k =>
(k -> a -> b -> c) -> Map k a -> Map k b -> Map k c
M.intersectionWithKey (\k
k (Int
t,v
v) (Int
t',v'
v') -> (Int
t, k -> v -> v' -> v''
f k
k v
v v'
v')) Map k (Int, v)
tvs Map k (Int, v')
tvs'

fromTV :: Ord k => Map k (Tag, v) -> OMap k v
fromTV :: Map k (Int, v) -> OMap k v
fromTV Map k (Int, v)
tvs = Map k (Int, v) -> Map Int (k, v) -> OMap k v
forall k v. Map k (Int, v) -> Map Int (k, v) -> OMap k v
OMap Map k (Int, v)
tvs Map Int (k, v)
kvs where
	kvs :: Map Int (k, v)
kvs = [(Int, (k, v))] -> Map Int (k, v)
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList [(Int
t,(k
k,v
v)) | (k
k,(Int
t,v
v)) <- Map k (Int, v) -> [(k, (Int, v))]
forall k a. Map k a -> [(k, a)]
M.toList Map k (Int, v)
tvs]

fromKV :: Ord k => Map Tag (k, v) -> OMap k v
fromKV :: Map Int (k, v) -> OMap k v
fromKV Map Int (k, v)
kvs = Map k (Int, v) -> Map Int (k, v) -> OMap k v
forall k v. Map k (Int, v) -> Map Int (k, v) -> OMap k v
OMap Map k (Int, v)
tvs Map Int (k, v)
kvs where
	tvs :: Map k (Int, v)
tvs = [(k, (Int, v))] -> Map k (Int, v)
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList [(k
k,(Int
t,v
v)) | (Int
t,(k
k,v
v)) <- Map Int (k, v) -> [(Int, (k, v))]
forall k a. Map k a -> [(k, a)]
M.toList Map Int (k, v)
kvs]

findIndex :: Ord k => k -> OMap k v -> Maybe Index
findIndex :: k -> OMap k v -> Maybe Int
findIndex k
k o :: OMap k v
o@(OMap Map k (Int, v)
tvs Map Int (k, v)
kvs) = do
	(Int
t, v
_) <- k -> Map k (Int, v) -> Maybe (Int, v)
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup k
k Map k (Int, v)
tvs
	Int -> Map Int (k, v) -> Maybe Int
forall k a. Ord k => k -> Map k a -> Maybe Int
M.lookupIndex Int
t Map Int (k, v)
kvs

elemAt :: OMap k v -> Index -> Maybe (k, v)
elemAt :: OMap k v -> Int -> Maybe (k, v)
elemAt o :: OMap k v
o@(OMap Map k (Int, v)
tvs Map Int (k, v)
kvs) Int
i = do
	Bool -> Maybe ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Int
0 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
i Bool -> Bool -> Bool
&& Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Map Int (k, v) -> Int
forall k a. Map k a -> Int
M.size Map Int (k, v)
kvs)
	(k, v) -> Maybe (k, v)
forall (m :: * -> *) a. Monad m => a -> m a
return ((k, v) -> Maybe (k, v))
-> ((Int, (k, v)) -> (k, v)) -> (Int, (k, v)) -> Maybe (k, v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int, (k, v)) -> (k, v)
forall a b. (a, b) -> b
snd ((Int, (k, v)) -> Maybe (k, v)) -> (Int, (k, v)) -> Maybe (k, v)
forall a b. (a -> b) -> a -> b
$ Int -> Map Int (k, v) -> (Int, (k, v))
forall k a. Int -> Map k a -> (k, a)
M.elemAt Int
i Map Int (k, v)
kvs

-- | Return key-value pairs in the order they were inserted.
assocs :: OMap k v -> [(k, v)]
assocs :: OMap k v -> [(k, v)]
assocs (OMap Map k (Int, v)
_ Map Int (k, v)
kvs) = ((Int, (k, v)) -> (k, v)) -> [(Int, (k, v))] -> [(k, v)]
forall a b. (a -> b) -> [a] -> [b]
map (Int, (k, v)) -> (k, v)
forall a b. (a, b) -> b
snd ([(Int, (k, v))] -> [(k, v)]) -> [(Int, (k, v))] -> [(k, v)]
forall a b. (a -> b) -> a -> b
$ Map Int (k, v) -> [(Int, (k, v))]
forall k a. Map k a -> [(k, a)]
M.toAscList Map Int (k, v)
kvs

-- | Return key-value pairs in order of increasing key.
toAscList :: OMap k v -> [(k, v)]
toAscList :: OMap k v -> [(k, v)]
toAscList (OMap Map k (Int, v)
tvs Map Int (k, v)
kvs) = ((k, (Int, v)) -> (k, v)) -> [(k, (Int, v))] -> [(k, v)]
forall a b. (a -> b) -> [a] -> [b]
map (\(k
k, (Int
t, v
v)) -> (k
k, v
v)) ([(k, (Int, v))] -> [(k, v)]) -> [(k, (Int, v))] -> [(k, v)]
forall a b. (a -> b) -> a -> b
$ Map k (Int, v) -> [(k, (Int, v))]
forall k a. Map k a -> [(k, a)]
M.toAscList Map k (Int, v)
tvs

-- | Convert an 'OMap' to a 'Map'.
--
-- /O(n)/, where /n/ is the size of the 'OMap'.
toMap :: OMap k v -> Map k v
toMap :: OMap k v -> Map k v
toMap (OMap Map k (Int, v)
tvs Map Int (k, v)
_) = ((Int, v) -> v) -> Map k (Int, v) -> Map k v
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Int, v) -> v
forall a b. (a, b) -> b
snd Map k (Int, v)
tvs

-- | Alter the value at k, or absence of. Can be used to insert delete or update
--   with the same semantics as 'Map's alter
alter :: Ord k => (Maybe v -> Maybe v) -> k -> OMap k v -> OMap k v
alter :: (Maybe v -> Maybe v) -> k -> OMap k v -> OMap k v
alter Maybe v -> Maybe v
f k
k om :: OMap k v
om@(OMap Map k (Int, v)
tvs Map Int (k, v)
kvs) =
  case (Int, v) -> Int
forall a b. (a, b) -> a
fst ((Int, v) -> Int) -> Maybe (Int, v) -> Maybe Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> k -> Map k (Int, v) -> Maybe (Int, v)
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup k
k Map k (Int, v)
tvs of
    Just Int
t -> Map k (Int, v) -> Map Int (k, v) -> OMap k v
forall k v. Map k (Int, v) -> Map Int (k, v) -> OMap k v
OMap ((Maybe (Int, v) -> Maybe (Int, v))
-> k -> Map k (Int, v) -> Map k (Int, v)
forall k a.
Ord k =>
(Maybe a -> Maybe a) -> k -> Map k a -> Map k a
M.alter ((v -> (Int, v)) -> Maybe v -> Maybe (Int, v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Int
t,) (Maybe v -> Maybe (Int, v))
-> (Maybe (Int, v) -> Maybe v) -> Maybe (Int, v) -> Maybe (Int, v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe v -> Maybe v
f (Maybe v -> Maybe v)
-> (Maybe (Int, v) -> Maybe v) -> Maybe (Int, v) -> Maybe v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Int, v) -> v) -> Maybe (Int, v) -> Maybe v
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Int, v) -> v
forall a b. (a, b) -> b
snd) k
k Map k (Int, v)
tvs)
                   ((Maybe (k, v) -> Maybe (k, v))
-> Int -> Map Int (k, v) -> Map Int (k, v)
forall k a.
Ord k =>
(Maybe a -> Maybe a) -> k -> Map k a -> Map k a
M.alter ((v -> (k, v)) -> Maybe v -> Maybe (k, v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (k
k,) (Maybe v -> Maybe (k, v))
-> (Maybe (k, v) -> Maybe v) -> Maybe (k, v) -> Maybe (k, v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe v -> Maybe v
f (Maybe v -> Maybe v)
-> (Maybe (k, v) -> Maybe v) -> Maybe (k, v) -> Maybe v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((k, v) -> v) -> Maybe (k, v) -> Maybe v
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (k, v) -> v
forall a b. (a, b) -> b
snd) Int
t Map Int (k, v)
kvs)
    Maybe Int
Nothing -> OMap k v -> (v -> OMap k v) -> Maybe v -> OMap k v
forall b a. b -> (a -> b) -> Maybe a -> b
maybe OMap k v
om ((OMap k v
om OMap k v -> (k, v) -> OMap k v
forall k v. Ord k => OMap k v -> (k, v) -> OMap k v
|>) ((k, v) -> OMap k v) -> (v -> (k, v)) -> v -> OMap k v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (k
k, )) (Maybe v -> OMap k v) -> Maybe v -> OMap k v
forall a b. (a -> b) -> a -> b
$ Maybe v -> Maybe v
f Maybe v
forall a. Maybe a
Nothing