{-# 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 = forall a. Show a => a -> String
show forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Vector a -> [a]
V.toList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall k v. CompactMap k v -> Vector v
getMap

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