{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DeriveTraversable #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE OverloadedStrings #-}

module Cardano.Slotting.Slot (
  SlotNo (..),
  WithOrigin (..),
  at,
  origin,
  fromWithOrigin,
  withOrigin,
  withOriginToMaybe,
  withOriginFromMaybe,
  EpochNo (..),
  EpochSize (..),
  EpochInterval (..),
  binOpEpochNo,
  addEpochInterval,
)
where

import Cardano.Binary (FromCBOR (..), ToCBOR (..))
import Codec.Serialise (Serialise (..))
import Control.DeepSeq (NFData (rnf))
import Data.Aeson (FromJSON (..), ToJSON (..), Value (String))
import Data.Typeable (Typeable)
import Data.Word (Word32, Word64)
import GHC.Generics (Generic)
import NoThunks.Class (NoThunks)
import Quiet (Quiet (..))

-- | The 0-based index for the Ourboros time slot.
newtype SlotNo = SlotNo {SlotNo -> Word64
unSlotNo :: Word64}
  deriving stock (SlotNo -> SlotNo -> Bool
(SlotNo -> SlotNo -> Bool)
-> (SlotNo -> SlotNo -> Bool) -> Eq SlotNo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SlotNo -> SlotNo -> Bool
== :: SlotNo -> SlotNo -> Bool
$c/= :: SlotNo -> SlotNo -> Bool
/= :: SlotNo -> SlotNo -> Bool
Eq, Eq SlotNo
Eq SlotNo =>
(SlotNo -> SlotNo -> Ordering)
-> (SlotNo -> SlotNo -> Bool)
-> (SlotNo -> SlotNo -> Bool)
-> (SlotNo -> SlotNo -> Bool)
-> (SlotNo -> SlotNo -> Bool)
-> (SlotNo -> SlotNo -> SlotNo)
-> (SlotNo -> SlotNo -> SlotNo)
-> Ord SlotNo
SlotNo -> SlotNo -> Bool
SlotNo -> SlotNo -> Ordering
SlotNo -> SlotNo -> SlotNo
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SlotNo -> SlotNo -> Ordering
compare :: SlotNo -> SlotNo -> Ordering
$c< :: SlotNo -> SlotNo -> Bool
< :: SlotNo -> SlotNo -> Bool
$c<= :: SlotNo -> SlotNo -> Bool
<= :: SlotNo -> SlotNo -> Bool
$c> :: SlotNo -> SlotNo -> Bool
> :: SlotNo -> SlotNo -> Bool
$c>= :: SlotNo -> SlotNo -> Bool
>= :: SlotNo -> SlotNo -> Bool
$cmax :: SlotNo -> SlotNo -> SlotNo
max :: SlotNo -> SlotNo -> SlotNo
$cmin :: SlotNo -> SlotNo -> SlotNo
min :: SlotNo -> SlotNo -> SlotNo
Ord, (forall x. SlotNo -> Rep SlotNo x)
-> (forall x. Rep SlotNo x -> SlotNo) -> Generic SlotNo
forall x. Rep SlotNo x -> SlotNo
forall x. SlotNo -> Rep SlotNo x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SlotNo -> Rep SlotNo x
from :: forall x. SlotNo -> Rep SlotNo x
$cto :: forall x. Rep SlotNo x -> SlotNo
to :: forall x. Rep SlotNo x -> SlotNo
Generic)
  deriving (Int -> SlotNo -> ShowS
[SlotNo] -> ShowS
SlotNo -> String
(Int -> SlotNo -> ShowS)
-> (SlotNo -> String) -> ([SlotNo] -> ShowS) -> Show SlotNo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SlotNo -> ShowS
showsPrec :: Int -> SlotNo -> ShowS
$cshow :: SlotNo -> String
show :: SlotNo -> String
$cshowList :: [SlotNo] -> ShowS
showList :: [SlotNo] -> ShowS
Show) via Quiet SlotNo
  deriving newtype (Int -> SlotNo
SlotNo -> Int
SlotNo -> [SlotNo]
SlotNo -> SlotNo
SlotNo -> SlotNo -> [SlotNo]
SlotNo -> SlotNo -> SlotNo -> [SlotNo]
(SlotNo -> SlotNo)
-> (SlotNo -> SlotNo)
-> (Int -> SlotNo)
-> (SlotNo -> Int)
-> (SlotNo -> [SlotNo])
-> (SlotNo -> SlotNo -> [SlotNo])
-> (SlotNo -> SlotNo -> [SlotNo])
-> (SlotNo -> SlotNo -> SlotNo -> [SlotNo])
-> Enum SlotNo
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: SlotNo -> SlotNo
succ :: SlotNo -> SlotNo
$cpred :: SlotNo -> SlotNo
pred :: SlotNo -> SlotNo
$ctoEnum :: Int -> SlotNo
toEnum :: Int -> SlotNo
$cfromEnum :: SlotNo -> Int
fromEnum :: SlotNo -> Int
$cenumFrom :: SlotNo -> [SlotNo]
enumFrom :: SlotNo -> [SlotNo]
$cenumFromThen :: SlotNo -> SlotNo -> [SlotNo]
enumFromThen :: SlotNo -> SlotNo -> [SlotNo]
$cenumFromTo :: SlotNo -> SlotNo -> [SlotNo]
enumFromTo :: SlotNo -> SlotNo -> [SlotNo]
$cenumFromThenTo :: SlotNo -> SlotNo -> SlotNo -> [SlotNo]
enumFromThenTo :: SlotNo -> SlotNo -> SlotNo -> [SlotNo]
Enum, SlotNo
SlotNo -> SlotNo -> Bounded SlotNo
forall a. a -> a -> Bounded a
$cminBound :: SlotNo
minBound :: SlotNo
$cmaxBound :: SlotNo
maxBound :: SlotNo
Bounded, Integer -> SlotNo
SlotNo -> SlotNo
SlotNo -> SlotNo -> SlotNo
(SlotNo -> SlotNo -> SlotNo)
-> (SlotNo -> SlotNo -> SlotNo)
-> (SlotNo -> SlotNo -> SlotNo)
-> (SlotNo -> SlotNo)
-> (SlotNo -> SlotNo)
-> (SlotNo -> SlotNo)
-> (Integer -> SlotNo)
-> Num SlotNo
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: SlotNo -> SlotNo -> SlotNo
+ :: SlotNo -> SlotNo -> SlotNo
$c- :: SlotNo -> SlotNo -> SlotNo
- :: SlotNo -> SlotNo -> SlotNo
$c* :: SlotNo -> SlotNo -> SlotNo
* :: SlotNo -> SlotNo -> SlotNo
$cnegate :: SlotNo -> SlotNo
negate :: SlotNo -> SlotNo
$cabs :: SlotNo -> SlotNo
abs :: SlotNo -> SlotNo
$csignum :: SlotNo -> SlotNo
signum :: SlotNo -> SlotNo
$cfromInteger :: Integer -> SlotNo
fromInteger :: Integer -> SlotNo
Num, SlotNo -> ()
(SlotNo -> ()) -> NFData SlotNo
forall a. (a -> ()) -> NFData a
$crnf :: SlotNo -> ()
rnf :: SlotNo -> ()
NFData, [SlotNo] -> Encoding
SlotNo -> Encoding
(SlotNo -> Encoding)
-> (forall s. Decoder s SlotNo)
-> ([SlotNo] -> Encoding)
-> (forall s. Decoder s [SlotNo])
-> Serialise SlotNo
forall s. Decoder s [SlotNo]
forall s. Decoder s SlotNo
forall a.
(a -> Encoding)
-> (forall s. Decoder s a)
-> ([a] -> Encoding)
-> (forall s. Decoder s [a])
-> Serialise a
$cencode :: SlotNo -> Encoding
encode :: SlotNo -> Encoding
$cdecode :: forall s. Decoder s SlotNo
decode :: forall s. Decoder s SlotNo
$cencodeList :: [SlotNo] -> Encoding
encodeList :: [SlotNo] -> Encoding
$cdecodeList :: forall s. Decoder s [SlotNo]
decodeList :: forall s. Decoder s [SlotNo]
Serialise, Context -> SlotNo -> IO (Maybe ThunkInfo)
Proxy SlotNo -> String
(Context -> SlotNo -> IO (Maybe ThunkInfo))
-> (Context -> SlotNo -> IO (Maybe ThunkInfo))
-> (Proxy SlotNo -> String)
-> NoThunks SlotNo
forall a.
(Context -> a -> IO (Maybe ThunkInfo))
-> (Context -> a -> IO (Maybe ThunkInfo))
-> (Proxy a -> String)
-> NoThunks a
$cnoThunks :: Context -> SlotNo -> IO (Maybe ThunkInfo)
noThunks :: Context -> SlotNo -> IO (Maybe ThunkInfo)
$cwNoThunks :: Context -> SlotNo -> IO (Maybe ThunkInfo)
wNoThunks :: Context -> SlotNo -> IO (Maybe ThunkInfo)
$cshowTypeOf :: Proxy SlotNo -> String
showTypeOf :: Proxy SlotNo -> String
NoThunks, [SlotNo] -> Value
[SlotNo] -> Encoding
SlotNo -> Bool
SlotNo -> Value
SlotNo -> Encoding
(SlotNo -> Value)
-> (SlotNo -> Encoding)
-> ([SlotNo] -> Value)
-> ([SlotNo] -> Encoding)
-> (SlotNo -> Bool)
-> ToJSON SlotNo
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: SlotNo -> Value
toJSON :: SlotNo -> Value
$ctoEncoding :: SlotNo -> Encoding
toEncoding :: SlotNo -> Encoding
$ctoJSONList :: [SlotNo] -> Value
toJSONList :: [SlotNo] -> Value
$ctoEncodingList :: [SlotNo] -> Encoding
toEncodingList :: [SlotNo] -> Encoding
$comitField :: SlotNo -> Bool
omitField :: SlotNo -> Bool
ToJSON, Maybe SlotNo
Value -> Parser [SlotNo]
Value -> Parser SlotNo
(Value -> Parser SlotNo)
-> (Value -> Parser [SlotNo]) -> Maybe SlotNo -> FromJSON SlotNo
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser SlotNo
parseJSON :: Value -> Parser SlotNo
$cparseJSONList :: Value -> Parser [SlotNo]
parseJSONList :: Value -> Parser [SlotNo]
$comittedField :: Maybe SlotNo
omittedField :: Maybe SlotNo
FromJSON)

instance ToCBOR SlotNo where
  toCBOR :: SlotNo -> Encoding
toCBOR = SlotNo -> Encoding
forall a. Serialise a => a -> Encoding
encode
  encodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size) -> Proxy SlotNo -> Size
encodedSizeExpr forall t. ToCBOR t => Proxy t -> Size
size = (forall t. ToCBOR t => Proxy t -> Size) -> Proxy Word64 -> Size
forall a.
ToCBOR a =>
(forall t. ToCBOR t => Proxy t -> Size) -> Proxy a -> Size
encodedSizeExpr Proxy t -> Size
forall t. ToCBOR t => Proxy t -> Size
size (Proxy Word64 -> Size)
-> (Proxy SlotNo -> Proxy Word64) -> Proxy SlotNo -> Size
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SlotNo -> Word64) -> Proxy SlotNo -> Proxy Word64
forall a b. (a -> b) -> Proxy a -> Proxy b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap SlotNo -> Word64
unSlotNo

instance FromCBOR SlotNo where
  fromCBOR :: forall s. Decoder s SlotNo
fromCBOR = Decoder s SlotNo
forall s. Decoder s SlotNo
forall a s. Serialise a => Decoder s a
decode

{-------------------------------------------------------------------------------
  WithOrigin
-------------------------------------------------------------------------------}

data WithOrigin t = Origin | At !t
  deriving
    ( WithOrigin t -> WithOrigin t -> Bool
(WithOrigin t -> WithOrigin t -> Bool)
-> (WithOrigin t -> WithOrigin t -> Bool) -> Eq (WithOrigin t)
forall t. Eq t => WithOrigin t -> WithOrigin t -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall t. Eq t => WithOrigin t -> WithOrigin t -> Bool
== :: WithOrigin t -> WithOrigin t -> Bool
$c/= :: forall t. Eq t => WithOrigin t -> WithOrigin t -> Bool
/= :: WithOrigin t -> WithOrigin t -> Bool
Eq
    , Eq (WithOrigin t)
Eq (WithOrigin t) =>
(WithOrigin t -> WithOrigin t -> Ordering)
-> (WithOrigin t -> WithOrigin t -> Bool)
-> (WithOrigin t -> WithOrigin t -> Bool)
-> (WithOrigin t -> WithOrigin t -> Bool)
-> (WithOrigin t -> WithOrigin t -> Bool)
-> (WithOrigin t -> WithOrigin t -> WithOrigin t)
-> (WithOrigin t -> WithOrigin t -> WithOrigin t)
-> Ord (WithOrigin t)
WithOrigin t -> WithOrigin t -> Bool
WithOrigin t -> WithOrigin t -> Ordering
WithOrigin t -> WithOrigin t -> WithOrigin t
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall t. Ord t => Eq (WithOrigin t)
forall t. Ord t => WithOrigin t -> WithOrigin t -> Bool
forall t. Ord t => WithOrigin t -> WithOrigin t -> Ordering
forall t. Ord t => WithOrigin t -> WithOrigin t -> WithOrigin t
$ccompare :: forall t. Ord t => WithOrigin t -> WithOrigin t -> Ordering
compare :: WithOrigin t -> WithOrigin t -> Ordering
$c< :: forall t. Ord t => WithOrigin t -> WithOrigin t -> Bool
< :: WithOrigin t -> WithOrigin t -> Bool
$c<= :: forall t. Ord t => WithOrigin t -> WithOrigin t -> Bool
<= :: WithOrigin t -> WithOrigin t -> Bool
$c> :: forall t. Ord t => WithOrigin t -> WithOrigin t -> Bool
> :: WithOrigin t -> WithOrigin t -> Bool
$c>= :: forall t. Ord t => WithOrigin t -> WithOrigin t -> Bool
>= :: WithOrigin t -> WithOrigin t -> Bool
$cmax :: forall t. Ord t => WithOrigin t -> WithOrigin t -> WithOrigin t
max :: WithOrigin t -> WithOrigin t -> WithOrigin t
$cmin :: forall t. Ord t => WithOrigin t -> WithOrigin t -> WithOrigin t
min :: WithOrigin t -> WithOrigin t -> WithOrigin t
Ord
    , Int -> WithOrigin t -> ShowS
[WithOrigin t] -> ShowS
WithOrigin t -> String
(Int -> WithOrigin t -> ShowS)
-> (WithOrigin t -> String)
-> ([WithOrigin t] -> ShowS)
-> Show (WithOrigin t)
forall t. Show t => Int -> WithOrigin t -> ShowS
forall t. Show t => [WithOrigin t] -> ShowS
forall t. Show t => WithOrigin t -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall t. Show t => Int -> WithOrigin t -> ShowS
showsPrec :: Int -> WithOrigin t -> ShowS
$cshow :: forall t. Show t => WithOrigin t -> String
show :: WithOrigin t -> String
$cshowList :: forall t. Show t => [WithOrigin t] -> ShowS
showList :: [WithOrigin t] -> ShowS
Show
    , (forall x. WithOrigin t -> Rep (WithOrigin t) x)
-> (forall x. Rep (WithOrigin t) x -> WithOrigin t)
-> Generic (WithOrigin t)
forall x. Rep (WithOrigin t) x -> WithOrigin t
forall x. WithOrigin t -> Rep (WithOrigin t) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall t x. Rep (WithOrigin t) x -> WithOrigin t
forall t x. WithOrigin t -> Rep (WithOrigin t) x
$cfrom :: forall t x. WithOrigin t -> Rep (WithOrigin t) x
from :: forall x. WithOrigin t -> Rep (WithOrigin t) x
$cto :: forall t x. Rep (WithOrigin t) x -> WithOrigin t
to :: forall x. Rep (WithOrigin t) x -> WithOrigin t
Generic
    , (forall a b. (a -> b) -> WithOrigin a -> WithOrigin b)
-> (forall a b. a -> WithOrigin b -> WithOrigin a)
-> Functor WithOrigin
forall a b. a -> WithOrigin b -> WithOrigin a
forall a b. (a -> b) -> WithOrigin a -> WithOrigin b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> WithOrigin a -> WithOrigin b
fmap :: forall a b. (a -> b) -> WithOrigin a -> WithOrigin b
$c<$ :: forall a b. a -> WithOrigin b -> WithOrigin a
<$ :: forall a b. a -> WithOrigin b -> WithOrigin a
Functor
    , (forall m. Monoid m => WithOrigin m -> m)
-> (forall m a. Monoid m => (a -> m) -> WithOrigin a -> m)
-> (forall m a. Monoid m => (a -> m) -> WithOrigin a -> m)
-> (forall a b. (a -> b -> b) -> b -> WithOrigin a -> b)
-> (forall a b. (a -> b -> b) -> b -> WithOrigin a -> b)
-> (forall b a. (b -> a -> b) -> b -> WithOrigin a -> b)
-> (forall b a. (b -> a -> b) -> b -> WithOrigin a -> b)
-> (forall a. (a -> a -> a) -> WithOrigin a -> a)
-> (forall a. (a -> a -> a) -> WithOrigin a -> a)
-> (forall a. WithOrigin a -> [a])
-> (forall a. WithOrigin a -> Bool)
-> (forall a. WithOrigin a -> Int)
-> (forall a. Eq a => a -> WithOrigin a -> Bool)
-> (forall a. Ord a => WithOrigin a -> a)
-> (forall a. Ord a => WithOrigin a -> a)
-> (forall a. Num a => WithOrigin a -> a)
-> (forall a. Num a => WithOrigin a -> a)
-> Foldable WithOrigin
forall a. Eq a => a -> WithOrigin a -> Bool
forall a. Num a => WithOrigin a -> a
forall a. Ord a => WithOrigin a -> a
forall m. Monoid m => WithOrigin m -> m
forall a. WithOrigin a -> Bool
forall a. WithOrigin a -> Int
forall a. WithOrigin a -> [a]
forall a. (a -> a -> a) -> WithOrigin a -> a
forall m a. Monoid m => (a -> m) -> WithOrigin a -> m
forall b a. (b -> a -> b) -> b -> WithOrigin a -> b
forall a b. (a -> b -> b) -> b -> WithOrigin a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => WithOrigin m -> m
fold :: forall m. Monoid m => WithOrigin m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> WithOrigin a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> WithOrigin a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> WithOrigin a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> WithOrigin a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> WithOrigin a -> b
foldr :: forall a b. (a -> b -> b) -> b -> WithOrigin a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> WithOrigin a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> WithOrigin a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> WithOrigin a -> b
foldl :: forall b a. (b -> a -> b) -> b -> WithOrigin a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> WithOrigin a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> WithOrigin a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> WithOrigin a -> a
foldr1 :: forall a. (a -> a -> a) -> WithOrigin a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> WithOrigin a -> a
foldl1 :: forall a. (a -> a -> a) -> WithOrigin a -> a
$ctoList :: forall a. WithOrigin a -> [a]
toList :: forall a. WithOrigin a -> [a]
$cnull :: forall a. WithOrigin a -> Bool
null :: forall a. WithOrigin a -> Bool
$clength :: forall a. WithOrigin a -> Int
length :: forall a. WithOrigin a -> Int
$celem :: forall a. Eq a => a -> WithOrigin a -> Bool
elem :: forall a. Eq a => a -> WithOrigin a -> Bool
$cmaximum :: forall a. Ord a => WithOrigin a -> a
maximum :: forall a. Ord a => WithOrigin a -> a
$cminimum :: forall a. Ord a => WithOrigin a -> a
minimum :: forall a. Ord a => WithOrigin a -> a
$csum :: forall a. Num a => WithOrigin a -> a
sum :: forall a. Num a => WithOrigin a -> a
$cproduct :: forall a. Num a => WithOrigin a -> a
product :: forall a. Num a => WithOrigin a -> a
Foldable
    , Functor WithOrigin
Foldable WithOrigin
(Functor WithOrigin, Foldable WithOrigin) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> WithOrigin a -> f (WithOrigin b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    WithOrigin (f a) -> f (WithOrigin a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> WithOrigin a -> m (WithOrigin b))
-> (forall (m :: * -> *) a.
    Monad m =>
    WithOrigin (m a) -> m (WithOrigin a))
-> Traversable WithOrigin
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
WithOrigin (m a) -> m (WithOrigin a)
forall (f :: * -> *) a.
Applicative f =>
WithOrigin (f a) -> f (WithOrigin a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> WithOrigin a -> m (WithOrigin b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> WithOrigin a -> f (WithOrigin b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> WithOrigin a -> f (WithOrigin b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> WithOrigin a -> f (WithOrigin b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
WithOrigin (f a) -> f (WithOrigin a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
WithOrigin (f a) -> f (WithOrigin a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> WithOrigin a -> m (WithOrigin b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> WithOrigin a -> m (WithOrigin b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
WithOrigin (m a) -> m (WithOrigin a)
sequence :: forall (m :: * -> *) a.
Monad m =>
WithOrigin (m a) -> m (WithOrigin a)
Traversable
    , [WithOrigin t] -> Encoding
WithOrigin t -> Encoding
(WithOrigin t -> Encoding)
-> (forall s. Decoder s (WithOrigin t))
-> ([WithOrigin t] -> Encoding)
-> (forall s. Decoder s [WithOrigin t])
-> Serialise (WithOrigin t)
forall s. Decoder s [WithOrigin t]
forall s. Decoder s (WithOrigin t)
forall t. Serialise t => [WithOrigin t] -> Encoding
forall t. Serialise t => WithOrigin t -> Encoding
forall t s. Serialise t => Decoder s [WithOrigin t]
forall t s. Serialise t => Decoder s (WithOrigin t)
forall a.
(a -> Encoding)
-> (forall s. Decoder s a)
-> ([a] -> Encoding)
-> (forall s. Decoder s [a])
-> Serialise a
$cencode :: forall t. Serialise t => WithOrigin t -> Encoding
encode :: WithOrigin t -> Encoding
$cdecode :: forall t s. Serialise t => Decoder s (WithOrigin t)
decode :: forall s. Decoder s (WithOrigin t)
$cencodeList :: forall t. Serialise t => [WithOrigin t] -> Encoding
encodeList :: [WithOrigin t] -> Encoding
$cdecodeList :: forall t s. Serialise t => Decoder s [WithOrigin t]
decodeList :: forall s. Decoder s [WithOrigin t]
Serialise
    , Context -> WithOrigin t -> IO (Maybe ThunkInfo)
Proxy (WithOrigin t) -> String
(Context -> WithOrigin t -> IO (Maybe ThunkInfo))
-> (Context -> WithOrigin t -> IO (Maybe ThunkInfo))
-> (Proxy (WithOrigin t) -> String)
-> NoThunks (WithOrigin t)
forall t.
NoThunks t =>
Context -> WithOrigin t -> IO (Maybe ThunkInfo)
forall t. NoThunks t => Proxy (WithOrigin t) -> String
forall a.
(Context -> a -> IO (Maybe ThunkInfo))
-> (Context -> a -> IO (Maybe ThunkInfo))
-> (Proxy a -> String)
-> NoThunks a
$cnoThunks :: forall t.
NoThunks t =>
Context -> WithOrigin t -> IO (Maybe ThunkInfo)
noThunks :: Context -> WithOrigin t -> IO (Maybe ThunkInfo)
$cwNoThunks :: forall t.
NoThunks t =>
Context -> WithOrigin t -> IO (Maybe ThunkInfo)
wNoThunks :: Context -> WithOrigin t -> IO (Maybe ThunkInfo)
$cshowTypeOf :: forall t. NoThunks t => Proxy (WithOrigin t) -> String
showTypeOf :: Proxy (WithOrigin t) -> String
NoThunks
    )

instance (Serialise t, Typeable t) => ToCBOR (WithOrigin t) where
  toCBOR :: WithOrigin t -> Encoding
toCBOR = WithOrigin t -> Encoding
forall a. Serialise a => a -> Encoding
encode

instance (Serialise t, Typeable t) => FromCBOR (WithOrigin t) where
  fromCBOR :: forall s. Decoder s (WithOrigin t)
fromCBOR = Decoder s (WithOrigin t)
forall s. Decoder s (WithOrigin t)
forall a s. Serialise a => Decoder s a
decode

instance Bounded t => Bounded (WithOrigin t) where
  minBound :: WithOrigin t
minBound = WithOrigin t
forall t. WithOrigin t
Origin
  maxBound :: WithOrigin t
maxBound = t -> WithOrigin t
forall t. t -> WithOrigin t
At t
forall a. Bounded a => a
maxBound

instance NFData a => NFData (WithOrigin a) where
  rnf :: WithOrigin a -> ()
rnf WithOrigin a
Origin = ()
  rnf (At a
t) = a -> ()
forall a. NFData a => a -> ()
rnf a
t

instance ToJSON a => ToJSON (WithOrigin a) where
  toJSON :: WithOrigin a -> Value
toJSON = \case
    WithOrigin a
Origin -> Text -> Value
String Text
"origin"
    At a
n -> a -> Value
forall a. ToJSON a => a -> Value
toJSON a
n

instance FromJSON a => FromJSON (WithOrigin a) where
  parseJSON :: Value -> Parser (WithOrigin a)
parseJSON = \case
    String Text
"origin" -> WithOrigin a -> Parser (WithOrigin a)
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure WithOrigin a
forall t. WithOrigin t
Origin
    Value
value -> a -> WithOrigin a
forall t. t -> WithOrigin t
At (a -> WithOrigin a) -> Parser a -> Parser (WithOrigin a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Value -> Parser a
forall a. FromJSON a => Value -> Parser a
parseJSON Value
value

at :: t -> WithOrigin t
at :: forall t. t -> WithOrigin t
at = t -> WithOrigin t
forall t. t -> WithOrigin t
At

origin :: WithOrigin t
origin :: forall t. WithOrigin t
origin = WithOrigin t
forall t. WithOrigin t
Origin

fromWithOrigin :: t -> WithOrigin t -> t
fromWithOrigin :: forall t. t -> WithOrigin t -> t
fromWithOrigin t
t WithOrigin t
Origin = t
t
fromWithOrigin t
_ (At t
t) = t
t

withOrigin :: b -> (t -> b) -> WithOrigin t -> b
withOrigin :: forall b t. b -> (t -> b) -> WithOrigin t -> b
withOrigin b
a t -> b
_ WithOrigin t
Origin = b
a
withOrigin b
_ t -> b
f (At t
t) = t -> b
f t
t

withOriginToMaybe :: WithOrigin t -> Maybe t
withOriginToMaybe :: forall t. WithOrigin t -> Maybe t
withOriginToMaybe WithOrigin t
Origin = Maybe t
forall a. Maybe a
Nothing
withOriginToMaybe (At t
t) = t -> Maybe t
forall a. a -> Maybe a
Just t
t

withOriginFromMaybe :: Maybe t -> WithOrigin t
withOriginFromMaybe :: forall t. Maybe t -> WithOrigin t
withOriginFromMaybe Maybe t
Nothing = WithOrigin t
forall t. WithOrigin t
Origin
withOriginFromMaybe (Just t
t) = t -> WithOrigin t
forall t. t -> WithOrigin t
At t
t

{-------------------------------------------------------------------------------
  Epochs
-------------------------------------------------------------------------------}

-- | An epoch, i.e. the number of the epoch.
newtype EpochNo = EpochNo {EpochNo -> Word64
unEpochNo :: Word64}
  deriving stock (EpochNo -> EpochNo -> Bool
(EpochNo -> EpochNo -> Bool)
-> (EpochNo -> EpochNo -> Bool) -> Eq EpochNo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EpochNo -> EpochNo -> Bool
== :: EpochNo -> EpochNo -> Bool
$c/= :: EpochNo -> EpochNo -> Bool
/= :: EpochNo -> EpochNo -> Bool
Eq, Eq EpochNo
Eq EpochNo =>
(EpochNo -> EpochNo -> Ordering)
-> (EpochNo -> EpochNo -> Bool)
-> (EpochNo -> EpochNo -> Bool)
-> (EpochNo -> EpochNo -> Bool)
-> (EpochNo -> EpochNo -> Bool)
-> (EpochNo -> EpochNo -> EpochNo)
-> (EpochNo -> EpochNo -> EpochNo)
-> Ord EpochNo
EpochNo -> EpochNo -> Bool
EpochNo -> EpochNo -> Ordering
EpochNo -> EpochNo -> EpochNo
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: EpochNo -> EpochNo -> Ordering
compare :: EpochNo -> EpochNo -> Ordering
$c< :: EpochNo -> EpochNo -> Bool
< :: EpochNo -> EpochNo -> Bool
$c<= :: EpochNo -> EpochNo -> Bool
<= :: EpochNo -> EpochNo -> Bool
$c> :: EpochNo -> EpochNo -> Bool
> :: EpochNo -> EpochNo -> Bool
$c>= :: EpochNo -> EpochNo -> Bool
>= :: EpochNo -> EpochNo -> Bool
$cmax :: EpochNo -> EpochNo -> EpochNo
max :: EpochNo -> EpochNo -> EpochNo
$cmin :: EpochNo -> EpochNo -> EpochNo
min :: EpochNo -> EpochNo -> EpochNo
Ord, (forall x. EpochNo -> Rep EpochNo x)
-> (forall x. Rep EpochNo x -> EpochNo) -> Generic EpochNo
forall x. Rep EpochNo x -> EpochNo
forall x. EpochNo -> Rep EpochNo x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. EpochNo -> Rep EpochNo x
from :: forall x. EpochNo -> Rep EpochNo x
$cto :: forall x. Rep EpochNo x -> EpochNo
to :: forall x. Rep EpochNo x -> EpochNo
Generic)
  deriving (Int -> EpochNo -> ShowS
[EpochNo] -> ShowS
EpochNo -> String
(Int -> EpochNo -> ShowS)
-> (EpochNo -> String) -> ([EpochNo] -> ShowS) -> Show EpochNo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> EpochNo -> ShowS
showsPrec :: Int -> EpochNo -> ShowS
$cshow :: EpochNo -> String
show :: EpochNo -> String
$cshowList :: [EpochNo] -> ShowS
showList :: [EpochNo] -> ShowS
Show) via Quiet EpochNo
  deriving newtype (Int -> EpochNo
EpochNo -> Int
EpochNo -> [EpochNo]
EpochNo -> EpochNo
EpochNo -> EpochNo -> [EpochNo]
EpochNo -> EpochNo -> EpochNo -> [EpochNo]
(EpochNo -> EpochNo)
-> (EpochNo -> EpochNo)
-> (Int -> EpochNo)
-> (EpochNo -> Int)
-> (EpochNo -> [EpochNo])
-> (EpochNo -> EpochNo -> [EpochNo])
-> (EpochNo -> EpochNo -> [EpochNo])
-> (EpochNo -> EpochNo -> EpochNo -> [EpochNo])
-> Enum EpochNo
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: EpochNo -> EpochNo
succ :: EpochNo -> EpochNo
$cpred :: EpochNo -> EpochNo
pred :: EpochNo -> EpochNo
$ctoEnum :: Int -> EpochNo
toEnum :: Int -> EpochNo
$cfromEnum :: EpochNo -> Int
fromEnum :: EpochNo -> Int
$cenumFrom :: EpochNo -> [EpochNo]
enumFrom :: EpochNo -> [EpochNo]
$cenumFromThen :: EpochNo -> EpochNo -> [EpochNo]
enumFromThen :: EpochNo -> EpochNo -> [EpochNo]
$cenumFromTo :: EpochNo -> EpochNo -> [EpochNo]
enumFromTo :: EpochNo -> EpochNo -> [EpochNo]
$cenumFromThenTo :: EpochNo -> EpochNo -> EpochNo -> [EpochNo]
enumFromThenTo :: EpochNo -> EpochNo -> EpochNo -> [EpochNo]
Enum, [EpochNo] -> Encoding
EpochNo -> Encoding
(EpochNo -> Encoding)
-> (forall s. Decoder s EpochNo)
-> ([EpochNo] -> Encoding)
-> (forall s. Decoder s [EpochNo])
-> Serialise EpochNo
forall s. Decoder s [EpochNo]
forall s. Decoder s EpochNo
forall a.
(a -> Encoding)
-> (forall s. Decoder s a)
-> ([a] -> Encoding)
-> (forall s. Decoder s [a])
-> Serialise a
$cencode :: EpochNo -> Encoding
encode :: EpochNo -> Encoding
$cdecode :: forall s. Decoder s EpochNo
decode :: forall s. Decoder s EpochNo
$cencodeList :: [EpochNo] -> Encoding
encodeList :: [EpochNo] -> Encoding
$cdecodeList :: forall s. Decoder s [EpochNo]
decodeList :: forall s. Decoder s [EpochNo]
Serialise, Typeable EpochNo
Typeable EpochNo =>
(EpochNo -> Encoding)
-> ((forall t. ToCBOR t => Proxy t -> Size)
    -> Proxy EpochNo -> Size)
-> ((forall t. ToCBOR t => Proxy t -> Size)
    -> Proxy [EpochNo] -> Size)
-> ToCBOR EpochNo
EpochNo -> Encoding
(forall t. ToCBOR t => Proxy t -> Size) -> Proxy [EpochNo] -> Size
(forall t. ToCBOR t => Proxy t -> Size) -> Proxy EpochNo -> Size
forall a.
Typeable a =>
(a -> Encoding)
-> ((forall t. ToCBOR t => Proxy t -> Size) -> Proxy a -> Size)
-> ((forall t. ToCBOR t => Proxy t -> Size) -> Proxy [a] -> Size)
-> ToCBOR a
$ctoCBOR :: EpochNo -> Encoding
toCBOR :: EpochNo -> Encoding
$cencodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size) -> Proxy EpochNo -> Size
encodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size) -> Proxy EpochNo -> Size
$cencodedListSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size) -> Proxy [EpochNo] -> Size
encodedListSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size) -> Proxy [EpochNo] -> Size
ToCBOR, Typeable EpochNo
Typeable EpochNo =>
(forall s. Decoder s EpochNo)
-> (Proxy EpochNo -> Text) -> FromCBOR EpochNo
Proxy EpochNo -> Text
forall s. Decoder s EpochNo
forall a.
Typeable a =>
(forall s. Decoder s a) -> (Proxy a -> Text) -> FromCBOR a
$cfromCBOR :: forall s. Decoder s EpochNo
fromCBOR :: forall s. Decoder s EpochNo
$clabel :: Proxy EpochNo -> Text
label :: Proxy EpochNo -> Text
FromCBOR, Context -> EpochNo -> IO (Maybe ThunkInfo)
Proxy EpochNo -> String
(Context -> EpochNo -> IO (Maybe ThunkInfo))
-> (Context -> EpochNo -> IO (Maybe ThunkInfo))
-> (Proxy EpochNo -> String)
-> NoThunks EpochNo
forall a.
(Context -> a -> IO (Maybe ThunkInfo))
-> (Context -> a -> IO (Maybe ThunkInfo))
-> (Proxy a -> String)
-> NoThunks a
$cnoThunks :: Context -> EpochNo -> IO (Maybe ThunkInfo)
noThunks :: Context -> EpochNo -> IO (Maybe ThunkInfo)
$cwNoThunks :: Context -> EpochNo -> IO (Maybe ThunkInfo)
wNoThunks :: Context -> EpochNo -> IO (Maybe ThunkInfo)
$cshowTypeOf :: Proxy EpochNo -> String
showTypeOf :: Proxy EpochNo -> String
NoThunks, [EpochNo] -> Value
[EpochNo] -> Encoding
EpochNo -> Bool
EpochNo -> Value
EpochNo -> Encoding
(EpochNo -> Value)
-> (EpochNo -> Encoding)
-> ([EpochNo] -> Value)
-> ([EpochNo] -> Encoding)
-> (EpochNo -> Bool)
-> ToJSON EpochNo
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: EpochNo -> Value
toJSON :: EpochNo -> Value
$ctoEncoding :: EpochNo -> Encoding
toEncoding :: EpochNo -> Encoding
$ctoJSONList :: [EpochNo] -> Value
toJSONList :: [EpochNo] -> Value
$ctoEncodingList :: [EpochNo] -> Encoding
toEncodingList :: [EpochNo] -> Encoding
$comitField :: EpochNo -> Bool
omitField :: EpochNo -> Bool
ToJSON, Maybe EpochNo
Value -> Parser [EpochNo]
Value -> Parser EpochNo
(Value -> Parser EpochNo)
-> (Value -> Parser [EpochNo]) -> Maybe EpochNo -> FromJSON EpochNo
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser EpochNo
parseJSON :: Value -> Parser EpochNo
$cparseJSONList :: Value -> Parser [EpochNo]
parseJSONList :: Value -> Parser [EpochNo]
$comittedField :: Maybe EpochNo
omittedField :: Maybe EpochNo
FromJSON, EpochNo -> ()
(EpochNo -> ()) -> NFData EpochNo
forall a. (a -> ()) -> NFData a
$crnf :: EpochNo -> ()
rnf :: EpochNo -> ()
NFData)

newtype EpochSize = EpochSize {EpochSize -> Word64
unEpochSize :: Word64}
  deriving stock (EpochSize -> EpochSize -> Bool
(EpochSize -> EpochSize -> Bool)
-> (EpochSize -> EpochSize -> Bool) -> Eq EpochSize
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EpochSize -> EpochSize -> Bool
== :: EpochSize -> EpochSize -> Bool
$c/= :: EpochSize -> EpochSize -> Bool
/= :: EpochSize -> EpochSize -> Bool
Eq, Eq EpochSize
Eq EpochSize =>
(EpochSize -> EpochSize -> Ordering)
-> (EpochSize -> EpochSize -> Bool)
-> (EpochSize -> EpochSize -> Bool)
-> (EpochSize -> EpochSize -> Bool)
-> (EpochSize -> EpochSize -> Bool)
-> (EpochSize -> EpochSize -> EpochSize)
-> (EpochSize -> EpochSize -> EpochSize)
-> Ord EpochSize
EpochSize -> EpochSize -> Bool
EpochSize -> EpochSize -> Ordering
EpochSize -> EpochSize -> EpochSize
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: EpochSize -> EpochSize -> Ordering
compare :: EpochSize -> EpochSize -> Ordering
$c< :: EpochSize -> EpochSize -> Bool
< :: EpochSize -> EpochSize -> Bool
$c<= :: EpochSize -> EpochSize -> Bool
<= :: EpochSize -> EpochSize -> Bool
$c> :: EpochSize -> EpochSize -> Bool
> :: EpochSize -> EpochSize -> Bool
$c>= :: EpochSize -> EpochSize -> Bool
>= :: EpochSize -> EpochSize -> Bool
$cmax :: EpochSize -> EpochSize -> EpochSize
max :: EpochSize -> EpochSize -> EpochSize
$cmin :: EpochSize -> EpochSize -> EpochSize
min :: EpochSize -> EpochSize -> EpochSize
Ord, (forall x. EpochSize -> Rep EpochSize x)
-> (forall x. Rep EpochSize x -> EpochSize) -> Generic EpochSize
forall x. Rep EpochSize x -> EpochSize
forall x. EpochSize -> Rep EpochSize x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. EpochSize -> Rep EpochSize x
from :: forall x. EpochSize -> Rep EpochSize x
$cto :: forall x. Rep EpochSize x -> EpochSize
to :: forall x. Rep EpochSize x -> EpochSize
Generic)
  deriving (Int -> EpochSize -> ShowS
[EpochSize] -> ShowS
EpochSize -> String
(Int -> EpochSize -> ShowS)
-> (EpochSize -> String)
-> ([EpochSize] -> ShowS)
-> Show EpochSize
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> EpochSize -> ShowS
showsPrec :: Int -> EpochSize -> ShowS
$cshow :: EpochSize -> String
show :: EpochSize -> String
$cshowList :: [EpochSize] -> ShowS
showList :: [EpochSize] -> ShowS
Show) via Quiet EpochSize
  deriving newtype (Int -> EpochSize
EpochSize -> Int
EpochSize -> [EpochSize]
EpochSize -> EpochSize
EpochSize -> EpochSize -> [EpochSize]
EpochSize -> EpochSize -> EpochSize -> [EpochSize]
(EpochSize -> EpochSize)
-> (EpochSize -> EpochSize)
-> (Int -> EpochSize)
-> (EpochSize -> Int)
-> (EpochSize -> [EpochSize])
-> (EpochSize -> EpochSize -> [EpochSize])
-> (EpochSize -> EpochSize -> [EpochSize])
-> (EpochSize -> EpochSize -> EpochSize -> [EpochSize])
-> Enum EpochSize
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: EpochSize -> EpochSize
succ :: EpochSize -> EpochSize
$cpred :: EpochSize -> EpochSize
pred :: EpochSize -> EpochSize
$ctoEnum :: Int -> EpochSize
toEnum :: Int -> EpochSize
$cfromEnum :: EpochSize -> Int
fromEnum :: EpochSize -> Int
$cenumFrom :: EpochSize -> [EpochSize]
enumFrom :: EpochSize -> [EpochSize]
$cenumFromThen :: EpochSize -> EpochSize -> [EpochSize]
enumFromThen :: EpochSize -> EpochSize -> [EpochSize]
$cenumFromTo :: EpochSize -> EpochSize -> [EpochSize]
enumFromTo :: EpochSize -> EpochSize -> [EpochSize]
$cenumFromThenTo :: EpochSize -> EpochSize -> EpochSize -> [EpochSize]
enumFromThenTo :: EpochSize -> EpochSize -> EpochSize -> [EpochSize]
Enum, Typeable EpochSize
Typeable EpochSize =>
(EpochSize -> Encoding)
-> ((forall t. ToCBOR t => Proxy t -> Size)
    -> Proxy EpochSize -> Size)
-> ((forall t. ToCBOR t => Proxy t -> Size)
    -> Proxy [EpochSize] -> Size)
-> ToCBOR EpochSize
EpochSize -> Encoding
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [EpochSize] -> Size
(forall t. ToCBOR t => Proxy t -> Size) -> Proxy EpochSize -> Size
forall a.
Typeable a =>
(a -> Encoding)
-> ((forall t. ToCBOR t => Proxy t -> Size) -> Proxy a -> Size)
-> ((forall t. ToCBOR t => Proxy t -> Size) -> Proxy [a] -> Size)
-> ToCBOR a
$ctoCBOR :: EpochSize -> Encoding
toCBOR :: EpochSize -> Encoding
$cencodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size) -> Proxy EpochSize -> Size
encodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size) -> Proxy EpochSize -> Size
$cencodedListSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [EpochSize] -> Size
encodedListSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [EpochSize] -> Size
ToCBOR, Typeable EpochSize
Typeable EpochSize =>
(forall s. Decoder s EpochSize)
-> (Proxy EpochSize -> Text) -> FromCBOR EpochSize
Proxy EpochSize -> Text
forall s. Decoder s EpochSize
forall a.
Typeable a =>
(forall s. Decoder s a) -> (Proxy a -> Text) -> FromCBOR a
$cfromCBOR :: forall s. Decoder s EpochSize
fromCBOR :: forall s. Decoder s EpochSize
$clabel :: Proxy EpochSize -> Text
label :: Proxy EpochSize -> Text
FromCBOR, Context -> EpochSize -> IO (Maybe ThunkInfo)
Proxy EpochSize -> String
(Context -> EpochSize -> IO (Maybe ThunkInfo))
-> (Context -> EpochSize -> IO (Maybe ThunkInfo))
-> (Proxy EpochSize -> String)
-> NoThunks EpochSize
forall a.
(Context -> a -> IO (Maybe ThunkInfo))
-> (Context -> a -> IO (Maybe ThunkInfo))
-> (Proxy a -> String)
-> NoThunks a
$cnoThunks :: Context -> EpochSize -> IO (Maybe ThunkInfo)
noThunks :: Context -> EpochSize -> IO (Maybe ThunkInfo)
$cwNoThunks :: Context -> EpochSize -> IO (Maybe ThunkInfo)
wNoThunks :: Context -> EpochSize -> IO (Maybe ThunkInfo)
$cshowTypeOf :: Proxy EpochSize -> String
showTypeOf :: Proxy EpochSize -> String
NoThunks, [EpochSize] -> Value
[EpochSize] -> Encoding
EpochSize -> Bool
EpochSize -> Value
EpochSize -> Encoding
(EpochSize -> Value)
-> (EpochSize -> Encoding)
-> ([EpochSize] -> Value)
-> ([EpochSize] -> Encoding)
-> (EpochSize -> Bool)
-> ToJSON EpochSize
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: EpochSize -> Value
toJSON :: EpochSize -> Value
$ctoEncoding :: EpochSize -> Encoding
toEncoding :: EpochSize -> Encoding
$ctoJSONList :: [EpochSize] -> Value
toJSONList :: [EpochSize] -> Value
$ctoEncodingList :: [EpochSize] -> Encoding
toEncodingList :: [EpochSize] -> Encoding
$comitField :: EpochSize -> Bool
omitField :: EpochSize -> Bool
ToJSON, Maybe EpochSize
Value -> Parser [EpochSize]
Value -> Parser EpochSize
(Value -> Parser EpochSize)
-> (Value -> Parser [EpochSize])
-> Maybe EpochSize
-> FromJSON EpochSize
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser EpochSize
parseJSON :: Value -> Parser EpochSize
$cparseJSONList :: Value -> Parser [EpochSize]
parseJSONList :: Value -> Parser [EpochSize]
$comittedField :: Maybe EpochSize
omittedField :: Maybe EpochSize
FromJSON, EpochSize -> ()
(EpochSize -> ()) -> NFData EpochSize
forall a. (a -> ()) -> NFData a
$crnf :: EpochSize -> ()
rnf :: EpochSize -> ()
NFData)

newtype EpochInterval = EpochInterval
  { EpochInterval -> Word32
unEpochInterval :: Word32
  }
  deriving (EpochInterval -> EpochInterval -> Bool
(EpochInterval -> EpochInterval -> Bool)
-> (EpochInterval -> EpochInterval -> Bool) -> Eq EpochInterval
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EpochInterval -> EpochInterval -> Bool
== :: EpochInterval -> EpochInterval -> Bool
$c/= :: EpochInterval -> EpochInterval -> Bool
/= :: EpochInterval -> EpochInterval -> Bool
Eq, Eq EpochInterval
Eq EpochInterval =>
(EpochInterval -> EpochInterval -> Ordering)
-> (EpochInterval -> EpochInterval -> Bool)
-> (EpochInterval -> EpochInterval -> Bool)
-> (EpochInterval -> EpochInterval -> Bool)
-> (EpochInterval -> EpochInterval -> Bool)
-> (EpochInterval -> EpochInterval -> EpochInterval)
-> (EpochInterval -> EpochInterval -> EpochInterval)
-> Ord EpochInterval
EpochInterval -> EpochInterval -> Bool
EpochInterval -> EpochInterval -> Ordering
EpochInterval -> EpochInterval -> EpochInterval
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: EpochInterval -> EpochInterval -> Ordering
compare :: EpochInterval -> EpochInterval -> Ordering
$c< :: EpochInterval -> EpochInterval -> Bool
< :: EpochInterval -> EpochInterval -> Bool
$c<= :: EpochInterval -> EpochInterval -> Bool
<= :: EpochInterval -> EpochInterval -> Bool
$c> :: EpochInterval -> EpochInterval -> Bool
> :: EpochInterval -> EpochInterval -> Bool
$c>= :: EpochInterval -> EpochInterval -> Bool
>= :: EpochInterval -> EpochInterval -> Bool
$cmax :: EpochInterval -> EpochInterval -> EpochInterval
max :: EpochInterval -> EpochInterval -> EpochInterval
$cmin :: EpochInterval -> EpochInterval -> EpochInterval
min :: EpochInterval -> EpochInterval -> EpochInterval
Ord, (forall x. EpochInterval -> Rep EpochInterval x)
-> (forall x. Rep EpochInterval x -> EpochInterval)
-> Generic EpochInterval
forall x. Rep EpochInterval x -> EpochInterval
forall x. EpochInterval -> Rep EpochInterval x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. EpochInterval -> Rep EpochInterval x
from :: forall x. EpochInterval -> Rep EpochInterval x
$cto :: forall x. Rep EpochInterval x -> EpochInterval
to :: forall x. Rep EpochInterval x -> EpochInterval
Generic)
  deriving (Int -> EpochInterval -> ShowS
[EpochInterval] -> ShowS
EpochInterval -> String
(Int -> EpochInterval -> ShowS)
-> (EpochInterval -> String)
-> ([EpochInterval] -> ShowS)
-> Show EpochInterval
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> EpochInterval -> ShowS
showsPrec :: Int -> EpochInterval -> ShowS
$cshow :: EpochInterval -> String
show :: EpochInterval -> String
$cshowList :: [EpochInterval] -> ShowS
showList :: [EpochInterval] -> ShowS
Show) via Quiet EpochInterval
  deriving newtype (Context -> EpochInterval -> IO (Maybe ThunkInfo)
Proxy EpochInterval -> String
(Context -> EpochInterval -> IO (Maybe ThunkInfo))
-> (Context -> EpochInterval -> IO (Maybe ThunkInfo))
-> (Proxy EpochInterval -> String)
-> NoThunks EpochInterval
forall a.
(Context -> a -> IO (Maybe ThunkInfo))
-> (Context -> a -> IO (Maybe ThunkInfo))
-> (Proxy a -> String)
-> NoThunks a
$cnoThunks :: Context -> EpochInterval -> IO (Maybe ThunkInfo)
noThunks :: Context -> EpochInterval -> IO (Maybe ThunkInfo)
$cwNoThunks :: Context -> EpochInterval -> IO (Maybe ThunkInfo)
wNoThunks :: Context -> EpochInterval -> IO (Maybe ThunkInfo)
$cshowTypeOf :: Proxy EpochInterval -> String
showTypeOf :: Proxy EpochInterval -> String
NoThunks, EpochInterval -> ()
(EpochInterval -> ()) -> NFData EpochInterval
forall a. (a -> ()) -> NFData a
$crnf :: EpochInterval -> ()
rnf :: EpochInterval -> ()
NFData, [EpochInterval] -> Value
[EpochInterval] -> Encoding
EpochInterval -> Bool
EpochInterval -> Value
EpochInterval -> Encoding
(EpochInterval -> Value)
-> (EpochInterval -> Encoding)
-> ([EpochInterval] -> Value)
-> ([EpochInterval] -> Encoding)
-> (EpochInterval -> Bool)
-> ToJSON EpochInterval
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: EpochInterval -> Value
toJSON :: EpochInterval -> Value
$ctoEncoding :: EpochInterval -> Encoding
toEncoding :: EpochInterval -> Encoding
$ctoJSONList :: [EpochInterval] -> Value
toJSONList :: [EpochInterval] -> Value
$ctoEncodingList :: [EpochInterval] -> Encoding
toEncodingList :: [EpochInterval] -> Encoding
$comitField :: EpochInterval -> Bool
omitField :: EpochInterval -> Bool
ToJSON, Maybe EpochInterval
Value -> Parser [EpochInterval]
Value -> Parser EpochInterval
(Value -> Parser EpochInterval)
-> (Value -> Parser [EpochInterval])
-> Maybe EpochInterval
-> FromJSON EpochInterval
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser EpochInterval
parseJSON :: Value -> Parser EpochInterval
$cparseJSONList :: Value -> Parser [EpochInterval]
parseJSONList :: Value -> Parser [EpochInterval]
$comittedField :: Maybe EpochInterval
omittedField :: Maybe EpochInterval
FromJSON, Typeable EpochInterval
Typeable EpochInterval =>
(EpochInterval -> Encoding)
-> ((forall t. ToCBOR t => Proxy t -> Size)
    -> Proxy EpochInterval -> Size)
-> ((forall t. ToCBOR t => Proxy t -> Size)
    -> Proxy [EpochInterval] -> Size)
-> ToCBOR EpochInterval
EpochInterval -> Encoding
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [EpochInterval] -> Size
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy EpochInterval -> Size
forall a.
Typeable a =>
(a -> Encoding)
-> ((forall t. ToCBOR t => Proxy t -> Size) -> Proxy a -> Size)
-> ((forall t. ToCBOR t => Proxy t -> Size) -> Proxy [a] -> Size)
-> ToCBOR a
$ctoCBOR :: EpochInterval -> Encoding
toCBOR :: EpochInterval -> Encoding
$cencodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy EpochInterval -> Size
encodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy EpochInterval -> Size
$cencodedListSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [EpochInterval] -> Size
encodedListSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [EpochInterval] -> Size
ToCBOR, Typeable EpochInterval
Typeable EpochInterval =>
(forall s. Decoder s EpochInterval)
-> (Proxy EpochInterval -> Text) -> FromCBOR EpochInterval
Proxy EpochInterval -> Text
forall s. Decoder s EpochInterval
forall a.
Typeable a =>
(forall s. Decoder s a) -> (Proxy a -> Text) -> FromCBOR a
$cfromCBOR :: forall s. Decoder s EpochInterval
fromCBOR :: forall s. Decoder s EpochInterval
$clabel :: Proxy EpochInterval -> Text
label :: Proxy EpochInterval -> Text
FromCBOR)

-- | Convenience function for doing binary operations on two `EpochNo`s
binOpEpochNo :: (Word64 -> Word64 -> Word64) -> EpochNo -> EpochNo -> EpochNo
binOpEpochNo :: (Word64 -> Word64 -> Word64) -> EpochNo -> EpochNo -> EpochNo
binOpEpochNo Word64 -> Word64 -> Word64
op EpochNo
en1 EpochNo
en2 = Word64 -> EpochNo
EpochNo (Word64 -> EpochNo) -> Word64 -> EpochNo
forall a b. (a -> b) -> a -> b
$ Word64 -> Word64 -> Word64
op (EpochNo -> Word64
unEpochNo EpochNo
en1) (EpochNo -> Word64
unEpochNo EpochNo
en2)

-- | Add a EpochInterval (a positive change) to an EpochNo to get a new EpochNo
addEpochInterval :: EpochNo -> EpochInterval -> EpochNo
addEpochInterval :: EpochNo -> EpochInterval -> EpochNo
addEpochInterval (EpochNo Word64
n) (EpochInterval Word32
m) = Word64 -> EpochNo
EpochNo (Word64
n Word64 -> Word64 -> Word64
forall a. Num a => a -> a -> a
+ Word32 -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word32
m)