{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE GeneralisedNewtypeDeriving #-}
{-# LANGUAGE QuantifiedConstraints #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE StandaloneKindSignatures #-}
{-# LANGUAGE TypeFamilies #-}

-- | Classes for 'MapKind's and concrete 'MapKind's
module Ouroboros.Consensus.Ledger.Tables.MapKind (
    -- * Classes
    CanMapKeysMK (..)
  , CanMapMK (..)
  , EqMK
  , NoThunksMK
  , ShowMK
  , ZeroableMK (..)
  , bimapLedgerTables
    -- * Concrete MapKinds
  , CodecMK (..)
  , DiffMK (..)
  , EmptyMK (..)
  , KeysMK (..)
  , SeqDiffMK (..)
  , TrackingMK (..)
  , ValuesMK (..)
  ) where

import qualified Codec.CBOR.Decoding as CBOR
import qualified Codec.CBOR.Encoding as CBOR
import           Data.Kind (Constraint)
import           Data.Map.Strict (Map)
import qualified Data.Map.Strict as Map
import           Data.Set (Set)
import qualified Data.Set as Set
import           GHC.Generics (Generic)
import           NoThunks.Class
import           Ouroboros.Consensus.Ledger.Tables.Basics
import           Ouroboros.Consensus.Ledger.Tables.Diff (Diff (..))
import           Ouroboros.Consensus.Storage.LedgerDB.V1.DiffSeq

{-------------------------------------------------------------------------------
  Classes
-------------------------------------------------------------------------------}

type ZeroableMK :: MapKind -> Constraint
class ZeroableMK mk where
  emptyMK :: forall k v. (Ord k, Eq v) => mk k v

type CanMapMK :: MapKind -> Constraint
class CanMapMK mk where
  mapMK :: (v -> v') -> mk k v -> mk k v'

type CanMapKeysMK :: MapKind -> Constraint
class CanMapKeysMK mk where
  -- | Instances defined for the standard mapkinds suffer from the same caveats
  -- as 'Data.Map.Strict.mapKeys' or 'Data.Set.map'
  mapKeysMK :: Ord k' => (k -> k') -> mk k v -> mk k' v

-- | For convenience, such that we don't have to include @QuantifiedConstraints@
-- everywhere.
type ShowMK :: MapKind -> Constraint
class (forall k v. (Show k, Show v) => Show (mk k v)) => ShowMK mk

-- | For convenience, such that we don't have to include @QuantifiedConstraints@
-- everywhere.
type EqMK :: MapKind -> Constraint
class (forall k v. (Eq k, Eq v) => Eq (mk k v)) => EqMK mk

-- | For convenience, such that we don't have to include @QuantifiedConstraints@
-- everywhere.
type NoThunksMK :: MapKind -> Constraint
class (forall k v. (NoThunks k, NoThunks v) => NoThunks (mk k v))
   => NoThunksMK mk

-- | Map both keys and values in ledger tables.
--
-- For keys, it has the same caveats as 'Data.Map.Strict.mapKeys' or
-- `Data.Set.map', namely that only injective functions are suitable to be used
-- here.
bimapLedgerTables ::
     forall x y mk. (
          CanMapKeysMK mk
        , CanMapMK mk
        , Ord (TxIn y)
        )
  => (TxIn x -> TxIn y)
  -> (TxOut x -> TxOut y)
  -> LedgerTables x mk
  -> LedgerTables y mk
bimapLedgerTables :: forall (x :: LedgerStateKind) (y :: LedgerStateKind)
       (mk :: MapKind).
(CanMapKeysMK mk, CanMapMK mk, Ord (TxIn y)) =>
(TxIn x -> TxIn y)
-> (TxOut x -> TxOut y) -> LedgerTables x mk -> LedgerTables y mk
bimapLedgerTables TxIn x -> TxIn y
f TxOut x -> TxOut y
g =
    mk (TxIn y) (TxOut y) -> LedgerTables y mk
forall (l :: LedgerStateKind) (mk :: MapKind).
mk (TxIn l) (TxOut l) -> LedgerTables l mk
LedgerTables
  (mk (TxIn y) (TxOut y) -> LedgerTables y mk)
-> (LedgerTables x mk -> mk (TxIn y) (TxOut y))
-> LedgerTables x mk
-> LedgerTables y mk
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (TxIn x -> TxIn y)
-> mk (TxIn x) (TxOut y) -> mk (TxIn y) (TxOut y)
forall k' k v. Ord k' => (k -> k') -> mk k v -> mk k' v
forall (mk :: MapKind) k' k v.
(CanMapKeysMK mk, Ord k') =>
(k -> k') -> mk k v -> mk k' v
mapKeysMK TxIn x -> TxIn y
f
  (mk (TxIn x) (TxOut y) -> mk (TxIn y) (TxOut y))
-> (LedgerTables x mk -> mk (TxIn x) (TxOut y))
-> LedgerTables x mk
-> mk (TxIn y) (TxOut y)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (TxOut x -> TxOut y)
-> mk (TxIn x) (TxOut x) -> mk (TxIn x) (TxOut y)
forall v v' k. (v -> v') -> mk k v -> mk k v'
forall (mk :: MapKind) v v' k.
CanMapMK mk =>
(v -> v') -> mk k v -> mk k v'
mapMK TxOut x -> TxOut y
g
  (mk (TxIn x) (TxOut x) -> mk (TxIn x) (TxOut y))
-> (LedgerTables x mk -> mk (TxIn x) (TxOut x))
-> LedgerTables x mk
-> mk (TxIn x) (TxOut y)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LedgerTables x mk -> mk (TxIn x) (TxOut x)
forall (l :: LedgerStateKind) (mk :: MapKind).
LedgerTables l mk -> mk (TxIn l) (TxOut l)
getLedgerTables

{-------------------------------------------------------------------------------
  EmptyMK
-------------------------------------------------------------------------------}

data EmptyMK k v = EmptyMK
  deriving stock ((forall x. EmptyMK k v -> Rep (EmptyMK k v) x)
-> (forall x. Rep (EmptyMK k v) x -> EmptyMK k v)
-> Generic (EmptyMK k v)
forall x. Rep (EmptyMK k v) x -> EmptyMK k v
forall x. EmptyMK k v -> Rep (EmptyMK k v) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall k v x. Rep (EmptyMK k v) x -> EmptyMK k v
forall k v x. EmptyMK k v -> Rep (EmptyMK k v) x
$cfrom :: forall k v x. EmptyMK k v -> Rep (EmptyMK k v) x
from :: forall x. EmptyMK k v -> Rep (EmptyMK k v) x
$cto :: forall k v x. Rep (EmptyMK k v) x -> EmptyMK k v
to :: forall x. Rep (EmptyMK k v) x -> EmptyMK k v
Generic, EmptyMK k v -> EmptyMK k v -> Bool
(EmptyMK k v -> EmptyMK k v -> Bool)
-> (EmptyMK k v -> EmptyMK k v -> Bool) -> Eq (EmptyMK k v)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall k v. EmptyMK k v -> EmptyMK k v -> Bool
$c== :: forall k v. EmptyMK k v -> EmptyMK k v -> Bool
== :: EmptyMK k v -> EmptyMK k v -> Bool
$c/= :: forall k v. EmptyMK k v -> EmptyMK k v -> Bool
/= :: EmptyMK k v -> EmptyMK k v -> Bool
Eq, Int -> EmptyMK k v -> ShowS
[EmptyMK k v] -> ShowS
EmptyMK k v -> String
(Int -> EmptyMK k v -> ShowS)
-> (EmptyMK k v -> String)
-> ([EmptyMK k v] -> ShowS)
-> Show (EmptyMK k v)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k v. Int -> EmptyMK k v -> ShowS
forall k v. [EmptyMK k v] -> ShowS
forall k v. EmptyMK k v -> String
$cshowsPrec :: forall k v. Int -> EmptyMK k v -> ShowS
showsPrec :: Int -> EmptyMK k v -> ShowS
$cshow :: forall k v. EmptyMK k v -> String
show :: EmptyMK k v -> String
$cshowList :: forall k v. [EmptyMK k v] -> ShowS
showList :: [EmptyMK k v] -> ShowS
Show)
  deriving anyclass Context -> EmptyMK k v -> IO (Maybe ThunkInfo)
Proxy (EmptyMK k v) -> String
(Context -> EmptyMK k v -> IO (Maybe ThunkInfo))
-> (Context -> EmptyMK k v -> IO (Maybe ThunkInfo))
-> (Proxy (EmptyMK k v) -> String)
-> NoThunks (EmptyMK k v)
forall a.
(Context -> a -> IO (Maybe ThunkInfo))
-> (Context -> a -> IO (Maybe ThunkInfo))
-> (Proxy a -> String)
-> NoThunks a
forall k v. Context -> EmptyMK k v -> IO (Maybe ThunkInfo)
forall k v. Proxy (EmptyMK k v) -> String
$cnoThunks :: forall k v. Context -> EmptyMK k v -> IO (Maybe ThunkInfo)
noThunks :: Context -> EmptyMK k v -> IO (Maybe ThunkInfo)
$cwNoThunks :: forall k v. Context -> EmptyMK k v -> IO (Maybe ThunkInfo)
wNoThunks :: Context -> EmptyMK k v -> IO (Maybe ThunkInfo)
$cshowTypeOf :: forall k v. Proxy (EmptyMK k v) -> String
showTypeOf :: Proxy (EmptyMK k v) -> String
NoThunks
  deriving anyclass ((forall k v. (Show k, Show v) => Show (EmptyMK k v)) =>
ShowMK EmptyMK
forall k v. (Show k, Show v) => Show (EmptyMK k v)
forall (mk :: MapKind).
(forall k v. (Show k, Show v) => Show (mk k v)) =>
ShowMK mk
ShowMK, (forall k v. (Eq k, Eq v) => Eq (EmptyMK k v)) => EqMK EmptyMK
forall k v. (Eq k, Eq v) => Eq (EmptyMK k v)
forall (mk :: MapKind).
(forall k v. (Eq k, Eq v) => Eq (mk k v)) =>
EqMK mk
EqMK, (forall k v. (NoThunks k, NoThunks v) => NoThunks (EmptyMK k v)) =>
NoThunksMK EmptyMK
forall k v. (NoThunks k, NoThunks v) => NoThunks (EmptyMK k v)
forall (mk :: MapKind).
(forall k v. (NoThunks k, NoThunks v) => NoThunks (mk k v)) =>
NoThunksMK mk
NoThunksMK)

instance ZeroableMK EmptyMK where
  emptyMK :: forall k v. (Ord k, Eq v) => EmptyMK k v
emptyMK = EmptyMK k v
forall k v. EmptyMK k v
EmptyMK

instance CanMapMK EmptyMK where
  mapMK :: forall v v' k. (v -> v') -> EmptyMK k v -> EmptyMK k v'
mapMK v -> v'
_ EmptyMK k v
EmptyMK = EmptyMK k v'
forall k v. EmptyMK k v
EmptyMK

instance CanMapKeysMK EmptyMK where
  mapKeysMK :: forall k' k v. Ord k' => (k -> k') -> EmptyMK k v -> EmptyMK k' v
mapKeysMK k -> k'
_ EmptyMK k v
EmptyMK = EmptyMK k' v
forall k v. EmptyMK k v
EmptyMK

{-------------------------------------------------------------------------------
  KeysMK
-------------------------------------------------------------------------------}

newtype KeysMK k v = KeysMK (Set k)
  deriving stock ((forall x. KeysMK k v -> Rep (KeysMK k v) x)
-> (forall x. Rep (KeysMK k v) x -> KeysMK k v)
-> Generic (KeysMK k v)
forall x. Rep (KeysMK k v) x -> KeysMK k v
forall x. KeysMK k v -> Rep (KeysMK k v) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall k v x. Rep (KeysMK k v) x -> KeysMK k v
forall k v x. KeysMK k v -> Rep (KeysMK k v) x
$cfrom :: forall k v x. KeysMK k v -> Rep (KeysMK k v) x
from :: forall x. KeysMK k v -> Rep (KeysMK k v) x
$cto :: forall k v x. Rep (KeysMK k v) x -> KeysMK k v
to :: forall x. Rep (KeysMK k v) x -> KeysMK k v
Generic, KeysMK k v -> KeysMK k v -> Bool
(KeysMK k v -> KeysMK k v -> Bool)
-> (KeysMK k v -> KeysMK k v -> Bool) -> Eq (KeysMK k v)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall k v. Eq k => KeysMK k v -> KeysMK k v -> Bool
$c== :: forall k v. Eq k => KeysMK k v -> KeysMK k v -> Bool
== :: KeysMK k v -> KeysMK k v -> Bool
$c/= :: forall k v. Eq k => KeysMK k v -> KeysMK k v -> Bool
/= :: KeysMK k v -> KeysMK k v -> Bool
Eq, Int -> KeysMK k v -> ShowS
[KeysMK k v] -> ShowS
KeysMK k v -> String
(Int -> KeysMK k v -> ShowS)
-> (KeysMK k v -> String)
-> ([KeysMK k v] -> ShowS)
-> Show (KeysMK k v)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k v. Show k => Int -> KeysMK k v -> ShowS
forall k v. Show k => [KeysMK k v] -> ShowS
forall k v. Show k => KeysMK k v -> String
$cshowsPrec :: forall k v. Show k => Int -> KeysMK k v -> ShowS
showsPrec :: Int -> KeysMK k v -> ShowS
$cshow :: forall k v. Show k => KeysMK k v -> String
show :: KeysMK k v -> String
$cshowList :: forall k v. Show k => [KeysMK k v] -> ShowS
showList :: [KeysMK k v] -> ShowS
Show)
  deriving newtype (NonEmpty (KeysMK k v) -> KeysMK k v
KeysMK k v -> KeysMK k v -> KeysMK k v
(KeysMK k v -> KeysMK k v -> KeysMK k v)
-> (NonEmpty (KeysMK k v) -> KeysMK k v)
-> (forall b. Integral b => b -> KeysMK k v -> KeysMK k v)
-> Semigroup (KeysMK k v)
forall b. Integral b => b -> KeysMK k v -> KeysMK k v
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
forall k v. Ord k => NonEmpty (KeysMK k v) -> KeysMK k v
forall k v. Ord k => KeysMK k v -> KeysMK k v -> KeysMK k v
forall k v b. (Ord k, Integral b) => b -> KeysMK k v -> KeysMK k v
$c<> :: forall k v. Ord k => KeysMK k v -> KeysMK k v -> KeysMK k v
<> :: KeysMK k v -> KeysMK k v -> KeysMK k v
$csconcat :: forall k v. Ord k => NonEmpty (KeysMK k v) -> KeysMK k v
sconcat :: NonEmpty (KeysMK k v) -> KeysMK k v
$cstimes :: forall k v b. (Ord k, Integral b) => b -> KeysMK k v -> KeysMK k v
stimes :: forall b. Integral b => b -> KeysMK k v -> KeysMK k v
Semigroup, Semigroup (KeysMK k v)
KeysMK k v
Semigroup (KeysMK k v) =>
KeysMK k v
-> (KeysMK k v -> KeysMK k v -> KeysMK k v)
-> ([KeysMK k v] -> KeysMK k v)
-> Monoid (KeysMK k v)
[KeysMK k v] -> KeysMK k v
KeysMK k v -> KeysMK k v -> KeysMK k v
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall k v. Ord k => Semigroup (KeysMK k v)
forall k v. Ord k => KeysMK k v
forall k v. Ord k => [KeysMK k v] -> KeysMK k v
forall k v. Ord k => KeysMK k v -> KeysMK k v -> KeysMK k v
$cmempty :: forall k v. Ord k => KeysMK k v
mempty :: KeysMK k v
$cmappend :: forall k v. Ord k => KeysMK k v -> KeysMK k v -> KeysMK k v
mappend :: KeysMK k v -> KeysMK k v -> KeysMK k v
$cmconcat :: forall k v. Ord k => [KeysMK k v] -> KeysMK k v
mconcat :: [KeysMK k v] -> KeysMK k v
Monoid)
  deriving anyclass Context -> KeysMK k v -> IO (Maybe ThunkInfo)
Proxy (KeysMK k v) -> String
(Context -> KeysMK k v -> IO (Maybe ThunkInfo))
-> (Context -> KeysMK k v -> IO (Maybe ThunkInfo))
-> (Proxy (KeysMK k v) -> String)
-> NoThunks (KeysMK k v)
forall a.
(Context -> a -> IO (Maybe ThunkInfo))
-> (Context -> a -> IO (Maybe ThunkInfo))
-> (Proxy a -> String)
-> NoThunks a
forall k v.
NoThunks k =>
Context -> KeysMK k v -> IO (Maybe ThunkInfo)
forall k v. NoThunks k => Proxy (KeysMK k v) -> String
$cnoThunks :: forall k v.
NoThunks k =>
Context -> KeysMK k v -> IO (Maybe ThunkInfo)
noThunks :: Context -> KeysMK k v -> IO (Maybe ThunkInfo)
$cwNoThunks :: forall k v.
NoThunks k =>
Context -> KeysMK k v -> IO (Maybe ThunkInfo)
wNoThunks :: Context -> KeysMK k v -> IO (Maybe ThunkInfo)
$cshowTypeOf :: forall k v. NoThunks k => Proxy (KeysMK k v) -> String
showTypeOf :: Proxy (KeysMK k v) -> String
NoThunks
  deriving anyclass ((forall k v. (Show k, Show v) => Show (KeysMK k v)) =>
ShowMK KeysMK
forall k v. (Show k, Show v) => Show (KeysMK k v)
forall (mk :: MapKind).
(forall k v. (Show k, Show v) => Show (mk k v)) =>
ShowMK mk
ShowMK, (forall k v. (Eq k, Eq v) => Eq (KeysMK k v)) => EqMK KeysMK
forall k v. (Eq k, Eq v) => Eq (KeysMK k v)
forall (mk :: MapKind).
(forall k v. (Eq k, Eq v) => Eq (mk k v)) =>
EqMK mk
EqMK, (forall k v. (NoThunks k, NoThunks v) => NoThunks (KeysMK k v)) =>
NoThunksMK KeysMK
forall k v. (NoThunks k, NoThunks v) => NoThunks (KeysMK k v)
forall (mk :: MapKind).
(forall k v. (NoThunks k, NoThunks v) => NoThunks (mk k v)) =>
NoThunksMK mk
NoThunksMK)

instance ZeroableMK KeysMK where
  emptyMK :: forall k v. (Ord k, Eq v) => KeysMK k v
emptyMK = Set k -> KeysMK k v
forall k v. Set k -> KeysMK k v
KeysMK Set k
forall a. Monoid a => a
mempty

instance CanMapMK KeysMK where
  mapMK :: forall v v' k. (v -> v') -> KeysMK k v -> KeysMK k v'
mapMK v -> v'
_ (KeysMK Set k
ks) = Set k -> KeysMK k v'
forall k v. Set k -> KeysMK k v
KeysMK Set k
ks

instance CanMapKeysMK KeysMK where
  mapKeysMK :: forall k' k v. Ord k' => (k -> k') -> KeysMK k v -> KeysMK k' v
mapKeysMK k -> k'
f (KeysMK Set k
ks) = Set k' -> KeysMK k' v
forall k v. Set k -> KeysMK k v
KeysMK (Set k' -> KeysMK k' v) -> Set k' -> KeysMK k' v
forall a b. (a -> b) -> a -> b
$ (k -> k') -> Set k -> Set k'
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map k -> k'
f Set k
ks

{-------------------------------------------------------------------------------
  ValuesMK
-------------------------------------------------------------------------------}

newtype ValuesMK k v = ValuesMK { forall k v. ValuesMK k v -> Map k v
getValuesMK :: Map k v }
  deriving stock ((forall x. ValuesMK k v -> Rep (ValuesMK k v) x)
-> (forall x. Rep (ValuesMK k v) x -> ValuesMK k v)
-> Generic (ValuesMK k v)
forall x. Rep (ValuesMK k v) x -> ValuesMK k v
forall x. ValuesMK k v -> Rep (ValuesMK k v) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall k v x. Rep (ValuesMK k v) x -> ValuesMK k v
forall k v x. ValuesMK k v -> Rep (ValuesMK k v) x
$cfrom :: forall k v x. ValuesMK k v -> Rep (ValuesMK k v) x
from :: forall x. ValuesMK k v -> Rep (ValuesMK k v) x
$cto :: forall k v x. Rep (ValuesMK k v) x -> ValuesMK k v
to :: forall x. Rep (ValuesMK k v) x -> ValuesMK k v
Generic, ValuesMK k v -> ValuesMK k v -> Bool
(ValuesMK k v -> ValuesMK k v -> Bool)
-> (ValuesMK k v -> ValuesMK k v -> Bool) -> Eq (ValuesMK k v)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall k v. (Eq k, Eq v) => ValuesMK k v -> ValuesMK k v -> Bool
$c== :: forall k v. (Eq k, Eq v) => ValuesMK k v -> ValuesMK k v -> Bool
== :: ValuesMK k v -> ValuesMK k v -> Bool
$c/= :: forall k v. (Eq k, Eq v) => ValuesMK k v -> ValuesMK k v -> Bool
/= :: ValuesMK k v -> ValuesMK k v -> Bool
Eq, Int -> ValuesMK k v -> ShowS
[ValuesMK k v] -> ShowS
ValuesMK k v -> String
(Int -> ValuesMK k v -> ShowS)
-> (ValuesMK k v -> String)
-> ([ValuesMK k v] -> ShowS)
-> Show (ValuesMK k v)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k v. (Show k, Show v) => Int -> ValuesMK k v -> ShowS
forall k v. (Show k, Show v) => [ValuesMK k v] -> ShowS
forall k v. (Show k, Show v) => ValuesMK k v -> String
$cshowsPrec :: forall k v. (Show k, Show v) => Int -> ValuesMK k v -> ShowS
showsPrec :: Int -> ValuesMK k v -> ShowS
$cshow :: forall k v. (Show k, Show v) => ValuesMK k v -> String
show :: ValuesMK k v -> String
$cshowList :: forall k v. (Show k, Show v) => [ValuesMK k v] -> ShowS
showList :: [ValuesMK k v] -> ShowS
Show)
  deriving anyclass Context -> ValuesMK k v -> IO (Maybe ThunkInfo)
Proxy (ValuesMK k v) -> String
(Context -> ValuesMK k v -> IO (Maybe ThunkInfo))
-> (Context -> ValuesMK k v -> IO (Maybe ThunkInfo))
-> (Proxy (ValuesMK k v) -> String)
-> NoThunks (ValuesMK k v)
forall a.
(Context -> a -> IO (Maybe ThunkInfo))
-> (Context -> a -> IO (Maybe ThunkInfo))
-> (Proxy a -> String)
-> NoThunks a
forall k v.
(NoThunks k, NoThunks v) =>
Context -> ValuesMK k v -> IO (Maybe ThunkInfo)
forall k v.
(NoThunks k, NoThunks v) =>
Proxy (ValuesMK k v) -> String
$cnoThunks :: forall k v.
(NoThunks k, NoThunks v) =>
Context -> ValuesMK k v -> IO (Maybe ThunkInfo)
noThunks :: Context -> ValuesMK k v -> IO (Maybe ThunkInfo)
$cwNoThunks :: forall k v.
(NoThunks k, NoThunks v) =>
Context -> ValuesMK k v -> IO (Maybe ThunkInfo)
wNoThunks :: Context -> ValuesMK k v -> IO (Maybe ThunkInfo)
$cshowTypeOf :: forall k v.
(NoThunks k, NoThunks v) =>
Proxy (ValuesMK k v) -> String
showTypeOf :: Proxy (ValuesMK k v) -> String
NoThunks
  deriving anyclass ((forall k v. (Show k, Show v) => Show (ValuesMK k v)) =>
ShowMK ValuesMK
forall k v. (Show k, Show v) => Show (ValuesMK k v)
forall (mk :: MapKind).
(forall k v. (Show k, Show v) => Show (mk k v)) =>
ShowMK mk
ShowMK, (forall k v. (Eq k, Eq v) => Eq (ValuesMK k v)) => EqMK ValuesMK
forall k v. (Eq k, Eq v) => Eq (ValuesMK k v)
forall (mk :: MapKind).
(forall k v. (Eq k, Eq v) => Eq (mk k v)) =>
EqMK mk
EqMK, (forall k v.
 (NoThunks k, NoThunks v) =>
 NoThunks (ValuesMK k v)) =>
NoThunksMK ValuesMK
forall k v. (NoThunks k, NoThunks v) => NoThunks (ValuesMK k v)
forall (mk :: MapKind).
(forall k v. (NoThunks k, NoThunks v) => NoThunks (mk k v)) =>
NoThunksMK mk
NoThunksMK)

instance ZeroableMK ValuesMK where
  emptyMK :: forall k v. (Ord k, Eq v) => ValuesMK k v
emptyMK = Map k v -> ValuesMK k v
forall k v. Map k v -> ValuesMK k v
ValuesMK Map k v
forall a. Monoid a => a
mempty

instance CanMapMK ValuesMK where
  mapMK :: forall v v' k. (v -> v') -> ValuesMK k v -> ValuesMK k v'
mapMK v -> v'
f (ValuesMK Map k v
vs) = Map k v' -> ValuesMK k v'
forall k v. Map k v -> ValuesMK k v
ValuesMK (Map k v' -> ValuesMK k v') -> Map k v' -> ValuesMK k v'
forall a b. (a -> b) -> a -> b
$ (v -> v') -> Map k v -> Map k v'
forall a b k. (a -> b) -> Map k a -> Map k b
Map.map v -> v'
f Map k v
vs

instance CanMapKeysMK ValuesMK where
  mapKeysMK :: forall k' k v. Ord k' => (k -> k') -> ValuesMK k v -> ValuesMK k' v
mapKeysMK k -> k'
f (ValuesMK Map k v
vs) = Map k' v -> ValuesMK k' v
forall k v. Map k v -> ValuesMK k v
ValuesMK (Map k' v -> ValuesMK k' v) -> Map k' v -> ValuesMK k' v
forall a b. (a -> b) -> a -> b
$ (k -> k') -> Map k v -> Map k' v
forall k2 k1 a. Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
Map.mapKeys k -> k'
f Map k v
vs

{-------------------------------------------------------------------------------
  DiffMK
-------------------------------------------------------------------------------}

newtype DiffMK k v = DiffMK { forall k v. DiffMK k v -> Diff k v
getDiffMK :: Diff k v }
  deriving stock ((forall x. DiffMK k v -> Rep (DiffMK k v) x)
-> (forall x. Rep (DiffMK k v) x -> DiffMK k v)
-> Generic (DiffMK k v)
forall x. Rep (DiffMK k v) x -> DiffMK k v
forall x. DiffMK k v -> Rep (DiffMK k v) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall k v x. Rep (DiffMK k v) x -> DiffMK k v
forall k v x. DiffMK k v -> Rep (DiffMK k v) x
$cfrom :: forall k v x. DiffMK k v -> Rep (DiffMK k v) x
from :: forall x. DiffMK k v -> Rep (DiffMK k v) x
$cto :: forall k v x. Rep (DiffMK k v) x -> DiffMK k v
to :: forall x. Rep (DiffMK k v) x -> DiffMK k v
Generic, DiffMK k v -> DiffMK k v -> Bool
(DiffMK k v -> DiffMK k v -> Bool)
-> (DiffMK k v -> DiffMK k v -> Bool) -> Eq (DiffMK k v)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall k v. (Eq k, Eq v) => DiffMK k v -> DiffMK k v -> Bool
$c== :: forall k v. (Eq k, Eq v) => DiffMK k v -> DiffMK k v -> Bool
== :: DiffMK k v -> DiffMK k v -> Bool
$c/= :: forall k v. (Eq k, Eq v) => DiffMK k v -> DiffMK k v -> Bool
/= :: DiffMK k v -> DiffMK k v -> Bool
Eq, Int -> DiffMK k v -> ShowS
[DiffMK k v] -> ShowS
DiffMK k v -> String
(Int -> DiffMK k v -> ShowS)
-> (DiffMK k v -> String)
-> ([DiffMK k v] -> ShowS)
-> Show (DiffMK k v)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k v. (Show k, Show v) => Int -> DiffMK k v -> ShowS
forall k v. (Show k, Show v) => [DiffMK k v] -> ShowS
forall k v. (Show k, Show v) => DiffMK k v -> String
$cshowsPrec :: forall k v. (Show k, Show v) => Int -> DiffMK k v -> ShowS
showsPrec :: Int -> DiffMK k v -> ShowS
$cshow :: forall k v. (Show k, Show v) => DiffMK k v -> String
show :: DiffMK k v -> String
$cshowList :: forall k v. (Show k, Show v) => [DiffMK k v] -> ShowS
showList :: [DiffMK k v] -> ShowS
Show)
  deriving newtype (forall a b. (a -> b) -> DiffMK k a -> DiffMK k b)
-> (forall a b. a -> DiffMK k b -> DiffMK k a)
-> Functor (DiffMK k)
forall a b. a -> DiffMK k b -> DiffMK k a
forall a b. (a -> b) -> DiffMK k a -> DiffMK k b
forall k a b. a -> DiffMK k b -> DiffMK k a
forall k a b. (a -> b) -> DiffMK k a -> DiffMK k b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall k a b. (a -> b) -> DiffMK k a -> DiffMK k b
fmap :: forall a b. (a -> b) -> DiffMK k a -> DiffMK k b
$c<$ :: forall k a b. a -> DiffMK k b -> DiffMK k a
<$ :: forall a b. a -> DiffMK k b -> DiffMK k a
Functor
  deriving anyclass Context -> DiffMK k v -> IO (Maybe ThunkInfo)
Proxy (DiffMK k v) -> String
(Context -> DiffMK k v -> IO (Maybe ThunkInfo))
-> (Context -> DiffMK k v -> IO (Maybe ThunkInfo))
-> (Proxy (DiffMK k v) -> String)
-> NoThunks (DiffMK k v)
forall a.
(Context -> a -> IO (Maybe ThunkInfo))
-> (Context -> a -> IO (Maybe ThunkInfo))
-> (Proxy a -> String)
-> NoThunks a
forall k v.
(NoThunks k, NoThunks v) =>
Context -> DiffMK k v -> IO (Maybe ThunkInfo)
forall k v.
(NoThunks k, NoThunks v) =>
Proxy (DiffMK k v) -> String
$cnoThunks :: forall k v.
(NoThunks k, NoThunks v) =>
Context -> DiffMK k v -> IO (Maybe ThunkInfo)
noThunks :: Context -> DiffMK k v -> IO (Maybe ThunkInfo)
$cwNoThunks :: forall k v.
(NoThunks k, NoThunks v) =>
Context -> DiffMK k v -> IO (Maybe ThunkInfo)
wNoThunks :: Context -> DiffMK k v -> IO (Maybe ThunkInfo)
$cshowTypeOf :: forall k v.
(NoThunks k, NoThunks v) =>
Proxy (DiffMK k v) -> String
showTypeOf :: Proxy (DiffMK k v) -> String
NoThunks
  deriving anyclass ((forall k v. (Show k, Show v) => Show (DiffMK k v)) =>
ShowMK DiffMK
forall k v. (Show k, Show v) => Show (DiffMK k v)
forall (mk :: MapKind).
(forall k v. (Show k, Show v) => Show (mk k v)) =>
ShowMK mk
ShowMK, (forall k v. (Eq k, Eq v) => Eq (DiffMK k v)) => EqMK DiffMK
forall k v. (Eq k, Eq v) => Eq (DiffMK k v)
forall (mk :: MapKind).
(forall k v. (Eq k, Eq v) => Eq (mk k v)) =>
EqMK mk
EqMK, (forall k v. (NoThunks k, NoThunks v) => NoThunks (DiffMK k v)) =>
NoThunksMK DiffMK
forall k v. (NoThunks k, NoThunks v) => NoThunks (DiffMK k v)
forall (mk :: MapKind).
(forall k v. (NoThunks k, NoThunks v) => NoThunks (mk k v)) =>
NoThunksMK mk
NoThunksMK)

instance ZeroableMK DiffMK where
  emptyMK :: forall k v. (Ord k, Eq v) => DiffMK k v
emptyMK = Diff k v -> DiffMK k v
forall k v. Diff k v -> DiffMK k v
DiffMK Diff k v
forall a. Monoid a => a
mempty

instance CanMapKeysMK DiffMK where
  mapKeysMK :: forall k' k v. Ord k' => (k -> k') -> DiffMK k v -> DiffMK k' v
mapKeysMK k -> k'
f (DiffMK (Diff Map k (Delta v)
m)) = Diff k' v -> DiffMK k' v
forall k v. Diff k v -> DiffMK k v
DiffMK (Diff k' v -> DiffMK k' v)
-> (Map k' (Delta v) -> Diff k' v)
-> Map k' (Delta v)
-> DiffMK k' v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map k' (Delta v) -> Diff k' v
forall k v. Map k (Delta v) -> Diff k v
Diff (Map k' (Delta v) -> DiffMK k' v)
-> Map k' (Delta v) -> DiffMK k' v
forall a b. (a -> b) -> a -> b
$
    (k -> k') -> Map k (Delta v) -> Map k' (Delta v)
forall k2 k1 a. Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
Map.mapKeys k -> k'
f Map k (Delta v)
m

instance CanMapMK DiffMK where
  mapMK :: forall v v' k. (v -> v') -> DiffMK k v -> DiffMK k v'
mapMK v -> v'
f (DiffMK Diff k v
d) = Diff k v' -> DiffMK k v'
forall k v. Diff k v -> DiffMK k v
DiffMK (Diff k v' -> DiffMK k v') -> Diff k v' -> DiffMK k v'
forall a b. (a -> b) -> a -> b
$ (v -> v') -> Diff k v -> Diff k v'
forall a b. (a -> b) -> Diff k a -> Diff k b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap v -> v'
f Diff k v
d

{-------------------------------------------------------------------------------
  TrackingMK
-------------------------------------------------------------------------------}

data TrackingMK k v = TrackingMK !(Map k v) !(Diff k v)
  deriving ((forall x. TrackingMK k v -> Rep (TrackingMK k v) x)
-> (forall x. Rep (TrackingMK k v) x -> TrackingMK k v)
-> Generic (TrackingMK k v)
forall x. Rep (TrackingMK k v) x -> TrackingMK k v
forall x. TrackingMK k v -> Rep (TrackingMK k v) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall k v x. Rep (TrackingMK k v) x -> TrackingMK k v
forall k v x. TrackingMK k v -> Rep (TrackingMK k v) x
$cfrom :: forall k v x. TrackingMK k v -> Rep (TrackingMK k v) x
from :: forall x. TrackingMK k v -> Rep (TrackingMK k v) x
$cto :: forall k v x. Rep (TrackingMK k v) x -> TrackingMK k v
to :: forall x. Rep (TrackingMK k v) x -> TrackingMK k v
Generic, TrackingMK k v -> TrackingMK k v -> Bool
(TrackingMK k v -> TrackingMK k v -> Bool)
-> (TrackingMK k v -> TrackingMK k v -> Bool)
-> Eq (TrackingMK k v)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall k v.
(Eq k, Eq v) =>
TrackingMK k v -> TrackingMK k v -> Bool
$c== :: forall k v.
(Eq k, Eq v) =>
TrackingMK k v -> TrackingMK k v -> Bool
== :: TrackingMK k v -> TrackingMK k v -> Bool
$c/= :: forall k v.
(Eq k, Eq v) =>
TrackingMK k v -> TrackingMK k v -> Bool
/= :: TrackingMK k v -> TrackingMK k v -> Bool
Eq, Int -> TrackingMK k v -> ShowS
[TrackingMK k v] -> ShowS
TrackingMK k v -> String
(Int -> TrackingMK k v -> ShowS)
-> (TrackingMK k v -> String)
-> ([TrackingMK k v] -> ShowS)
-> Show (TrackingMK k v)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k v. (Show k, Show v) => Int -> TrackingMK k v -> ShowS
forall k v. (Show k, Show v) => [TrackingMK k v] -> ShowS
forall k v. (Show k, Show v) => TrackingMK k v -> String
$cshowsPrec :: forall k v. (Show k, Show v) => Int -> TrackingMK k v -> ShowS
showsPrec :: Int -> TrackingMK k v -> ShowS
$cshow :: forall k v. (Show k, Show v) => TrackingMK k v -> String
show :: TrackingMK k v -> String
$cshowList :: forall k v. (Show k, Show v) => [TrackingMK k v] -> ShowS
showList :: [TrackingMK k v] -> ShowS
Show, Context -> TrackingMK k v -> IO (Maybe ThunkInfo)
Proxy (TrackingMK k v) -> String
(Context -> TrackingMK k v -> IO (Maybe ThunkInfo))
-> (Context -> TrackingMK k v -> IO (Maybe ThunkInfo))
-> (Proxy (TrackingMK k v) -> String)
-> NoThunks (TrackingMK k v)
forall a.
(Context -> a -> IO (Maybe ThunkInfo))
-> (Context -> a -> IO (Maybe ThunkInfo))
-> (Proxy a -> String)
-> NoThunks a
forall k v.
(NoThunks k, NoThunks v) =>
Context -> TrackingMK k v -> IO (Maybe ThunkInfo)
forall k v.
(NoThunks k, NoThunks v) =>
Proxy (TrackingMK k v) -> String
$cnoThunks :: forall k v.
(NoThunks k, NoThunks v) =>
Context -> TrackingMK k v -> IO (Maybe ThunkInfo)
noThunks :: Context -> TrackingMK k v -> IO (Maybe ThunkInfo)
$cwNoThunks :: forall k v.
(NoThunks k, NoThunks v) =>
Context -> TrackingMK k v -> IO (Maybe ThunkInfo)
wNoThunks :: Context -> TrackingMK k v -> IO (Maybe ThunkInfo)
$cshowTypeOf :: forall k v.
(NoThunks k, NoThunks v) =>
Proxy (TrackingMK k v) -> String
showTypeOf :: Proxy (TrackingMK k v) -> String
NoThunks)
  deriving anyclass ((forall k v. (Show k, Show v) => Show (TrackingMK k v)) =>
ShowMK TrackingMK
forall k v. (Show k, Show v) => Show (TrackingMK k v)
forall (mk :: MapKind).
(forall k v. (Show k, Show v) => Show (mk k v)) =>
ShowMK mk
ShowMK, (forall k v. (Eq k, Eq v) => Eq (TrackingMK k v)) =>
EqMK TrackingMK
forall k v. (Eq k, Eq v) => Eq (TrackingMK k v)
forall (mk :: MapKind).
(forall k v. (Eq k, Eq v) => Eq (mk k v)) =>
EqMK mk
EqMK, (forall k v.
 (NoThunks k, NoThunks v) =>
 NoThunks (TrackingMK k v)) =>
NoThunksMK TrackingMK
forall k v. (NoThunks k, NoThunks v) => NoThunks (TrackingMK k v)
forall (mk :: MapKind).
(forall k v. (NoThunks k, NoThunks v) => NoThunks (mk k v)) =>
NoThunksMK mk
NoThunksMK)

instance ZeroableMK TrackingMK where
  emptyMK :: forall k v. (Ord k, Eq v) => TrackingMK k v
emptyMK = Map k v -> Diff k v -> TrackingMK k v
forall k v. Map k v -> Diff k v -> TrackingMK k v
TrackingMK Map k v
forall a. Monoid a => a
mempty Diff k v
forall a. Monoid a => a
mempty

instance CanMapMK TrackingMK where
  mapMK :: forall v v' k. (v -> v') -> TrackingMK k v -> TrackingMK k v'
mapMK v -> v'
f (TrackingMK Map k v
vs Diff k v
d) = Map k v' -> Diff k v' -> TrackingMK k v'
forall k v. Map k v -> Diff k v -> TrackingMK k v
TrackingMK ((v -> v') -> Map k v -> Map k v'
forall a b k. (a -> b) -> Map k a -> Map k b
Map.map v -> v'
f Map k v
vs) ((v -> v') -> Diff k v -> Diff k v'
forall a b. (a -> b) -> Diff k a -> Diff k b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap v -> v'
f Diff k v
d)

instance CanMapKeysMK TrackingMK where
  mapKeysMK :: forall k' k v.
Ord k' =>
(k -> k') -> TrackingMK k v -> TrackingMK k' v
mapKeysMK k -> k'
f (TrackingMK Map k v
vs Diff k v
d) =
      Map k' v -> Diff k' v -> TrackingMK k' v
forall k v. Map k v -> Diff k v -> TrackingMK k v
TrackingMK
        (ValuesMK k' v -> Map k' v
forall k v. ValuesMK k v -> Map k v
getValuesMK (ValuesMK k' v -> Map k' v)
-> (Map k v -> ValuesMK k' v) -> Map k v -> Map k' v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (k -> k') -> ValuesMK k v -> ValuesMK k' v
forall k' k v. Ord k' => (k -> k') -> ValuesMK k v -> ValuesMK k' v
forall (mk :: MapKind) k' k v.
(CanMapKeysMK mk, Ord k') =>
(k -> k') -> mk k v -> mk k' v
mapKeysMK k -> k'
f (ValuesMK k v -> ValuesMK k' v)
-> (Map k v -> ValuesMK k v) -> Map k v -> ValuesMK k' v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map k v -> ValuesMK k v
forall k v. Map k v -> ValuesMK k v
ValuesMK (Map k v -> Map k' v) -> Map k v -> Map k' v
forall a b. (a -> b) -> a -> b
$ Map k v
vs)
        (DiffMK k' v -> Diff k' v
forall k v. DiffMK k v -> Diff k v
getDiffMK (DiffMK k' v -> Diff k' v)
-> (Diff k v -> DiffMK k' v) -> Diff k v -> Diff k' v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (k -> k') -> DiffMK k v -> DiffMK k' v
forall k' k v. Ord k' => (k -> k') -> DiffMK k v -> DiffMK k' v
forall (mk :: MapKind) k' k v.
(CanMapKeysMK mk, Ord k') =>
(k -> k') -> mk k v -> mk k' v
mapKeysMK k -> k'
f (DiffMK k v -> DiffMK k' v)
-> (Diff k v -> DiffMK k v) -> Diff k v -> DiffMK k' v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Diff k v -> DiffMK k v
forall k v. Diff k v -> DiffMK k v
DiffMK (Diff k v -> Diff k' v) -> Diff k v -> Diff k' v
forall a b. (a -> b) -> a -> b
$ Diff k v
d)

{-------------------------------------------------------------------------------
  SeqDiffMK
-------------------------------------------------------------------------------}

newtype SeqDiffMK  k v = SeqDiffMK { forall k v. SeqDiffMK k v -> DiffSeq k v
getSeqDiffMK :: DiffSeq k v }
  deriving stock ((forall x. SeqDiffMK k v -> Rep (SeqDiffMK k v) x)
-> (forall x. Rep (SeqDiffMK k v) x -> SeqDiffMK k v)
-> Generic (SeqDiffMK k v)
forall x. Rep (SeqDiffMK k v) x -> SeqDiffMK k v
forall x. SeqDiffMK k v -> Rep (SeqDiffMK k v) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall k v x. Rep (SeqDiffMK k v) x -> SeqDiffMK k v
forall k v x. SeqDiffMK k v -> Rep (SeqDiffMK k v) x
$cfrom :: forall k v x. SeqDiffMK k v -> Rep (SeqDiffMK k v) x
from :: forall x. SeqDiffMK k v -> Rep (SeqDiffMK k v) x
$cto :: forall k v x. Rep (SeqDiffMK k v) x -> SeqDiffMK k v
to :: forall x. Rep (SeqDiffMK k v) x -> SeqDiffMK k v
Generic, SeqDiffMK k v -> SeqDiffMK k v -> Bool
(SeqDiffMK k v -> SeqDiffMK k v -> Bool)
-> (SeqDiffMK k v -> SeqDiffMK k v -> Bool) -> Eq (SeqDiffMK k v)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall k v. (Eq k, Eq v) => SeqDiffMK k v -> SeqDiffMK k v -> Bool
$c== :: forall k v. (Eq k, Eq v) => SeqDiffMK k v -> SeqDiffMK k v -> Bool
== :: SeqDiffMK k v -> SeqDiffMK k v -> Bool
$c/= :: forall k v. (Eq k, Eq v) => SeqDiffMK k v -> SeqDiffMK k v -> Bool
/= :: SeqDiffMK k v -> SeqDiffMK k v -> Bool
Eq, Int -> SeqDiffMK k v -> ShowS
[SeqDiffMK k v] -> ShowS
SeqDiffMK k v -> String
(Int -> SeqDiffMK k v -> ShowS)
-> (SeqDiffMK k v -> String)
-> ([SeqDiffMK k v] -> ShowS)
-> Show (SeqDiffMK k v)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k v. (Show k, Show v) => Int -> SeqDiffMK k v -> ShowS
forall k v. (Show k, Show v) => [SeqDiffMK k v] -> ShowS
forall k v. (Show k, Show v) => SeqDiffMK k v -> String
$cshowsPrec :: forall k v. (Show k, Show v) => Int -> SeqDiffMK k v -> ShowS
showsPrec :: Int -> SeqDiffMK k v -> ShowS
$cshow :: forall k v. (Show k, Show v) => SeqDiffMK k v -> String
show :: SeqDiffMK k v -> String
$cshowList :: forall k v. (Show k, Show v) => [SeqDiffMK k v] -> ShowS
showList :: [SeqDiffMK k v] -> ShowS
Show)
  deriving anyclass Context -> SeqDiffMK k v -> IO (Maybe ThunkInfo)
Proxy (SeqDiffMK k v) -> String
(Context -> SeqDiffMK k v -> IO (Maybe ThunkInfo))
-> (Context -> SeqDiffMK k v -> IO (Maybe ThunkInfo))
-> (Proxy (SeqDiffMK k v) -> String)
-> NoThunks (SeqDiffMK k v)
forall a.
(Context -> a -> IO (Maybe ThunkInfo))
-> (Context -> a -> IO (Maybe ThunkInfo))
-> (Proxy a -> String)
-> NoThunks a
forall k v.
(NoThunks k, NoThunks v) =>
Context -> SeqDiffMK k v -> IO (Maybe ThunkInfo)
forall k v.
(NoThunks k, NoThunks v) =>
Proxy (SeqDiffMK k v) -> String
$cnoThunks :: forall k v.
(NoThunks k, NoThunks v) =>
Context -> SeqDiffMK k v -> IO (Maybe ThunkInfo)
noThunks :: Context -> SeqDiffMK k v -> IO (Maybe ThunkInfo)
$cwNoThunks :: forall k v.
(NoThunks k, NoThunks v) =>
Context -> SeqDiffMK k v -> IO (Maybe ThunkInfo)
wNoThunks :: Context -> SeqDiffMK k v -> IO (Maybe ThunkInfo)
$cshowTypeOf :: forall k v.
(NoThunks k, NoThunks v) =>
Proxy (SeqDiffMK k v) -> String
showTypeOf :: Proxy (SeqDiffMK k v) -> String
NoThunks
  deriving anyclass ((forall k v. (Show k, Show v) => Show (SeqDiffMK k v)) =>
ShowMK SeqDiffMK
forall k v. (Show k, Show v) => Show (SeqDiffMK k v)
forall (mk :: MapKind).
(forall k v. (Show k, Show v) => Show (mk k v)) =>
ShowMK mk
ShowMK, (forall k v. (Eq k, Eq v) => Eq (SeqDiffMK k v)) => EqMK SeqDiffMK
forall k v. (Eq k, Eq v) => Eq (SeqDiffMK k v)
forall (mk :: MapKind).
(forall k v. (Eq k, Eq v) => Eq (mk k v)) =>
EqMK mk
EqMK, (forall k v.
 (NoThunks k, NoThunks v) =>
 NoThunks (SeqDiffMK k v)) =>
NoThunksMK SeqDiffMK
forall k v. (NoThunks k, NoThunks v) => NoThunks (SeqDiffMK k v)
forall (mk :: MapKind).
(forall k v. (NoThunks k, NoThunks v) => NoThunks (mk k v)) =>
NoThunksMK mk
NoThunksMK)

instance ZeroableMK SeqDiffMK where
  emptyMK :: forall k v. (Ord k, Eq v) => SeqDiffMK k v
emptyMK = DiffSeq k v -> SeqDiffMK k v
forall k v. DiffSeq k v -> SeqDiffMK k v
SeqDiffMK DiffSeq k v
forall k v. (Ord k, Eq v) => DiffSeq k v
empty

{-------------------------------------------------------------------------------
  CodecMK
-------------------------------------------------------------------------------}

-- | A codec 'MapKind' that will be used to refer to @'LedgerTables' l CodecMK@
-- as the codecs that can encode every key and value in the @'LedgerTables' l
-- mk@.
--
-- It is important to note that in the context of the HardForkCombinator, the
-- key @k@ has to be accessible from any era we are currently in, regardless of
-- which era it was created in. Because of that, we need that the serialization
-- of the key remains stable accross eras.
--
-- Ledger will provide more efficient encoders than CBOR, which will produce a
-- @'ShortByteString'@ directly.
--
-- See also 'HasCanonicalTxIn' in
-- "Ouroboros.Consensus.HardFork.Combinator.Ledger".
--
-- We will serialize UTxO maps as unstowed ledger tables when storing snapshots
-- while using an in-memory backend for the LedgerDB.
data CodecMK k v = CodecMK {
    forall k v. CodecMK k v -> k -> Encoding
encodeKey   :: !(k -> CBOR.Encoding)
  , forall k v. CodecMK k v -> v -> Encoding
encodeValue :: !(v -> CBOR.Encoding)
  , forall k v. CodecMK k v -> forall s. Decoder s k
decodeKey   :: !(forall s . CBOR.Decoder s k)
  , forall k v. CodecMK k v -> forall s. Decoder s v
decodeValue :: !(forall s . CBOR.Decoder s v)
  }