module Frontend.Cache where

import Prelude

import Data.Foldable (class Foldable)
import Data.Map as M
import Data.Maybe (Maybe)
import Data.Tuple (Tuple(..), snd)

-- TODO: limit capacity

data Cache a = Cache
  { cache :: M.Map Int (Tuple Int a)
  , i :: Int
  }

empty :: forall a. Cache a
empty = Cache { cache: M.empty, i: 0 }

insert :: forall a. Int -> a -> Cache a -> Cache a
insert k v (Cache c) = Cache
  { cache: M.insert k (Tuple c.i v) c.cache
  , i: c.i + 1
  }

insertFoldable :: forall a f. Foldable f => Functor f => f (Tuple Int a) -> Cache a -> Cache a
insertFoldable f (Cache c) = Cache
  { cache: M.fromFoldable (map (\(Tuple k v) -> Tuple k (Tuple c.i v)) f) `M.union` c.cache
  , i: c.i + 1
  }

size :: forall a. Cache a -> Int
size (Cache c) = M.size c.cache

lookup :: forall v. Int -> Cache v -> Maybe v
lookup v (Cache c) = snd <$> M.lookup v c.cache