| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Ouroboros.Consensus.Util.IOLike
Synopsis
- class (MonadAsync m, MonadLabelledSTM m, MonadTraceSTM m, MonadMVar m, MonadEventlog m, MonadFork m, MonadST m, MonadDelay m, MonadThread m, MonadThrow m, MonadCatch m, MonadMask m, MonadMonotonicTime m, MonadEvaluate m, MonadTraceSTM m, Alternative (STM m), MonadCatch (STM m), PrimMonad m, MonadLabelledSTM m, MonadBase m m, ∀ a. NoThunks (m a), ∀ a. NoThunks a ⇒ NoThunks (StrictTVar m a), ∀ a. NoThunks a ⇒ NoThunks (StrictSVar m a), ∀ a. NoThunks a ⇒ NoThunks (StrictMVar m a), ∀ a. NoThunks a ⇒ NoThunks (StrictTVar m a), ∀ a. NoThunks a ⇒ NoThunks (StrictMVar m a), ∀ a. NoThunks a ⇒ NoThunks (StrictTMVar m a)) ⇒ IOLike (m ∷ Type → Type) where
- forgetSignKeyKES ∷ KESAlgorithm v ⇒ SignKeyKES v → m ()
- class (Typeable e, Show e) ⇒ Exception e where
- toException ∷ e → SomeException
- fromException ∷ SomeException → Maybe e
- displayException ∷ e → String
- backtraceDesired ∷ e → Bool
- data ExitCase a
- class MonadThrow m ⇒ MonadCatch (m ∷ Type → Type) where
- catch ∷ Exception e ⇒ m a → (e → m a) → m a
- catchJust ∷ Exception e ⇒ (e → Maybe b) → m a → (b → m a) → m a
- try ∷ Exception e ⇒ m a → m (Either e a)
- tryJust ∷ Exception e ⇒ (e → Maybe b) → m a → m (Either b a)
- handle ∷ Exception e ⇒ (e → m a) → m a → m a
- handleJust ∷ Exception 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)
- class MonadCatch m ⇒ MonadMask (m ∷ Type → Type) where
- 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
- class Monad m ⇒ MonadThrow (m ∷ Type → Type) where
- throwIO ∷ Exception 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
- annotateIO ∷ ExceptionAnnotation e ⇒ e → m a → m a
- data SomeException
- module Ouroboros.Consensus.Util.MonadSTM.NormalForm
- module Ouroboros.Consensus.Util.NormalForm.StrictMVar
- module Ouroboros.Consensus.Util.NormalForm.StrictTVar
- class MonadThread m ⇒ MonadFork (m ∷ Type → Type) where
- forkIO ∷ m () → m (ThreadId m)
- forkOn ∷ Int → m () → m (ThreadId m)
- forkIOWithUnmask ∷ ((∀ a. m a → m a) → m ()) → m (ThreadId m)
- forkFinally ∷ m a → (Either SomeException a → m ()) → m (ThreadId m)
- throwTo ∷ Exception e ⇒ ThreadId m → e → m ()
- killThread ∷ ThreadId m → m ()
- yield ∷ m ()
- class (Monad m, Eq (ThreadId m), Ord (ThreadId m), Show (ThreadId m)) ⇒ MonadThread (m ∷ Type → Type) where
- type ThreadId (m ∷ Type → Type)
- myThreadId ∷ m (ThreadId m)
- labelThread ∷ ThreadId m → String → m ()
- labelThisThread ∷ MonadThread m ⇒ String → m ()
- data ExceptionInLinkedThread = ExceptionInLinkedThread String SomeException
- class (MonadSTM m, MonadThread m) ⇒ MonadAsync (m ∷ Type → Type) where
- type Async (m ∷ Type → Type) = (async ∷ Type → Type) | async → m
- async ∷ m a → m (Async m a)
- asyncBound ∷ m a → m (Async m a)
- asyncOn ∷ Int → m a → m (Async m a)
- asyncThreadId ∷ Async m a → ThreadId m
- withAsync ∷ m a → (Async m a → m b) → m b
- withAsyncBound ∷ m a → (Async m a → m b) → m b
- withAsyncOn ∷ Int → m a → (Async m a → m b) → m b
- waitSTM ∷ Async m a → STM m a
- pollSTM ∷ Async m a → STM m (Maybe (Either SomeException a))
- waitCatchSTM ∷ Async 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)
- waitEitherSTM ∷ Async m a → Async m b → STM m (Either a b)
- waitEitherSTM_ ∷ Async m a → Async m b → STM m ()
- waitEitherCatchSTM ∷ Async m a → Async m b → STM m (Either (Either SomeException a) (Either SomeException b))
- waitBothSTM ∷ Async m a → Async m b → STM m (a, b)
- wait ∷ Async m a → m a
- poll ∷ Async m a → m (Maybe (Either SomeException a))
- waitCatch ∷ Async m a → m (Either SomeException a)
- cancel ∷ Async m a → m ()
- cancelWith ∷ Exception e ⇒ Async m a → e → m ()
- uninterruptibleCancel ∷ Async 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)
- waitEither ∷ Async m a → Async m b → m (Either a b)
- waitEitherCatch ∷ Async m a → Async m b → m (Either (Either SomeException a) (Either SomeException b))
- waitEitherCancel ∷ Async m a → Async m b → m (Either a b)
- waitEitherCatchCancel ∷ Async m a → Async m b → m (Either (Either SomeException a) (Either SomeException b))
- waitEither_ ∷ Async m a → Async m b → m ()
- waitBoth ∷ Async 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)
- asyncOnWithUnmask ∷ Int → ((∀ b. m b → m b) → m a) → m (Async m a)
- withAsyncWithUnmask ∷ ((∀ c. m c → m c) → m a) → (Async m a → m b) → m b
- withAsyncOnWithUnmask ∷ Int → ((∀ c. m c → m c) → m a) → (Async m a → m b) → m b
- compareAsyncs ∷ Async m a → Async m b → Ordering
- link ∷ (MonadAsync m, MonadFork m, MonadMask m) ⇒ Async m a → m ()
- linkTo ∷ (MonadAsync m, MonadFork m, MonadMask m) ⇒ ThreadId m → Async m a → m ()
- class PrimMonad m ⇒ MonadST (m ∷ Type → Type) where
- stToIO ∷ ST (PrimState m) a → m a
- withLiftST ∷ (∀ s. (∀ a. ST s a → m a) → b) → b
- class Monad m ⇒ PrimMonad (m ∷ Type → Type) where
- data DiffTime
- class MonadMonotonicTimeNSec m ⇒ MonadMonotonicTime (m ∷ Type → Type) where
- getMonotonicTime ∷ m Time
- newtype Time = Time DiffTime
- addTime ∷ DiffTime → Time → Time
- diffTime ∷ Time → Time → DiffTime
- class (MonadDelay m, MonadMonotonicTime m) ⇒ MonadDelay (m ∷ Type → Type) where
- threadDelay ∷ DiffTime → m ()
- class Monad m ⇒ MonadEventlog (m ∷ Type → Type) where
- traceEventIO ∷ String → m ()
- traceMarkerIO ∷ String → m ()
- class MonadThrow m ⇒ MonadEvaluate (m ∷ Type → Type) where
- evaluate ∷ a → m a
- class NoThunks a where
Documentation
class (MonadAsync m, MonadLabelledSTM m, MonadTraceSTM m, MonadMVar m, MonadEventlog m, MonadFork m, MonadST m, MonadDelay m, MonadThread m, MonadThrow m, MonadCatch m, MonadMask m, MonadMonotonicTime m, MonadEvaluate m, MonadTraceSTM m, Alternative (STM m), MonadCatch (STM m), PrimMonad m, MonadLabelledSTM m, MonadBase m m, ∀ a. NoThunks (m a), ∀ a. NoThunks a ⇒ NoThunks (StrictTVar m a), ∀ a. NoThunks a ⇒ NoThunks (StrictSVar m a), ∀ a. NoThunks a ⇒ NoThunks (StrictMVar m a), ∀ a. NoThunks a ⇒ NoThunks (StrictTVar m a), ∀ a. NoThunks a ⇒ NoThunks (StrictMVar m a), ∀ a. NoThunks a ⇒ NoThunks (StrictTMVar m a)) ⇒ IOLike (m ∷ Type → Type) 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
| IOLike IO Source # | |
Defined in Ouroboros.Consensus.Util.IOLike Methods forgetSignKeyKES ∷ KESAlgorithm v ⇒ SignKeyKES v → IO () Source # | |
| (IOLike m, ∀ a. NoThunks (StrictTVar (WithEarlyExit m) a), ∀ a. NoThunks (StrictSVar (WithEarlyExit m) a), ∀ a. NoThunks (StrictMVar (WithEarlyExit m) a)) ⇒ IOLike (WithEarlyExit m) Source # | |
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 #
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 MyExceptionThe 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 = frontendExceptionFromExceptionWe 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 #
toException should produce a SomeException with no attached ExceptionContext.
fromException ∷ SomeException → Maybe e #
displayException ∷ e → String #
Render this exception value in a human-friendly manner.
Default implementation: show
@since base-4.8.0.0
backtraceDesired ∷ e → Bool #
Instances
Used in generalBracket
See exceptions package for discussion and motivation.
Constructors
| ExitCaseSuccess a | |
| ExitCaseException SomeException | |
| ExitCaseAbort |
class MonadThrow m ⇒ MonadCatch (m ∷ Type → Type) where Source #
Catching exceptions.
Covers standard utilities to respond to exceptions.
Minimal complete definition
Methods
catch ∷ Exception e ⇒ m a → (e → m a) → m a Source #
catchJust ∷ Exception e ⇒ (e → Maybe b) → m a → (b → m a) → m a Source #
try ∷ Exception e ⇒ m a → m (Either e a) Source #
tryJust ∷ Exception e ⇒ (e → Maybe b) → m a → m (Either b a) Source #
handle ∷ Exception e ⇒ (e → m a) → m a → m a Source #
handleJust ∷ Exception e ⇒ (e → Maybe b) → (b → m a) → m a → m a Source #
onException ∷ m a → m b → m a Source #
bracketOnError ∷ m a → (a → m b) → (a → m c) → m c Source #
generalBracket ∷ m a → (a → ExitCase b → m c) → (a → m b) → m (b, c) Source #
General form of bracket
See http://hackage.haskell.org/package/exceptions-0.10.0/docs/Control-Monad-Catch.html#v:generalBracket for discussion and motivation.
default generalBracket ∷ MonadMask m ⇒ m a → (a → ExitCase b → m c) → (a → m b) → m (b, c) Source #
Instances
class MonadCatch m ⇒ MonadMask (m ∷ Type → Type) where Source #
Support for safely working in the presence of asynchronous exceptions.
This is typically not needed directly as the utilities in MonadThrow and
MonadCatch cover most use cases.
Minimal complete definition
Methods
mask ∷ ((∀ a. m a → m a) → m b) → m b Source #
uninterruptibleMask ∷ ((∀ a. m a → m a) → m b) → m b Source #
uninterruptibleMask_ ∷ m a → m a Source #
Instances
class Monad m ⇒ MonadThrow (m ∷ Type → Type) where Source #
Throwing exceptions, and resource handling in the presence of exceptions.
Does not include the ability to respond to exceptions.
Minimal complete definition
Methods
throwIO ∷ Exception e ⇒ e → m a Source #
bracket ∷ m a → (a → m b) → (a → m c) → m c Source #
default bracket ∷ MonadCatch m ⇒ m a → (a → m b) → (a → m c) → m c Source #
bracket_ ∷ m a → m b → m c → m c Source #
finally ∷ m a → m b → m a Source #
annotateIO ∷ ExceptionAnnotation e ⇒ e → m a → m a Source #
Instances
data SomeException #
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
| Exception SomeException | This drops any attached @since base-3.0 |
Defined in GHC.Internal.Exception.Type | |
| Show SomeException | Since: ghc-internal-3.0 |
Defined in GHC.Internal.Exception.Type Methods showsPrec ∷ Int → SomeException → ShowS # show ∷ SomeException → String # showList ∷ [SomeException] → ShowS # | |
Variables with NoThunks invariants
MonadFork, TODO: Should we hide this in favour of MonadAsync?
class MonadThread m ⇒ MonadFork (m ∷ Type → Type) where Source #
Minimal complete definition
forkIO, forkOn, forkIOWithUnmask, forkFinally, throwTo, yield
Methods
forkIO ∷ m () → m (ThreadId m) Source #
forkOn ∷ Int → m () → m (ThreadId m) Source #
forkIOWithUnmask ∷ ((∀ a. m a → m a) → m ()) → m (ThreadId m) Source #
forkFinally ∷ m a → (Either SomeException a → m ()) → m (ThreadId m) Source #
throwTo ∷ Exception e ⇒ ThreadId m → e → m () Source #
killThread ∷ ThreadId m → m () Source #
Instances
class (Monad m, Eq (ThreadId m), Ord (ThreadId m), Show (ThreadId m)) ⇒ MonadThread (m ∷ Type → Type) where Source #
Instances
| MonadThread IO | |||||
Defined in Control.Monad.Class.MonadFork Associated Types
| |||||
| MonadThread m ⇒ MonadThread (WithEarlyExit m) Source # | |||||
Defined in Ouroboros.Consensus.Util.EarlyExit Associated Types
Methods myThreadId ∷ WithEarlyExit m (ThreadId (WithEarlyExit m)) Source # labelThread ∷ ThreadId (WithEarlyExit m) → String → WithEarlyExit m () Source # | |||||
| MonadThread m ⇒ MonadThread (ReaderT r m) | |||||
Defined in Control.Monad.Class.MonadFork Associated Types
| |||||
labelThisThread ∷ MonadThread m ⇒ String → m () Source #
Apply the label to the current thread
MonadAsync
data ExceptionInLinkedThread Source #
Exception from child thread re-raised in parent thread
We record the thread ID of the child thread as a String. This avoids
an m parameter in the type, which is important: ExceptionInLinkedThread
must be an instance of Exception, requiring it to be Typeable; if m
appeared in the type, we would require m to be Typeable, which does not
work with with the simulator, as it would require a Typeable constraint
on the s parameter of IOSim.
Constructors
| ExceptionInLinkedThread String SomeException |
Instances
class (MonadSTM m, MonadThread m) ⇒ MonadAsync (m ∷ Type → Type) where Source #
Minimal complete definition
async, asyncBound, asyncOn, asyncThreadId, cancel, cancelWith, asyncWithUnmask, asyncOnWithUnmask, waitCatchSTM, pollSTM
Associated Types
type Async (m ∷ Type → Type) = (async ∷ Type → Type) | async → m Source #
An asynchronous action
See Async.
Methods
async ∷ m a → m (Async m a) Source #
See async.
asyncBound ∷ m a → m (Async m a) Source #
See asyncBound.
asyncOn ∷ Int → m a → m (Async m a) Source #
See asyncOn.
asyncThreadId ∷ Async m a → ThreadId m Source #
See asyncThreadId.
withAsync ∷ m a → (Async m a → m b) → m b Source #
See withAsync.
withAsyncBound ∷ m a → (Async m a → m b) → m b Source #
See withAsyncBound.
default withAsyncBound ∷ MonadMask m ⇒ m a → (Async m a → m b) → m b Source #
withAsyncOn ∷ Int → m a → (Async m a → m b) → m b Source #
See withAsyncOn.
waitSTM ∷ Async m a → STM m a Source #
See waitSTM.
pollSTM ∷ Async m a → STM m (Maybe (Either SomeException a)) Source #
See pollSTM.
waitCatchSTM ∷ Async m a → STM m (Either SomeException a) Source #
See waitCatchSTM.
waitAnySTM ∷ [Async m a] → STM m (Async m a, a) Source #
See waitAnySTM.
default waitAnySTM ∷ MonadThrow (STM m) ⇒ [Async m a] → STM m (Async m a, a) Source #
waitAnyCatchSTM ∷ [Async m a] → STM m (Async m a, Either SomeException a) Source #
See waitAnyCatchSTM.
waitEitherSTM ∷ Async m a → Async m b → STM m (Either a b) Source #
See waitEitherSTM.
default waitEitherSTM ∷ MonadThrow (STM m) ⇒ Async m a → Async m b → STM m (Either a b) Source #
waitEitherSTM_ ∷ Async m a → Async m b → STM m () Source #
See waitEitherSTM_.
default waitEitherSTM_ ∷ MonadThrow (STM m) ⇒ Async m a → Async m b → STM m () Source #
waitEitherCatchSTM ∷ Async m a → Async m b → STM m (Either (Either SomeException a) (Either SomeException b)) Source #
See waitEitherCatchSTM.
waitBothSTM ∷ Async m a → Async m b → STM m (a, b) Source #
See waitBothSTM.
default waitBothSTM ∷ MonadThrow (STM m) ⇒ Async m a → Async m b → STM m (a, b) Source #
wait ∷ Async m a → m a Source #
See wait.
poll ∷ Async m a → m (Maybe (Either SomeException a)) Source #
See poll.
waitCatch ∷ Async m a → m (Either SomeException a) Source #
See waitCatch.
cancel ∷ Async m a → m () Source #
See cancel.
cancelWith ∷ Exception e ⇒ Async m a → e → m () Source #
See cancelWith.
uninterruptibleCancel ∷ Async m a → m () Source #
default uninterruptibleCancel ∷ MonadMask m ⇒ Async m a → m () Source #
waitAny ∷ [Async m a] → m (Async m a, a) Source #
See waitAny.
waitAnyCatch ∷ [Async m a] → m (Async m a, Either SomeException a) Source #
See waitAnyCatch.
waitAnyCancel ∷ [Async m a] → m (Async m a, a) Source #
See waitAnyCancel.
default waitAnyCancel ∷ MonadThrow m ⇒ [Async m a] → m (Async m a, a) Source #
waitAnyCatchCancel ∷ [Async m a] → m (Async m a, Either SomeException a) Source #
See waitAnyCatchCancel.
default waitAnyCatchCancel ∷ MonadThrow m ⇒ [Async m a] → m (Async m a, Either SomeException a) Source #
waitEither ∷ Async m a → Async m b → m (Either a b) Source #
See waitEither.
waitEitherCatch ∷ Async m a → Async m b → m (Either (Either SomeException a) (Either SomeException b)) Source #
Note, IO-based implementations should override the default
implementation. See the async package implementation and comments.
http://hackage.haskell.org/package/async-2.2.1/docs/src/Control.Concurrent.Async.html#waitEitherCatch
See waitEitherCatch.
waitEitherCancel ∷ Async m a → Async m b → m (Either a b) Source #
See waitEitherCancel.
default waitEitherCancel ∷ MonadThrow m ⇒ Async m a → Async m b → m (Either a b) Source #
waitEitherCatchCancel ∷ Async m a → Async m b → m (Either (Either SomeException a) (Either SomeException b)) Source #
default waitEitherCatchCancel ∷ MonadThrow m ⇒ Async m a → Async m b → m (Either (Either SomeException a) (Either SomeException b)) Source #
waitEither_ ∷ Async m a → Async m b → m () Source #
See waitEither_.
waitBoth ∷ Async m a → Async m b → m (a, b) Source #
See waitBoth.
race ∷ m a → m b → m (Either a b) Source #
See race.
race_ ∷ m a → m b → m () Source #
See race_.
concurrently ∷ m a → m b → m (a, b) Source #
See concurrently.
concurrently_ ∷ m a → m b → m () Source #
See concurrently_.
asyncWithUnmask ∷ ((∀ b. m b → m b) → m a) → m (Async m a) Source #
See concurrently_.
asyncOnWithUnmask ∷ Int → ((∀ b. m b → m b) → m a) → m (Async m a) Source #
See asyncOnWithUnmask.
withAsyncWithUnmask ∷ ((∀ c. m c → m c) → m a) → (Async m a → m b) → m b Source #
See withAsyncWithUnmask.
default withAsyncWithUnmask ∷ MonadMask m ⇒ ((∀ c. m c → m c) → m a) → (Async m a → m b) → m b Source #
withAsyncOnWithUnmask ∷ Int → ((∀ c. m c → m c) → m a) → (Async m a → m b) → m b Source #
default withAsyncOnWithUnmask ∷ MonadMask m ⇒ Int → ((∀ c. m c → m c) → m a) → (Async m a → m b) → m b Source #
compareAsyncs ∷ Async m a → Async m b → Ordering Source #
See compareAsyncs.
Instances
MonadST
class PrimMonad m ⇒ MonadST (m ∷ Type → Type) where Source #
This class is for abstracting over stToIO which allows running ST
actions in IO. In this case it is to allow running ST actions within
another monad m.
The normal type of stToIO is:
stToIO :: ST RealWorld a -> IO a
We have two approaches to abstracting over this, a new and an older
(deprecated) method. The new method borrows the primitive package's
PrimMonad and PrimState type family. This gives us:
stToIO :: ST (PrimState m) a -> m a
Which for IO is exactly the same as above. For ST it is identity, while
for IOSim it is
stToIO :: ST s a -> IOSim s a
The older (deprecated) method is tricky because we need to not care about
both the IO, and also the RealWorld, and it does so avoiding mentioning
any s type (which is what the PrimState type family gives access to).
The solution is to write an action that is given the liftST as an argument
and where that action itself is polymorphic in the s parameter. This
allows us to instantiate it with RealWorld in the IO case, and the local
s in a case where we are embedding into another ST action.
Minimal complete definition
Methods
stToIO ∷ ST (PrimState m) a → m a Source #
Since: io-classes-1.4.1.0
withLiftST ∷ (∀ s. (∀ a. ST s a → m a) → b) → b Source #
Deprecated. Use stToIO instead.
Instances
| MonadST IO | |
| MonadST (ST s) | |
| MonadST m ⇒ MonadST (WithEarlyExit m) Source # | |
Defined in Ouroboros.Consensus.Util.EarlyExit Methods stToIO ∷ ST (PrimState (WithEarlyExit m)) a → WithEarlyExit m a Source # withLiftST ∷ (∀ s. (∀ a. ST s a → WithEarlyExit m a) → b) → b Source # | |
| (MonadST m, PrimMonad m) ⇒ MonadST (ReaderT r m) | |
class Monad m ⇒ PrimMonad (m ∷ Type → Type) where Source #
Class of monads which can perform primitive state-transformer actions.
Methods
primitive ∷ (State# (PrimState m) → (# State# (PrimState m), a #)) → m a Source #
Execute a primitive operation.
Instances
| PrimMonad IO | |||||
| PrimMonad (ST s) | |||||
| PrimMonad (ST s) | |||||
| PrimMonad m ⇒ PrimMonad (GenT m) | |||||
| PrimMonad m ⇒ PrimMonad (PropertyT m) | |||||
| PrimMonad m ⇒ PrimMonad (TestT m) | |||||
| PrimMonad m ⇒ PrimMonad (TreeT m) | |||||
| PrimMonad m ⇒ PrimMonad (WithEarlyExit m) Source # | |||||
Defined in Ouroboros.Consensus.Util.EarlyExit Associated Types
Methods primitive ∷ (State# (PrimState (WithEarlyExit m)) → (# State# (PrimState (WithEarlyExit m)), a #)) → WithEarlyExit m a Source # | |||||
| PrimMonad m ⇒ PrimMonad (ResourceT m) | |||||
Defined in Control.Monad.Trans.Resource.Internal Associated Types
| |||||
| PrimMonad m ⇒ PrimMonad (MaybeT m) | |||||
| (Monoid w, PrimMonad m) ⇒ PrimMonad (AccumT w m) | Since: primitive-0.6.3.0 | ||||
| PrimMonad m ⇒ PrimMonad (ExceptT e m) | |||||
| PrimMonad m ⇒ PrimMonad (IdentityT m) | |||||
| PrimMonad m ⇒ PrimMonad (ReaderT r m) | |||||
| PrimMonad m ⇒ PrimMonad (SelectT r m) | |||||
| PrimMonad m ⇒ PrimMonad (StateT s m) | |||||
| PrimMonad m ⇒ PrimMonad (StateT s m) | |||||
| (Monoid w, PrimMonad m) ⇒ PrimMonad (WriterT w m) | |||||
| (Monoid w, PrimMonad m) ⇒ PrimMonad (WriterT w m) | |||||
| (Monoid w, PrimMonad m) ⇒ PrimMonad (WriterT w m) | |||||
| PrimMonad (CekM uni fun s) | |||||
Defined in UntypedPlutusCore.Evaluation.Machine.Cek.Internal Associated Types
| |||||
| PrimMonad m ⇒ PrimMonad (ContT r m) | Since: primitive-0.6.3.0 | ||||
| (Monoid w, PrimMonad m) ⇒ PrimMonad (RWST r w s m) | |||||
| (Monoid w, PrimMonad m) ⇒ PrimMonad (RWST r w s m) | |||||
| (Monoid w, PrimMonad m) ⇒ PrimMonad (RWST r w s m) | |||||
MonadTime
This is a length of time, as measured by a clock.
Conversion functions such as fromInteger and realToFrac will treat it as seconds.
For example, (0.010 :: DiffTime) corresponds to 10 milliseconds.
It has a precision of one picosecond (= 10^-12 s). Enumeration functions will treat it as picoseconds.
Instances
| FromJSON DiffTime | This instance includes a bounds check to prevent maliciously
large inputs to fill up the memory of the target system. You can
newtype |
| ToJSON DiffTime | |
| NFData DiffTime | |
Defined in Data.Time.Clock.Internal.DiffTime | |
| Data DiffTime | |
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 # gunfold ∷ (∀ b r. Data b ⇒ c (b → r) → c r) → (∀ r. r → c r) → Constr → c DiffTime # toConstr ∷ DiffTime → Constr # dataTypeOf ∷ DiffTime → DataType # dataCast1 ∷ Typeable t ⇒ (∀ d. Data d ⇒ c (t d)) → Maybe (c DiffTime) # dataCast2 ∷ Typeable t ⇒ (∀ d e. (Data d, Data e) ⇒ c (t d e)) → Maybe (c DiffTime) # gmapT ∷ (∀ b. Data b ⇒ b → b) → DiffTime → DiffTime # gmapQl ∷ (r → r' → r) → r → (∀ d. Data d ⇒ d → r') → DiffTime → r # gmapQr ∷ ∀ r r'. (r' → r → r) → r → (∀ d. Data d ⇒ d → r') → DiffTime → r # gmapQ ∷ (∀ d. Data d ⇒ d → u) → DiffTime → [u] # gmapQi ∷ Int → (∀ d. Data d ⇒ d → u) → DiffTime → u # gmapM ∷ Monad m ⇒ (∀ d. Data d ⇒ d → m d) → DiffTime → m DiffTime # gmapMp ∷ MonadPlus m ⇒ (∀ d. Data d ⇒ d → m d) → DiffTime → m DiffTime # gmapMo ∷ MonadPlus m ⇒ (∀ d. Data d ⇒ d → m d) → DiffTime → m DiffTime # | |
| Enum DiffTime | |
| Num DiffTime | |
| Read DiffTime | |
| Fractional DiffTime | |
| Real DiffTime | |
Defined in Data.Time.Clock.Internal.DiffTime Methods toRational ∷ DiffTime → Rational # | |
| RealFrac DiffTime | |
| Show DiffTime | |
| Eq DiffTime | |
| Ord DiffTime | |
Defined in Data.Time.Clock.Internal.DiffTime | |
| NoThunks DiffTime | |
class MonadMonotonicTimeNSec m ⇒ MonadMonotonicTime (m ∷ Type → Type) where Source #
Minimal complete definition
Nothing
Instances
| MonadMonotonicTime IO | |
Defined in Control.Monad.Class.MonadTime.SI Methods | |
| MonadMonotonicTime m ⇒ MonadMonotonicTime (WithEarlyExit m) Source # | |
Defined in Ouroboros.Consensus.Util.EarlyExit Methods | |
| MonadMonotonicTime m ⇒ MonadMonotonicTime (ReaderT r m) | |
Defined in Control.Monad.Class.MonadTime.SI Methods getMonotonicTime ∷ ReaderT r m Time Source # | |
A point in time in a monotonic clock.
The epoch for this clock is arbitrary and does not correspond to any wall
clock or calendar, and is not guaranteed to be the same epoch across
program runs. It is represented as the DiffTime from this arbitrary epoch.
Instances
| NFData Time | |||||
Defined in Control.Monad.Class.MonadTime.SI | |||||
| Generic Time | |||||
Defined in Control.Monad.Class.MonadTime.SI Associated Types
| |||||
| Show Time | |||||
| Eq Time | |||||
| Ord Time | |||||
| NoThunks Time | |||||
| Condense Time Source # | |||||
| type Rep Time | |||||
Defined in Control.Monad.Class.MonadTime.SI type Rep Time = D1 ('MetaData "Time" "Control.Monad.Class.MonadTime.SI" "si-timers-1.5.0.0-d87837c545438fc5ebd4f279f57ab161d38e1ff942f4ae1e8af560c60b342a5d" 'True) (C1 ('MetaCons "Time" 'PrefixI 'False) (S1 ('MetaSel ('Nothing ∷ Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DiffTime))) | |||||
addTime ∷ DiffTime → Time → Time infixr 9 Source #
Add a duration to a point in time, giving another time.
diffTime ∷ Time → Time → DiffTime Source #
The time duration between two points in time (positive or negative).
MonadDelay
class (MonadDelay m, MonadMonotonicTime m) ⇒ MonadDelay (m ∷ Type → Type) where Source #
Methods
threadDelay ∷ DiffTime → m () Source #
Instances
| MonadDelay IO | Thread delay. This implementation will not over- or underflow. For delay larger than what For delays smaller than `minBound :: Int` seconds, `minBound :: Int` will be used instead. |
Defined in Control.Monad.Class.MonadTimer.SI Methods threadDelay ∷ DiffTime → IO () Source # | |
| MonadDelay m ⇒ MonadDelay (WithEarlyExit m) Source # | |
Defined in Ouroboros.Consensus.Util.EarlyExit Methods threadDelay ∷ DiffTime → WithEarlyExit m () Source # | |
| MonadDelay m ⇒ MonadDelay (ReaderT r m) | |
Defined in Control.Monad.Class.MonadTimer.SI Methods threadDelay ∷ DiffTime → ReaderT r m () Source # | |
MonadEventlog
class Monad m ⇒ MonadEventlog (m ∷ Type → Type) where Source #
Methods
traceEventIO ∷ String → m () Source #
Emits a message to the eventlog, if eventlog profiling is available and enabled at runtime.
traceMarkerIO ∷ String → m () Source #
Emits a marker to the eventlog, if eventlog profiling is available and enabled at runtime.
The String is the name of the marker. The name is just used in the
profiling tools to help you keep clear which marker is which.
Instances
| MonadEventlog IO | |
Defined in Control.Monad.Class.MonadEventlog | |
| MonadEventlog m ⇒ MonadEventlog (WithEarlyExit m) Source # | |
Defined in Ouroboros.Consensus.Util.EarlyExit Methods traceEventIO ∷ String → WithEarlyExit m () Source # traceMarkerIO ∷ String → WithEarlyExit m () Source # | |
| MonadEventlog m ⇒ MonadEventlog (ReaderT r m) | |
Defined in Control.Monad.Class.MonadEventlog Methods traceEventIO ∷ String → ReaderT r m () Source # traceMarkerIO ∷ String → ReaderT r m () Source # | |
MonadEvaluate
class MonadThrow m ⇒ MonadEvaluate (m ∷ Type → Type) where Source #
Monads which can evaluate.
Instances
| MonadEvaluate IO | |
Defined in Control.Monad.Class.MonadThrow | |
| (MonadEvaluate m, MonadCatch m) ⇒ MonadEvaluate (WithEarlyExit m) Source # | |
Defined in Ouroboros.Consensus.Util.EarlyExit Methods evaluate ∷ a → WithEarlyExit m a Source # | |
| MonadEvaluate m ⇒ MonadEvaluate (ReaderT r m) | |
Defined in Control.Monad.Class.MonadThrow | |
NoThunks
class NoThunks a where Source #
Check a value for unexpected thunks
Minimal complete definition
Nothing
Methods
noThunks ∷ Context → a → IO (Maybe ThunkInfo) Source #
Check if the argument does not contain any unexpected thunks
For most datatypes, we should have that
noThunks ctxt x == Nothing
if and only if
checkContainsThunks x
For some datatypes however, some thunks are expected. For example, the
internal fingertree Sequence might contain thunks (this is
important for the asymptotic complexity of this data structure). However,
we should still check that the values in the sequence don't contain any
unexpected thunks.
This means that we need to traverse the sequence, which might force some of
the thunks in the tree. In general, it is acceptable for
noThunks to force such "expected thunks", as long as it always
reports the unexpected thunks.
The default implementation of noThunks checks that the argument is in
WHNF, and if so, adds the type into the context (using showTypeOf or
whereFrom if available), and calls wNoThunks. See ThunkInfo for
a detailed discussion of the type context.
See also discussion of caveats listed for checkContainsThunks.
wNoThunks ∷ Context → a → IO (Maybe ThunkInfo) Source #
Check that the argument is in normal form, assuming it is in WHNF.
The context will already have been extended with the type we're looking at, so all that's left is to look at the thunks inside the type. The default implementation uses GHC Generics to do this.
default wNoThunks ∷ (Generic a, GWNoThunks ('[] ∷ [Symbol]) (Rep a)) ⇒ Context → a → IO (Maybe ThunkInfo) Source #
showTypeOf ∷ Proxy a → String Source #
Show type a (to add to the context)
We try hard to avoid Typeable constraints in this module: there are types
with no Typeable instance but with a NoThunks instance (most
important example are types such as ST s which rely on parametric
polymorphism). By default we should therefore only show the "outer layer";
for example, if we have a type
Seq (ST s ())
then showTypeOf should just give Seq, leaving it up to the instance for
ST to decide how to implement showTypeOf; this keeps things
compositional. The default implementation does precisely this using the
metadata that GHC Generics provides.
For convenience, however, some of the deriving via newtype wrappers we
provide do depend on Typeable; see below.
Instances
| NoThunks ByteString | Instance for string bytestrings Strict bytestrings shouldn't contain any thunks, but could, due to https://gitlab.haskell.org/ghc/ghc/issues/17290. However, such thunks can't retain any data that they shouldn't, and so it's safe to ignore such thunks. |
Defined in NoThunks.Class | |
| NoThunks ByteString | Instance for lazy bytestrings Defined manually so that it piggy-backs on the one for strict bytestrings. |
Defined in NoThunks.Class | |
| NoThunks ShortByteString | Instance for short bytestrings We have data ShortByteString = SBS ByteArray# Values of this type consist of a tag followed by an _unboxed_ byte array, which can't contain thunks. Therefore we only check WHNF. |
Defined in NoThunks.Class | |
| NoThunks Seed | |
| NoThunks Point | |
| NoThunks Output | |
| NoThunks Proof | |
| NoThunks Seed | |
| NoThunks SignKey | |
| NoThunks VerKey | |
| NoThunks Output | |
| NoThunks Proof | |
| NoThunks Seed | |
| NoThunks SignKey | |
| NoThunks VerKey | |
| NoThunks ProtocolMagicId | |
Defined in Cardano.Crypto.ProtocolMagic | |
| NoThunks RequiresNetworkMagic | |
Defined in Cardano.Crypto.ProtocolMagic | |
| NoThunks CompactRedeemVerificationKey | |
Defined in Cardano.Crypto.Signing.Redeem.Compact | |
| NoThunks RedeemSigningKey | |
Defined in Cardano.Crypto.Signing.Redeem.SigningKey | |
| NoThunks RedeemVerificationKey | |
| NoThunks VerificationKey | |
Defined in Cardano.Crypto.Signing.VerificationKey | |
| NoThunks AddrAttributes | |
Defined in Cardano.Chain.Common.AddrAttributes | |
| NoThunks HDAddressPayload | |
Defined in Cardano.Chain.Common.AddrAttributes | |
| NoThunks AddrType | |
| NoThunks Address | |
| NoThunks UnparsedFields | |
Defined in Cardano.Chain.Common.Attributes | |
| NoThunks BlockCount | |
Defined in Cardano.Chain.Common.BlockCount | |
| NoThunks ChainDifficulty | |
Defined in Cardano.Chain.Common.ChainDifficulty | |
| NoThunks CompactAddress | |
Defined in Cardano.Chain.Common.Compact | |
| NoThunks Lovelace | |
| NoThunks LovelacePortion | |
Defined in Cardano.Chain.Common.LovelacePortion | |
| NoThunks NetworkMagic | |
Defined in Cardano.Chain.Common.NetworkMagic | |
| NoThunks TxFeePolicy | |
Defined in Cardano.Chain.Common.TxFeePolicy | |
| NoThunks TxSizeLinear | |
Defined in Cardano.Chain.Common.TxSizeLinear | |
| NoThunks Addr | |
| NoThunks BootstrapAddress | |
Defined in Cardano.Ledger.Address | |
| NoThunks CompactAddr | |
Defined in Cardano.Ledger.Address | |
| NoThunks RewardAccount | |
Defined in Cardano.Ledger.Address | |
| NoThunks Withdrawals | |
Defined in Cardano.Ledger.Address | |
| NoThunks ActiveSlotCoeff | |
Defined in Cardano.Ledger.BaseTypes | |
| NoThunks Anchor | |
| NoThunks BlocksMade | |
Defined in Cardano.Ledger.BaseTypes | |
| NoThunks CertIx | |
| NoThunks DnsName | |
| NoThunks Globals | |
| NoThunks Network | |
| NoThunks NonNegativeInterval | |
Defined in Cardano.Ledger.BaseTypes | |
| NoThunks Nonce | |
| NoThunks Port | |
| NoThunks PositiveInterval | |
Defined in Cardano.Ledger.BaseTypes | |
| NoThunks PositiveUnitInterval | |
Defined in Cardano.Ledger.BaseTypes | |
| NoThunks ProtVer | |
| NoThunks Relation | |
| NoThunks Seed | |
| NoThunks TxIx | |
| NoThunks UnitInterval | |
Defined in Cardano.Ledger.BaseTypes | |
| NoThunks Url | |
| NoThunks CommitteeAuthorization | |
Defined in Cardano.Ledger.CertState | |
| NoThunks FutureGenDeleg | |
Defined in Cardano.Ledger.CertState | |
| NoThunks InstantaneousRewards | |
Defined in Cardano.Ledger.CertState | |
| NoThunks Coin | |
| NoThunks DeltaCoin | |
| NoThunks Ptr | |
| NoThunks SlotNo32 | |
| NoThunks StakeReference | |
Defined in Cardano.Ledger.Credential | |
| NoThunks DRep | |
| NoThunks DRepState | |
| NoThunks GenDelegPair | |
Defined in Cardano.Ledger.Hashes | |
| NoThunks GenDelegs | |
| NoThunks ScriptHash | |
Defined in Cardano.Ledger.Hashes | |
| NoThunks TxAuxDataHash | |
Defined in Cardano.Ledger.Hashes | |
| NoThunks BootstrapWitness | |
Defined in Cardano.Ledger.Keys.Bootstrap | |
| NoThunks BootstrapWitnessRaw | |
Defined in Cardano.Ledger.Keys.Bootstrap | |
| NoThunks ChainCode | |
| NoThunks Metadatum | |
| NoThunks CostModel | |
| NoThunks CostModels | |
Defined in Cardano.Ledger.Plutus.CostModels | |
| NoThunks ExUnits | |
| NoThunks Prices | |
| NoThunks Language | |
| NoThunks PlutusBinary | |
Defined in Cardano.Ledger.Plutus.Language | |
| NoThunks TxOutSource | |
Defined in Cardano.Ledger.Plutus.TxInfo | |
| NoThunks PoolMetadata | |
Defined in Cardano.Ledger.PoolParams | |
| NoThunks PoolParams | |
Defined in Cardano.Ledger.PoolParams | |
| NoThunks StakePoolRelay | |
Defined in Cardano.Ledger.PoolParams | |
| NoThunks Reward | |
| NoThunks RewardType | |
Defined in Cardano.Ledger.Rewards | |
| NoThunks Duration | |
| NoThunks TxId | |
| NoThunks TxIn | |
| NoThunks RDPair | |
| NoThunks StakeCredentials | |
Defined in Cardano.Ledger.UMap | |
| NoThunks UMElem | |
| NoThunks UMap | |
| NoThunks BlockNo | |
| NoThunks EpochInterval | |
Defined in Cardano.Slotting.Slot | |
| NoThunks EpochNo | |
| NoThunks EpochSize | |
| NoThunks SlotNo | |
| NoThunks RelativeTime | |
Defined in Cardano.Slotting.Time | |
| NoThunks SlotLength | |
Defined in Cardano.Slotting.Time | |
| NoThunks SystemStart | |
Defined in Cardano.Slotting.Time | |
| NoThunks FsPath Source # | |
| NoThunks CRC Source # | |
| NoThunks Void | |
| NoThunks ThreadId | |
| NoThunks All | |
| NoThunks Any | |
| NoThunks Int16 | |
| NoThunks Int32 | |
| NoThunks Int64 | |
| NoThunks Int8 | |
| NoThunks CallStack | Since CallStacks can't retain application data, we don't want to check them for thunks at all |
| NoThunks Word16 | |
| NoThunks Word32 | |
| NoThunks Word64 | |
| NoThunks Word8 | |
| NoThunks GenesisWindow Source # | |
Defined in Ouroboros.Consensus.Block.Abstract | |
| NoThunks IsEBB Source # | |
| NoThunks CurrentSlot Source # | |
Defined in Ouroboros.Consensus.BlockchainTime.API | |
| NoThunks SecurityParam Source # | |
Defined in Ouroboros.Consensus.Config.SecurityParam | |
| NoThunks Past Source # | |
| NoThunks TransitionInfo Source # | |
| NoThunks EraParams Source # | |
| NoThunks SafeZone Source # | |
| NoThunks Bound Source # | |
| NoThunks EraEnd Source # | |
| NoThunks EraSummary Source # | |
Defined in Ouroboros.Consensus.HardFork.History.Summary | |
| NoThunks TriggerHardFork Source # | |
Defined in Ouroboros.Consensus.HardFork.Simple | |
| NoThunks ComputeLedgerEvents Source # | |
Defined in Ouroboros.Consensus.Ledger.Basics | |
| NoThunks ByteSize32 Source # | |
Defined in Ouroboros.Consensus.Ledger.SupportsMempool | |
| NoThunks MempoolSize Source # | |
Defined in Ouroboros.Consensus.Mempool.Capacity | |
| NoThunks TicketNo Source # | |
| NoThunks DisengagedInitState Source # | |
| NoThunks JumperInitState Source # | |
| NoThunks ObjectorInitState Source # | |
| NoThunks GsmState Source # | |
| NoThunks NumCoreNodes Source # | |
Defined in Ouroboros.Consensus.Node.ProtocolInfo | |
| NoThunks CoreNodeId Source # | |
Defined in Ouroboros.Consensus.NodeId | |
| NoThunks NodeId Source # | |
| NoThunks BftParams Source # | |
| NoThunks BftValidationErr Source # | |
Defined in Ouroboros.Consensus.Protocol.BFT | |
| NoThunks LeaderSchedule Source # | |
Defined in Ouroboros.Consensus.Protocol.LeaderSchedule | |
| NoThunks PBftParams Source # | |
Defined in Ouroboros.Consensus.Protocol.PBFT | |
| NoThunks PBftSelectView Source # | |
Defined in Ouroboros.Consensus.Protocol.PBFT | |
| NoThunks PBftSignatureThreshold Source # | |
Defined in Ouroboros.Consensus.Protocol.PBFT | |
| NoThunks PBftMockVerKeyHash Source # | |
Defined in Ouroboros.Consensus.Protocol.PBFT.Crypto | |
| NoThunks ScheduledGc Source # | |
| NoThunks FollowerKey Source # | |
| NoThunks IteratorKey Source # | |
| NoThunks PrefixLen Source # | |
| NoThunks ChunkInfo Source # | |
| NoThunks ChunkNo Source # | |
| NoThunks ChunkSize Source # | |
| NoThunks RelativeSlot Source # | |
| NoThunks ChunkSlot Source # | |
| NoThunks PrimaryIndex Source # | |
| NoThunks BlockOffset Source # | |
| NoThunks BlockSize Source # | |
| NoThunks HeaderOffset Source # | |
| NoThunks HeaderSize Source # | |
| NoThunks BlockOrEBB Source # | |
| NoThunks QueryBatchSize Source # | |
Defined in Ouroboros.Consensus.Storage.LedgerDB.Args | |
| NoThunks ForkerKey Source # | |
| NoThunks SnapshotPolicy Source # | |
| NoThunks Status Source # | |
| NoThunks Length Source # | |
| NoThunks SlotNoLB Source # | |
| NoThunks SlotNoUB Source # | |
| NoThunks HandleArgs Source # | |
Defined in Ouroboros.Consensus.Storage.LedgerDB.V2.Args | |
| NoThunks BlockOffset Source # | |
| NoThunks BlockSize Source # | |
| NoThunks PrettyCallStack Source # | |
Defined in Ouroboros.Consensus.Util.CallStack | |
| NoThunks Fingerprint Source # | |
Defined in Ouroboros.Consensus.Util.STM | |
| NoThunks OutboundConnectionsState | |
Defined in Cardano.Network.PeerSelection.LocalRootPeers | |
| NoThunks LedgerStateJudgement | |
Defined in Cardano.Network.Types | |
| NoThunks MaxSlotNo | |
| NoThunks ChainSelStarvation | |
| NoThunks NetworkMagic | |
Defined in Ouroboros.Network.Magic | |
| NoThunks AfterSlot | |
| NoThunks UseLedgerPeers | |
| NoThunks SizeInBytes | |
Defined in Ouroboros.Network.SizeInBytes | |
| NoThunks ConcreteHeaderHash | |
Defined in Ouroboros.Network.Mock.ConcreteBlock | |
| NoThunks NumTxIdsToAck | |
| NoThunks NumTxIdsToReq | |
| NoThunks Data | |
| NoThunks CostModelApplyError | |
| NoThunks ExBudget | |
| NoThunks ExCPU | |
| NoThunks ExMemory | |
| NoThunks SatInt | |
| NoThunks EvaluationContext | |
Defined in PlutusLedgerApi.Common.Eval | |
| NoThunks ScriptForEvaluation | |
Defined in PlutusLedgerApi.Common.SerialisedScript | |
| NoThunks PlutusLedgerLanguage | |
Defined in PlutusLedgerApi.Common.Versions | |
| NoThunks Appenders | |
| NoThunks RAWState | |
| NoThunks Readers | |
| NoThunks Writers | |
| NoThunks Age | |
| NoThunks PrettyCallStack | |
| NoThunks RegistryStatus | |
| NoThunks ResourceId | |
Defined in Control.ResourceRegistry | |
| NoThunks Time | |
| NoThunks PObject | |
| NoThunks Text | |
| NoThunks Text | |
| NoThunks Day | |
| NoThunks DiffTime | |
| NoThunks NominalDiffTime | |
Defined in NoThunks.Class | |
| NoThunks UTCTime | |
| NoThunks UniversalTime | |
Defined in NoThunks.Class | |
| NoThunks TimeLocale | |
Defined in NoThunks.Class | |
| NoThunks LocalTime | |
| NoThunks TimeOfDay | |
| NoThunks TimeZone | |
| NoThunks ZonedTime | |
| NoThunks Integer | |
| NoThunks Natural | |
| NoThunks () | |
| NoThunks Bool | |
| NoThunks Char | |
| NoThunks Double | |
| NoThunks Float | |
| NoThunks Int | |
| NoThunks Word | |
| NoThunks a ⇒ NoThunks (First a) | |
| NoThunks a ⇒ NoThunks (Last a) | |
| NoThunks a ⇒ NoThunks (Max a) | |
| NoThunks a ⇒ NoThunks (Min a) | |
| NoThunks a ⇒ NoThunks (WrappedMonoid a) | |
Defined in NoThunks.Class | |
| NoThunks (SigDSIGN EcdsaSecp256k1DSIGN) | |
| NoThunks (SigDSIGN Ed25519DSIGN) | |
| NoThunks (SigDSIGN Ed448DSIGN) | |
| NoThunks (SigDSIGN MockDSIGN) | |
| NoThunks (SigDSIGN NeverDSIGN) | |
| NoThunks (SigDSIGN SchnorrSecp256k1DSIGN) | |
| NoThunks (SignKeyDSIGN EcdsaSecp256k1DSIGN) | |
Defined in Cardano.Crypto.DSIGN.EcdsaSecp256k1 Methods noThunks ∷ Context → SignKeyDSIGN EcdsaSecp256k1DSIGN → IO (Maybe ThunkInfo) Source # wNoThunks ∷ Context → SignKeyDSIGN EcdsaSecp256k1DSIGN → IO (Maybe ThunkInfo) Source # showTypeOf ∷ Proxy (SignKeyDSIGN EcdsaSecp256k1DSIGN) → String Source # | |
| NoThunks (SignKeyDSIGN Ed25519DSIGN) | |
Defined in Cardano.Crypto.DSIGN.Ed25519 Methods noThunks ∷ Context → SignKeyDSIGN Ed25519DSIGN → IO (Maybe ThunkInfo) Source # wNoThunks ∷ Context → SignKeyDSIGN Ed25519DSIGN → IO (Maybe ThunkInfo) Source # showTypeOf ∷ Proxy (SignKeyDSIGN Ed25519DSIGN) → String Source # | |
| NoThunks (SignKeyDSIGN Ed448DSIGN) | |
Defined in Cardano.Crypto.DSIGN.Ed448 Methods noThunks ∷ Context → SignKeyDSIGN Ed448DSIGN → IO (Maybe ThunkInfo) Source # wNoThunks ∷ Context → SignKeyDSIGN Ed448DSIGN → IO (Maybe ThunkInfo) Source # showTypeOf ∷ Proxy (SignKeyDSIGN Ed448DSIGN) → String Source # | |
| NoThunks (SignKeyDSIGN MockDSIGN) | |
| NoThunks (SignKeyDSIGN NeverDSIGN) | |
Defined in Cardano.Crypto.DSIGN.NeverUsed Methods noThunks ∷ Context → SignKeyDSIGN NeverDSIGN → IO (Maybe ThunkInfo) Source # wNoThunks ∷ Context → SignKeyDSIGN NeverDSIGN → IO (Maybe ThunkInfo) Source # showTypeOf ∷ Proxy (SignKeyDSIGN NeverDSIGN) → String Source # | |
| NoThunks (SignKeyDSIGN SchnorrSecp256k1DSIGN) | |
Defined in Cardano.Crypto.DSIGN.SchnorrSecp256k1 Methods noThunks ∷ Context → SignKeyDSIGN SchnorrSecp256k1DSIGN → IO (Maybe ThunkInfo) Source # wNoThunks ∷ Context → SignKeyDSIGN SchnorrSecp256k1DSIGN → IO (Maybe ThunkInfo) Source # showTypeOf ∷ Proxy (SignKeyDSIGN SchnorrSecp256k1DSIGN) → String Source # | |
| NoThunks (SignKeyDSIGNM Ed25519DSIGN) | |
Defined in Cardano.Crypto.DSIGN.Ed25519 Methods noThunks ∷ Context → SignKeyDSIGNM Ed25519DSIGN → IO (Maybe ThunkInfo) Source # wNoThunks ∷ Context → SignKeyDSIGNM Ed25519DSIGN → IO (Maybe ThunkInfo) Source # showTypeOf ∷ Proxy (SignKeyDSIGNM Ed25519DSIGN) → String Source # | |
| NoThunks (VerKeyDSIGN EcdsaSecp256k1DSIGN) | |
Defined in Cardano.Crypto.DSIGN.EcdsaSecp256k1 Methods noThunks ∷ Context → VerKeyDSIGN EcdsaSecp256k1DSIGN → IO (Maybe ThunkInfo) Source # wNoThunks ∷ Context → VerKeyDSIGN EcdsaSecp256k1DSIGN → IO (Maybe ThunkInfo) Source # showTypeOf ∷ Proxy (VerKeyDSIGN EcdsaSecp256k1DSIGN) → String Source # | |
| NoThunks (VerKeyDSIGN Ed25519DSIGN) | |
Defined in Cardano.Crypto.DSIGN.Ed25519 Methods noThunks ∷ Context → VerKeyDSIGN Ed25519DSIGN → IO (Maybe ThunkInfo) Source # wNoThunks ∷ Context → VerKeyDSIGN Ed25519DSIGN → IO (Maybe ThunkInfo) Source # showTypeOf ∷ Proxy (VerKeyDSIGN Ed25519DSIGN) → String Source # | |
| NoThunks (VerKeyDSIGN Ed448DSIGN) | |
Defined in Cardano.Crypto.DSIGN.Ed448 Methods noThunks ∷ Context → VerKeyDSIGN Ed448DSIGN → IO (Maybe ThunkInfo) Source # wNoThunks ∷ Context → VerKeyDSIGN Ed448DSIGN → IO (Maybe ThunkInfo) Source # showTypeOf ∷ Proxy (VerKeyDSIGN Ed448DSIGN) → String Source # | |
| NoThunks (VerKeyDSIGN MockDSIGN) | |
| NoThunks (VerKeyDSIGN NeverDSIGN) | |
Defined in Cardano.Crypto.DSIGN.NeverUsed Methods noThunks ∷ Context → VerKeyDSIGN NeverDSIGN → IO (Maybe ThunkInfo) Source # wNoThunks ∷ Context → VerKeyDSIGN NeverDSIGN → IO (Maybe ThunkInfo) Source # showTypeOf ∷ Proxy (VerKeyDSIGN NeverDSIGN) → String Source # | |
| NoThunks (VerKeyDSIGN SchnorrSecp256k1DSIGN) | |
Defined in Cardano.Crypto.DSIGN.SchnorrSecp256k1 Methods noThunks ∷ Context → VerKeyDSIGN SchnorrSecp256k1DSIGN → IO (Maybe ThunkInfo) Source # wNoThunks ∷ Context → VerKeyDSIGN SchnorrSecp256k1DSIGN → IO (Maybe ThunkInfo) Source # showTypeOf ∷ Proxy (VerKeyDSIGN SchnorrSecp256k1DSIGN) → String Source # | |
| DSIGNMAlgorithm d ⇒ NoThunks (SigKES (CompactSingleKES d)) | |
| KESAlgorithm d ⇒ NoThunks (SigKES (CompactSumKES h d)) | |
| NoThunks (SigKES (MockKES t)) | |
| NoThunks (SigKES NeverKES) | |
| DSIGNMAlgorithm d ⇒ NoThunks (SigKES (SimpleKES d t)) | |
| DSIGNAlgorithm d ⇒ NoThunks (SigKES (SingleKES d)) | |
| KESAlgorithm d ⇒ NoThunks (SigKES (SumKES h d)) | |
| DSIGNMAlgorithm d ⇒ NoThunks (SignKeyKES (CompactSingleKES d)) | |
Defined in Cardano.Crypto.KES.CompactSingle Methods noThunks ∷ Context → SignKeyKES (CompactSingleKES d) → IO (Maybe ThunkInfo) Source # wNoThunks ∷ Context → SignKeyKES (CompactSingleKES d) → IO (Maybe ThunkInfo) Source # showTypeOf ∷ Proxy (SignKeyKES (CompactSingleKES d)) → String Source # | |
| NoThunks (SignKeyKES (CompactSumKES h d)) | |
Defined in Cardano.Crypto.KES.CompactSum Methods noThunks ∷ Context → SignKeyKES (CompactSumKES h d) → IO (Maybe ThunkInfo) Source # wNoThunks ∷ Context → SignKeyKES (CompactSumKES h d) → IO (Maybe ThunkInfo) Source # showTypeOf ∷ Proxy (SignKeyKES (CompactSumKES h d)) → String Source # | |
| NoThunks (SignKeyKES (MockKES t)) | |
| NoThunks (SignKeyKES NeverKES) | |
| DSIGNMAlgorithm d ⇒ NoThunks (SignKeyKES (SimpleKES d t)) | |
| DSIGNMAlgorithm d ⇒ NoThunks (SignKeyKES (SingleKES d)) | |
| NoThunks (SignKeyKES (SumKES h d)) | |
| KESAlgorithm v ⇒ NoThunks (SignKeyWithPeriodKES v) | |
Defined in Cardano.Crypto.KES.Class | |
| DSIGNAlgorithm d ⇒ NoThunks (UnsoundPureSignKeyKES (CompactSingleKES d)) | |
Defined in Cardano.Crypto.KES.CompactSingle Methods noThunks ∷ Context → UnsoundPureSignKeyKES (CompactSingleKES d) → IO (Maybe ThunkInfo) Source # wNoThunks ∷ Context → UnsoundPureSignKeyKES (CompactSingleKES d) → IO (Maybe ThunkInfo) Source # showTypeOf ∷ Proxy (UnsoundPureSignKeyKES (CompactSingleKES d)) → String Source # | |
| (NoThunks (UnsoundPureSignKeyKES d), KESAlgorithm d) ⇒ NoThunks (UnsoundPureSignKeyKES (CompactSumKES h d)) | |
Defined in Cardano.Crypto.KES.CompactSum Methods noThunks ∷ Context → UnsoundPureSignKeyKES (CompactSumKES h d) → IO (Maybe ThunkInfo) Source # wNoThunks ∷ Context → UnsoundPureSignKeyKES (CompactSumKES h d) → IO (Maybe ThunkInfo) Source # showTypeOf ∷ Proxy (UnsoundPureSignKeyKES (CompactSumKES h d)) → String Source # | |
| NoThunks (UnsoundPureSignKeyKES (MockKES t)) | |
| NoThunks (UnsoundPureSignKeyKES NeverKES) | |
| DSIGNMAlgorithm d ⇒ NoThunks (UnsoundPureSignKeyKES (SimpleKES d t)) | |
Defined in Cardano.Crypto.KES.Simple | |
| DSIGNAlgorithm d ⇒ NoThunks (UnsoundPureSignKeyKES (SingleKES d)) | |
| (NoThunks (UnsoundPureSignKeyKES d), KESAlgorithm d) ⇒ NoThunks (UnsoundPureSignKeyKES (SumKES h d)) | |
| DSIGNMAlgorithm d ⇒ NoThunks (VerKeyKES (CompactSingleKES d)) | |
| KESAlgorithm d ⇒ NoThunks (VerKeyKES (CompactSumKES h d)) | |
| NoThunks (VerKeyKES (MockKES t)) | |
| NoThunks (VerKeyKES NeverKES) | |
| DSIGNMAlgorithm d ⇒ NoThunks (VerKeyKES (SimpleKES d t)) | |
| DSIGNMAlgorithm d ⇒ NoThunks (VerKeyKES (SingleKES d)) | |
| KESAlgorithm d ⇒ NoThunks (VerKeyKES (SumKES h d)) | |
| NoThunks (MLockedSizedBytes n) | |
| NoThunks (MLockedSeed n) | |
Defined in Cardano.Crypto.Libsodium.MLockedSeed | |
| NoThunks (MLockedForeignPtr a) | |
Defined in Cardano.Crypto.Libsodium.Memory.Internal | |
| NoThunks (PackedBytes n) | |
Defined in Cardano.Crypto.PackedBytes | |
| NoThunks (PinnedSizedBytes n) | |
Defined in Cardano.Crypto.PinnedSizedBytes | |
| NoThunks (CertVRF MockVRF) | |
| NoThunks (CertVRF NeverVRF) | |
| NoThunks (CertVRF SimpleVRF) | |
| NoThunks (CertVRF PraosVRF) | |
| NoThunks (CertVRF PraosBatchCompatVRF) | |
| NoThunks (OutputVRF v) | |
| NoThunks (SignKeyVRF MockVRF) | |
| NoThunks (SignKeyVRF NeverVRF) | |
| NoThunks (SignKeyVRF SimpleVRF) | |
| NoThunks (SignKeyVRF PraosVRF) | |
| NoThunks (SignKeyVRF PraosBatchCompatVRF) | |
Defined in Cardano.Crypto.VRF.PraosBatchCompat Methods noThunks ∷ Context → SignKeyVRF PraosBatchCompatVRF → IO (Maybe ThunkInfo) Source # wNoThunks ∷ Context → SignKeyVRF PraosBatchCompatVRF → IO (Maybe ThunkInfo) Source # showTypeOf ∷ Proxy (SignKeyVRF PraosBatchCompatVRF) → String Source # | |
| NoThunks (VerKeyVRF MockVRF) | |
| NoThunks (VerKeyVRF NeverVRF) | |
| NoThunks (VerKeyVRF SimpleVRF) | |
| NoThunks (VerKeyVRF PraosVRF) | |
| NoThunks (VerKeyVRF PraosBatchCompatVRF) | |
| NoThunks a ⇒ NoThunks (AProtocolMagic a) | |
Defined in Cardano.Crypto.ProtocolMagic | |
| NoThunks (Signature a) | |
| NoThunks a ⇒ NoThunks (Sized a) | |
| NoThunks h ⇒ NoThunks (Attributes h) | |
Defined in Cardano.Chain.Common.Attributes | |
| NoThunks (MerkleRoot a) | |
Defined in Cardano.Chain.Common.Merkle | |
| NoThunks a ⇒ NoThunks (NonZero a) | |
| NoThunks (CommitteeState era) | |
Defined in Cardano.Ledger.CertState | |
| NoThunks (DState era) | |
| NoThunks (PState era) | |
| NoThunks (VState era) | |
| NoThunks (CompactForm Coin) | |
| NoThunks (CompactForm DeltaCoin) | |
| NoThunks (Credential kr) | |
Defined in Cardano.Ledger.Credential | |
| NoThunks (NoGenesis era) Source # | |
| NoThunks (NoUpdate a) | |
| NoThunks (KeyHash r) | |
| NoThunks (SafeHash i) | |
| NoThunks (VRFVerKeyHash r) | |
Defined in Cardano.Ledger.Hashes | |
| NoThunks (VKey kd) | |
| Typeable kr ⇒ NoThunks (WitVKey kr) | |
| (Typeable t, NoThunks t) ⇒ NoThunks (MemoBytes t) | |
| NoThunks (BinaryData era) | |
Defined in Cardano.Ledger.Plutus.Data | |
| Typeable era ⇒ NoThunks (Data era) | |
| NoThunks (Datum era) | |
| NoThunks (PlutusData era) | |
Defined in Cardano.Ledger.Plutus.Data | |
| NoThunks a ⇒ NoThunks (ExUnits' a) | |
| NoThunks (Plutus l) | |
| NoThunks (PlutusRunnable l) | |
Defined in Cardano.Ledger.Plutus.Language | |
| NoThunks (EpochInfo m) | |
| NoThunks t ⇒ NoThunks (WithOrigin t) | |
Defined in Cardano.Slotting.Slot | |
| NoThunks a ⇒ NoThunks (StrictMaybe a) | |
Defined in Data.Maybe.Strict | |
| NoThunks a ⇒ NoThunks (StrictSeq a) | Instance for The internal fingertree in |
| NoThunks a ⇒ NoThunks (IntMap a) | |
| NoThunks a ⇒ NoThunks (Seq a) | Instance for The internal fingertree in |
| NoThunks a ⇒ NoThunks (Set a) | |
| NoThunks v ⇒ NoThunks (Delta v) | |
| NoThunks v ⇒ NoThunks (DeltaHistory v) | |
Defined in Data.Map.Diff.Strict.Internal | |
| NoThunks (SomeHasFS m) Source # | |
| NoThunks (Handle h) Source # | |
| NoThunks a ⇒ NoThunks (NonEmpty a) | |
| NoThunks a ⇒ NoThunks (TVar a) | |
| NoThunks a ⇒ NoThunks (Identity a) | |
| NoThunks a ⇒ NoThunks (First a) | |
| NoThunks a ⇒ NoThunks (Last a) | |
| NoThunks a ⇒ NoThunks (Dual a) | |
| NoThunks a ⇒ NoThunks (Product a) | |
| NoThunks a ⇒ NoThunks (Sum a) | |
| NoThunks a ⇒ NoThunks (IORef a) | |
| NoThunks a ⇒ NoThunks (MVar a) | |
| NoThunks a ⇒ NoThunks (Ratio a) | |
| NoThunks (IO a) | We do not check IO actions for captured thunks by default See instance for |
| NoThunks a ⇒ NoThunks (MultiSet a) Source # | |
| NoThunks (AllowThunk a) | |
Defined in NoThunks.Class | |
| Typeable a ⇒ NoThunks (InspectHeap a) | |
Defined in NoThunks.Class | |
| Typeable a ⇒ NoThunks (OnlyCheckWhnf a) | |
Defined in NoThunks.Class | |
| CanHardFork xs ⇒ NoThunks (BlockConfig (HardForkBlock xs)) Source # | |
Defined in Ouroboros.Consensus.HardFork.Combinator.Basics Methods noThunks ∷ Context → BlockConfig (HardForkBlock xs) → IO (Maybe ThunkInfo) Source # wNoThunks ∷ Context → BlockConfig (HardForkBlock xs) → IO (Maybe ThunkInfo) Source # showTypeOf ∷ Proxy (BlockConfig (HardForkBlock xs)) → String Source # | |
| NoThunks (BlockConfig (DualBlock m a)) Source # | |
| CanHardFork xs ⇒ NoThunks (CodecConfig (HardForkBlock xs)) Source # | |
Defined in Ouroboros.Consensus.HardFork.Combinator.Basics Methods noThunks ∷ Context → CodecConfig (HardForkBlock xs) → IO (Maybe ThunkInfo) Source # wNoThunks ∷ Context → CodecConfig (HardForkBlock xs) → IO (Maybe ThunkInfo) Source # showTypeOf ∷ Proxy (CodecConfig (HardForkBlock xs)) → String Source # | |
| (NoThunks (CodecConfig m), NoThunks (CodecConfig a)) ⇒ NoThunks (CodecConfig (DualBlock m a)) Source # | |
| CanHardFork xs ⇒ NoThunks (Header (HardForkBlock xs)) Source # | |
| NoThunks (Header (DualBlock m a)) Source # | |
| CanHardFork xs ⇒ NoThunks (StorageConfig (HardForkBlock xs)) Source # | |
Defined in Ouroboros.Consensus.HardFork.Combinator.Basics Methods noThunks ∷ Context → StorageConfig (HardForkBlock xs) → IO (Maybe ThunkInfo) Source # wNoThunks ∷ Context → StorageConfig (HardForkBlock xs) → IO (Maybe ThunkInfo) Source # showTypeOf ∷ Proxy (StorageConfig (HardForkBlock xs)) → String Source # | |
| (NoThunks (StorageConfig m), NoThunks (StorageConfig a)) ⇒ NoThunks (StorageConfig (DualBlock m a)) Source # | |
| (StandardHash blk, Typeable blk) ⇒ NoThunks (RealPoint blk) Source # | |
| ConsensusProtocol proto ⇒ NoThunks (SelectViewTentativeState proto) Source # | |
| NoThunks (BlockchainTime m) Source # | |
Defined in Ouroboros.Consensus.BlockchainTime.API | |
| NoThunks (SystemTime m) Source # | |
| NoThunks (HeaderHash blk) ⇒ NoThunks (CheckpointsMap blk) Source # | |
Defined in Ouroboros.Consensus.Config | |
| (ConsensusProtocol (BlockProtocol blk), NoThunks (LedgerConfig blk), NoThunks (BlockConfig blk), NoThunks (CodecConfig blk), NoThunks (StorageConfig blk), NoThunks (HeaderHash blk)) ⇒ NoThunks (TopLevelConfig blk) Source # | |
Defined in Ouroboros.Consensus.Config | |
| CanHardFork xs ⇒ NoThunks (MismatchEraInfo xs) Source # | |
| CanHardFork xs ⇒ NoThunks (OneEraEnvelopeErr xs) Source # | |
| CanHardFork xs ⇒ NoThunks (OneEraGenTx xs) Source # | |
| CanHardFork xs ⇒ NoThunks (OneEraGenTxId xs) Source # | |
| CanHardFork xs ⇒ NoThunks (OneEraHeader xs) Source # | |
| CanHardFork xs ⇒ NoThunks (OneEraLedgerError xs) Source # | |
| CanHardFork xs ⇒ NoThunks (OneEraSelectView xs) Source # | |
| CanHardFork xs ⇒ NoThunks (OneEraTentativeHeaderState xs) Source # | |
| CanHardFork xs ⇒ NoThunks (OneEraTipInfo xs) Source # | |
| CanHardFork xs ⇒ NoThunks (OneEraValidatedGenTx xs) Source # | |
| CanHardFork xs ⇒ NoThunks (OneEraValidationErr xs) Source # | |
| CanHardFork xs ⇒ NoThunks (PerEraBlockConfig xs) Source # | |
| CanHardFork xs ⇒ NoThunks (PerEraCodecConfig xs) Source # | |
| CanHardFork xs ⇒ NoThunks (PerEraConsensusConfig xs) Source # | |
| CanHardFork xs ⇒ NoThunks (PerEraLedgerConfig xs) Source # | |
| CanHardFork xs ⇒ NoThunks (PerEraStorageConfig xs) Source # | |
| CanHardFork xs ⇒ NoThunks (HardForkLedgerConfig xs) Source # | |
| NoThunks (LedgerEraInfo blk) Source # | |
Defined in Ouroboros.Consensus.HardFork.Combinator.Info | |
| NoThunks (SingleEraInfo blk) Source # | |
Defined in Ouroboros.Consensus.HardFork.Combinator.Info | |
| CanHardFork xs ⇒ NoThunks (HardForkEnvelopeErr xs) Source # | |
| CanHardFork xs ⇒ NoThunks (HardForkLedgerError xs) Source # | |
| NoThunks (PartialConsensusConfig (BlockProtocol blk)) ⇒ NoThunks (WrapPartialConsensusConfig blk) Source # | |
| NoThunks (PartialLedgerConfig blk) ⇒ NoThunks (WrapPartialLedgerConfig blk) Source # | |
| CanHardFork xs ⇒ NoThunks (HardForkSelectView xs) Source # | |
| CanHardFork xs ⇒ NoThunks (HardForkValidationErr xs) Source # | |
| NoThunks (EraTranslation xs) Source # | |
| NoThunks (Shape xs) Source # | |
| NoThunks (Summary xs) Source # | |
| (BlockSupportsProtocol blk, HasAnnTip blk) ⇒ NoThunks (HeaderStateHistory blk) Source # | |
Defined in Ouroboros.Consensus.HeaderStateHistory | |
| (BlockSupportsProtocol blk, HasAnnTip blk) ⇒ NoThunks (HeaderStateWithTime blk) Source # | |
Defined in Ouroboros.Consensus.HeaderStateHistory | |
| HasAnnTip blk ⇒ NoThunks (AnnTip blk) Source # | |
| (ValidateEnvelope blk, Typeable blk) ⇒ NoThunks (HeaderEnvelopeError blk) Source # | |
Defined in Ouroboros.Consensus.HeaderValidation | |
| (BlockSupportsProtocol blk, ValidateEnvelope blk) ⇒ NoThunks (HeaderError blk) Source # | |
Defined in Ouroboros.Consensus.HeaderValidation | |
| (BlockSupportsProtocol blk, HasAnnTip blk) ⇒ NoThunks (HeaderState blk) Source # | |
Defined in Ouroboros.Consensus.HeaderValidation | |
| NoThunks (Header blk) ⇒ NoThunks (HeaderWithTime blk) Source # | |
Defined in Ouroboros.Consensus.HeaderValidation | |
| StandardHash blk ⇒ NoThunks (TipInfoIsEBB blk) Source # | |
Defined in Ouroboros.Consensus.HeaderValidation | |
| CanHardFork xs ⇒ NoThunks (Validated (GenTx (HardForkBlock xs))) Source # | |
| NoThunks (Validated (GenTx (DualBlock m a))) Source # | |
| (ConsensusProtocol (BlockProtocol blk), NoThunks (BlockConfig blk), NoThunks (CodecConfig blk), NoThunks (LedgerConfig blk), NoThunks (StorageConfig blk), NoThunks (HeaderHash blk)) ⇒ NoThunks (ExtLedgerCfg blk) Source # | |
Defined in Ouroboros.Consensus.Ledger.Extended | |
| LedgerSupportsProtocol blk ⇒ NoThunks (ExtValidationError blk) Source # | |
Defined in Ouroboros.Consensus.Ledger.Extended | |
| CanHardFork xs ⇒ NoThunks (GenTx (HardForkBlock xs)) Source # | |
| NoThunks (GenTx (DualBlock m a)) Source # | |
| NoThunks a ⇒ NoThunks (IgnoringOverflow a) Source # | |
Defined in Ouroboros.Consensus.Ledger.SupportsMempool | |
| CanHardFork xs ⇒ NoThunks (TxId (GenTx (HardForkBlock xs))) Source # | |
| NoThunks (TxId (GenTx (DualBlock m a))) Source # | |
| NoThunks v ⇒ NoThunks (Delta v) Source # | |
| (NoThunks (Validated (GenTx blk)), NoThunks (GenTxId blk), NoThunks (TickedLedgerState blk DiffMK), NoThunks (TxIn (LedgerState blk)), NoThunks (TxOut (LedgerState blk)), NoThunks (TxMeasure blk), StandardHash blk, Typeable blk) ⇒ NoThunks (InternalState blk) Source # | |
Defined in Ouroboros.Consensus.Mempool.Impl.Common | |
| NoThunks a ⇒ NoThunks (Our a) Source # | |
| NoThunks a ⇒ NoThunks (Their a) Source # | |
| (HasHeader blk, LedgerSupportsProtocol blk, NoThunks (Header blk)) ⇒ NoThunks (Instruction blk) Source # | |
| (HasHeader blk, LedgerSupportsProtocol blk, NoThunks (Header blk)) ⇒ NoThunks (JumpInstruction blk) Source # | |
| (HasHeader blk, LedgerSupportsProtocol blk, NoThunks (Header blk)) ⇒ NoThunks (JumpResult blk) Source # | |
| (HasHeader blk, LedgerSupportsProtocol blk, NoThunks (Header blk)) ⇒ NoThunks (ChainSyncJumpingJumperState blk) Source # | |
| (HasHeader blk, NoThunks (Header blk)) ⇒ NoThunks (ChainSyncState blk) Source # | |
| (HasHeader blk, LedgerSupportsProtocol blk, NoThunks (Header blk)) ⇒ NoThunks (DynamoInitState blk) Source # | |
| LedgerSupportsProtocol blk ⇒ NoThunks (JumpInfo blk) Source # | |
| CanHardFork xs ⇒ NoThunks (ConsensusConfig (HardForkProtocol xs)) Source # | |
Defined in Ouroboros.Consensus.HardFork.Combinator.Basics Methods noThunks ∷ Context → ConsensusConfig (HardForkProtocol xs) → IO (Maybe ThunkInfo) Source # wNoThunks ∷ Context → ConsensusConfig (HardForkProtocol xs) → IO (Maybe ThunkInfo) Source # showTypeOf ∷ Proxy (ConsensusConfig (HardForkProtocol xs)) → String Source # | |
| BftCrypto c ⇒ NoThunks (ConsensusConfig (Bft c)) Source # | |
| ConsensusProtocol p ⇒ NoThunks (ConsensusConfig (ModChainSel p s)) Source # | |
Defined in Ouroboros.Consensus.Protocol.ModChainSel Methods noThunks ∷ Context → ConsensusConfig (ModChainSel p s) → IO (Maybe ThunkInfo) Source # wNoThunks ∷ Context → ConsensusConfig (ModChainSel p s) → IO (Maybe ThunkInfo) Source # showTypeOf ∷ Proxy (ConsensusConfig (ModChainSel p s)) → String Source # | |
| NoThunks (ConsensusConfig (PBft c)) Source # | |
| PBftCrypto c ⇒ NoThunks (PBftCanBeLeader c) Source # | |
Defined in Ouroboros.Consensus.Protocol.PBFT | |
| PBftCrypto c ⇒ NoThunks (PBftCannotForge c) Source # | |
Defined in Ouroboros.Consensus.Protocol.PBFT | |
| PBftCrypto c ⇒ NoThunks (PBftIsLeader c) Source # | |
Defined in Ouroboros.Consensus.Protocol.PBFT | |
| PBftCrypto c ⇒ NoThunks (PBftLedgerView c) Source # | |
Defined in Ouroboros.Consensus.Protocol.PBFT | |
| PBftCrypto c ⇒ NoThunks (PBftValidationErr c) Source # | |
Defined in Ouroboros.Consensus.Protocol.PBFT | |
| PBftCrypto c ⇒ NoThunks (PBftSigner c) Source # | |
Defined in Ouroboros.Consensus.Protocol.PBFT.State | |
| PBftCrypto c ⇒ NoThunks (PBftState c) Source # | |
| NoThunks a ⇒ NoThunks (LoE a) Source # | |
| NoThunks (InvalidBlockPunishment m) Source # | |
| StandardHash blk ⇒ NoThunks (FollowerRollState blk) Source # | |
| (HasHeader blk, NoThunks (Header blk)) ⇒ NoThunks (InternalChain blk) Source # | |
| LedgerSupportsProtocol blk ⇒ NoThunks (InvalidBlockInfo blk) Source # | |
| (StandardHash blk, Typeable blk) ⇒ NoThunks (StreamFrom blk) Source # | |
Defined in Ouroboros.Consensus.Storage.Common | |
| (StandardHash blk, Typeable blk) ⇒ NoThunks (StreamTo blk) Source # | |
| StandardHash blk ⇒ NoThunks (Tip blk) Source # | |
| StandardHash blk ⇒ NoThunks (Entry blk) Source # | |
| NoThunks a ⇒ NoThunks (WithBlockSize a) Source # | |
| NoThunks (LedgerCfg l) ⇒ NoThunks (LedgerDbCfg l) Source # | |
Defined in Ouroboros.Consensus.Storage.LedgerDB.API | |
| NoThunks (LiveLMDBFS m) Source # | |
| NoThunks (SnapshotsFS m) Source # | |
| (NoThunks (TxIn l), NoThunks (TxOut l), NoThunks (l EmptyMK)) ⇒ NoThunks (DbChangelog l) Source # | |
| NoThunks (RAWLock m ()) ⇒ NoThunks (LedgerDBLock m) Source # | |
Defined in Ouroboros.Consensus.Storage.LedgerDB.V1.Lock | |
| (StandardHash blk, Typeable blk) ⇒ NoThunks (BlockInfo blk) Source # | |
| StandardHash blk ⇒ NoThunks (FileInfo blk) Source # | |
| StandardHash blk ⇒ NoThunks (Index blk) Source # | |
| (StandardHash blk, Typeable blk) ⇒ NoThunks (InternalBlockInfo blk) Source # | |
| NoThunks (ChainDepState (BlockProtocol blk)) ⇒ NoThunks (WrapChainDepState blk) Source # | |
Defined in Ouroboros.Consensus.TypeFamilyWrappers | |
| NoThunks (OtherHeaderEnvelopeError blk) ⇒ NoThunks (WrapEnvelopeErr blk) Source # | |
Defined in Ouroboros.Consensus.TypeFamilyWrappers | |
| NoThunks (GenTxId blk) ⇒ NoThunks (WrapGenTxId blk) Source # | |
Defined in Ouroboros.Consensus.TypeFamilyWrappers | |
| NoThunks (LedgerError blk) ⇒ NoThunks (WrapLedgerErr blk) Source # | |
Defined in Ouroboros.Consensus.TypeFamilyWrappers | |
| NoThunks (SelectView (BlockProtocol blk)) ⇒ NoThunks (WrapSelectView blk) Source # | |
Defined in Ouroboros.Consensus.TypeFamilyWrappers | |
| NoThunks (TentativeHeaderState blk) ⇒ NoThunks (WrapTentativeHeaderState blk) Source # | |
Defined in Ouroboros.Consensus.TypeFamilyWrappers | |
| NoThunks (TipInfo blk) ⇒ NoThunks (WrapTipInfo blk) Source # | |
Defined in Ouroboros.Consensus.TypeFamilyWrappers | |
| NoThunks (TxIn (LedgerState blk)) ⇒ NoThunks (WrapTxIn blk) Source # | |
| NoThunks (TxOut (LedgerState blk)) ⇒ NoThunks (WrapTxOut blk) Source # | |
| NoThunks (Validated (GenTx blk)) ⇒ NoThunks (WrapValidatedGenTx blk) Source # | |
Defined in Ouroboros.Consensus.TypeFamilyWrappers | |
| NoThunks (ValidationErr (BlockProtocol blk)) ⇒ NoThunks (WrapValidationErr blk) Source # | |
Defined in Ouroboros.Consensus.TypeFamilyWrappers | |
| NoThunks (StrictMVar m ()) ⇒ NoThunks (Fuse m) Source # | |
| NoThunks (m ()) ⇒ NoThunks (Config m) Source # | |
| NoThunks (m ()) ⇒ NoThunks (State m) Source # | |
| NoThunks a ⇒ NoThunks (WithFingerprint a) Source # | |
Defined in Ouroboros.Consensus.Util.STM | |
| StandardHash block ⇒ NoThunks (Anchor block) | |
| NoThunks (BuiltinSemanticsVariant DefaultFun) | |
Defined in PlutusCore.Default.Builtins Methods noThunks ∷ Context → BuiltinSemanticsVariant DefaultFun → IO (Maybe ThunkInfo) Source # wNoThunks ∷ Context → BuiltinSemanticsVariant DefaultFun → IO (Maybe ThunkInfo) Source # showTypeOf ∷ Proxy (BuiltinSemanticsVariant DefaultFun) → String Source # | |
| NoThunks (BuiltinRuntime val) | |
Defined in PlutusCore.Builtin.Runtime | |
| AllBF NoThunks f CekMachineCostsBase ⇒ NoThunks (CekMachineCostsBase f) | |
| NoThunks st ⇒ NoThunks (Poisonable st) | |
| NoThunks (Context m) | |
| NoThunks (KnownThreads m) | |
| NoThunks (RegistryState m) | |
| NoThunks (Release m) | |
| NoThunks (Resource m) | |
| NoThunks (ResourceRegistry m) ⇒ NoThunks (ResourceKey m) | |
Defined in Control.ResourceRegistry | |
| (∀ a. NoThunks a ⇒ NoThunks (StrictTVar m a)) ⇒ NoThunks (ResourceRegistry m) | |
Defined in Control.ResourceRegistry | |
| NoThunks (TransferredTo st) | |
| NoThunks a ⇒ NoThunks (Threshold a) | |
| NoThunks a ⇒ NoThunks (Vector a) | |
| NoThunks (Vector a) | Unboxed vectors can't contain thunks Implementation note: defined manually rather than using |
| NoThunks a ⇒ NoThunks (Maybe a) | |
| NoThunks a ⇒ NoThunks (Solo a) | |
| NoThunks a ⇒ NoThunks [a] | |
| (NoThunks a, NoThunks b) ⇒ NoThunks (Arg a b) | |
| DSIGNAlgorithm v ⇒ NoThunks (SignedDSIGN v a) | |
Defined in Cardano.Crypto.DSIGN.Class | |
| NoThunks (Hash h a) | |
| KESAlgorithm v ⇒ NoThunks (SignedKES v a) | |
| VRFAlgorithm v ⇒ NoThunks (CertifiedVRF v a) | |
Defined in Cardano.Crypto.VRF.Class | |
| NoThunks (AbstractHash algo a) | |
Defined in Cardano.Crypto.Hashing | |
| (NoThunks b, NoThunks a) ⇒ NoThunks (Annotated b a) | |
| NoThunks a ⇒ NoThunks (BoundedRatio b a) | |
| NoThunks a ⇒ NoThunks (Mismatch r a) | |
| (Era era, NoThunks (TxSeq era), NoThunks h) ⇒ NoThunks (Block h era) | |
| NoThunks a ⇒ NoThunks (StrictFingerTree v a) | |
Defined in Data.FingerTree.Strict | |
| NoThunks (Decoder s a) Source # | |
| (NoThunks k, NoThunks v) ⇒ NoThunks (Map k v) | |
| NoThunks (Tracer m ev) Source # | |
| (NoThunks k, NoThunks v) ⇒ NoThunks (Diff k v) | |
| (NoThunks a, NoThunks b) ⇒ NoThunks (Either a b) | |
| (HasFields s a, Generic a, Typeable a, GWNoThunks s (Rep a)) ⇒ NoThunks (AllowThunksIn s a) | |
Defined in NoThunks.Class | |
| KnownSymbol name ⇒ NoThunks (InspectHeapNamed name a) | |
Defined in NoThunks.Class | |
| KnownSymbol name ⇒ NoThunks (OnlyCheckWhnfNamed name a) | |
Defined in NoThunks.Class | |
| NoThunks (OneEraHash xs) Source # | |
| NoThunks (f blk) ⇒ NoThunks (Current f blk) Source # | |
| (All SingleEraBlock xs, ∀ blk. SingleEraBlock blk ⇒ NoThunks (f blk)) ⇒ NoThunks (HardForkState f xs) Source # | |
| (NoThunksMK mk, CanHardFork xs) ⇒ NoThunks (LedgerState (HardForkBlock xs) mk) Source # | |
Defined in Ouroboros.Consensus.HardFork.Combinator.Basics Methods noThunks ∷ Context → LedgerState (HardForkBlock xs) mk → IO (Maybe ThunkInfo) Source # wNoThunks ∷ Context → LedgerState (HardForkBlock xs) mk → IO (Maybe ThunkInfo) Source # showTypeOf ∷ Proxy (LedgerState (HardForkBlock xs) mk) → String Source # | |
| NoThunks (LedgerState (DualBlock m a) mk) Source # | |
| NoThunks (DualLedgerConfig m a) Source # | |
Defined in Ouroboros.Consensus.Ledger.Dual | |
| NoThunks (DualLedgerError m a) Source # | |
Defined in Ouroboros.Consensus.Ledger.Dual | |
| (NoThunksMK mk, LedgerSupportsProtocol blk) ⇒ NoThunks (ExtLedgerState blk mk) Source # | We override This makes debugging a bit easier, as the block gets used to resolve all kinds of type families. |
Defined in Ouroboros.Consensus.Ledger.Extended | |
| NoThunks (mk (TxIn l) (TxOut l)) ⇒ NoThunks (LedgerTables l mk) Source # | |
Defined in Ouroboros.Consensus.Ledger.Tables.Basics | |
| (NoThunks k, NoThunks v) ⇒ NoThunks (Diff k v) Source # | |
| (NoThunks k, NoThunks v) ⇒ NoThunks (DiffMK k v) Source # | |
| NoThunks (EmptyMK k v) Source # | |
| NoThunks k ⇒ NoThunks (KeysMK k v) Source # | |
| (NoThunks k, NoThunks v) ⇒ NoThunks (SeqDiffMK k v) Source # | |
| (NoThunks k, NoThunks v) ⇒ NoThunks (TrackingMK k v) Source # | |
Defined in Ouroboros.Consensus.Ledger.Tables.MapKind | |
| (NoThunks k, NoThunks v) ⇒ NoThunks (ValuesMK k v) Source # | |
| (NoThunks tx, NoThunks sz) ⇒ NoThunks (TxSeq sz tx) Source # | |
| (NoThunks tx, NoThunks sz) ⇒ NoThunks (TxTicket sz tx) Source # | |
| (IOLike m, HasHeader blk, NoThunks (Header blk)) ⇒ NoThunks (ChainSyncStateView m blk) Source # | |
| (IOLike m, HasHeader blk, NoThunks (Header blk)) ⇒ NoThunks (Jumping m blk) Source # | |
| (IOLike m, HasHeader blk, LedgerSupportsProtocol blk, NoThunks (Header blk)) ⇒ NoThunks (ChainSyncClientHandle m blk) Source # | |
| (IOLike m, HasHeader blk, LedgerSupportsProtocol blk, NoThunks (Header blk)) ⇒ NoThunks (ChainSyncJumpingState m blk) Source # | |
| (BftCrypto c, Typeable toSign) ⇒ NoThunks (BftFields c toSign) Source # | |
| (PBftCrypto c, Typeable toSign) ⇒ NoThunks (PBftFields c toSign) Source # | |
Defined in Ouroboros.Consensus.Protocol.PBFT | |
| (IOLike m, LedgerSupportsProtocol blk, BlockSupportsDiffusionPipelining blk) ⇒ NoThunks (ChainDbEnv m blk) Source # | We include |
| (IOLike m, LedgerSupportsProtocol blk, BlockSupportsDiffusionPipelining blk) ⇒ NoThunks (ChainDbState m blk) Source # | |
| NoThunks (ChainSelQueue m blk) Source # | |
| NoThunks (FollowerHandle m blk) Source # | |
| NoThunks (ImmutableDB m blk) Source # | |
Defined in Ouroboros.Consensus.Storage.ImmutableDB.API | |
| (NoThunks k, NoThunks v) ⇒ NoThunks (DiffSeq k v) Source # | |
| (NoThunks k, NoThunks v) ⇒ NoThunks (Element k v) Source # | |
| NoThunks (InternalMeasure k v) Source # | |
| (NoThunks k, NoThunks v) ⇒ NoThunks (RootMeasure k v) Source # | |
| (IOLike m, NoThunks (l EmptyMK)) ⇒ NoThunks (LedgerSeq m l) Source # | |
| NoThunks (LedgerTablesHandle m l) Source # | |
| (IOLike m, NoThunks (l EmptyMK)) ⇒ NoThunks (StateRef m l) Source # | |
| NoThunks (VolatileDB m blk) Source # | |
Defined in Ouroboros.Consensus.Storage.VolatileDB.API | |
| (StandardHash blk, Typeable blk) ⇒ NoThunks (InternalState blk h) Source # | |
| (StandardHash blk, Typeable blk) ⇒ NoThunks (OpenState blk h) Source # | |
| (∀ a'. NoThunks (m a')) ⇒ NoThunks (WithEarlyExit m a) Source # | |
Defined in Ouroboros.Consensus.Util.EarlyExit | |
| NoThunks a ⇒ NoThunks (StrictSVar IO a) Source # | |
| NoThunks (StrictSVar m a) ⇒ NoThunks (StrictSVar (WithEarlyExit m) a) Source # | |
Defined in Ouroboros.Consensus.Util.EarlyExit Methods noThunks ∷ Context → StrictSVar (WithEarlyExit m) a → IO (Maybe ThunkInfo) Source # wNoThunks ∷ Context → StrictSVar (WithEarlyExit m) a → IO (Maybe ThunkInfo) Source # showTypeOf ∷ Proxy (StrictSVar (WithEarlyExit m) a) → String Source # | |
| (StandardHash block, Typeable block) ⇒ NoThunks (ChainHash block) | |
| StandardHash block ⇒ NoThunks (Point block) | |
| StandardHash b ⇒ NoThunks (Tip b) | |
| (NoThunks slot, NoThunks hash) ⇒ NoThunks (Block slot hash) | |
| (Bounded fun, Enum fun) ⇒ NoThunks (BuiltinsRuntime fun val) | |
Defined in PlutusCore.Builtin.Runtime | |
| (NoThunks p, NoThunks v, Ord p) ⇒ NoThunks (IntPSQ p v) Source # | |
| (NoThunks (StrictTMVar m (Poisonable st)), NoThunks (StrictMVar m ()), NoThunks (StrictTVar m (Poisonable RAWState))) ⇒ NoThunks (RAWLock m st) | |
| NoThunks (Thread m a) | |
| NoThunks (StrictMVar IO a) ⇒ NoThunks (StrictMVar IO a) Source # | |
| NoThunks (StrictTVar IO a) ⇒ NoThunks (StrictTVar IO a) Source # | |
| NoThunks a ⇒ NoThunks (StrictMVar IO a) Source # | |
| NoThunks (StrictMVar m a) ⇒ NoThunks (StrictMVar (WithEarlyExit m) a) Source # | |
Defined in Ouroboros.Consensus.Util.EarlyExit Methods noThunks ∷ Context → StrictMVar (WithEarlyExit m) a → IO (Maybe ThunkInfo) Source # wNoThunks ∷ Context → StrictMVar (WithEarlyExit m) a → IO (Maybe ThunkInfo) Source # showTypeOf ∷ Proxy (StrictMVar (WithEarlyExit m) a) → String Source # | |
| NoThunks a ⇒ NoThunks (StrictTMVar IO a) Source # | |
| NoThunks (StrictTMVar m a) ⇒ NoThunks (StrictTMVar (WithEarlyExit m) a) Source # | |
Defined in Ouroboros.Consensus.Util.EarlyExit Methods noThunks ∷ Context → StrictTMVar (WithEarlyExit m) a → IO (Maybe ThunkInfo) Source # wNoThunks ∷ Context → StrictTMVar (WithEarlyExit m) a → IO (Maybe ThunkInfo) Source # showTypeOf ∷ Proxy (StrictTMVar (WithEarlyExit m) a) → String Source # | |
| NoThunks a ⇒ NoThunks (StrictTVar IO a) Source # | |
| NoThunks (StrictTVar m a) ⇒ NoThunks (StrictTVar (WithEarlyExit m) a) Source # | |
Defined in Ouroboros.Consensus.Util.EarlyExit Methods noThunks ∷ Context → StrictTVar (WithEarlyExit m) a → IO (Maybe ThunkInfo) Source # wNoThunks ∷ Context → StrictTVar (WithEarlyExit m) a → IO (Maybe ThunkInfo) Source # showTypeOf ∷ Proxy (StrictTVar (WithEarlyExit m) a) → String Source # | |
| (NoThunks a, NoThunks b) ⇒ NoThunks (a, b) | |
| NoThunks (a → b) | We do NOT check function closures for captured thunks by default Since we have no type information about the values captured in a thunk, the
only check we could possibly do is By default we therefore only check if the function is in WHNF, and don't
check the captured values at all. If you want a stronger check, you can
use |
| NoThunks a ⇒ NoThunks (StrictFingerTree vr vi a) | |
Defined in Data.FingerTree.RootMeasured.Strict | |
| NoThunks (f a) ⇒ NoThunks (Ap f a) | |
| NoThunks (f a) ⇒ NoThunks (Alt f a) | |
| (All SingleEraBlock xs, ∀ x. SingleEraBlock x ⇒ NoThunks (f x), KnownSymbol name) ⇒ NoThunks (LiftNamedNP name f xs) Source # | |
| (All SingleEraBlock xs, ∀ x. SingleEraBlock x ⇒ NoThunks (f x), KnownSymbol name) ⇒ NoThunks (LiftNamedNS name f xs) Source # | |
| NoThunks (f a) ⇒ NoThunks (WithBlockNo f a) Source # | |
| (IOLike m, HasHeader blk, LedgerSupportsProtocol blk, NoThunks (STM m ()), NoThunks (Header blk), NoThunks (STM m (Map peer (ChainSyncClientHandle m blk))), NoThunks (STM m (StrictSeq (peer, ChainSyncClientHandle m blk)))) ⇒ NoThunks (ChainSyncClientHandleCollection peer m blk) Source # | |
| StandardHash blk ⇒ NoThunks (FollowerState m blk b) Source # | |
| NoThunks (Iterator m blk b) Source # | |
| NoThunks (Index m blk h) Source # | |
| StandardHash blk ⇒ NoThunks (InternalState m blk h) Source # | |
| StandardHash blk ⇒ NoThunks (OpenState m blk h) Source # | |
| NoThunks (LedgerDB m l blk) Source # | |
| NoThunks (BackingStoreValueHandle m keys values) Source # | |
| (IOLike m, LedgerSupportsProtocol blk, NoThunks (l EmptyMK), NoThunks (TxIn l), NoThunks (TxOut l)) ⇒ NoThunks (ForkerEnv m l blk) Source # | |
| (IOLike m, LedgerSupportsProtocol blk, NoThunks (l EmptyMK), NoThunks (TxIn l), NoThunks (TxOut l)) ⇒ NoThunks (ForkerEnv m l blk) Source # | |
| NoThunks (Ticked (LedgerState (DualBlock m a)) mk) Source # | |
Defined in Ouroboros.Consensus.Ledger.Dual | |
| (NoThunks a, NoThunks b) ⇒ NoThunks (AnchoredSeq v a b) | |
Defined in Ouroboros.Network.AnchoredSeq | |
| NoThunks b ⇒ NoThunks (MeasuredWith v a b) | |
| (NoThunks machinecosts, Bounded fun, Enum fun) ⇒ NoThunks (MachineParameters machinecosts fun val) | |
| NoThunks a ⇒ NoThunks (K a b) Source # | |
| All (Compose NoThunks f) xs ⇒ NoThunks (NP f xs) | |
| All (Compose NoThunks f) xs ⇒ NoThunks (NS f xs) | |
| (NoThunks (kv k), NoThunks (vv v), Typeable kv, Typeable vv, Typeable k, Typeable v) ⇒ NoThunks (KVVector kv vv (k, v)) | |
| (NoThunks a, NoThunks b, NoThunks c) ⇒ NoThunks (a, b, c) | |
| (All SingleEraBlock xs, ∀ x. SingleEraBlock x ⇒ NoThunks (f x), ∀ x. SingleEraBlock x ⇒ NoThunks (g x), KnownSymbol name) ⇒ NoThunks (LiftNamedMismatch name f g xs) Source # | |
| (All SingleEraBlock xs, ∀ x. SingleEraBlock x ⇒ NoThunks (f x), ∀ x. SingleEraBlock x ⇒ NoThunks (g x), KnownSymbol name) ⇒ NoThunks (LiftNamedTelescope name f g xs) Source # | |
| NoThunks (TestInternals m l blk) Source # | |
Defined in Ouroboros.Consensus.Storage.LedgerDB.API | |
| NoThunks (BackingStore m keys values diff) Source # | |
| (Typeable f, Typeable blk) ⇒ NoThunks (SomeSecond (NestedCtxt f) blk) Source # | We can write a manual instance using the following quantified constraint: forall a. NoThunks (f blk a) However, this constraint would have to be propagated all the way up, which is
rather verbose and annoying (standalone deriving has to be used), hence we
use |
Defined in Ouroboros.Consensus.Block.NestedContent Methods noThunks ∷ Context → SomeSecond (NestedCtxt f) blk → IO (Maybe ThunkInfo) Source # wNoThunks ∷ Context → SomeSecond (NestedCtxt f) blk → IO (Maybe ThunkInfo) Source # showTypeOf ∷ Proxy (SomeSecond (NestedCtxt f) blk) → String Source # | |
| (All (Compose NoThunks f) xs, All (Compose NoThunks g) xs) ⇒ NoThunks (Mismatch f g xs) | |
| (All (Compose NoThunks g) xs, All (Compose NoThunks f) xs) ⇒ NoThunks (Telescope g f xs) | |
| (NoThunks (kv k), NoThunks (vv v), Typeable kv, Typeable vv, Typeable k, Typeable v) ⇒ NoThunks (VMap kv vv k v) | |
| (NoThunks a, NoThunks b, NoThunks c, NoThunks d) ⇒ NoThunks (a, b, c, d) | |
| NoThunks (Ticked (f a)) ⇒ NoThunks (((Ticked ∷ Type → Type) :.: f) a) Source # | |
| NoThunks (f y2 x2) ⇒ NoThunks (Flip f x2 y2) | |
| (NoThunks a, NoThunks b, NoThunks c, NoThunks d, NoThunks e) ⇒ NoThunks (a, b, c, d, e) | |
| (NoThunks a, NoThunks b, NoThunks c, NoThunks d, NoThunks e, NoThunks f) ⇒ NoThunks (a, b, c, d, e, f) | |
| (NoThunks a, NoThunks b, NoThunks c, NoThunks d, NoThunks e, NoThunks f, NoThunks g) ⇒ NoThunks (a, b, c, d, e, f, g) | |