{-# LANGUAGE CPP #-}
module Data.CompactMap
    ( CompactMap
    , fromList
    , toVector
    , lookup
    , getLE
    , getIndex
    ) where

import qualified Data.CompactMap.Generic as CM
import qualified Data.Vector as V
import Data.Foldable as F
import Prelude hiding (lookup)

newtype CompactMap k v = CompactMap { forall k v. CompactMap k v -> CompactMap Vector k v
getCM :: CM.CompactMap V.Vector k v }

instance Show v => Show (CompactMap k v) where
    show :: CompactMap k v -> String
show = [v] -> String
forall a. Show a => a -> String
show ([v] -> String)
-> (CompactMap k v -> [v]) -> CompactMap k v -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vector v -> [v]
forall a. Vector a -> [a]
V.toList (Vector v -> [v])
-> (CompactMap k v -> Vector v) -> CompactMap k v -> [v]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CompactMap k v -> Vector v
forall k v. CompactMap k v -> Vector v
getMap

instance Foldable (CompactMap k) where
    fold :: forall m. Monoid m => CompactMap k m -> m
fold       = Vector m -> m
forall m. Monoid m => Vector m -> m
forall (t :: * -> *) m. (Foldable t, Monoid m) => t m -> m
F.fold       (Vector m -> m)
-> (CompactMap k m -> Vector m) -> CompactMap k m -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CompactMap k m -> Vector m
forall k v. CompactMap k v -> Vector v
getMap
    foldr :: forall a b. (a -> b -> b) -> b -> CompactMap k a -> b
foldr a -> b -> b
f b
i  = (a -> b -> b) -> b -> Vector a -> b
forall a b. (a -> b -> b) -> b -> Vector a -> b
V.foldr a -> b -> b
f b
i  (Vector a -> b)
-> (CompactMap k a -> Vector a) -> CompactMap k a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CompactMap k a -> Vector a
forall k v. CompactMap k v -> Vector v
getMap
    foldr' :: forall a b. (a -> b -> b) -> b -> CompactMap k a -> b
foldr' a -> b -> b
f b
i = (a -> b -> b) -> b -> Vector a -> b
forall a b. (a -> b -> b) -> b -> Vector a -> b
V.foldr' a -> b -> b
f b
i (Vector a -> b)
-> (CompactMap k a -> Vector a) -> CompactMap k a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CompactMap k a -> Vector a
forall k v. CompactMap k v -> Vector v
getMap
    foldr1 :: forall a. (a -> a -> a) -> CompactMap k a -> a
foldr1 a -> a -> a
f   = (a -> a -> a) -> Vector a -> a
forall a. (a -> a -> a) -> Vector a -> a
V.foldr1 a -> a -> a
f   (Vector a -> a)
-> (CompactMap k a -> Vector a) -> CompactMap k a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CompactMap k a -> Vector a
forall k v. CompactMap k v -> Vector v
getMap
    foldl :: forall b a. (b -> a -> b) -> b -> CompactMap k a -> b
foldl b -> a -> b
f b
i  = (b -> a -> b) -> b -> Vector a -> b
forall a b. (a -> b -> a) -> a -> Vector b -> a
V.foldl b -> a -> b
f b
i  (Vector a -> b)
-> (CompactMap k a -> Vector a) -> CompactMap k a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CompactMap k a -> Vector a
forall k v. CompactMap k v -> Vector v
getMap
    foldl' :: forall b a. (b -> a -> b) -> b -> CompactMap k a -> b
foldl' b -> a -> b
f b
i = (b -> a -> b) -> b -> Vector a -> b
forall a b. (a -> b -> a) -> a -> Vector b -> a
V.foldl' b -> a -> b
f b
i (Vector a -> b)
-> (CompactMap k a -> Vector a) -> CompactMap k a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CompactMap k a -> Vector a
forall k v. CompactMap k v -> Vector v
getMap
    foldl1 :: forall a. (a -> a -> a) -> CompactMap k a -> a
foldl1 a -> a -> a
f   = (a -> a -> a) -> Vector a -> a
forall a. (a -> a -> a) -> Vector a -> a
V.foldl1 a -> a -> a
f   (Vector a -> a)
-> (CompactMap k a -> Vector a) -> CompactMap k a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CompactMap k a -> Vector a
forall k v. CompactMap k v -> Vector v
getMap
    foldMap :: forall m a. Monoid m => (a -> m) -> CompactMap k a -> m
foldMap a -> m
f  = (a -> m) -> Vector a -> m
forall m a. Monoid m => (a -> m) -> Vector a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
F.foldMap a -> m
f  (Vector a -> m)
-> (CompactMap k a -> Vector a) -> CompactMap k a -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CompactMap k a -> Vector a
forall k v. CompactMap k v -> Vector v
getMap
#if MIN_VERSION_base(4,8,0)
    toList :: forall a. CompactMap k a -> [a]
toList     = Vector a -> [a]
forall a. Vector a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
F.toList     (Vector a -> [a])
-> (CompactMap k a -> Vector a) -> CompactMap k a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CompactMap k a -> Vector a
forall k v. CompactMap k v -> Vector v
getMap
    elem :: forall a. Eq a => a -> CompactMap k a -> Bool
elem a
e     = a -> Vector a -> Bool
forall a. Eq a => a -> Vector a -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
F.elem a
e     (Vector a -> Bool)
-> (CompactMap k a -> Vector a) -> CompactMap k a -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CompactMap k a -> Vector a
forall k v. CompactMap k v -> Vector v
getMap
    null :: forall a. CompactMap k a -> Bool
null       = Vector a -> Bool
forall a. Vector a -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
F.null       (Vector a -> Bool)
-> (CompactMap k a -> Vector a) -> CompactMap k a -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CompactMap k a -> Vector a
forall k v. CompactMap k v -> Vector v
getMap
    minimum :: forall a. Ord a => CompactMap k a -> a
minimum    = Vector a -> a
forall a. Ord a => Vector a -> a
forall (t :: * -> *) a. (Foldable t, Ord a) => t a -> a
F.minimum    (Vector a -> a)
-> (CompactMap k a -> Vector a) -> CompactMap k a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CompactMap k a -> Vector a
forall k v. CompactMap k v -> Vector v
getMap
    maximum :: forall a. Ord a => CompactMap k a -> a
maximum    = Vector a -> a
forall a. Ord a => Vector a -> a
forall (t :: * -> *) a. (Foldable t, Ord a) => t a -> a
F.maximum    (Vector a -> a)
-> (CompactMap k a -> Vector a) -> CompactMap k a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CompactMap k a -> Vector a
forall k v. CompactMap k v -> Vector v
getMap
    length :: forall a. CompactMap k a -> Int
length     = Vector a -> Int
forall a. Vector a -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
F.length     (Vector a -> Int)
-> (CompactMap k a -> Vector a) -> CompactMap k a -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CompactMap k a -> Vector a
forall k v. CompactMap k v -> Vector v
getMap
    sum :: forall a. Num a => CompactMap k a -> a
sum        = Vector a -> a
forall a. Num a => Vector a -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
F.sum        (Vector a -> a)
-> (CompactMap k a -> Vector a) -> CompactMap k a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CompactMap k a -> Vector a
forall k v. CompactMap k v -> Vector v
getMap
    product :: forall a. Num a => CompactMap k a -> a
product    = Vector a -> a
forall a. Num a => Vector a -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
F.product    (Vector a -> a)
-> (CompactMap k a -> Vector a) -> CompactMap k a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CompactMap k a -> Vector a
forall k v. CompactMap k v -> Vector v
getMap
#endif

getMap :: CompactMap k v -> V.Vector v
getMap :: forall k v. CompactMap k v -> Vector v
getMap = CompactMap Vector k v -> Vector v
forall (vec :: * -> *) v k.
Vector vec v =>
CompactMap vec k v -> vec v
CM.toVector (CompactMap Vector k v -> Vector v)
-> (CompactMap k v -> CompactMap Vector k v)
-> CompactMap k v
-> Vector v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CompactMap k v -> CompactMap Vector k v
forall k v. CompactMap k v -> CompactMap Vector k v
getCM
{-# INLINE getMap #-}

fromList :: Ord k => [v] -> (v -> k) -> CompactMap k v
fromList :: forall k v. Ord k => [v] -> (v -> k) -> CompactMap k v
fromList [v]
lst v -> k
f = CompactMap Vector k v -> CompactMap k v
forall k v. CompactMap Vector k v -> CompactMap k v
CompactMap ([v] -> (v -> k) -> CompactMap Vector k v
forall (vec :: * -> *) v k.
(Vector vec v, Ord k) =>
[v] -> (v -> k) -> CompactMap vec k v
CM.fromList [v]
lst v -> k
f)

toVector :: CompactMap k v -> V.Vector v
toVector :: forall k v. CompactMap k v -> Vector v
toVector = CompactMap k v -> Vector v
forall k v. CompactMap k v -> Vector v
getMap
{-# INLINE toVector #-}

lookup :: Ord k => k -> CompactMap k v -> Maybe v
lookup :: forall k v. Ord k => k -> CompactMap k v -> Maybe v
lookup k
k (CompactMap CompactMap Vector k v
cm) = k -> CompactMap Vector k v -> Maybe v
forall (vec :: * -> *) v k.
(Vector vec v, Ord k) =>
k -> CompactMap vec k v -> Maybe v
CM.lookup k
k CompactMap Vector k v
cm

getLE :: Ord k => k -> CompactMap k v -> Maybe (Int, v)
getLE :: forall k v. Ord k => k -> CompactMap k v -> Maybe (Int, v)
getLE k
k (CompactMap CompactMap Vector k v
cm) = k -> CompactMap Vector k v -> Maybe (Int, v)
forall (vec :: * -> *) v k.
(Vector vec v, Ord k) =>
k -> CompactMap vec k v -> Maybe (Int, v)
CM.getLE k
k CompactMap Vector k v
cm

getIndex :: Int -> CompactMap k v -> Maybe v
getIndex :: forall k v. Int -> CompactMap k v -> Maybe v
getIndex Int
i (CompactMap CompactMap Vector k v
cm) = Int -> CompactMap Vector k v -> Maybe v
forall (vec :: * -> *) v k.
Vector vec v =>
Int -> CompactMap vec k v -> Maybe v
CM.getIndex Int
i CompactMap Vector k v
cm