{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE RecordWildCards, PolymorphicComponents #-}
{-# LANGUAGE ConstraintKinds #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE PolyKinds #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
import GHC.Prim ( Constraint )
import qualified Data.Map    as Map
import qualified Data.IntMap as IntMap
import Data.Hashable (Hashable)
import qualified Data.HashMap.Strict as HM


data MapLike (conK :: * -> Constraint) (m :: * -> *) = MapLike 
  { lookup :: (conK (KeyType m)) => KeyType m -> m a -> Maybe a
  , insert :: (conK (KeyType m)) => KeyType m -> a -> m a -> m a
  , empty  :: forall a . m a
  }

type family KeyType m :: *



-- Data.Map
type instance KeyType (Map.Map k) = k
     
mapMap :: MapLike Ord (Map.Map k)
mapMap = MapLike
  { lookup = Map.lookup
  , insert = Map.insert
  , empty  = Map.empty
  }



-- Data.IntMap
type instance KeyType IntMap.IntMap = Int
     
mapIntMap :: MapLike Ord IntMap.IntMap
mapIntMap = MapLike
  { lookup = IntMap.lookup
  , insert = IntMap.insert
  , empty  = IntMap.empty
  }



-- HashMap
type instance KeyType (HM.HashMap k) = k

mapHashMap :: MapLike (Hashable :&&: Eq) (HM.HashMap k)
mapHashMap = MapLike
  { lookup = HM.lookup
  , insert = HM.insert
  , empty  = HM.empty
  }

-- We need AND for constraints of kind (* -> Constraint)
class (c1 t, c2 t) => (:&&:) (c1 :: * -> Constraint)  (c2 :: * -> Constraint) (t :: *)
instance (c1 t, c2 t) => (:&&:) c1 c2 t