ouroboros-consensus-0.1.0.0: Consensus layer for the Ouroboros blockchain protocol
Safe HaskellNone
LanguageHaskell2010

Ouroboros.Consensus.Util.IOLike

Synopsis

Documentation

class (MonadAsync m, MonadEventlog m, MonadFork m, MonadST m, MonadDelay m, MonadThread m, MonadThrow m, MonadCatch m, MonadMask m, MonadMonotonicTime m, MonadEvaluate m, MonadThrow (STM m), ∀ a. NoThunks (m a), ∀ a. NoThunks a ⇒ NoThunks (StrictTVar m a), ∀ a. NoThunks a ⇒ NoThunks (StrictMVar m a)) ⇒ IOLike m where Source #

Methods

forgetSignKeyKES ∷ KESAlgorithm v ⇒ SignKeyKES v → m () Source #

Securely forget a KES signing key.

No-op for the IOSim, but forgetSignKeyKES for IO.

Instances

Instances details
IOLike IO Source # 
Instance details

Defined in Ouroboros.Consensus.Util.IOLike

Methods

forgetSignKeyKES ∷ KESAlgorithm v ⇒ SignKeyKES v → IO () Source #

(IOLike m, ∀ a. NoThunks (StrictTVar (WithEarlyExit m) a), ∀ a. NoThunks (StrictMVar (WithEarlyExit m) a), MonadCatch (STM m)) ⇒ IOLike (WithEarlyExit m) Source # 
Instance details

Defined in Ouroboros.Consensus.Util.EarlyExit

Methods

forgetSignKeyKES ∷ KESAlgorithm v ⇒ SignKeyKES v → WithEarlyExit m () Source #

Re-exports

MonadThrow

class (Typeable e, Show e) ⇒ Exception e where Source #

Any type that you wish to throw or catch as an exception must be an instance of the Exception class. The simplest case is a new exception type directly below the root:

data MyException = ThisException | ThatException
    deriving Show

instance Exception MyException

The default method definitions in the Exception class do what we need in this case. You can now throw and catch ThisException and ThatException as exceptions:

*Main> throw ThisException `catch` \e -> putStrLn ("Caught " ++ show (e :: MyException))
Caught ThisException

In more complicated examples, you may wish to define a whole hierarchy of exceptions:

---------------------------------------------------------------------
-- Make the root exception type for all the exceptions in a compiler

data SomeCompilerException = forall e . Exception e => SomeCompilerException e

instance Show SomeCompilerException where
    show (SomeCompilerException e) = show e

instance Exception SomeCompilerException

compilerExceptionToException :: Exception e => e -> SomeException
compilerExceptionToException = toException . SomeCompilerException

compilerExceptionFromException :: Exception e => SomeException -> Maybe e
compilerExceptionFromException x = do
    SomeCompilerException a <- fromException x
    cast a

---------------------------------------------------------------------
-- Make a subhierarchy for exceptions in the frontend of the compiler

data SomeFrontendException = forall e . Exception e => SomeFrontendException e

instance Show SomeFrontendException where
    show (SomeFrontendException e) = show e

instance Exception SomeFrontendException where
    toException = compilerExceptionToException
    fromException = compilerExceptionFromException

frontendExceptionToException :: Exception e => e -> SomeException
frontendExceptionToException = toException . SomeFrontendException

frontendExceptionFromException :: Exception e => SomeException -> Maybe e
frontendExceptionFromException x = do
    SomeFrontendException a <- fromException x
    cast a

---------------------------------------------------------------------
-- Make an exception type for a particular frontend compiler exception

data MismatchedParentheses = MismatchedParentheses
    deriving Show

instance Exception MismatchedParentheses where
    toException   = frontendExceptionToException
    fromException = frontendExceptionFromException

We can now catch a MismatchedParentheses exception as MismatchedParentheses, SomeFrontendException or SomeCompilerException, but not other types, e.g. IOException:

*Main> throw MismatchedParentheses `catch` \e -> putStrLn ("Caught " ++ show (e :: MismatchedParentheses))
Caught MismatchedParentheses
*Main> throw MismatchedParentheses `catch` \e -> putStrLn ("Caught " ++ show (e :: SomeFrontendException))
Caught MismatchedParentheses
*Main> throw MismatchedParentheses `catch` \e -> putStrLn ("Caught " ++ show (e :: SomeCompilerException))
Caught MismatchedParentheses
*Main> throw MismatchedParentheses `catch` \e -> putStrLn ("Caught " ++ show (e :: IOException))
*** Exception: MismatchedParentheses

Minimal complete definition

Nothing

Methods

toException ∷ e → SomeException Source #

fromExceptionSomeExceptionMaybe e Source #

displayException ∷ e → String Source #

Render this exception value in a human-friendly manner.

Default implementation: show.

Since: base-4.8.0.0

Instances

Instances details
Exception Void

Since: base-4.8.0.0

Instance details

Defined in Data.Void

Exception PatternMatchFail

Since: base-4.0

Instance details

Defined in Control.Exception.Base

Exception RecSelError

Since: base-4.0

Instance details

Defined in Control.Exception.Base

Exception RecConError

Since: base-4.0

Instance details

Defined in Control.Exception.Base

Exception RecUpdError

Since: base-4.0

Instance details

Defined in Control.Exception.Base

Exception NoMethodError

Since: base-4.0

Instance details

Defined in Control.Exception.Base

Exception TypeError

Since: base-4.9.0.0

Instance details

Defined in Control.Exception.Base

Exception NonTermination

Since: base-4.0

Instance details

Defined in Control.Exception.Base

Exception NestedAtomically

Since: base-4.0

Instance details

Defined in Control.Exception.Base

Exception BlockedIndefinitelyOnMVar

Since: base-4.1.0.0

Instance details

Defined in GHC.IO.Exception

Exception BlockedIndefinitelyOnSTM

Since: base-4.1.0.0

Instance details

Defined in GHC.IO.Exception

Exception Deadlock

Since: base-4.1.0.0

Instance details

Defined in GHC.IO.Exception

Exception AllocationLimitExceeded

Since: base-4.8.0.0

Instance details

Defined in GHC.IO.Exception

Exception CompactionFailed

Since: base-4.10.0.0

Instance details

Defined in GHC.IO.Exception

Exception AssertionFailed

Since: base-4.1.0.0

Instance details

Defined in GHC.IO.Exception

Exception SomeAsyncException

Since: base-4.7.0.0

Instance details

Defined in GHC.IO.Exception

Exception AsyncException

Since: base-4.7.0.0

Instance details

Defined in GHC.IO.Exception

Exception ArrayException

Since: base-4.1.0.0

Instance details

Defined in GHC.IO.Exception

Exception FixIOException

Since: base-4.11.0.0

Instance details

Defined in GHC.IO.Exception

Exception ExitCode

Since: base-4.1.0.0

Instance details

Defined in GHC.IO.Exception

Exception IOException

Since: base-4.1.0.0

Instance details

Defined in GHC.IO.Exception

Exception ErrorCall

Since: base-4.0.0.0

Instance details

Defined in GHC.Exception

Exception ArithException

Since: base-4.0.0.0

Instance details

Defined in GHC.Exception.Type

Exception SomeException

Since: base-3.0

Instance details

Defined in GHC.Exception.Type

Exception MuxError 
Instance details

Defined in Network.Mux.Trace

Exception MuxRuntimeError 
Instance details

Defined in Network.Mux.Types

Exception TxSubmissionProtocolError 
Instance details

Defined in Ouroboros.Network.TxSubmission.Outbound

Exception TxSubmissionProtocolError 
Instance details

Defined in Ouroboros.Network.TxSubmission.Inbound

Exception KeepAliveProtocolFailure 
Instance details

Defined in Ouroboros.Network.Protocol.KeepAlive.Type

Exception BlockFetchProtocolFailure 
Instance details

Defined in Ouroboros.Network.BlockFetch.Client

Exception ExceptionInHandler 
Instance details

Defined in Ouroboros.Network.ConnectionManager.Types

Exception ProtocolLimitFailure 
Instance details

Defined in Ouroboros.Network.Driver.Limits

Exception DecoderFailure 
Instance details

Defined in Ouroboros.Network.Driver.Simple

Exception SubscriberError 
Instance details

Defined in Ouroboros.Network.Subscription.Worker

Exception PromiseWriterException 
Instance details

Defined in Ouroboros.Network.ConnectionManager.Types

Exception SomeConnectionManagerError 
Instance details

Defined in Ouroboros.Network.ConnectionManager.Types

Exception DeserialiseFailure 
Instance details

Defined in Codec.CBOR.Read

Methods

toException ∷ DeserialiseFailure → SomeException Source #

fromExceptionSomeExceptionMaybe DeserialiseFailure Source #

displayException ∷ DeserialiseFailure → String Source #

Exception DecoderError 
Instance details

Defined in Cardano.Binary.FromCBOR

Methods

toException ∷ DecoderError → SomeException Source #

fromExceptionSomeExceptionMaybe DecoderError Source #

displayException ∷ DecoderError → String Source #

Exception ASCII7_Invalid 
Instance details

Defined in Basement.String.Encoding.ASCII7

Methods

toException ∷ ASCII7_Invalid → SomeException Source #

fromExceptionSomeExceptionMaybe ASCII7_Invalid Source #

displayException ∷ ASCII7_Invalid → String Source #

Exception ISO_8859_1_Invalid 
Instance details

Defined in Basement.String.Encoding.ISO_8859_1

Methods

toException ∷ ISO_8859_1_Invalid → SomeException Source #

fromExceptionSomeExceptionMaybe ISO_8859_1_Invalid Source #

displayException ∷ ISO_8859_1_Invalid → String Source #

Exception UTF16_Invalid 
Instance details

Defined in Basement.String.Encoding.UTF16

Methods

toException ∷ UTF16_Invalid → SomeException Source #

fromExceptionSomeExceptionMaybe UTF16_Invalid Source #

displayException ∷ UTF16_Invalid → String Source #

Exception UTF32_Invalid 
Instance details

Defined in Basement.String.Encoding.UTF32

Methods

toException ∷ UTF32_Invalid → SomeException Source #

fromExceptionSomeExceptionMaybe UTF32_Invalid Source #

displayException ∷ UTF32_Invalid → String Source #

Exception CryptoError 
Instance details

Defined in Crypto.Error.Types

Methods

toException ∷ CryptoError → SomeException Source #

fromExceptionSomeExceptionMaybe CryptoError Source #

displayException ∷ CryptoError → String Source #

Exception FsError Source # 
Instance details

Defined in Ouroboros.Consensus.Storage.FS.API.Types

Exception AsyncCancelled 
Instance details

Defined in Control.Concurrent.Async

Methods

toException ∷ AsyncCancelled → SomeException Source #

fromExceptionSomeExceptionMaybe AsyncCancelled Source #

displayException ∷ AsyncCancelled → String Source #

Exception ExceptionInLinkedThread 
Instance details

Defined in Control.Monad.Class.MonadAsync

Exception BlockedIndefinitely 
Instance details

Defined in Control.Monad.Class.MonadSTM

Methods

toException ∷ BlockedIndefinitely → SomeException Source #

fromExceptionSomeExceptionMaybe BlockedIndefinitely Source #

displayException ∷ BlockedIndefinitely → String Source #

Exception DNSError 
Instance details

Defined in Network.DNS.Types

Methods

toException ∷ DNSError → SomeException Source #

fromExceptionSomeExceptionMaybe DNSError Source #

displayException ∷ DNSError → String Source #

Exception BimapException 
Instance details

Defined in Data.Bimap

Methods

toException ∷ BimapException → SomeException Source #

fromExceptionSomeExceptionMaybe BimapException Source #

displayException ∷ BimapException → String Source #

Exception ExceptionInLinkedThread 
Instance details

Defined in Control.Concurrent.Async

Methods

toException ∷ ExceptionInLinkedThread → SomeException Source #

fromExceptionSomeExceptionMaybe ExceptionInLinkedThread Source #

displayException ∷ ExceptionInLinkedThread → String Source #

Exception DbMarkerError Source # 
Instance details

Defined in Ouroboros.Consensus.Node.DbMarker

Exception DbLocked Source # 
Instance details

Defined in Ouroboros.Consensus.Node.DbLock

Exception DataMeasureClassOverflowException 
Instance details

Defined in Data.Measure.Class

Methods

toException ∷ DataMeasureClassOverflowException → SomeException Source #

fromExceptionSomeExceptionMaybe DataMeasureClassOverflowException Source #

displayException ∷ DataMeasureClassOverflowException → String Source #

Exception ChunkAssertionFailure Source # 
Instance details

Defined in Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Internal

Exception CodecFailure 
Instance details

Defined in Network.TypedProtocol.Codec

Methods

toException ∷ CodecFailure → SomeException Source #

fromExceptionSomeExceptionMaybe CodecFailure Source #

displayException ∷ CodecFailure → String Source #

Exception OutsideForecastRange Source # 
Instance details

Defined in Ouroboros.Consensus.Forecast

Exception ResourceRegistryThreadException Source # 
Instance details

Defined in Ouroboros.Consensus.Util.ResourceRegistry

Exception TempRegistryException Source # 
Instance details

Defined in Ouroboros.Consensus.Util.ResourceRegistry

Exception RegistryClosedException Source # 
Instance details

Defined in Ouroboros.Consensus.Util.ResourceRegistry

Exception PastHorizonException Source # 
Instance details

Defined in Ouroboros.Consensus.HardFork.History.Qry

Exception SystemClockMovedBackException Source # 
Instance details

Defined in Ouroboros.Consensus.BlockchainTime.WallClock.Util

Exception VersionError Source # 
Instance details

Defined in Ouroboros.Consensus.Util.Versioned

Exception HardForkEncoderException Source # 
Instance details

Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.Common

Exception ChainSyncClientException Source # 
Instance details

Defined in Ouroboros.Consensus.MiniProtocol.ChainSync.Client

Exception BlockFetchServerException Source # 
Instance details

Defined in Ouroboros.Consensus.MiniProtocol.BlockFetch.Server

Exception SeedBytesExhausted 
Instance details

Defined in Cardano.Crypto.Seed

Methods

toException ∷ SeedBytesExhausted → SomeException Source #

fromExceptionSomeExceptionMaybe SeedBytesExhausted Source #

displayException ∷ SeedBytesExhausted → String Source #

(Typeable ntnAddr, Show ntnAddr) ⇒ Exception (Failure ntnAddr) 
Instance details

Defined in Ouroboros.Network.Diffusion.Common

(Typeable vNumber, Show vNumber) ⇒ Exception (RefuseReason vNumber) 
Instance details

Defined in Ouroboros.Network.Protocol.Handshake.Type

(Typeable vNumber, Show vNumber) ⇒ Exception (HandshakeProtocolError vNumber) 
Instance details

Defined in Ouroboros.Network.Protocol.Handshake.Type

(Show peerAddr, Typeable peerAddr) ⇒ Exception (ConnectionManagerError peerAddr) 
Instance details

Defined in Ouroboros.Network.ConnectionManager.Types

(StandardHash blk, Typeable blk) ⇒ Exception (VolatileDBError blk) Source # 
Instance details

Defined in Ouroboros.Consensus.Storage.VolatileDB.API

(StandardHash blk, Typeable blk) ⇒ Exception (ImmutableDBError blk) Source # 
Instance details

Defined in Ouroboros.Consensus.Storage.ImmutableDB.API

(Typeable blk, StandardHash blk) ⇒ Exception (ChainDbError blk) Source # 
Instance details

Defined in Ouroboros.Consensus.Storage.ChainDB.API

(Typeable blk, StandardHash blk) ⇒ Exception (ChainDbFailure blk) Source # 
Instance details

Defined in Ouroboros.Consensus.Storage.ChainDB.API

data ExitCase a #

Instances

Instances details
Functor ExitCase 
Instance details

Defined in Control.Monad.Class.MonadThrow

Methods

fmap ∷ (a → b) → ExitCase a → ExitCase b Source #

(<$) ∷ a → ExitCase b → ExitCase a Source #

Show a ⇒ Show (ExitCase a) 
Instance details

Defined in Control.Monad.Class.MonadThrow

class MonadThrow m ⇒ MonadCatch (m ∷ TypeType) where #

Minimal complete definition

catch

Methods

catchException e ⇒ m a → (e → m a) → m a #

catchJustException e ⇒ (e → Maybe b) → m a → (b → m a) → m a #

tryException e ⇒ m a → m (Either e a) #

tryJustException e ⇒ (e → Maybe b) → m a → m (Either b a) #

handleException e ⇒ (e → m a) → m a → m a #

handleJustException e ⇒ (e → Maybe b) → (b → m a) → m a → m a #

onException ∷ m a → m b → m a #

bracketOnError ∷ m a → (a → m b) → (a → m c) → m c #

generalBracket ∷ m a → (a → ExitCase b → m c) → (a → m b) → m (b, c) #

Instances

Instances details
MonadCatch IO 
Instance details

Defined in Control.Monad.Class.MonadThrow

Methods

catchException e ⇒ IO a → (e → IO a) → IO a #

catchJustException e ⇒ (e → Maybe b) → IO a → (b → IO a) → IO a #

tryException e ⇒ IO a → IO (Either e a) #

tryJustException e ⇒ (e → Maybe b) → IO a → IO (Either b a) #

handleException e ⇒ (e → IO a) → IO a → IO a #

handleJustException e ⇒ (e → Maybe b) → (b → IO a) → IO a → IO a #

onExceptionIO a → IO b → IO a #

bracketOnErrorIO a → (a → IO b) → (a → IO c) → IO c #

generalBracketIO a → (a → ExitCase b → IO c) → (a → IO b) → IO (b, c) #

MonadCatch STM 
Instance details

Defined in Control.Monad.Class.MonadThrow

Methods

catchException e ⇒ STM a → (e → STM a) → STM a #

catchJustException e ⇒ (e → Maybe b) → STM a → (b → STM a) → STM a #

tryException e ⇒ STM a → STM (Either e a) #

tryJustException e ⇒ (e → Maybe b) → STM a → STM (Either b a) #

handleException e ⇒ (e → STM a) → STM a → STM a #

handleJustException e ⇒ (e → Maybe b) → (b → STM a) → STM a → STM a #

onExceptionSTM a → STM b → STM a #

bracketOnErrorSTM a → (a → STM b) → (a → STM c) → STM c #

generalBracketSTM a → (a → ExitCase b → STM c) → (a → STM b) → STM (b, c) #

MonadCatch m ⇒ MonadCatch (WithEarlyExit m) Source # 
Instance details

Defined in Ouroboros.Consensus.Util.EarlyExit

Methods

catchException e ⇒ WithEarlyExit m a → (e → WithEarlyExit m a) → WithEarlyExit m a #

catchJustException e ⇒ (e → Maybe b) → WithEarlyExit m a → (b → WithEarlyExit m a) → WithEarlyExit m a #

tryException e ⇒ WithEarlyExit m a → WithEarlyExit m (Either e a) #

tryJustException e ⇒ (e → Maybe b) → WithEarlyExit m a → WithEarlyExit m (Either b a) #

handleException e ⇒ (e → WithEarlyExit m a) → WithEarlyExit m a → WithEarlyExit m a #

handleJustException e ⇒ (e → Maybe b) → (b → WithEarlyExit m a) → WithEarlyExit m a → WithEarlyExit m a #

onExceptionWithEarlyExit m a → WithEarlyExit m b → WithEarlyExit m a #

bracketOnErrorWithEarlyExit m a → (a → WithEarlyExit m b) → (a → WithEarlyExit m c) → WithEarlyExit m c #

generalBracketWithEarlyExit m a → (a → ExitCase b → WithEarlyExit m c) → (a → WithEarlyExit m b) → WithEarlyExit m (b, c) #

MonadCatch m ⇒ MonadCatch (ExceptT e m) 
Instance details

Defined in Control.Monad.Class.MonadThrow

Methods

catchException e0 ⇒ ExceptT e m a → (e0 → ExceptT e m a) → ExceptT e m a #

catchJustException e0 ⇒ (e0 → Maybe b) → ExceptT e m a → (b → ExceptT e m a) → ExceptT e m a #

tryException e0 ⇒ ExceptT e m a → ExceptT e m (Either e0 a) #

tryJustException e0 ⇒ (e0 → Maybe b) → ExceptT e m a → ExceptT e m (Either b a) #

handleException e0 ⇒ (e0 → ExceptT e m a) → ExceptT e m a → ExceptT e m a #

handleJustException e0 ⇒ (e0 → Maybe b) → (b → ExceptT e m a) → ExceptT e m a → ExceptT e m a #

onExceptionExceptT e m a → ExceptT e m b → ExceptT e m a #

bracketOnErrorExceptT e m a → (a → ExceptT e m b) → (a → ExceptT e m c) → ExceptT e m c #

generalBracketExceptT e m a → (a → ExitCase b → ExceptT e m c) → (a → ExceptT e m b) → ExceptT e m (b, c) #

MonadCatch m ⇒ MonadCatch (ReaderT r m) 
Instance details

Defined in Control.Monad.Class.MonadThrow

Methods

catchException e ⇒ ReaderT r m a → (e → ReaderT r m a) → ReaderT r m a #

catchJustException e ⇒ (e → Maybe b) → ReaderT r m a → (b → ReaderT r m a) → ReaderT r m a #

tryException e ⇒ ReaderT r m a → ReaderT r m (Either e a) #

tryJustException e ⇒ (e → Maybe b) → ReaderT r m a → ReaderT r m (Either b a) #

handleException e ⇒ (e → ReaderT r m a) → ReaderT r m a → ReaderT r m a #

handleJustException e ⇒ (e → Maybe b) → (b → ReaderT r m a) → ReaderT r m a → ReaderT r m a #

onExceptionReaderT r m a → ReaderT r m b → ReaderT r m a #

bracketOnErrorReaderT r m a → (a → ReaderT r m b) → (a → ReaderT r m c) → ReaderT r m c #

generalBracketReaderT r m a → (a → ExitCase b → ReaderT r m c) → (a → ReaderT r m b) → ReaderT r m (b, c) #

MonadCatch m ⇒ MonadCatch (WithTempRegistry st m) Source # 
Instance details

Defined in Ouroboros.Consensus.Util.ResourceRegistry

Methods

catchException e ⇒ WithTempRegistry st m a → (e → WithTempRegistry st m a) → WithTempRegistry st m a #

catchJustException e ⇒ (e → Maybe b) → WithTempRegistry st m a → (b → WithTempRegistry st m a) → WithTempRegistry st m a #

tryException e ⇒ WithTempRegistry st m a → WithTempRegistry st m (Either e a) #

tryJustException e ⇒ (e → Maybe b) → WithTempRegistry st m a → WithTempRegistry st m (Either b a) #

handleException e ⇒ (e → WithTempRegistry st m a) → WithTempRegistry st m a → WithTempRegistry st m a #

handleJustException e ⇒ (e → Maybe b) → (b → WithTempRegistry st m a) → WithTempRegistry st m a → WithTempRegistry st m a #

onExceptionWithTempRegistry st m a → WithTempRegistry st m b → WithTempRegistry st m a #

bracketOnErrorWithTempRegistry st m a → (a → WithTempRegistry st m b) → (a → WithTempRegistry st m c) → WithTempRegistry st m c #

generalBracketWithTempRegistry st m a → (a → ExitCase b → WithTempRegistry st m c) → (a → WithTempRegistry st m b) → WithTempRegistry st m (b, c) #

(MonadSTM m, MonadThrow (STM m), MonadCatch (STM m)) ⇒ MonadCatch (WrappedSTM t r m) 
Instance details

Defined in Control.Monad.Class.MonadSTM

Methods

catchException e ⇒ WrappedSTM t r m a → (e → WrappedSTM t r m a) → WrappedSTM t r m a #

catchJustException e ⇒ (e → Maybe b) → WrappedSTM t r m a → (b → WrappedSTM t r m a) → WrappedSTM t r m a #

tryException e ⇒ WrappedSTM t r m a → WrappedSTM t r m (Either e a) #

tryJustException e ⇒ (e → Maybe b) → WrappedSTM t r m a → WrappedSTM t r m (Either b a) #

handleException e ⇒ (e → WrappedSTM t r m a) → WrappedSTM t r m a → WrappedSTM t r m a #

handleJustException e ⇒ (e → Maybe b) → (b → WrappedSTM t r m a) → WrappedSTM t r m a → WrappedSTM t r m a #

onExceptionWrappedSTM t r m a → WrappedSTM t r m b → WrappedSTM t r m a #

bracketOnErrorWrappedSTM t r m a → (a → WrappedSTM t r m b) → (a → WrappedSTM t r m c) → WrappedSTM t r m c #

generalBracketWrappedSTM t r m a → (a → ExitCase b → WrappedSTM t r m c) → (a → WrappedSTM t r m b) → WrappedSTM t r m (b, c) #

class MonadCatch m ⇒ MonadMask (m ∷ TypeType) where #

Minimal complete definition

mask, uninterruptibleMask

Methods

mask ∷ ((∀ a. m a → m a) → m b) → m b #

uninterruptibleMask ∷ ((∀ a. m a → m a) → m b) → m b #

mask_ ∷ m a → m a #

uninterruptibleMask_ ∷ m a → m a #

Instances

Instances details
MonadMask IO 
Instance details

Defined in Control.Monad.Class.MonadThrow

Methods

mask ∷ ((∀ a. IO a → IO a) → IO b) → IO b #

uninterruptibleMask ∷ ((∀ a. IO a → IO a) → IO b) → IO b #

mask_IO a → IO a #

uninterruptibleMask_IO a → IO a #

MonadMask m ⇒ MonadMask (WithEarlyExit m) Source # 
Instance details

Defined in Ouroboros.Consensus.Util.EarlyExit

Methods

mask ∷ ((∀ a. WithEarlyExit m a → WithEarlyExit m a) → WithEarlyExit m b) → WithEarlyExit m b #

uninterruptibleMask ∷ ((∀ a. WithEarlyExit m a → WithEarlyExit m a) → WithEarlyExit m b) → WithEarlyExit m b #

mask_WithEarlyExit m a → WithEarlyExit m a #

uninterruptibleMask_WithEarlyExit m a → WithEarlyExit m a #

MonadMask m ⇒ MonadMask (ExceptT e m) 
Instance details

Defined in Control.Monad.Class.MonadThrow

Methods

mask ∷ ((∀ a. ExceptT e m a → ExceptT e m a) → ExceptT e m b) → ExceptT e m b #

uninterruptibleMask ∷ ((∀ a. ExceptT e m a → ExceptT e m a) → ExceptT e m b) → ExceptT e m b #

mask_ExceptT e m a → ExceptT e m a #

uninterruptibleMask_ExceptT e m a → ExceptT e m a #

MonadMask m ⇒ MonadMask (ReaderT r m) 
Instance details

Defined in Control.Monad.Class.MonadThrow

Methods

mask ∷ ((∀ a. ReaderT r m a → ReaderT r m a) → ReaderT r m b) → ReaderT r m b #

uninterruptibleMask ∷ ((∀ a. ReaderT r m a → ReaderT r m a) → ReaderT r m b) → ReaderT r m b #

mask_ReaderT r m a → ReaderT r m a #

uninterruptibleMask_ReaderT r m a → ReaderT r m a #

MonadMask m ⇒ MonadMask (WithTempRegistry st m) Source # 
Instance details

Defined in Ouroboros.Consensus.Util.ResourceRegistry

Methods

mask ∷ ((∀ a. WithTempRegistry st m a → WithTempRegistry st m a) → WithTempRegistry st m b) → WithTempRegistry st m b #

uninterruptibleMask ∷ ((∀ a. WithTempRegistry st m a → WithTempRegistry st m a) → WithTempRegistry st m b) → WithTempRegistry st m b #

mask_WithTempRegistry st m a → WithTempRegistry st m a #

uninterruptibleMask_WithTempRegistry st m a → WithTempRegistry st m a #

class Monad m ⇒ MonadThrow (m ∷ TypeType) where #

Minimal complete definition

throwIO

Methods

throwIOException e ⇒ e → m a #

bracket ∷ m a → (a → m b) → (a → m c) → m c #

bracket_ ∷ m a → m b → m c → m c #

finally ∷ m a → m b → m a #

Instances

Instances details
MonadThrow IO 
Instance details

Defined in Control.Monad.Class.MonadThrow

Methods

throwIOException e ⇒ e → IO a #

bracketIO a → (a → IO b) → (a → IO c) → IO c #

bracket_IO a → IO b → IO c → IO c #

finallyIO a → IO b → IO a #

MonadThrow STM 
Instance details

Defined in Control.Monad.Class.MonadThrow

Methods

throwIOException e ⇒ e → STM a #

bracketSTM a → (a → STM b) → (a → STM c) → STM c #

bracket_STM a → STM b → STM c → STM c #

finallySTM a → STM b → STM a #

MonadCatch m ⇒ MonadThrow (WithEarlyExit m) Source # 
Instance details

Defined in Ouroboros.Consensus.Util.EarlyExit

Methods

throwIOException e ⇒ e → WithEarlyExit m a #

bracketWithEarlyExit m a → (a → WithEarlyExit m b) → (a → WithEarlyExit m c) → WithEarlyExit m c #

bracket_WithEarlyExit m a → WithEarlyExit m b → WithEarlyExit m c → WithEarlyExit m c #

finallyWithEarlyExit m a → WithEarlyExit m b → WithEarlyExit m a #

MonadCatch m ⇒ MonadThrow (ExceptT e m) 
Instance details

Defined in Control.Monad.Class.MonadThrow

Methods

throwIOException e0 ⇒ e0 → ExceptT e m a #

bracketExceptT e m a → (a → ExceptT e m b) → (a → ExceptT e m c) → ExceptT e m c #

bracket_ExceptT e m a → ExceptT e m b → ExceptT e m c → ExceptT e m c #

finallyExceptT e m a → ExceptT e m b → ExceptT e m a #

MonadThrow m ⇒ MonadThrow (ReaderT r m) 
Instance details

Defined in Control.Monad.Class.MonadThrow

Methods

throwIOException e ⇒ e → ReaderT r m a #

bracketReaderT r m a → (a → ReaderT r m b) → (a → ReaderT r m c) → ReaderT r m c #

bracket_ReaderT r m a → ReaderT r m b → ReaderT r m c → ReaderT r m c #

finallyReaderT r m a → ReaderT r m b → ReaderT r m a #

MonadThrow m ⇒ MonadThrow (WithTempRegistry st m) Source # 
Instance details

Defined in Ouroboros.Consensus.Util.ResourceRegistry

Methods

throwIOException e ⇒ e → WithTempRegistry st m a #

bracketWithTempRegistry st m a → (a → WithTempRegistry st m b) → (a → WithTempRegistry st m c) → WithTempRegistry st m c #

bracket_WithTempRegistry st m a → WithTempRegistry st m b → WithTempRegistry st m c → WithTempRegistry st m c #

finallyWithTempRegistry st m a → WithTempRegistry st m b → WithTempRegistry st m a #

(MonadSTM m, MonadThrow (STM m), MonadCatch (STM m)) ⇒ MonadThrow (WrappedSTM t r m) 
Instance details

Defined in Control.Monad.Class.MonadSTM

Methods

throwIOException e ⇒ e → WrappedSTM t r m a #

bracketWrappedSTM t r m a → (a → WrappedSTM t r m b) → (a → WrappedSTM t r m c) → WrappedSTM t r m c #

bracket_WrappedSTM t r m a → WrappedSTM t r m b → WrappedSTM t r m c → WrappedSTM t r m c #

finallyWrappedSTM t r m a → WrappedSTM t r m b → WrappedSTM t r m a #

data SomeException Source #

The SomeException type is the root of the exception type hierarchy. When an exception of type e is thrown, behind the scenes it is encapsulated in a SomeException.

Instances

Instances details
Show SomeException

Since: base-3.0

Instance details

Defined in GHC.Exception.Type

Exception SomeException

Since: base-3.0

Instance details

Defined in GHC.Exception.Type

MonadSTM

MonadFork, TODO: Should we hide this in favour of MonadAsync?

class MonadThread m ⇒ MonadFork (m ∷ TypeType) where #

Minimal complete definition

forkIO, forkIOWithUnmask, throwTo, yield

Methods

forkIO ∷ m () → m (ThreadId m) #

forkIOWithUnmask ∷ ((∀ a. m a → m a) → m ()) → m (ThreadId m) #

throwToException e ⇒ ThreadId m → e → m () #

killThreadThreadId m → m () #

yield ∷ m () #

Instances

Instances details
MonadFork IO 
Instance details

Defined in Control.Monad.Class.MonadFork

Methods

forkIOIO () → IO (ThreadId IO) #

forkIOWithUnmask ∷ ((∀ a. IO a → IO a) → IO ()) → IO (ThreadId IO) #

throwToException e ⇒ ThreadId IO → e → IO () #

killThreadThreadId IOIO () #

yieldIO () #

MonadFork m ⇒ MonadFork (WithEarlyExit m) Source # 
Instance details

Defined in Ouroboros.Consensus.Util.EarlyExit

MonadFork m ⇒ MonadFork (ReaderT e m) 
Instance details

Defined in Control.Monad.Class.MonadFork

Methods

forkIOReaderT e m () → ReaderT e m (ThreadId (ReaderT e m)) #

forkIOWithUnmask ∷ ((∀ a. ReaderT e m a → ReaderT e m a) → ReaderT e m ()) → ReaderT e m (ThreadId (ReaderT e m)) #

throwToException e0 ⇒ ThreadId (ReaderT e m) → e0 → ReaderT e m () #

killThreadThreadId (ReaderT e m) → ReaderT e m () #

yieldReaderT e m () #

class (Monad m, Eq (ThreadId m), Ord (ThreadId m), Show (ThreadId m)) ⇒ MonadThread (m ∷ TypeType) where #

Associated Types

type ThreadId (m ∷ TypeType) #

Methods

myThreadId ∷ m (ThreadId m) #

labelThreadThreadId m → String → m () #

Instances

Instances details
MonadThread IO 
Instance details

Defined in Control.Monad.Class.MonadFork

Associated Types

type ThreadId IO #

Methods

myThreadIdIO (ThreadId IO) #

labelThreadThreadId IOStringIO () #

MonadThread m ⇒ MonadThread (WithEarlyExit m) Source # 
Instance details

Defined in Ouroboros.Consensus.Util.EarlyExit

Associated Types

type ThreadId (WithEarlyExit m) #

MonadThread m ⇒ MonadThread (ReaderT r m) 
Instance details

Defined in Control.Monad.Class.MonadFork

Associated Types

type ThreadId (ReaderT r m) #

Methods

myThreadIdReaderT r m (ThreadId (ReaderT r m)) #

labelThreadThreadId (ReaderT r m) → StringReaderT r m () #

labelThisThreadMonadThread m ⇒ String → m () #

MonadAsync

class (MonadSTM m, MonadThread m) ⇒ MonadAsync (m ∷ TypeType) where #

Associated Types

type Async (m ∷ TypeType) = (async ∷ TypeType) | async → m #

Methods

async ∷ m a → m (Async m a) #

asyncThreadIdAsync m a → ThreadId m #

withAsync ∷ m a → (Async m a → m b) → m b #

waitSTMAsync m a → STM m a #

pollSTMAsync m a → STM m (Maybe (Either SomeException a)) #

waitCatchSTMAsync m a → STM m (Either SomeException a) #

waitAnySTM ∷ [Async m a] → STM m (Async m a, a) #

waitAnyCatchSTM ∷ [Async m a] → STM m (Async m a, Either SomeException a) #

waitEitherSTMAsync m a → Async m b → STM m (Either a b) #

waitEitherSTM_Async m a → Async m b → STM m () #

waitEitherCatchSTMAsync m a → Async m b → STM m (Either (Either SomeException a) (Either SomeException b)) #

waitBothSTMAsync m a → Async m b → STM m (a, b) #

waitAsync m a → m a #

pollAsync m a → m (Maybe (Either SomeException a)) #

waitCatchAsync m a → m (Either SomeException a) #

cancelAsync m a → m () #

cancelWithException e ⇒ Async m a → e → m () #

uninterruptibleCancelAsync m a → m () #

waitAny ∷ [Async m a] → m (Async m a, a) #

waitAnyCatch ∷ [Async m a] → m (Async m a, Either SomeException a) #

waitAnyCancel ∷ [Async m a] → m (Async m a, a) #

waitAnyCatchCancel ∷ [Async m a] → m (Async m a, Either SomeException a) #

waitEitherAsync m a → Async m b → m (Either a b) #

waitEitherCatchAsync m a → Async m b → m (Either (Either SomeException a) (Either SomeException b)) #

waitEitherCancelAsync m a → Async m b → m (Either a b) #

waitEitherCatchCancelAsync m a → Async m b → m (Either (Either SomeException a) (Either SomeException b)) #

waitEither_Async m a → Async m b → m () #

waitBothAsync m a → Async m b → m (a, b) #

race ∷ m a → m b → m (Either a b) #

race_ ∷ m a → m b → m () #

concurrently ∷ m a → m b → m (a, b) #

concurrently_ ∷ m a → m b → m () #

asyncWithUnmask ∷ ((∀ b. m b → m b) → m a) → m (Async m a) #

Instances

Instances details
MonadAsync IO 
Instance details

Defined in Control.Monad.Class.MonadAsync

Associated Types

type Async IO = (async ∷ TypeType) #

Methods

asyncIO a → IO (Async IO a) #

asyncThreadIdAsync IO a → ThreadId IO #

withAsyncIO a → (Async IO a → IO b) → IO b #

waitSTMAsync IO a → STM IO a #

pollSTMAsync IO a → STM IO (Maybe (Either SomeException a)) #

waitCatchSTMAsync IO a → STM IO (Either SomeException a) #

waitAnySTM ∷ [Async IO a] → STM IO (Async IO a, a) #

waitAnyCatchSTM ∷ [Async IO a] → STM IO (Async IO a, Either SomeException a) #

waitEitherSTMAsync IO a → Async IO b → STM IO (Either a b) #

waitEitherSTM_Async IO a → Async IO b → STM IO () #

waitEitherCatchSTMAsync IO a → Async IO b → STM IO (Either (Either SomeException a) (Either SomeException b)) #

waitBothSTMAsync IO a → Async IO b → STM IO (a, b) #

waitAsync IO a → IO a #

pollAsync IO a → IO (Maybe (Either SomeException a)) #

waitCatchAsync IO a → IO (Either SomeException a) #

cancelAsync IO a → IO () #

cancelWithException e ⇒ Async IO a → e → IO () #

uninterruptibleCancelAsync IO a → IO () #

waitAny ∷ [Async IO a] → IO (Async IO a, a) #

waitAnyCatch ∷ [Async IO a] → IO (Async IO a, Either SomeException a) #

waitAnyCancel ∷ [Async IO a] → IO (Async IO a, a) #

waitAnyCatchCancel ∷ [Async IO a] → IO (Async IO a, Either SomeException a) #

waitEitherAsync IO a → Async IO b → IO (Either a b) #

waitEitherCatchAsync IO a → Async IO b → IO (Either (Either SomeException a) (Either SomeException b)) #

waitEitherCancelAsync IO a → Async IO b → IO (Either a b) #

waitEitherCatchCancelAsync IO a → Async IO b → IO (Either (Either SomeException a) (Either SomeException b)) #

waitEither_Async IO a → Async IO b → IO () #

waitBothAsync IO a → Async IO b → IO (a, b) #

raceIO a → IO b → IO (Either a b) #

race_IO a → IO b → IO () #

concurrentlyIO a → IO b → IO (a, b) #

concurrently_IO a → IO b → IO () #

asyncWithUnmask ∷ ((∀ b. IO b → IO b) → IO a) → IO (Async IO a) #

(MonadMask m, MonadAsync m, MonadCatch (STM m)) ⇒ MonadAsync (WithEarlyExit m) Source # 
Instance details

Defined in Ouroboros.Consensus.Util.EarlyExit

Associated Types

type Async (WithEarlyExit m) = (async ∷ TypeType) #

Methods

asyncWithEarlyExit m a → WithEarlyExit m (Async (WithEarlyExit m) a) #

asyncThreadIdAsync (WithEarlyExit m) a → ThreadId (WithEarlyExit m) #

withAsyncWithEarlyExit m a → (Async (WithEarlyExit m) a → WithEarlyExit m b) → WithEarlyExit m b #

waitSTMAsync (WithEarlyExit m) a → STM (WithEarlyExit m) a #

pollSTMAsync (WithEarlyExit m) a → STM (WithEarlyExit m) (Maybe (Either SomeException a)) #

waitCatchSTMAsync (WithEarlyExit m) a → STM (WithEarlyExit m) (Either SomeException a) #

waitAnySTM ∷ [Async (WithEarlyExit m) a] → STM (WithEarlyExit m) (Async (WithEarlyExit m) a, a) #

waitAnyCatchSTM ∷ [Async (WithEarlyExit m) a] → STM (WithEarlyExit m) (Async (WithEarlyExit m) a, Either SomeException a) #

waitEitherSTMAsync (WithEarlyExit m) a → Async (WithEarlyExit m) b → STM (WithEarlyExit m) (Either a b) #

waitEitherSTM_Async (WithEarlyExit m) a → Async (WithEarlyExit m) b → STM (WithEarlyExit m) () #

waitEitherCatchSTMAsync (WithEarlyExit m) a → Async (WithEarlyExit m) b → STM (WithEarlyExit m) (Either (Either SomeException a) (Either SomeException b)) #

waitBothSTMAsync (WithEarlyExit m) a → Async (WithEarlyExit m) b → STM (WithEarlyExit m) (a, b) #

waitAsync (WithEarlyExit m) a → WithEarlyExit m a #

pollAsync (WithEarlyExit m) a → WithEarlyExit m (Maybe (Either SomeException a)) #

waitCatchAsync (WithEarlyExit m) a → WithEarlyExit m (Either SomeException a) #

cancelAsync (WithEarlyExit m) a → WithEarlyExit m () #

cancelWithException e ⇒ Async (WithEarlyExit m) a → e → WithEarlyExit m () #

uninterruptibleCancelAsync (WithEarlyExit m) a → WithEarlyExit m () #

waitAny ∷ [Async (WithEarlyExit m) a] → WithEarlyExit m (Async (WithEarlyExit m) a, a) #

waitAnyCatch ∷ [Async (WithEarlyExit m) a] → WithEarlyExit m (Async (WithEarlyExit m) a, Either SomeException a) #

waitAnyCancel ∷ [Async (WithEarlyExit m) a] → WithEarlyExit m (Async (WithEarlyExit m) a, a) #

waitAnyCatchCancel ∷ [Async (WithEarlyExit m) a] → WithEarlyExit m (Async (WithEarlyExit m) a, Either SomeException a) #

waitEitherAsync (WithEarlyExit m) a → Async (WithEarlyExit m) b → WithEarlyExit m (Either a b) #

waitEitherCatchAsync (WithEarlyExit m) a → Async (WithEarlyExit m) b → WithEarlyExit m (Either (Either SomeException a) (Either SomeException b)) #

waitEitherCancelAsync (WithEarlyExit m) a → Async (WithEarlyExit m) b → WithEarlyExit m (Either a b) #

waitEitherCatchCancelAsync (WithEarlyExit m) a → Async (WithEarlyExit m) b → WithEarlyExit m (Either (Either SomeException a) (Either SomeException b)) #

waitEither_Async (WithEarlyExit m) a → Async (WithEarlyExit m) b → WithEarlyExit m () #

waitBothAsync (WithEarlyExit m) a → Async (WithEarlyExit m) b → WithEarlyExit m (a, b) #

raceWithEarlyExit m a → WithEarlyExit m b → WithEarlyExit m (Either a b) #

race_WithEarlyExit m a → WithEarlyExit m b → WithEarlyExit m () #

concurrentlyWithEarlyExit m a → WithEarlyExit m b → WithEarlyExit m (a, b) #

concurrently_WithEarlyExit m a → WithEarlyExit m b → WithEarlyExit m () #

asyncWithUnmask ∷ ((∀ b. WithEarlyExit m b → WithEarlyExit m b) → WithEarlyExit m a) → WithEarlyExit m (Async (WithEarlyExit m) a) #

(MonadAsync m, MonadCatch (STM m)) ⇒ MonadAsync (ReaderT r m) 
Instance details

Defined in Control.Monad.Class.MonadAsync

Associated Types

type Async (ReaderT r m) = (async ∷ TypeType) #

Methods

asyncReaderT r m a → ReaderT r m (Async (ReaderT r m) a) #

asyncThreadIdAsync (ReaderT r m) a → ThreadId (ReaderT r m) #

withAsyncReaderT r m a → (Async (ReaderT r m) a → ReaderT r m b) → ReaderT r m b #

waitSTMAsync (ReaderT r m) a → STM (ReaderT r m) a #

pollSTMAsync (ReaderT r m) a → STM (ReaderT r m) (Maybe (Either SomeException a)) #

waitCatchSTMAsync (ReaderT r m) a → STM (ReaderT r m) (Either SomeException a) #

waitAnySTM ∷ [Async (ReaderT r m) a] → STM (ReaderT r m) (Async (ReaderT r m) a, a) #

waitAnyCatchSTM ∷ [Async (ReaderT r m) a] → STM (ReaderT r m) (Async (ReaderT r m) a, Either SomeException a) #

waitEitherSTMAsync (ReaderT r m) a → Async (ReaderT r m) b → STM (ReaderT r m) (Either a b) #

waitEitherSTM_Async (ReaderT r m) a → Async (ReaderT r m) b → STM (ReaderT r m) () #

waitEitherCatchSTMAsync (ReaderT r m) a → Async (ReaderT r m) b → STM (ReaderT r m) (Either (Either SomeException a) (Either SomeException b)) #

waitBothSTMAsync (ReaderT r m) a → Async (ReaderT r m) b → STM (ReaderT r m) (a, b) #

waitAsync (ReaderT r m) a → ReaderT r m a #

pollAsync (ReaderT r m) a → ReaderT r m (Maybe (Either SomeException a)) #

waitCatchAsync (ReaderT r m) a → ReaderT r m (Either SomeException a) #

cancelAsync (ReaderT r m) a → ReaderT r m () #

cancelWithException e ⇒ Async (ReaderT r m) a → e → ReaderT r m () #

uninterruptibleCancelAsync (ReaderT r m) a → ReaderT r m () #

waitAny ∷ [Async (ReaderT r m) a] → ReaderT r m (Async (ReaderT r m) a, a) #

waitAnyCatch ∷ [Async (ReaderT r m) a] → ReaderT r m (Async (ReaderT r m) a, Either SomeException a) #

waitAnyCancel ∷ [Async (ReaderT r m) a] → ReaderT r m (Async (ReaderT r m) a, a) #

waitAnyCatchCancel ∷ [Async (ReaderT r m) a] → ReaderT r m (Async (ReaderT r m) a, Either SomeException a) #

waitEitherAsync (ReaderT r m) a → Async (ReaderT r m) b → ReaderT r m (Either a b) #

waitEitherCatchAsync (ReaderT r m) a → Async (ReaderT r m) b → ReaderT r m (Either (Either SomeException a) (Either SomeException b)) #

waitEitherCancelAsync (ReaderT r m) a → Async (ReaderT r m) b → ReaderT r m (Either a b) #

waitEitherCatchCancelAsync (ReaderT r m) a → Async (ReaderT r m) b → ReaderT r m (Either (Either SomeException a) (Either SomeException b)) #

waitEither_Async (ReaderT r m) a → Async (ReaderT r m) b → ReaderT r m () #

waitBothAsync (ReaderT r m) a → Async (ReaderT r m) b → ReaderT r m (a, b) #

raceReaderT r m a → ReaderT r m b → ReaderT r m (Either a b) #

race_ReaderT r m a → ReaderT r m b → ReaderT r m () #

concurrentlyReaderT r m a → ReaderT r m b → ReaderT r m (a, b) #

concurrently_ReaderT r m a → ReaderT r m b → ReaderT r m () #

asyncWithUnmask ∷ ((∀ b. ReaderT r m b → ReaderT r m b) → ReaderT r m a) → ReaderT r m (Async (ReaderT r m) a) #

link ∷ (MonadAsync m, MonadFork m, MonadMask m) ⇒ Async m a → m () #

linkTo ∷ (MonadAsync m, MonadFork m, MonadMask m) ⇒ ThreadId m → Async m a → m () #

MonadST

class Monad m ⇒ MonadST (m ∷ TypeType) where #

Methods

withLiftST ∷ (∀ s. (∀ a. ST s a → m a) → b) → b #

Instances

Instances details
MonadST IO 
Instance details

Defined in Control.Monad.Class.MonadST

Methods

withLiftST ∷ (∀ s. (∀ a. ST s a → IO a) → b) → b #

MonadST (ST s) 
Instance details

Defined in Control.Monad.Class.MonadST

Methods

withLiftST ∷ (∀ s0. (∀ a. ST s0 a → ST s a) → b) → b #

MonadST m ⇒ MonadST (WithEarlyExit m) Source # 
Instance details

Defined in Ouroboros.Consensus.Util.EarlyExit

Methods

withLiftST ∷ (∀ s. (∀ a. ST s a → WithEarlyExit m a) → b) → b #

MonadST m ⇒ MonadST (ReaderT r m) 
Instance details

Defined in Control.Monad.Class.MonadST

Methods

withLiftST ∷ (∀ s. (∀ a. ST s a → ReaderT r m a) → b) → b #

MonadTime

data DiffTime Source #

This is a length of time, as measured by a clock. Conversion functions will treat it as seconds. It has a precision of 10^-12 s.

Instances

Instances details
Enum DiffTime 
Instance details

Defined in Data.Time.Clock.Internal.DiffTime

Eq DiffTime 
Instance details

Defined in Data.Time.Clock.Internal.DiffTime

Fractional DiffTime 
Instance details

Defined in Data.Time.Clock.Internal.DiffTime

Data DiffTime 
Instance details

Defined in Data.Time.Clock.Internal.DiffTime

Methods

gfoldl ∷ (∀ d b. Data d ⇒ c (d → b) → d → c b) → (∀ g. g → c g) → DiffTime → c DiffTime Source #

gunfold ∷ (∀ b r. Data b ⇒ c (b → r) → c r) → (∀ r. r → c r) → Constr → c DiffTime Source #

toConstrDiffTimeConstr Source #

dataTypeOfDiffTimeDataType Source #

dataCast1Typeable t ⇒ (∀ d. Data d ⇒ c (t d)) → Maybe (c DiffTime) Source #

dataCast2Typeable t ⇒ (∀ d e. (Data d, Data e) ⇒ c (t d e)) → Maybe (c DiffTime) Source #

gmapT ∷ (∀ b. Data b ⇒ b → b) → DiffTimeDiffTime Source #

gmapQl ∷ (r → r' → r) → r → (∀ d. Data d ⇒ d → r') → DiffTime → r Source #

gmapQr ∷ ∀ r r'. (r' → r → r) → r → (∀ d. Data d ⇒ d → r') → DiffTime → r Source #

gmapQ ∷ (∀ d. Data d ⇒ d → u) → DiffTime → [u] Source #

gmapQiInt → (∀ d. Data d ⇒ d → u) → DiffTime → u Source #

gmapMMonad m ⇒ (∀ d. Data d ⇒ d → m d) → DiffTime → m DiffTime Source #

gmapMpMonadPlus m ⇒ (∀ d. Data d ⇒ d → m d) → DiffTime → m DiffTime Source #

gmapMoMonadPlus m ⇒ (∀ d. Data d ⇒ d → m d) → DiffTime → m DiffTime Source #

Num DiffTime 
Instance details

Defined in Data.Time.Clock.Internal.DiffTime

Ord DiffTime 
Instance details

Defined in Data.Time.Clock.Internal.DiffTime

Real DiffTime 
Instance details

Defined in Data.Time.Clock.Internal.DiffTime

RealFrac DiffTime 
Instance details

Defined in Data.Time.Clock.Internal.DiffTime

Methods

properFractionIntegral b ⇒ DiffTime → (b, DiffTime) Source #

truncateIntegral b ⇒ DiffTime → b Source #

roundIntegral b ⇒ DiffTime → b Source #

ceilingIntegral b ⇒ DiffTime → b Source #

floorIntegral b ⇒ DiffTime → b Source #

Show DiffTime 
Instance details

Defined in Data.Time.Clock.Internal.DiffTime

NFData DiffTime 
Instance details

Defined in Data.Time.Clock.Internal.DiffTime

Methods

rnfDiffTime → () Source #

NoThunks DiffTime 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → DiffTimeIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → DiffTimeIO (Maybe ThunkInfo) #

showTypeOfProxy DiffTimeString #

class Monad m ⇒ MonadMonotonicTime (m ∷ TypeType) where #

Methods

getMonotonicTime ∷ m Time #

newtype Time #

Constructors

Time DiffTime 

Instances

Instances details
Eq Time 
Instance details

Defined in Control.Monad.Class.MonadTime

Methods

(==)TimeTimeBool Source #

(/=)TimeTimeBool Source #

Ord Time 
Instance details

Defined in Control.Monad.Class.MonadTime

Methods

compareTimeTimeOrdering Source #

(<)TimeTimeBool Source #

(<=)TimeTimeBool Source #

(>)TimeTimeBool Source #

(>=)TimeTimeBool Source #

maxTimeTimeTime Source #

minTimeTimeTime Source #

Show Time 
Instance details

Defined in Control.Monad.Class.MonadTime

Methods

showsPrecIntTimeShowS Source #

showTimeString Source #

showList ∷ [Time] → ShowS Source #

Generic Time 
Instance details

Defined in Control.Monad.Class.MonadTime

Associated Types

type Rep TimeTypeType Source #

Methods

fromTimeRep Time x Source #

toRep Time x → Time Source #

NoThunks Time Source # 
Instance details

Defined in Ouroboros.Consensus.Util.Orphans

Methods

noThunks ∷ Context → TimeIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → TimeIO (Maybe ThunkInfo) #

showTypeOfProxy TimeString #

Condense Time Source # 
Instance details

Defined in Ouroboros.Consensus.Util.Condense

Methods

condenseTimeString Source #

SAct (SuspendDecision Time) (Maybe (PeerState m))

Action of SuspendDecision on Maybe PeerState. We use this action together with alter function.

Note: SuspendDecision does not act on PeerState, only the sub-semigroup generated by SuspendConsumer and SuspendPeer does.

Instance details

Defined in Ouroboros.Network.Subscription.PeerState

type Rep Time 
Instance details

Defined in Control.Monad.Class.MonadTime

type Rep Time = D1 ('MetaData "Time" "Control.Monad.Class.MonadTime" "io-classes-0.2.0.0-d55904d28f362aa3b91ecfeff5678db3e4b5f7a1ee5f6f56b3ba6520dd6d7a28" 'True) (C1 ('MetaCons "Time" 'PrefixI 'False) (S1 ('MetaSel ('NothingMaybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DiffTime)))

addTimeDiffTimeTimeTime #

MonadDelay

class Monad m ⇒ MonadDelay (m ∷ TypeType) where #

Minimal complete definition

Nothing

Methods

threadDelayDiffTime → m () #

Instances

Instances details
MonadDelay IO 
Instance details

Defined in Control.Monad.Class.MonadTimer

Methods

threadDelayDiffTimeIO () #

MonadDelay m ⇒ MonadDelay (WithEarlyExit m) Source # 
Instance details

Defined in Ouroboros.Consensus.Util.EarlyExit

Methods

threadDelayDiffTimeWithEarlyExit m () #

MonadDelay m ⇒ MonadDelay (ExceptT e m) 
Instance details

Defined in Control.Monad.Class.MonadTimer

Methods

threadDelayDiffTimeExceptT e m () #

MonadDelay m ⇒ MonadDelay (ReaderT r m) 
Instance details

Defined in Control.Monad.Class.MonadTimer

Methods

threadDelayDiffTimeReaderT r m () #

MonadDelay m ⇒ MonadDelay (StateT s m) 
Instance details

Defined in Control.Monad.Class.MonadTimer

Methods

threadDelayDiffTimeStateT s m () #

(Monoid w, MonadDelay m) ⇒ MonadDelay (WriterT w m) 
Instance details

Defined in Control.Monad.Class.MonadTimer

Methods

threadDelayDiffTimeWriterT w m () #

MonadDelay m ⇒ MonadDelay (ContT r m) 
Instance details

Defined in Control.Monad.Class.MonadTimer

Methods

threadDelayDiffTimeContT r m () #

(Monoid w, MonadDelay m) ⇒ MonadDelay (RWST r w s m) 
Instance details

Defined in Control.Monad.Class.MonadTimer

Methods

threadDelayDiffTimeRWST r w s m () #

MonadEventlog

class Monad m ⇒ MonadEventlog (m ∷ TypeType) where #

Methods

traceEventIOString → m () #

traceMarkerIOString → m () #

Instances

Instances details
MonadEventlog IO 
Instance details

Defined in Control.Monad.Class.MonadEventlog

Methods

traceEventIOStringIO () #

traceMarkerIOStringIO () #

MonadEventlog m ⇒ MonadEventlog (WithEarlyExit m) Source # 
Instance details

Defined in Ouroboros.Consensus.Util.EarlyExit

MonadEventlog m ⇒ MonadEventlog (ReaderT r m) 
Instance details

Defined in Control.Monad.Class.MonadEventlog

Methods

traceEventIOStringReaderT r m () #

traceMarkerIOStringReaderT r m () #

MonadEvaluate

class MonadThrow m ⇒ MonadEvaluate (m ∷ TypeType) where #

Methods

evaluate ∷ a → m a #

Instances

Instances details
MonadEvaluate IO 
Instance details

Defined in Control.Monad.Class.MonadThrow

Methods

evaluate ∷ a → IO a #

(MonadEvaluate m, MonadCatch m) ⇒ MonadEvaluate (WithEarlyExit m) Source # 
Instance details

Defined in Ouroboros.Consensus.Util.EarlyExit

Methods

evaluate ∷ a → WithEarlyExit m a #

MonadEvaluate m ⇒ MonadEvaluate (ReaderT r m) 
Instance details

Defined in Control.Monad.Class.MonadThrow

Methods

evaluate ∷ a → ReaderT r m a #

NoThunks

class NoThunks a where #

Minimal complete definition

Nothing

Methods

noThunks ∷ Context → a → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → a → IO (Maybe ThunkInfo) #

showTypeOfProxy a → String #

Instances

Instances details
NoThunks Bool 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → BoolIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → BoolIO (Maybe ThunkInfo) #

showTypeOfProxy BoolString #

NoThunks Char 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → CharIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → CharIO (Maybe ThunkInfo) #

showTypeOfProxy CharString #

NoThunks Double 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → DoubleIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → DoubleIO (Maybe ThunkInfo) #

showTypeOfProxy DoubleString #

NoThunks Float 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → FloatIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → FloatIO (Maybe ThunkInfo) #

showTypeOfProxy FloatString #

NoThunks Int 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → IntIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → IntIO (Maybe ThunkInfo) #

showTypeOfProxy IntString #

NoThunks Int8 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → Int8IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → Int8IO (Maybe ThunkInfo) #

showTypeOfProxy Int8String #

NoThunks Int16 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → Int16IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → Int16IO (Maybe ThunkInfo) #

showTypeOfProxy Int16String #

NoThunks Int32 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → Int32IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → Int32IO (Maybe ThunkInfo) #

showTypeOfProxy Int32String #

NoThunks Int64 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → Int64IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → Int64IO (Maybe ThunkInfo) #

showTypeOfProxy Int64String #

NoThunks Integer 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → IntegerIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → IntegerIO (Maybe ThunkInfo) #

showTypeOfProxy IntegerString #

NoThunks Natural 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → NaturalIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → NaturalIO (Maybe ThunkInfo) #

showTypeOfProxy NaturalString #

NoThunks Word 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → WordIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → WordIO (Maybe ThunkInfo) #

showTypeOfProxy WordString #

NoThunks Word8 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → Word8IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → Word8IO (Maybe ThunkInfo) #

showTypeOfProxy Word8String #

NoThunks Word16 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → Word16IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → Word16IO (Maybe ThunkInfo) #

showTypeOfProxy Word16String #

NoThunks Word32 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → Word32IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → Word32IO (Maybe ThunkInfo) #

showTypeOfProxy Word32String #

NoThunks Word64 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → Word64IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → Word64IO (Maybe ThunkInfo) #

showTypeOfProxy Word64String #

NoThunks CallStack 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → CallStackIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → CallStackIO (Maybe ThunkInfo) #

showTypeOfProxy CallStackString #

NoThunks () 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → () → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → () → IO (Maybe ThunkInfo) #

showTypeOfProxy () → String #

NoThunks Void 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → VoidIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → VoidIO (Maybe ThunkInfo) #

showTypeOfProxy VoidString #

NoThunks ShortByteString 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → ShortByteStringIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → ShortByteStringIO (Maybe ThunkInfo) #

showTypeOfProxy ShortByteStringString #

NoThunks ByteString 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → ByteStringIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → ByteStringIO (Maybe ThunkInfo) #

showTypeOfProxy ByteStringString #

NoThunks ByteString 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → ByteStringIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → ByteStringIO (Maybe ThunkInfo) #

showTypeOfProxy ByteStringString #

NoThunks DiffTime 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → DiffTimeIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → DiffTimeIO (Maybe ThunkInfo) #

showTypeOfProxy DiffTimeString #

NoThunks MaxSlotNo 
Instance details

Defined in Ouroboros.Network.Block

Methods

noThunks ∷ Context → MaxSlotNoIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → MaxSlotNoIO (Maybe ThunkInfo) #

showTypeOfProxy MaxSlotNoString #

NoThunks BlockNo 
Instance details

Defined in Cardano.Slotting.Block

Methods

noThunks ∷ Context → BlockNoIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → BlockNoIO (Maybe ThunkInfo) #

showTypeOfProxy BlockNoString #

NoThunks SlotNo 
Instance details

Defined in Cardano.Slotting.Slot

Methods

noThunks ∷ Context → SlotNoIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → SlotNoIO (Maybe ThunkInfo) #

showTypeOfProxy SlotNoString #

NoThunks NetworkMagic 
Instance details

Defined in Ouroboros.Network.Magic

Methods

noThunks ∷ Context → NetworkMagicIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → NetworkMagicIO (Maybe ThunkInfo) #

showTypeOfProxy NetworkMagicString #

NoThunks Text 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → TextIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → TextIO (Maybe ThunkInfo) #

showTypeOfProxy TextString #

NoThunks Text 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → TextIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → TextIO (Maybe ThunkInfo) #

showTypeOfProxy TextString #

NoThunks ZonedTime 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → ZonedTimeIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → ZonedTimeIO (Maybe ThunkInfo) #

showTypeOfProxy ZonedTimeString #

NoThunks TimeLocale 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → TimeLocaleIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → TimeLocaleIO (Maybe ThunkInfo) #

showTypeOfProxy TimeLocaleString #

NoThunks LocalTime 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → LocalTimeIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → LocalTimeIO (Maybe ThunkInfo) #

showTypeOfProxy LocalTimeString #

NoThunks TimeOfDay 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → TimeOfDayIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → TimeOfDayIO (Maybe ThunkInfo) #

showTypeOfProxy TimeOfDayString #

NoThunks TimeZone 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → TimeZoneIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → TimeZoneIO (Maybe ThunkInfo) #

showTypeOfProxy TimeZoneString #

NoThunks UniversalTime 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → UniversalTimeIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → UniversalTimeIO (Maybe ThunkInfo) #

showTypeOfProxy UniversalTimeString #

NoThunks UTCTime 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → UTCTimeIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → UTCTimeIO (Maybe ThunkInfo) #

showTypeOfProxy UTCTimeString #

NoThunks NominalDiffTime 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → NominalDiffTimeIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → NominalDiffTimeIO (Maybe ThunkInfo) #

showTypeOfProxy NominalDiffTimeString #

NoThunks Day 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → DayIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → DayIO (Maybe ThunkInfo) #

showTypeOfProxy DayString #

NoThunks RelativeTime 
Instance details

Defined in Cardano.Slotting.Time

Methods

noThunks ∷ Context → RelativeTimeIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → RelativeTimeIO (Maybe ThunkInfo) #

showTypeOfProxy RelativeTimeString #

NoThunks SlotLength 
Instance details

Defined in Cardano.Slotting.Time

Methods

noThunks ∷ Context → SlotLengthIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → SlotLengthIO (Maybe ThunkInfo) #

showTypeOfProxy SlotLengthString #

NoThunks SystemStart 
Instance details

Defined in Cardano.Slotting.Time

Methods

noThunks ∷ Context → SystemStartIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → SystemStartIO (Maybe ThunkInfo) #

showTypeOfProxy SystemStartString #

NoThunks SecurityParam Source # 
Instance details

Defined in Ouroboros.Consensus.Config.SecurityParam

Methods

noThunks ∷ Context → SecurityParamIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → SecurityParamIO (Maybe ThunkInfo) #

showTypeOfProxy SecurityParamString #

NoThunks EpochNo 
Instance details

Defined in Cardano.Slotting.Slot

Methods

noThunks ∷ Context → EpochNoIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → EpochNoIO (Maybe ThunkInfo) #

showTypeOfProxy EpochNoString #

NoThunks EpochSize 
Instance details

Defined in Cardano.Slotting.Slot

Methods

noThunks ∷ Context → EpochSizeIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → EpochSizeIO (Maybe ThunkInfo) #

showTypeOfProxy EpochSizeString #

NoThunks TriggerHardFork Source # 
Instance details

Defined in Ouroboros.Consensus.HardFork.Simple

Methods

noThunks ∷ Context → TriggerHardForkIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → TriggerHardForkIO (Maybe ThunkInfo) #

showTypeOfProxy TriggerHardForkString #

NoThunks Time Source # 
Instance details

Defined in Ouroboros.Consensus.Util.Orphans

Methods

noThunks ∷ Context → TimeIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → TimeIO (Maybe ThunkInfo) #

showTypeOfProxy TimeString #

NoThunks DiskPolicy Source # 
Instance details

Defined in Ouroboros.Consensus.Storage.LedgerDB.DiskPolicy

Methods

noThunks ∷ Context → DiskPolicyIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → DiskPolicyIO (Maybe ThunkInfo) #

showTypeOfProxy DiskPolicyString #

NoThunks PrettyCallStack Source # 
Instance details

Defined in Ouroboros.Consensus.Util.CallStack

Methods

noThunks ∷ Context → PrettyCallStackIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → PrettyCallStackIO (Maybe ThunkInfo) #

showTypeOfProxy PrettyCallStackString #

NoThunks Seed 
Instance details

Defined in Cardano.Crypto.Seed

Methods

noThunks ∷ Context → Seed → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → Seed → IO (Maybe ThunkInfo) #

showTypeOfProxy Seed → String #

NoThunks FsPath Source # 
Instance details

Defined in Ouroboros.Consensus.Storage.FS.API.Types

Methods

noThunks ∷ Context → FsPathIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → FsPathIO (Maybe ThunkInfo) #

showTypeOfProxy FsPathString #

NoThunks CRC Source # 
Instance details

Defined in Ouroboros.Consensus.Storage.FS.CRC

Methods

noThunks ∷ Context → CRCIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → CRCIO (Maybe ThunkInfo) #

showTypeOfProxy CRCString #

NoThunks PBftMockVerKeyHash Source # 
Instance details

Defined in Ouroboros.Consensus.Protocol.PBFT.Crypto

Methods

noThunks ∷ Context → PBftMockVerKeyHashIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → PBftMockVerKeyHashIO (Maybe ThunkInfo) #

showTypeOfProxy PBftMockVerKeyHashString #

NoThunks CoreNodeId Source # 
Instance details

Defined in Ouroboros.Consensus.NodeId

Methods

noThunks ∷ Context → CoreNodeIdIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → CoreNodeIdIO (Maybe ThunkInfo) #

showTypeOfProxy CoreNodeIdString #

NoThunks NodeId Source # 
Instance details

Defined in Ouroboros.Consensus.NodeId

Methods

noThunks ∷ Context → NodeIdIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → NodeIdIO (Maybe ThunkInfo) #

showTypeOfProxy NodeIdString #

NoThunks IsEBB Source # 
Instance details

Defined in Ouroboros.Consensus.Block.EBB

Methods

noThunks ∷ Context → IsEBBIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → IsEBBIO (Maybe ThunkInfo) #

showTypeOfProxy IsEBBString #

NoThunks PrefixLen Source # 
Instance details

Defined in Ouroboros.Consensus.Storage.Common

Methods

noThunks ∷ Context → PrefixLenIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → PrefixLenIO (Maybe ThunkInfo) #

showTypeOfProxy PrefixLenString #

NoThunks BlockOffset Source # 
Instance details

Defined in Ouroboros.Consensus.Storage.VolatileDB.Impl.Types

Methods

noThunks ∷ Context → BlockOffsetIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → BlockOffsetIO (Maybe ThunkInfo) #

showTypeOfProxy BlockOffsetString #

NoThunks BlockSize Source # 
Instance details

Defined in Ouroboros.Consensus.Storage.VolatileDB.Impl.Types

Methods

noThunks ∷ Context → BlockSizeIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → BlockSizeIO (Maybe ThunkInfo) #

showTypeOfProxy BlockSizeString #

NoThunks LeaderSchedule Source # 
Instance details

Defined in Ouroboros.Consensus.Protocol.LeaderSchedule

Methods

noThunks ∷ Context → LeaderScheduleIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → LeaderScheduleIO (Maybe ThunkInfo) #

showTypeOfProxy LeaderScheduleString #

NoThunks MempoolCapacityBytes Source # 
Instance details

Defined in Ouroboros.Consensus.Mempool.API

Methods

noThunks ∷ Context → MempoolCapacityBytesIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → MempoolCapacityBytesIO (Maybe ThunkInfo) #

showTypeOfProxy MempoolCapacityBytesString #

NoThunks TicketNo Source # 
Instance details

Defined in Ouroboros.Consensus.Mempool.TxSeq

Methods

noThunks ∷ Context → TicketNoIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → TicketNoIO (Maybe ThunkInfo) #

showTypeOfProxy TicketNoString #

NoThunks SafeZone Source # 
Instance details

Defined in Ouroboros.Consensus.HardFork.History.EraParams

Methods

noThunks ∷ Context → SafeZoneIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → SafeZoneIO (Maybe ThunkInfo) #

showTypeOfProxy SafeZoneString #

NoThunks EraParams Source # 
Instance details

Defined in Ouroboros.Consensus.HardFork.History.EraParams

Methods

noThunks ∷ Context → EraParamsIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → EraParamsIO (Maybe ThunkInfo) #

showTypeOfProxy EraParamsString #

NoThunks RelativeSlot Source # 
Instance details

Defined in Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Internal

Methods

noThunks ∷ Context → RelativeSlotIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → RelativeSlotIO (Maybe ThunkInfo) #

showTypeOfProxy RelativeSlotString #

NoThunks ChunkNo Source # 
Instance details

Defined in Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Internal

Methods

noThunks ∷ Context → ChunkNoIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → ChunkNoIO (Maybe ThunkInfo) #

showTypeOfProxy ChunkNoString #

NoThunks ChunkSize Source # 
Instance details

Defined in Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Internal

Methods

noThunks ∷ Context → ChunkSizeIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → ChunkSizeIO (Maybe ThunkInfo) #

showTypeOfProxy ChunkSizeString #

NoThunks ChunkInfo Source # 
Instance details

Defined in Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Internal

Methods

noThunks ∷ Context → ChunkInfoIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → ChunkInfoIO (Maybe ThunkInfo) #

showTypeOfProxy ChunkInfoString #

NoThunks NumCoreNodes Source # 
Instance details

Defined in Ouroboros.Consensus.Node.ProtocolInfo

Methods

noThunks ∷ Context → NumCoreNodesIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → NumCoreNodesIO (Maybe ThunkInfo) #

showTypeOfProxy NumCoreNodesString #

NoThunks BftValidationErr Source # 
Instance details

Defined in Ouroboros.Consensus.Protocol.BFT

Methods

noThunks ∷ Context → BftValidationErrIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → BftValidationErrIO (Maybe ThunkInfo) #

showTypeOfProxy BftValidationErrString #

NoThunks BftParams Source # 
Instance details

Defined in Ouroboros.Consensus.Protocol.BFT

Methods

noThunks ∷ Context → BftParamsIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → BftParamsIO (Maybe ThunkInfo) #

showTypeOfProxy BftParamsString #

NoThunks BlockOrEBB Source # 
Instance details

Defined in Ouroboros.Consensus.Storage.ImmutableDB.Impl.Types

Methods

noThunks ∷ Context → BlockOrEBBIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → BlockOrEBBIO (Maybe ThunkInfo) #

showTypeOfProxy BlockOrEBBString #

NoThunks ChunkSlot Source # 
Instance details

Defined in Ouroboros.Consensus.Storage.ImmutableDB.Chunks.Layout

Methods

noThunks ∷ Context → ChunkSlotIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → ChunkSlotIO (Maybe ThunkInfo) #

showTypeOfProxy ChunkSlotString #

NoThunks PrimaryIndex Source # 
Instance details

Defined in Ouroboros.Consensus.Storage.ImmutableDB.Impl.Index.Primary

Methods

noThunks ∷ Context → PrimaryIndexIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → PrimaryIndexIO (Maybe ThunkInfo) #

showTypeOfProxy PrimaryIndexString #

NoThunks BlockSize Source # 
Instance details

Defined in Ouroboros.Consensus.Storage.ImmutableDB.Impl.Index.Secondary

Methods

noThunks ∷ Context → BlockSizeIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → BlockSizeIO (Maybe ThunkInfo) #

showTypeOfProxy BlockSizeString #

NoThunks HeaderSize Source # 
Instance details

Defined in Ouroboros.Consensus.Storage.ImmutableDB.Impl.Index.Secondary

Methods

noThunks ∷ Context → HeaderSizeIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → HeaderSizeIO (Maybe ThunkInfo) #

showTypeOfProxy HeaderSizeString #

NoThunks HeaderOffset Source # 
Instance details

Defined in Ouroboros.Consensus.Storage.ImmutableDB.Impl.Index.Secondary

Methods

noThunks ∷ Context → HeaderOffsetIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → HeaderOffsetIO (Maybe ThunkInfo) #

showTypeOfProxy HeaderOffsetString #

NoThunks BlockOffset Source # 
Instance details

Defined in Ouroboros.Consensus.Storage.ImmutableDB.Impl.Index.Secondary

Methods

noThunks ∷ Context → BlockOffsetIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → BlockOffsetIO (Maybe ThunkInfo) #

showTypeOfProxy BlockOffsetString #

NoThunks EraEnd Source # 
Instance details

Defined in Ouroboros.Consensus.HardFork.History.Summary

Methods

noThunks ∷ Context → EraEndIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → EraEndIO (Maybe ThunkInfo) #

showTypeOfProxy EraEndString #

NoThunks EraSummary Source # 
Instance details

Defined in Ouroboros.Consensus.HardFork.History.Summary

Methods

noThunks ∷ Context → EraSummaryIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → EraSummaryIO (Maybe ThunkInfo) #

showTypeOfProxy EraSummaryString #

NoThunks Bound Source # 
Instance details

Defined in Ouroboros.Consensus.HardFork.History.Summary

Methods

noThunks ∷ Context → BoundIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → BoundIO (Maybe ThunkInfo) #

showTypeOfProxy BoundString #

NoThunks TransitionInfo Source # 
Instance details

Defined in Ouroboros.Consensus.HardFork.Combinator.State.Types

Methods

noThunks ∷ Context → TransitionInfoIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → TransitionInfoIO (Maybe ThunkInfo) #

showTypeOfProxy TransitionInfoString #

NoThunks Past Source # 
Instance details

Defined in Ouroboros.Consensus.HardFork.Combinator.State.Types

Methods

noThunks ∷ Context → PastIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → PastIO (Maybe ThunkInfo) #

showTypeOfProxy PastString #

NoThunks Fingerprint Source # 
Instance details

Defined in Ouroboros.Consensus.Util.STM

Methods

noThunks ∷ Context → FingerprintIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → FingerprintIO (Maybe ThunkInfo) #

showTypeOfProxy FingerprintString #

NoThunks CurrentSlot Source # 
Instance details

Defined in Ouroboros.Consensus.BlockchainTime.API

Methods

noThunks ∷ Context → CurrentSlotIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → CurrentSlotIO (Maybe ThunkInfo) #

showTypeOfProxy CurrentSlotString #

NoThunks FollowerKey Source # 
Instance details

Defined in Ouroboros.Consensus.Storage.ChainDB.Impl.Types

Methods

noThunks ∷ Context → FollowerKeyIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → FollowerKeyIO (Maybe ThunkInfo) #

showTypeOfProxy FollowerKeyString #

NoThunks IteratorKey Source # 
Instance details

Defined in Ouroboros.Consensus.Storage.ChainDB.Impl.Types

Methods

noThunks ∷ Context → IteratorKeyIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → IteratorKeyIO (Maybe ThunkInfo) #

showTypeOfProxy IteratorKeyString #

NoThunks ScheduledGc Source # 
Instance details

Defined in Ouroboros.Consensus.Storage.ChainDB.Impl.Background

Methods

noThunks ∷ Context → ScheduledGcIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → ScheduledGcIO (Maybe ThunkInfo) #

showTypeOfProxy ScheduledGcString #

NoThunks PBftParams Source # 
Instance details

Defined in Ouroboros.Consensus.Protocol.PBFT

Methods

noThunks ∷ Context → PBftParamsIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → PBftParamsIO (Maybe ThunkInfo) #

showTypeOfProxy PBftParamsString #

NoThunks PBftSignatureThreshold Source # 
Instance details

Defined in Ouroboros.Consensus.Protocol.PBFT

Methods

noThunks ∷ Context → PBftSignatureThresholdIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → PBftSignatureThresholdIO (Maybe ThunkInfo) #

showTypeOfProxy PBftSignatureThresholdString #

NoThunks PBftSelectView Source # 
Instance details

Defined in Ouroboros.Consensus.Protocol.PBFT

Methods

noThunks ∷ Context → PBftSelectViewIO (Maybe ThunkInfo) #

wNoThunks ∷ Context → PBftSelectViewIO (Maybe ThunkInfo) #

showTypeOfProxy PBftSelectViewString #

NoThunks a ⇒ NoThunks [a] 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → [a] → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → [a] → IO (Maybe ThunkInfo) #

showTypeOfProxy [a] → String #

NoThunks a ⇒ NoThunks (Maybe a) 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → Maybe a → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → Maybe a → IO (Maybe ThunkInfo) #

showTypeOfProxy (Maybe a) → String #

NoThunks a ⇒ NoThunks (Ratio a) 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → Ratio a → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → Ratio a → IO (Maybe ThunkInfo) #

showTypeOfProxy (Ratio a) → String #

NoThunks (IO a) 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → IO a → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → IO a → IO (Maybe ThunkInfo) #

showTypeOfProxy (IO a) → String #

NoThunks a ⇒ NoThunks (TVar a) 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → TVar a → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → TVar a → IO (Maybe ThunkInfo) #

showTypeOfProxy (TVar a) → String #

NoThunks a ⇒ NoThunks (IORef a) 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → IORef a → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → IORef a → IO (Maybe ThunkInfo) #

showTypeOfProxy (IORef a) → String #

NoThunks a ⇒ NoThunks (MVar a) 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → MVar a → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → MVar a → IO (Maybe ThunkInfo) #

showTypeOfProxy (MVar a) → String #

NoThunks a ⇒ NoThunks (NonEmpty a) 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → NonEmpty a → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → NonEmpty a → IO (Maybe ThunkInfo) #

showTypeOfProxy (NonEmpty a) → String #

NoThunks a ⇒ NoThunks (IntMap a) 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → IntMap a → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → IntMap a → IO (Maybe ThunkInfo) #

showTypeOfProxy (IntMap a) → String #

NoThunks a ⇒ NoThunks (Seq a) 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → Seq a → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → Seq a → IO (Maybe ThunkInfo) #

showTypeOfProxy (Seq a) → String #

NoThunks a ⇒ NoThunks (Set a) 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → Set a → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → Set a → IO (Maybe ThunkInfo) #

showTypeOfProxy (Set a) → String #

StandardHash block ⇒ NoThunks (Anchor block) 
Instance details

Defined in Ouroboros.Network.AnchoredFragment

Methods

noThunks ∷ Context → Anchor block → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → Anchor block → IO (Maybe ThunkInfo) #

showTypeOfProxy (Anchor block) → String #

(StandardHash block, Typeable block) ⇒ NoThunks (ChainHash block) 
Instance details

Defined in Ouroboros.Network.Block

Methods

noThunks ∷ Context → ChainHash block → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → ChainHash block → IO (Maybe ThunkInfo) #

showTypeOfProxy (ChainHash block) → String #

StandardHash block ⇒ NoThunks (Point block) 
Instance details

Defined in Ouroboros.Network.Block

Methods

noThunks ∷ Context → Point block → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → Point block → IO (Maybe ThunkInfo) #

showTypeOfProxy (Point block) → String #

StandardHash b ⇒ NoThunks (Tip b) 
Instance details

Defined in Ouroboros.Network.Block

Methods

noThunks ∷ Context → Tip b → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → Tip b → IO (Maybe ThunkInfo) #

showTypeOfProxy (Tip b) → String #

NoThunks t ⇒ NoThunks (WithOrigin t) 
Instance details

Defined in Cardano.Slotting.Slot

Methods

noThunks ∷ Context → WithOrigin t → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → WithOrigin t → IO (Maybe ThunkInfo) #

showTypeOfProxy (WithOrigin t) → String #

Typeable addr ⇒ NoThunks (ConnectionId addr) 
Instance details

Defined in Ouroboros.Network.ConnectionId

Methods

noThunks ∷ Context → ConnectionId addr → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → ConnectionId addr → IO (Maybe ThunkInfo) #

showTypeOfProxy (ConnectionId addr) → String #

NoThunks (AllowThunk a) 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → AllowThunk a → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → AllowThunk a → IO (Maybe ThunkInfo) #

showTypeOfProxy (AllowThunk a) → String #

Typeable a ⇒ NoThunks (InspectHeap a) 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → InspectHeap a → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → InspectHeap a → IO (Maybe ThunkInfo) #

showTypeOfProxy (InspectHeap a) → String #

Typeable a ⇒ NoThunks (OnlyCheckWhnf a) 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → OnlyCheckWhnf a → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → OnlyCheckWhnf a → IO (Maybe ThunkInfo) #

showTypeOfProxy (OnlyCheckWhnf a) → String #

NoThunks (Vector a) 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → Vector a → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → Vector a → IO (Maybe ThunkInfo) #

showTypeOfProxy (Vector a) → String #

NoThunks a ⇒ NoThunks (Vector a) 
Instance details

Defined in NoThunks.Class

Methods

noThunks ∷ Context → Vector a → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → Vector a → IO (Maybe ThunkInfo) #

showTypeOfProxy (Vector a) → String #

NoThunks (SystemTime m) Source # 
Instance details

Defined in Ouroboros.Consensus.BlockchainTime.WallClock.Types

Methods

noThunks ∷ Context → SystemTime m → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → SystemTime m → IO (Maybe ThunkInfo) #

showTypeOfProxy (SystemTime m) → String #

NoThunks (LedgerEraInfo blk) Source # 
Instance details

Defined in Ouroboros.Consensus.HardFork.Combinator.Info

Methods

noThunks ∷ Context → LedgerEraInfo blk → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → LedgerEraInfo blk → IO (Maybe ThunkInfo) #

showTypeOfProxy (LedgerEraInfo blk) → String #

NoThunks (SingleEraInfo blk) Source # 
Instance details

Defined in Ouroboros.Consensus.HardFork.Combinator.Info

Methods

noThunks ∷ Context → SingleEraInfo blk → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → SingleEraInfo blk → IO (Maybe ThunkInfo) #

showTypeOfProxy (SingleEraInfo blk) → String #

NoThunks a ⇒ NoThunks (StrictSeq a) 
Instance details

Defined in Data.Sequence.Strict

Methods

noThunks ∷ Context → StrictSeq a → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → StrictSeq a → IO (Maybe ThunkInfo) #

showTypeOfProxy (StrictSeq a) → String #

NoThunks (Ticked (LedgerState (DualBlock m a))) Source # 
Instance details

Defined in Ouroboros.Consensus.Ledger.Dual

Methods

noThunks ∷ Context → Ticked (LedgerState (DualBlock m a)) → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → Ticked (LedgerState (DualBlock m a)) → IO (Maybe ThunkInfo) #

showTypeOfProxy (Ticked (LedgerState (DualBlock m a))) → String #

CanHardFork xs ⇒ NoThunks (Ticked (LedgerState (HardForkBlock xs))) Source # 
Instance details

Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger

Methods

noThunks ∷ Context → Ticked (LedgerState (HardForkBlock xs)) → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → Ticked (LedgerState (HardForkBlock xs)) → IO (Maybe ThunkInfo) #

showTypeOfProxy (Ticked (LedgerState (HardForkBlock xs))) → String #

NoThunks (PackedBytes n) 
Instance details

Defined in Cardano.Crypto.PackedBytes

Methods

noThunks ∷ Context → PackedBytes n → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → PackedBytes n → IO (Maybe ThunkInfo) #

showTypeOfProxy (PackedBytes n) → String #

NoThunks (SigDSIGN EcdsaSecp256k1DSIGN) 
Instance details

Defined in Cardano.Crypto.DSIGN.EcdsaSecp256k1

Methods

noThunks ∷ Context → SigDSIGN EcdsaSecp256k1DSIGN → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → SigDSIGN EcdsaSecp256k1DSIGN → IO (Maybe ThunkInfo) #

showTypeOfProxy (SigDSIGN EcdsaSecp256k1DSIGN) → String #

NoThunks (SigDSIGN Ed25519DSIGN) 
Instance details

Defined in Cardano.Crypto.DSIGN.Ed25519

Methods

noThunks ∷ Context → SigDSIGN Ed25519DSIGN → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → SigDSIGN Ed25519DSIGN → IO (Maybe ThunkInfo) #

showTypeOfProxy (SigDSIGN Ed25519DSIGN) → String #

NoThunks (SigDSIGN Ed448DSIGN) 
Instance details

Defined in Cardano.Crypto.DSIGN.Ed448

Methods

noThunks ∷ Context → SigDSIGN Ed448DSIGN → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → SigDSIGN Ed448DSIGN → IO (Maybe ThunkInfo) #

showTypeOfProxy (SigDSIGN Ed448DSIGN) → String #

NoThunks (SigDSIGN MockDSIGN) 
Instance details

Defined in Cardano.Crypto.DSIGN.Mock

Methods

noThunks ∷ Context → SigDSIGN MockDSIGN → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → SigDSIGN MockDSIGN → IO (Maybe ThunkInfo) #

showTypeOfProxy (SigDSIGN MockDSIGN) → String #

NoThunks (SigDSIGN NeverDSIGN) 
Instance details

Defined in Cardano.Crypto.DSIGN.NeverUsed

Methods

noThunks ∷ Context → SigDSIGN NeverDSIGN → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → SigDSIGN NeverDSIGN → IO (Maybe ThunkInfo) #

showTypeOfProxy (SigDSIGN NeverDSIGN) → String #

NoThunks (SigDSIGN SchnorrSecp256k1DSIGN) 
Instance details

Defined in Cardano.Crypto.DSIGN.SchnorrSecp256k1

Methods

noThunks ∷ Context → SigDSIGN SchnorrSecp256k1DSIGN → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → SigDSIGN SchnorrSecp256k1DSIGN → IO (Maybe ThunkInfo) #

showTypeOfProxy (SigDSIGN SchnorrSecp256k1DSIGN) → String #

NoThunks (SignKeyDSIGN EcdsaSecp256k1DSIGN) 
Instance details

Defined in Cardano.Crypto.DSIGN.EcdsaSecp256k1

Methods

noThunks ∷ Context → SignKeyDSIGN EcdsaSecp256k1DSIGN → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → SignKeyDSIGN EcdsaSecp256k1DSIGN → IO (Maybe ThunkInfo) #

showTypeOfProxy (SignKeyDSIGN EcdsaSecp256k1DSIGN) → String #

NoThunks (SignKeyDSIGN Ed25519DSIGN) 
Instance details

Defined in Cardano.Crypto.DSIGN.Ed25519

Methods

noThunks ∷ Context → SignKeyDSIGN Ed25519DSIGN → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → SignKeyDSIGN Ed25519DSIGN → IO (Maybe ThunkInfo) #

showTypeOfProxy (SignKeyDSIGN Ed25519DSIGN) → String #

NoThunks (SignKeyDSIGN Ed448DSIGN) 
Instance details

Defined in Cardano.Crypto.DSIGN.Ed448

Methods

noThunks ∷ Context → SignKeyDSIGN Ed448DSIGN → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → SignKeyDSIGN Ed448DSIGN → IO (Maybe ThunkInfo) #

showTypeOfProxy (SignKeyDSIGN Ed448DSIGN) → String #

NoThunks (SignKeyDSIGN MockDSIGN) 
Instance details

Defined in Cardano.Crypto.DSIGN.Mock

Methods

noThunks ∷ Context → SignKeyDSIGN MockDSIGN → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → SignKeyDSIGN MockDSIGN → IO (Maybe ThunkInfo) #

showTypeOfProxy (SignKeyDSIGN MockDSIGN) → String #

NoThunks (SignKeyDSIGN NeverDSIGN) 
Instance details

Defined in Cardano.Crypto.DSIGN.NeverUsed

Methods

noThunks ∷ Context → SignKeyDSIGN NeverDSIGN → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → SignKeyDSIGN NeverDSIGN → IO (Maybe ThunkInfo) #

showTypeOfProxy (SignKeyDSIGN NeverDSIGN) → String #

NoThunks (SignKeyDSIGN SchnorrSecp256k1DSIGN) 
Instance details

Defined in Cardano.Crypto.DSIGN.SchnorrSecp256k1

Methods

noThunks ∷ Context → SignKeyDSIGN SchnorrSecp256k1DSIGN → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → SignKeyDSIGN SchnorrSecp256k1DSIGN → IO (Maybe ThunkInfo) #

showTypeOfProxy (SignKeyDSIGN SchnorrSecp256k1DSIGN) → String #

NoThunks (VerKeyDSIGN EcdsaSecp256k1DSIGN) 
Instance details

Defined in Cardano.Crypto.DSIGN.EcdsaSecp256k1

Methods

noThunks ∷ Context → VerKeyDSIGN EcdsaSecp256k1DSIGN → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → VerKeyDSIGN EcdsaSecp256k1DSIGN → IO (Maybe ThunkInfo) #

showTypeOfProxy (VerKeyDSIGN EcdsaSecp256k1DSIGN) → String #

NoThunks (VerKeyDSIGN Ed25519DSIGN) 
Instance details

Defined in Cardano.Crypto.DSIGN.Ed25519

Methods

noThunks ∷ Context → VerKeyDSIGN Ed25519DSIGN → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → VerKeyDSIGN Ed25519DSIGN → IO (Maybe ThunkInfo) #

showTypeOfProxy (VerKeyDSIGN Ed25519DSIGN) → String #

NoThunks (VerKeyDSIGN Ed448DSIGN) 
Instance details

Defined in Cardano.Crypto.DSIGN.Ed448

Methods

noThunks ∷ Context → VerKeyDSIGN Ed448DSIGN → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → VerKeyDSIGN Ed448DSIGN → IO (Maybe ThunkInfo) #

showTypeOfProxy (VerKeyDSIGN Ed448DSIGN) → String #

NoThunks (VerKeyDSIGN MockDSIGN) 
Instance details

Defined in Cardano.Crypto.DSIGN.Mock

Methods

noThunks ∷ Context → VerKeyDSIGN MockDSIGN → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → VerKeyDSIGN MockDSIGN → IO (Maybe ThunkInfo) #

showTypeOfProxy (VerKeyDSIGN MockDSIGN) → String #

NoThunks (VerKeyDSIGN NeverDSIGN) 
Instance details

Defined in Cardano.Crypto.DSIGN.NeverUsed

Methods

noThunks ∷ Context → VerKeyDSIGN NeverDSIGN → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → VerKeyDSIGN NeverDSIGN → IO (Maybe ThunkInfo) #

showTypeOfProxy (VerKeyDSIGN NeverDSIGN) → String #

NoThunks (VerKeyDSIGN SchnorrSecp256k1DSIGN) 
Instance details

Defined in Cardano.Crypto.DSIGN.SchnorrSecp256k1

Methods

noThunks ∷ Context → VerKeyDSIGN SchnorrSecp256k1DSIGN → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → VerKeyDSIGN SchnorrSecp256k1DSIGN → IO (Maybe ThunkInfo) #

showTypeOfProxy (VerKeyDSIGN SchnorrSecp256k1DSIGN) → String #

DSIGNAlgorithm d ⇒ NoThunks (SigKES (CompactSingleKES d)) 
Instance details

Defined in Cardano.Crypto.KES.CompactSingle

Methods

noThunks ∷ Context → SigKES (CompactSingleKES d) → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → SigKES (CompactSingleKES d) → IO (Maybe ThunkInfo) #

showTypeOfProxy (SigKES (CompactSingleKES d)) → String #

KESAlgorithm d ⇒ NoThunks (SigKES (CompactSumKES h d)) 
Instance details

Defined in Cardano.Crypto.KES.CompactSum

Methods

noThunks ∷ Context → SigKES (CompactSumKES h d) → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → SigKES (CompactSumKES h d) → IO (Maybe ThunkInfo) #

showTypeOfProxy (SigKES (CompactSumKES h d)) → String #

NoThunks (SigKES (MockKES t)) 
Instance details

Defined in Cardano.Crypto.KES.Mock

Methods

noThunks ∷ Context → SigKES (MockKES t) → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → SigKES (MockKES t) → IO (Maybe ThunkInfo) #

showTypeOfProxy (SigKES (MockKES t)) → String #

NoThunks (SigKES NeverKES) 
Instance details

Defined in Cardano.Crypto.KES.NeverUsed

Methods

noThunks ∷ Context → SigKES NeverKES → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → SigKES NeverKES → IO (Maybe ThunkInfo) #

showTypeOfProxy (SigKES NeverKES) → String #

DSIGNAlgorithm d ⇒ NoThunks (SigKES (SimpleKES d t)) 
Instance details

Defined in Cardano.Crypto.KES.Simple

Methods

noThunks ∷ Context → SigKES (SimpleKES d t) → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → SigKES (SimpleKES d t) → IO (Maybe ThunkInfo) #

showTypeOfProxy (SigKES (SimpleKES d t)) → String #

DSIGNAlgorithm d ⇒ NoThunks (SigKES (SingleKES d)) 
Instance details

Defined in Cardano.Crypto.KES.Single

Methods

noThunks ∷ Context → SigKES (SingleKES d) → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → SigKES (SingleKES d) → IO (Maybe ThunkInfo) #

showTypeOfProxy (SigKES (SingleKES d)) → String #

KESAlgorithm d ⇒ NoThunks (SigKES (SumKES h d)) 
Instance details

Defined in Cardano.Crypto.KES.Sum

Methods

noThunks ∷ Context → SigKES (SumKES h d) → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → SigKES (SumKES h d) → IO (Maybe ThunkInfo) #

showTypeOfProxy (SigKES (SumKES h d)) → String #

DSIGNAlgorithm d ⇒ NoThunks (SignKeyKES (CompactSingleKES d)) 
Instance details

Defined in Cardano.Crypto.KES.CompactSingle

Methods

noThunks ∷ Context → SignKeyKES (CompactSingleKES d) → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → SignKeyKES (CompactSingleKES d) → IO (Maybe ThunkInfo) #

showTypeOfProxy (SignKeyKES (CompactSingleKES d)) → String #

KESAlgorithm d ⇒ NoThunks (SignKeyKES (CompactSumKES h d)) 
Instance details

Defined in Cardano.Crypto.KES.CompactSum

Methods

noThunks ∷ Context → SignKeyKES (CompactSumKES h d) → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → SignKeyKES (CompactSumKES h d) → IO (Maybe ThunkInfo) #

showTypeOfProxy (SignKeyKES (CompactSumKES h d)) → String #

NoThunks (SignKeyKES (MockKES t)) 
Instance details

Defined in Cardano.Crypto.KES.Mock

Methods

noThunks ∷ Context → SignKeyKES (MockKES t) → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → SignKeyKES (MockKES t) → IO (Maybe ThunkInfo) #

showTypeOfProxy (SignKeyKES (MockKES t)) → String #

NoThunks (SignKeyKES NeverKES) 
Instance details

Defined in Cardano.Crypto.KES.NeverUsed

Methods

noThunks ∷ Context → SignKeyKES NeverKES → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → SignKeyKES NeverKES → IO (Maybe ThunkInfo) #

showTypeOfProxy (SignKeyKES NeverKES) → String #

DSIGNAlgorithm d ⇒ NoThunks (SignKeyKES (SimpleKES d t)) 
Instance details

Defined in Cardano.Crypto.KES.Simple

Methods

noThunks ∷ Context → SignKeyKES (SimpleKES d t) → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → SignKeyKES (SimpleKES d t) → IO (Maybe ThunkInfo) #

showTypeOfProxy (SignKeyKES (SimpleKES d t)) → String #

DSIGNAlgorithm d ⇒ NoThunks (SignKeyKES (SingleKES d)) 
Instance details

Defined in Cardano.Crypto.KES.Single

Methods

noThunks ∷ Context → SignKeyKES (SingleKES d) → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → SignKeyKES (SingleKES d) → IO (Maybe ThunkInfo) #

showTypeOfProxy (SignKeyKES (SingleKES d)) → String #

KESAlgorithm d ⇒ NoThunks (SignKeyKES (SumKES h d)) 
Instance details

Defined in Cardano.Crypto.KES.Sum

Methods

noThunks ∷ Context → SignKeyKES (SumKES h d) → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → SignKeyKES (SumKES h d) → IO (Maybe ThunkInfo) #

showTypeOfProxy (SignKeyKES (SumKES h d)) → String #

DSIGNAlgorithm d ⇒ NoThunks (VerKeyKES (CompactSingleKES d)) 
Instance details

Defined in Cardano.Crypto.KES.CompactSingle

Methods

noThunks ∷ Context → VerKeyKES (CompactSingleKES d) → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → VerKeyKES (CompactSingleKES d) → IO (Maybe ThunkInfo) #

showTypeOfProxy (VerKeyKES (CompactSingleKES d)) → String #

OptimizedKESAlgorithm d ⇒ NoThunks (VerKeyKES (CompactSumKES h d)) 
Instance details

Defined in Cardano.Crypto.KES.CompactSum

Methods

noThunks ∷ Context → VerKeyKES (CompactSumKES h d) → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → VerKeyKES (CompactSumKES h d) → IO (Maybe ThunkInfo) #

showTypeOfProxy (VerKeyKES (CompactSumKES h d)) → String #

NoThunks (VerKeyKES (MockKES t)) 
Instance details

Defined in Cardano.Crypto.KES.Mock

Methods

noThunks ∷ Context → VerKeyKES (MockKES t) → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → VerKeyKES (MockKES t) → IO (Maybe ThunkInfo) #

showTypeOfProxy (VerKeyKES (MockKES t)) → String #

NoThunks (VerKeyKES NeverKES) 
Instance details

Defined in Cardano.Crypto.KES.NeverUsed

Methods

noThunks ∷ Context → VerKeyKES NeverKES → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → VerKeyKES NeverKES → IO (Maybe ThunkInfo) #

showTypeOfProxy (VerKeyKES NeverKES) → String #

DSIGNAlgorithm d ⇒ NoThunks (VerKeyKES (SimpleKES d t)) 
Instance details

Defined in Cardano.Crypto.KES.Simple

Methods

noThunks ∷ Context → VerKeyKES (SimpleKES d t) → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → VerKeyKES (SimpleKES d t) → IO (Maybe ThunkInfo) #

showTypeOfProxy (VerKeyKES (SimpleKES d t)) → String #

DSIGNAlgorithm d ⇒ NoThunks (VerKeyKES (SingleKES d)) 
Instance details

Defined in Cardano.Crypto.KES.Single

Methods

noThunks ∷ Context → VerKeyKES (SingleKES d) → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → VerKeyKES (SingleKES d) → IO (Maybe ThunkInfo) #

showTypeOfProxy (VerKeyKES (SingleKES d)) → String #

KESAlgorithm d ⇒ NoThunks (VerKeyKES (SumKES h d)) 
Instance details

Defined in Cardano.Crypto.KES.Sum

Methods

noThunks ∷ Context → VerKeyKES (SumKES h d) → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → VerKeyKES (SumKES h d) → IO (Maybe ThunkInfo) #

showTypeOfProxy (VerKeyKES (SumKES h d)) → String #

NoThunks (PinnedSizedBytes n) 
Instance details

Defined in Cardano.Crypto.PinnedSizedBytes

Methods

noThunks ∷ Context → PinnedSizedBytes n → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → PinnedSizedBytes n → IO (Maybe ThunkInfo) #

showTypeOfProxy (PinnedSizedBytes n) → String #

NoThunks (Handle h) Source # 
Instance details

Defined in Ouroboros.Consensus.Storage.FS.API.Types

Methods

noThunks ∷ Context → Handle h → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → Handle h → IO (Maybe ThunkInfo) #

showTypeOfProxy (Handle h) → String #

NoThunks (SomeHasFS m) Source # 
Instance details

Defined in Ouroboros.Consensus.Storage.FS.API

Methods

noThunks ∷ Context → SomeHasFS m → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → SomeHasFS m → IO (Maybe ThunkInfo) #

showTypeOfProxy (SomeHasFS m) → String #

NoThunks (Header (DualBlock m a)) Source # 
Instance details

Defined in Ouroboros.Consensus.Ledger.Dual

Methods

noThunks ∷ Context → Header (DualBlock m a) → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → Header (DualBlock m a) → IO (Maybe ThunkInfo) #

showTypeOfProxy (Header (DualBlock m a)) → String #

CanHardFork xs ⇒ NoThunks (Header (HardForkBlock xs)) Source # 
Instance details

Defined in Ouroboros.Consensus.HardFork.Combinator.Block

Methods

noThunks ∷ Context → Header (HardForkBlock xs) → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → Header (HardForkBlock xs) → IO (Maybe ThunkInfo) #

showTypeOfProxy (Header (HardForkBlock xs)) → String #

(NoThunks (StorageConfig m), NoThunks (StorageConfig a)) ⇒ NoThunks (StorageConfig (DualBlock m a)) Source # 
Instance details

Defined in Ouroboros.Consensus.Ledger.Dual

Methods

noThunks ∷ Context → StorageConfig (DualBlock m a) → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → StorageConfig (DualBlock m a) → IO (Maybe ThunkInfo) #

showTypeOfProxy (StorageConfig (DualBlock m a)) → String #

CanHardFork xs ⇒ NoThunks (StorageConfig (HardForkBlock xs)) Source # 
Instance details

Defined in Ouroboros.Consensus.HardFork.Combinator.Basics

Methods

noThunks ∷ Context → StorageConfig (HardForkBlock xs) → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → StorageConfig (HardForkBlock xs) → IO (Maybe ThunkInfo) #

showTypeOfProxy (StorageConfig (HardForkBlock xs)) → String #

(NoThunks (CodecConfig m), NoThunks (CodecConfig a)) ⇒ NoThunks (CodecConfig (DualBlock m a)) Source # 
Instance details

Defined in Ouroboros.Consensus.Ledger.Dual

Methods

noThunks ∷ Context → CodecConfig (DualBlock m a) → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → CodecConfig (DualBlock m a) → IO (Maybe ThunkInfo) #

showTypeOfProxy (CodecConfig (DualBlock m a)) → String #

CanHardFork xs ⇒ NoThunks (CodecConfig (HardForkBlock xs)) Source # 
Instance details

Defined in Ouroboros.Consensus.HardFork.Combinator.Basics

Methods

noThunks ∷ Context → CodecConfig (HardForkBlock xs) → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → CodecConfig (HardForkBlock xs) → IO (Maybe ThunkInfo) #

showTypeOfProxy (CodecConfig (HardForkBlock xs)) → String #

NoThunks (BlockConfig (DualBlock m a)) Source # 
Instance details

Defined in Ouroboros.Consensus.Ledger.Dual

Methods

noThunks ∷ Context → BlockConfig (DualBlock m a) → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → BlockConfig (DualBlock m a) → IO (Maybe ThunkInfo) #

showTypeOfProxy (BlockConfig (DualBlock m a)) → String #

CanHardFork xs ⇒ NoThunks (BlockConfig (HardForkBlock xs)) Source # 
Instance details

Defined in Ouroboros.Consensus.HardFork.Combinator.Basics

Methods

noThunks ∷ Context → BlockConfig (HardForkBlock xs) → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → BlockConfig (HardForkBlock xs) → IO (Maybe ThunkInfo) #

showTypeOfProxy (BlockConfig (HardForkBlock xs)) → String #

ConsensusProtocol p ⇒ NoThunks (ConsensusConfig (ModChainSel p s)) Source # 
Instance details

Defined in Ouroboros.Consensus.Protocol.ModChainSel

Methods

noThunks ∷ Context → ConsensusConfig (ModChainSel p s) → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → ConsensusConfig (ModChainSel p s) → IO (Maybe ThunkInfo) #

showTypeOfProxy (ConsensusConfig (ModChainSel p s)) → String #

BftCrypto c ⇒ NoThunks (ConsensusConfig (Bft c)) Source # 
Instance details

Defined in Ouroboros.Consensus.Protocol.BFT

Methods

noThunks ∷ Context → ConsensusConfig (Bft c) → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → ConsensusConfig (Bft c) → IO (Maybe ThunkInfo) #

showTypeOfProxy (ConsensusConfig (Bft c)) → String #

CanHardFork xs ⇒ NoThunks (ConsensusConfig (HardForkProtocol xs)) Source # 
Instance details

Defined in Ouroboros.Consensus.HardFork.Combinator.Basics

Methods

noThunks ∷ Context → ConsensusConfig (HardForkProtocol xs) → IO (Maybe ThunkInfo) #

wNoThunks ∷ Context → ConsensusConfig (HardForkProtocol xs) → IO (Maybe ThunkInfo) #

showTypeOfProxy (ConsensusConfig (HardForkProtocol xs)) → String #

NoThunks (ConsensusConfig (PBft c))