{-# OPTIONS_GHC -Wno-orphans #-}

-- | This module exposes concrete instances to run a mockchain. There are 4 of
-- them :
--
-- - `DirectMockChain` exposes the minimal set of effects required to run a
--   mockchain, without the ability to branch or modify runs. Use this only if
--   you specifically want to disallow `Ltl` modifications.
--
-- - `StagedMockChain` exposes all the primitives required to run a mockchain,
--   with the addition of branching and `Ltl` modifications using tweaks. This
--   should be the environement to use in 99% of the cases.
--
-- - `ExtendedStagedMockChain` exposes the same primitives as `StagedMockChain`,
--   with an additional custom effect that can both be used in the main thread
--   and in the associated tweaks. This allows a mockchain run to depend on
--   arbitrary additional effects (if multiple effects are needed, this single
--   effect can be instantiated to a `Bundle` wrapping up those effects).
--
-- - `FullMockChain` exposes all the effects used to process a mockchain run,
--   including intermediate hidden in the other instances. This should only be
--   used when explicitly executing internal primitives of cooked, such as
--   balancing, is required.
module Cooked.MockChain.Instances
  ( -- * Direct, simple mockchain instance
    DirectEffs,
    DirectMockChain,

    -- * Staged mockchain instance with all effects
    FullTweakEffs,
    FullTweak,
    FullEffs,
    FullMockChain,

    -- * Staged mockchain instance with minimal effects
    StagedTweakEffs,
    StagedTweak,
    StagedEffs,
    StagedMockChain,

    -- * Staged mockchain instance with minimal effects and a custom effect
    InterpretAlone (..),
    ExtendedStagedTweakEffs,
    ExtendedStagedTweak,
    ExtendedStagedEffs,
    ExtendedStagedMockChain,
  )
where

import Cooked.Ltl
import Cooked.MockChain.Error
import Cooked.MockChain.Journal
import Cooked.MockChain.Log
import Cooked.MockChain.Misc
import Cooked.MockChain.Read
import Cooked.MockChain.Runnable
import Cooked.MockChain.State
import Cooked.MockChain.Tweak
import Cooked.MockChain.Write
import Ledger.Tx qualified as Ledger
import Polysemy
import Polysemy.Bundle
import Polysemy.Error
import Polysemy.Fail
import Polysemy.NonDet
import Polysemy.State
import Polysemy.Writer

-- | The most direct stack of effects to run a mockchain
type DirectEffs =
  '[ MockChainWrite,
     MockChainRead,
     MockChainMisc,
     Fail
   ]

-- | A mockchain computation built on top of the `DirectEffs` stack of effects
type DirectMockChain a = Sem DirectEffs a

instance RunnableMockChain DirectEffs where
  runMockChain :: forall a.
MockChainState -> Sem DirectEffs a -> [RawMockChainReturn a]
runMockChain MockChainState
mcst =
    (RawMockChainReturn a
-> [RawMockChainReturn a] -> [RawMockChainReturn a]
forall a. a -> [a] -> [a]
: [])
      (RawMockChainReturn a -> [RawMockChainReturn a])
-> (Sem DirectEffs a -> RawMockChainReturn a)
-> Sem DirectEffs a
-> [RawMockChainReturn a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sem '[] (RawMockChainReturn a) -> RawMockChainReturn a
forall a. Sem '[] a -> a
run
      (Sem '[] (RawMockChainReturn a) -> RawMockChainReturn a)
-> (Sem DirectEffs a -> Sem '[] (RawMockChainReturn a))
-> Sem DirectEffs a
-> RawMockChainReturn a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sem
  '[Writer MockChainJournal]
  (MockChainState, Either MockChainError a)
-> Sem '[] (RawMockChainReturn a)
forall o (r :: EffectRow) a.
Monoid o =>
Sem (Writer o : r) a -> Sem r (o, a)
runWriter
      (Sem
   '[Writer MockChainJournal]
   (MockChainState, Either MockChainError a)
 -> Sem '[] (RawMockChainReturn a))
-> (Sem DirectEffs a
    -> Sem
         '[Writer MockChainJournal]
         (MockChainState, Either MockChainError a))
-> Sem DirectEffs a
-> Sem '[] (RawMockChainReturn a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (MockChainLogEntry -> MockChainJournal)
-> Sem
     '[MockChainLog, Writer MockChainJournal]
     (MockChainState, Either MockChainError a)
-> Sem
     '[Writer MockChainJournal]
     (MockChainState, Either MockChainError a)
forall j (effs :: EffectRow) a.
Member (Writer j) effs =>
(MockChainLogEntry -> j)
-> Sem (MockChainLog : effs) a -> Sem effs a
runMockChainLog MockChainLogEntry -> MockChainJournal
fromLogEntry
      (Sem
   '[MockChainLog, Writer MockChainJournal]
   (MockChainState, Either MockChainError a)
 -> Sem
      '[Writer MockChainJournal]
      (MockChainState, Either MockChainError a))
-> (Sem DirectEffs a
    -> Sem
         '[MockChainLog, Writer MockChainJournal]
         (MockChainState, Either MockChainError a))
-> Sem DirectEffs a
-> Sem
     '[Writer MockChainJournal]
     (MockChainState, Either MockChainError a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MockChainState
-> Sem
     '[State MockChainState, MockChainLog, Writer MockChainJournal]
     (Either MockChainError a)
-> Sem
     '[MockChainLog, Writer MockChainJournal]
     (MockChainState, Either MockChainError a)
forall s (r :: EffectRow) a.
s -> Sem (State s : r) a -> Sem r (s, a)
runState MockChainState
mcst
      (Sem
   '[State MockChainState, MockChainLog, Writer MockChainJournal]
   (Either MockChainError a)
 -> Sem
      '[MockChainLog, Writer MockChainJournal]
      (MockChainState, Either MockChainError a))
-> (Sem DirectEffs a
    -> Sem
         '[State MockChainState, MockChainLog, Writer MockChainJournal]
         (Either MockChainError a))
-> Sem DirectEffs a
-> Sem
     '[MockChainLog, Writer MockChainJournal]
     (MockChainState, Either MockChainError a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sem
  '[Error MockChainError, State MockChainState, MockChainLog,
    Writer MockChainJournal]
  a
-> Sem
     '[State MockChainState, MockChainLog, Writer MockChainJournal]
     (Either MockChainError a)
forall e (r :: EffectRow) a.
Sem (Error e : r) a -> Sem r (Either e a)
runError
      (Sem
   '[Error MockChainError, State MockChainState, MockChainLog,
     Writer MockChainJournal]
   a
 -> Sem
      '[State MockChainState, MockChainLog, Writer MockChainJournal]
      (Either MockChainError a))
-> (Sem DirectEffs a
    -> Sem
         '[Error MockChainError, State MockChainState, MockChainLog,
           Writer MockChainJournal]
         a)
-> Sem DirectEffs a
-> Sem
     '[State MockChainState, MockChainLog, Writer MockChainJournal]
     (Either MockChainError a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sem
  '[Error ToCardanoError, Error MockChainError, State MockChainState,
    MockChainLog, Writer MockChainJournal]
  a
-> Sem
     '[Error MockChainError, State MockChainState, MockChainLog,
       Writer MockChainJournal]
     a
forall (effs :: EffectRow) a.
Member (Error MockChainError) effs =>
Sem (Error ToCardanoError : effs) a -> Sem effs a
runToCardanoErrorInMockChainError
      (Sem
   '[Error ToCardanoError, Error MockChainError, State MockChainState,
     MockChainLog, Writer MockChainJournal]
   a
 -> Sem
      '[Error MockChainError, State MockChainState, MockChainLog,
        Writer MockChainJournal]
      a)
-> (Sem DirectEffs a
    -> Sem
         '[Error ToCardanoError, Error MockChainError, State MockChainState,
           MockChainLog, Writer MockChainJournal]
         a)
-> Sem DirectEffs a
-> Sem
     '[Error MockChainError, State MockChainState, MockChainLog,
       Writer MockChainJournal]
     a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sem
  '[Fail, Error ToCardanoError, Error MockChainError,
    State MockChainState, MockChainLog, Writer MockChainJournal]
  a
-> Sem
     '[Error ToCardanoError, Error MockChainError, State MockChainState,
       MockChainLog, Writer MockChainJournal]
     a
forall (effs :: EffectRow) a.
Member (Error MockChainError) effs =>
Sem (Fail : effs) a -> Sem effs a
runFailInMockChainError
      (Sem
   '[Fail, Error ToCardanoError, Error MockChainError,
     State MockChainState, MockChainLog, Writer MockChainJournal]
   a
 -> Sem
      '[Error ToCardanoError, Error MockChainError, State MockChainState,
        MockChainLog, Writer MockChainJournal]
      a)
-> (Sem DirectEffs a
    -> Sem
         '[Fail, Error ToCardanoError, Error MockChainError,
           State MockChainState, MockChainLog, Writer MockChainJournal]
         a)
-> Sem DirectEffs a
-> Sem
     '[Error ToCardanoError, Error MockChainError, State MockChainState,
       MockChainLog, Writer MockChainJournal]
     a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String -> BuiltinByteString -> MockChainJournal)
-> ((PrettyCookedOpts -> DocCooked) -> MockChainJournal)
-> (String -> Bool -> MockChainJournal)
-> Sem
     '[MockChainMisc, Fail, Error ToCardanoError, Error MockChainError,
       State MockChainState, MockChainLog, Writer MockChainJournal]
     a
-> Sem
     '[Fail, Error ToCardanoError, Error MockChainError,
       State MockChainState, MockChainLog, Writer MockChainJournal]
     a
forall (effs :: EffectRow) a j.
Member (Writer j) effs =>
(String -> BuiltinByteString -> j)
-> ((PrettyCookedOpts -> DocCooked) -> j)
-> (String -> Bool -> j)
-> Sem (MockChainMisc : effs) a
-> Sem effs a
runMockChainMisc String -> BuiltinByteString -> MockChainJournal
fromAlias (PrettyCookedOpts -> DocCooked) -> MockChainJournal
fromNote String -> Bool -> MockChainJournal
fromAssert
      (Sem
   '[MockChainMisc, Fail, Error ToCardanoError, Error MockChainError,
     State MockChainState, MockChainLog, Writer MockChainJournal]
   a
 -> Sem
      '[Fail, Error ToCardanoError, Error MockChainError,
        State MockChainState, MockChainLog, Writer MockChainJournal]
      a)
-> (Sem DirectEffs a
    -> Sem
         '[MockChainMisc, Fail, Error ToCardanoError, Error MockChainError,
           State MockChainState, MockChainLog, Writer MockChainJournal]
         a)
-> Sem DirectEffs a
-> Sem
     '[Fail, Error ToCardanoError, Error MockChainError,
       State MockChainState, MockChainLog, Writer MockChainJournal]
     a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sem
  '[MockChainRead, MockChainMisc, Fail, Error ToCardanoError,
    Error MockChainError, State MockChainState, MockChainLog,
    Writer MockChainJournal]
  a
-> Sem
     '[MockChainMisc, Fail, Error ToCardanoError, Error MockChainError,
       State MockChainState, MockChainLog, Writer MockChainJournal]
     a
forall (effs :: EffectRow) a.
Members
  '[State MockChainState, Error ToCardanoError, Error MockChainError]
  effs =>
Sem (MockChainRead : effs) a -> Sem effs a
runMockChainRead
      (Sem
   '[MockChainRead, MockChainMisc, Fail, Error ToCardanoError,
     Error MockChainError, State MockChainState, MockChainLog,
     Writer MockChainJournal]
   a
 -> Sem
      '[MockChainMisc, Fail, Error ToCardanoError, Error MockChainError,
        State MockChainState, MockChainLog, Writer MockChainJournal]
      a)
-> (Sem DirectEffs a
    -> Sem
         '[MockChainRead, MockChainMisc, Fail, Error ToCardanoError,
           Error MockChainError, State MockChainState, MockChainLog,
           Writer MockChainJournal]
         a)
-> Sem DirectEffs a
-> Sem
     '[MockChainMisc, Fail, Error ToCardanoError, Error MockChainError,
       State MockChainState, MockChainLog, Writer MockChainJournal]
     a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sem
  '[MockChainWrite, MockChainRead, MockChainMisc, Fail,
    Error ToCardanoError, Error MockChainError, State MockChainState,
    MockChainLog, Writer MockChainJournal]
  a
-> Sem
     '[MockChainRead, MockChainMisc, Fail, Error ToCardanoError,
       Error MockChainError, State MockChainState, MockChainLog,
       Writer MockChainJournal]
     a
forall (effs :: EffectRow) a.
Members
  '[State MockChainState, Error ToCardanoError, Error MockChainError,
    MockChainLog, MockChainRead, Fail]
  effs =>
Sem (MockChainWrite : effs) a -> Sem effs a
runMockChainWrite
      (Sem
   '[MockChainWrite, MockChainRead, MockChainMisc, Fail,
     Error ToCardanoError, Error MockChainError, State MockChainState,
     MockChainLog, Writer MockChainJournal]
   a
 -> Sem
      '[MockChainRead, MockChainMisc, Fail, Error ToCardanoError,
        Error MockChainError, State MockChainState, MockChainLog,
        Writer MockChainJournal]
      a)
-> (Sem DirectEffs a
    -> Sem
         '[MockChainWrite, MockChainRead, MockChainMisc, Fail,
           Error ToCardanoError, Error MockChainError, State MockChainState,
           MockChainLog, Writer MockChainJournal]
         a)
-> Sem DirectEffs a
-> Sem
     '[MockChainRead, MockChainMisc, Fail, Error ToCardanoError,
       Error MockChainError, State MockChainState, MockChainLog,
       Writer MockChainJournal]
     a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (index :: Nat) (inserted :: EffectRow) (head :: EffectRow)
       (oldTail :: EffectRow) (tail :: EffectRow) (old :: EffectRow)
       (full :: EffectRow) a.
(ListOfLength index head, WhenStuck index InsertAtUnprovidedIndex,
 old ~ Append head oldTail, tail ~ Append inserted oldTail,
 full ~ Append head tail,
 InsertAtIndex index head tail oldTail full inserted) =>
Sem old a -> Sem full a
insertAt @4
        @[ Error Ledger.ToCardanoError,
           Error MockChainError,
           State MockChainState,
           MockChainLog,
           Writer MockChainJournal
         ]

-- | A stack of effects aimed at being used as modifications for a
-- `FullMockChain` computation
type FullTweakEffs =
  '[ MockChainMisc,
     MockChainRead,
     Fail,
     Error Ledger.ToCardanoError,
     Error MockChainError,
     State MockChainState,
     MockChainLog,
     Writer MockChainJournal
   ]

-- | A tweak computation based on the `FullTweakEffs` stack of effects
type FullTweak a = TypedTweak FullTweakEffs a

-- | A stack of effects which allows everything allowed by `StagedEffs` with the
-- addition of all the lower level effects required to interpret it.
type FullEffs =
  '[ ModifyGlobally (UntypedTweak FullTweakEffs),
     MockChainWrite,
     ModifyLocally (UntypedTweak FullTweakEffs),
     State [Ltl (UntypedTweak FullTweakEffs)],
     MockChainMisc,
     MockChainRead,
     Fail,
     Error Ledger.ToCardanoError,
     Error MockChainError,
     State MockChainState,
     MockChainLog,
     Writer MockChainJournal,
     NonDet
   ]

-- | A mockchain computation built on top of the `FullEffs` stack of effects
type FullMockChain a = Sem FullEffs a

instance RunnableMockChain FullEffs where
  runMockChain :: forall a.
MockChainState -> Sem FullEffs a -> [RawMockChainReturn a]
runMockChain MockChainState
mcst =
    Sem '[] [RawMockChainReturn a] -> [RawMockChainReturn a]
forall a. Sem '[] a -> a
run
      (Sem '[] [RawMockChainReturn a] -> [RawMockChainReturn a])
-> (Sem FullEffs a -> Sem '[] [RawMockChainReturn a])
-> Sem FullEffs a
-> [RawMockChainReturn a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sem '[NonDet] (RawMockChainReturn a)
-> Sem '[] [RawMockChainReturn a]
forall (f :: * -> *) (r :: EffectRow) a.
Alternative f =>
Sem (NonDet : r) a -> Sem r (f a)
runNonDet
      (Sem '[NonDet] (RawMockChainReturn a)
 -> Sem '[] [RawMockChainReturn a])
-> (Sem FullEffs a -> Sem '[NonDet] (RawMockChainReturn a))
-> Sem FullEffs a
-> Sem '[] [RawMockChainReturn a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sem
  '[Writer MockChainJournal, NonDet]
  (MockChainState, Either MockChainError a)
-> Sem '[NonDet] (RawMockChainReturn a)
forall o (r :: EffectRow) a.
Monoid o =>
Sem (Writer o : r) a -> Sem r (o, a)
runWriter
      (Sem
   '[Writer MockChainJournal, NonDet]
   (MockChainState, Either MockChainError a)
 -> Sem '[NonDet] (RawMockChainReturn a))
-> (Sem FullEffs a
    -> Sem
         '[Writer MockChainJournal, NonDet]
         (MockChainState, Either MockChainError a))
-> Sem FullEffs a
-> Sem '[NonDet] (RawMockChainReturn a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (MockChainLogEntry -> MockChainJournal)
-> Sem
     '[MockChainLog, Writer MockChainJournal, NonDet]
     (MockChainState, Either MockChainError a)
-> Sem
     '[Writer MockChainJournal, NonDet]
     (MockChainState, Either MockChainError a)
forall j (effs :: EffectRow) a.
Member (Writer j) effs =>
(MockChainLogEntry -> j)
-> Sem (MockChainLog : effs) a -> Sem effs a
runMockChainLog MockChainLogEntry -> MockChainJournal
fromLogEntry
      (Sem
   '[MockChainLog, Writer MockChainJournal, NonDet]
   (MockChainState, Either MockChainError a)
 -> Sem
      '[Writer MockChainJournal, NonDet]
      (MockChainState, Either MockChainError a))
-> (Sem FullEffs a
    -> Sem
         '[MockChainLog, Writer MockChainJournal, NonDet]
         (MockChainState, Either MockChainError a))
-> Sem FullEffs a
-> Sem
     '[Writer MockChainJournal, NonDet]
     (MockChainState, Either MockChainError a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MockChainState
-> Sem
     '[State MockChainState, MockChainLog, Writer MockChainJournal,
       NonDet]
     (Either MockChainError a)
-> Sem
     '[MockChainLog, Writer MockChainJournal, NonDet]
     (MockChainState, Either MockChainError a)
forall s (r :: EffectRow) a.
s -> Sem (State s : r) a -> Sem r (s, a)
runState MockChainState
mcst
      (Sem
   '[State MockChainState, MockChainLog, Writer MockChainJournal,
     NonDet]
   (Either MockChainError a)
 -> Sem
      '[MockChainLog, Writer MockChainJournal, NonDet]
      (MockChainState, Either MockChainError a))
-> (Sem FullEffs a
    -> Sem
         '[State MockChainState, MockChainLog, Writer MockChainJournal,
           NonDet]
         (Either MockChainError a))
-> Sem FullEffs a
-> Sem
     '[MockChainLog, Writer MockChainJournal, NonDet]
     (MockChainState, Either MockChainError a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sem
  '[Error MockChainError, State MockChainState, MockChainLog,
    Writer MockChainJournal, NonDet]
  a
-> Sem
     '[State MockChainState, MockChainLog, Writer MockChainJournal,
       NonDet]
     (Either MockChainError a)
forall e (r :: EffectRow) a.
Sem (Error e : r) a -> Sem r (Either e a)
runError
      (Sem
   '[Error MockChainError, State MockChainState, MockChainLog,
     Writer MockChainJournal, NonDet]
   a
 -> Sem
      '[State MockChainState, MockChainLog, Writer MockChainJournal,
        NonDet]
      (Either MockChainError a))
-> (Sem FullEffs a
    -> Sem
         '[Error MockChainError, State MockChainState, MockChainLog,
           Writer MockChainJournal, NonDet]
         a)
-> Sem FullEffs a
-> Sem
     '[State MockChainState, MockChainLog, Writer MockChainJournal,
       NonDet]
     (Either MockChainError a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sem
  '[Error ToCardanoError, Error MockChainError, State MockChainState,
    MockChainLog, Writer MockChainJournal, NonDet]
  a
-> Sem
     '[Error MockChainError, State MockChainState, MockChainLog,
       Writer MockChainJournal, NonDet]
     a
forall (effs :: EffectRow) a.
Member (Error MockChainError) effs =>
Sem (Error ToCardanoError : effs) a -> Sem effs a
runToCardanoErrorInMockChainError
      (Sem
   '[Error ToCardanoError, Error MockChainError, State MockChainState,
     MockChainLog, Writer MockChainJournal, NonDet]
   a
 -> Sem
      '[Error MockChainError, State MockChainState, MockChainLog,
        Writer MockChainJournal, NonDet]
      a)
-> (Sem FullEffs a
    -> Sem
         '[Error ToCardanoError, Error MockChainError, State MockChainState,
           MockChainLog, Writer MockChainJournal, NonDet]
         a)
-> Sem FullEffs a
-> Sem
     '[Error MockChainError, State MockChainState, MockChainLog,
       Writer MockChainJournal, NonDet]
     a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sem
  '[Fail, Error ToCardanoError, Error MockChainError,
    State MockChainState, MockChainLog, Writer MockChainJournal,
    NonDet]
  a
-> Sem
     '[Error ToCardanoError, Error MockChainError, State MockChainState,
       MockChainLog, Writer MockChainJournal, NonDet]
     a
forall (effs :: EffectRow) a.
Member (Error MockChainError) effs =>
Sem (Fail : effs) a -> Sem effs a
runFailInMockChainError
      (Sem
   '[Fail, Error ToCardanoError, Error MockChainError,
     State MockChainState, MockChainLog, Writer MockChainJournal,
     NonDet]
   a
 -> Sem
      '[Error ToCardanoError, Error MockChainError, State MockChainState,
        MockChainLog, Writer MockChainJournal, NonDet]
      a)
-> (Sem FullEffs a
    -> Sem
         '[Fail, Error ToCardanoError, Error MockChainError,
           State MockChainState, MockChainLog, Writer MockChainJournal,
           NonDet]
         a)
-> Sem FullEffs a
-> Sem
     '[Error ToCardanoError, Error MockChainError, State MockChainState,
       MockChainLog, Writer MockChainJournal, NonDet]
     a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sem
  '[MockChainRead, Fail, Error ToCardanoError, Error MockChainError,
    State MockChainState, MockChainLog, Writer MockChainJournal,
    NonDet]
  a
-> Sem
     '[Fail, Error ToCardanoError, Error MockChainError,
       State MockChainState, MockChainLog, Writer MockChainJournal,
       NonDet]
     a
forall (effs :: EffectRow) a.
Members
  '[State MockChainState, Error ToCardanoError, Error MockChainError]
  effs =>
Sem (MockChainRead : effs) a -> Sem effs a
runMockChainRead
      (Sem
   '[MockChainRead, Fail, Error ToCardanoError, Error MockChainError,
     State MockChainState, MockChainLog, Writer MockChainJournal,
     NonDet]
   a
 -> Sem
      '[Fail, Error ToCardanoError, Error MockChainError,
        State MockChainState, MockChainLog, Writer MockChainJournal,
        NonDet]
      a)
-> (Sem FullEffs a
    -> Sem
         '[MockChainRead, Fail, Error ToCardanoError, Error MockChainError,
           State MockChainState, MockChainLog, Writer MockChainJournal,
           NonDet]
         a)
-> Sem FullEffs a
-> Sem
     '[Fail, Error ToCardanoError, Error MockChainError,
       State MockChainState, MockChainLog, Writer MockChainJournal,
       NonDet]
     a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String -> BuiltinByteString -> MockChainJournal)
-> ((PrettyCookedOpts -> DocCooked) -> MockChainJournal)
-> (String -> Bool -> MockChainJournal)
-> Sem
     '[MockChainMisc, MockChainRead, Fail, Error ToCardanoError,
       Error MockChainError, State MockChainState, MockChainLog,
       Writer MockChainJournal, NonDet]
     a
-> Sem
     '[MockChainRead, Fail, Error ToCardanoError, Error MockChainError,
       State MockChainState, MockChainLog, Writer MockChainJournal,
       NonDet]
     a
forall (effs :: EffectRow) a j.
Member (Writer j) effs =>
(String -> BuiltinByteString -> j)
-> ((PrettyCookedOpts -> DocCooked) -> j)
-> (String -> Bool -> j)
-> Sem (MockChainMisc : effs) a
-> Sem effs a
runMockChainMisc String -> BuiltinByteString -> MockChainJournal
fromAlias (PrettyCookedOpts -> DocCooked) -> MockChainJournal
fromNote String -> Bool -> MockChainJournal
fromAssert
      (Sem
   '[MockChainMisc, MockChainRead, Fail, Error ToCardanoError,
     Error MockChainError, State MockChainState, MockChainLog,
     Writer MockChainJournal, NonDet]
   a
 -> Sem
      '[MockChainRead, Fail, Error ToCardanoError, Error MockChainError,
        State MockChainState, MockChainLog, Writer MockChainJournal,
        NonDet]
      a)
-> (Sem FullEffs a
    -> Sem
         '[MockChainMisc, MockChainRead, Fail, Error ToCardanoError,
           Error MockChainError, State MockChainState, MockChainLog,
           Writer MockChainJournal, NonDet]
         a)
-> Sem FullEffs a
-> Sem
     '[MockChainRead, Fail, Error ToCardanoError, Error MockChainError,
       State MockChainState, MockChainLog, Writer MockChainJournal,
       NonDet]
     a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Ltl (UntypedTweak FullTweakEffs)]
-> Sem
     '[State [Ltl (UntypedTweak FullTweakEffs)], MockChainMisc,
       MockChainRead, Fail, Error ToCardanoError, Error MockChainError,
       State MockChainState, MockChainLog, Writer MockChainJournal,
       NonDet]
     a
-> Sem
     '[MockChainMisc, MockChainRead, Fail, Error ToCardanoError,
       Error MockChainError, State MockChainState, MockChainLog,
       Writer MockChainJournal, NonDet]
     a
forall s (r :: EffectRow) a. s -> Sem (State s : r) a -> Sem r a
evalState []
      (Sem
   '[State [Ltl (UntypedTweak FullTweakEffs)], MockChainMisc,
     MockChainRead, Fail, Error ToCardanoError, Error MockChainError,
     State MockChainState, MockChainLog, Writer MockChainJournal,
     NonDet]
   a
 -> Sem
      '[MockChainMisc, MockChainRead, Fail, Error ToCardanoError,
        Error MockChainError, State MockChainState, MockChainLog,
        Writer MockChainJournal, NonDet]
      a)
-> (Sem FullEffs a
    -> Sem
         '[State [Ltl (UntypedTweak FullTweakEffs)], MockChainMisc,
           MockChainRead, Fail, Error ToCardanoError, Error MockChainError,
           State MockChainState, MockChainLog, Writer MockChainJournal,
           NonDet]
         a)
-> Sem FullEffs a
-> Sem
     '[MockChainMisc, MockChainRead, Fail, Error ToCardanoError,
       Error MockChainError, State MockChainState, MockChainLog,
       Writer MockChainJournal, NonDet]
     a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sem
  '[ModifyLocally (UntypedTweak FullTweakEffs),
    State [Ltl (UntypedTweak FullTweakEffs)], MockChainMisc,
    MockChainRead, Fail, Error ToCardanoError, Error MockChainError,
    State MockChainState, MockChainLog, Writer MockChainJournal,
    NonDet]
  a
-> Sem
     '[State [Ltl (UntypedTweak FullTweakEffs)], MockChainMisc,
       MockChainRead, Fail, Error ToCardanoError, Error MockChainError,
       State MockChainState, MockChainLog, Writer MockChainJournal,
       NonDet]
     a
forall modification (effs :: EffectRow) a.
Members '[State [Ltl modification], NonDet] effs =>
Sem (ModifyLocally modification : effs) a -> Sem effs a
runModifyLocally
      (Sem
   '[ModifyLocally (UntypedTweak FullTweakEffs),
     State [Ltl (UntypedTweak FullTweakEffs)], MockChainMisc,
     MockChainRead, Fail, Error ToCardanoError, Error MockChainError,
     State MockChainState, MockChainLog, Writer MockChainJournal,
     NonDet]
   a
 -> Sem
      '[State [Ltl (UntypedTweak FullTweakEffs)], MockChainMisc,
        MockChainRead, Fail, Error ToCardanoError, Error MockChainError,
        State MockChainState, MockChainLog, Writer MockChainJournal,
        NonDet]
      a)
-> (Sem FullEffs a
    -> Sem
         '[ModifyLocally (UntypedTweak FullTweakEffs),
           State [Ltl (UntypedTweak FullTweakEffs)], MockChainMisc,
           MockChainRead, Fail, Error ToCardanoError, Error MockChainError,
           State MockChainState, MockChainLog, Writer MockChainJournal,
           NonDet]
         a)
-> Sem FullEffs a
-> Sem
     '[State [Ltl (UntypedTweak FullTweakEffs)], MockChainMisc,
       MockChainRead, Fail, Error ToCardanoError, Error MockChainError,
       State MockChainState, MockChainLog, Writer MockChainJournal,
       NonDet]
     a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sem
  '[MockChainWrite, ModifyLocally (UntypedTweak FullTweakEffs),
    State [Ltl (UntypedTweak FullTweakEffs)], MockChainMisc,
    MockChainRead, Fail, Error ToCardanoError, Error MockChainError,
    State MockChainState, MockChainLog, Writer MockChainJournal,
    NonDet]
  a
-> Sem
     '[ModifyLocally (UntypedTweak FullTweakEffs),
       State [Ltl (UntypedTweak FullTweakEffs)], MockChainMisc,
       MockChainRead, Fail, Error ToCardanoError, Error MockChainError,
       State MockChainState, MockChainLog, Writer MockChainJournal,
       NonDet]
     a
forall (effs :: EffectRow) a.
Members
  '[State MockChainState, Error ToCardanoError, Error MockChainError,
    MockChainLog, MockChainRead, Fail]
  effs =>
Sem (MockChainWrite : effs) a -> Sem effs a
runMockChainWrite
      (Sem
   '[MockChainWrite, ModifyLocally (UntypedTweak FullTweakEffs),
     State [Ltl (UntypedTweak FullTweakEffs)], MockChainMisc,
     MockChainRead, Fail, Error ToCardanoError, Error MockChainError,
     State MockChainState, MockChainLog, Writer MockChainJournal,
     NonDet]
   a
 -> Sem
      '[ModifyLocally (UntypedTweak FullTweakEffs),
        State [Ltl (UntypedTweak FullTweakEffs)], MockChainMisc,
        MockChainRead, Fail, Error ToCardanoError, Error MockChainError,
        State MockChainState, MockChainLog, Writer MockChainJournal,
        NonDet]
      a)
-> (Sem FullEffs a
    -> Sem
         '[MockChainWrite, ModifyLocally (UntypedTweak FullTweakEffs),
           State [Ltl (UntypedTweak FullTweakEffs)], MockChainMisc,
           MockChainRead, Fail, Error ToCardanoError, Error MockChainError,
           State MockChainState, MockChainLog, Writer MockChainJournal,
           NonDet]
         a)
-> Sem FullEffs a
-> Sem
     '[ModifyLocally (UntypedTweak FullTweakEffs),
       State [Ltl (UntypedTweak FullTweakEffs)], MockChainMisc,
       MockChainRead, Fail, Error ToCardanoError, Error MockChainError,
       State MockChainState, MockChainLog, Writer MockChainJournal,
       NonDet]
     a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (tweakEffs :: EffectRow) (effs :: EffectRow) a.
(Members '[ModifyLocally (UntypedTweak tweakEffs), NonDet] effs,
 Subsume tweakEffs effs) =>
Sem (MockChainWrite : effs) a -> Sem (MockChainWrite : effs) a
reinterpretMockChainWriteWithTweak @FullTweakEffs
      (Sem
   '[MockChainWrite, ModifyLocally (UntypedTweak FullTweakEffs),
     State [Ltl (UntypedTweak FullTweakEffs)], MockChainMisc,
     MockChainRead, Fail, Error ToCardanoError, Error MockChainError,
     State MockChainState, MockChainLog, Writer MockChainJournal,
     NonDet]
   a
 -> Sem
      '[MockChainWrite, ModifyLocally (UntypedTweak FullTweakEffs),
        State [Ltl (UntypedTweak FullTweakEffs)], MockChainMisc,
        MockChainRead, Fail, Error ToCardanoError, Error MockChainError,
        State MockChainState, MockChainLog, Writer MockChainJournal,
        NonDet]
      a)
-> (Sem FullEffs a
    -> Sem
         '[MockChainWrite, ModifyLocally (UntypedTweak FullTweakEffs),
           State [Ltl (UntypedTweak FullTweakEffs)], MockChainMisc,
           MockChainRead, Fail, Error ToCardanoError, Error MockChainError,
           State MockChainState, MockChainLog, Writer MockChainJournal,
           NonDet]
         a)
-> Sem FullEffs a
-> Sem
     '[MockChainWrite, ModifyLocally (UntypedTweak FullTweakEffs),
       State [Ltl (UntypedTweak FullTweakEffs)], MockChainMisc,
       MockChainRead, Fail, Error ToCardanoError, Error MockChainError,
       State MockChainState, MockChainLog, Writer MockChainJournal,
       NonDet]
     a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sem FullEffs a
-> Sem
     '[MockChainWrite, ModifyLocally (UntypedTweak FullTweakEffs),
       State [Ltl (UntypedTweak FullTweakEffs)], MockChainMisc,
       MockChainRead, Fail, Error ToCardanoError, Error MockChainError,
       State MockChainState, MockChainLog, Writer MockChainJournal,
       NonDet]
     a
forall mod (effs :: EffectRow) a.
Members '[State [Ltl mod], NonDet] effs =>
Sem (ModifyGlobally mod : effs) a -> Sem effs a
runModifyGlobally

-- | A stack of effects aimed at being used as modifications for a
-- `StagedMockChain` computation
type ExtendedStagedTweakEffs extraEff =
  '[ extraEff,
     MockChainMisc,
     MockChainRead,
     Fail
   ]

-- | A tweak computation based on the `ExtendedStagedTweakEffs` stack of effects
type ExtendedStagedTweak extraEff a = TypedTweak (ExtendedStagedTweakEffs extraEff) a

-- | A stack of effects which allows everything allowed by `DirectEffs` with the
-- addition of branching and `Ltl` modification with tweaks living in
-- `ExtendedStagedTweakEffs`
type ExtendedStagedEffs extraEff =
  '[ ModifyGlobally (UntypedTweak (ExtendedStagedTweakEffs extraEff)),
     MockChainWrite,
     extraEff,
     MockChainMisc,
     MockChainRead,
     Fail,
     NonDet
   ]

-- | A mockchain computation built on top of the `ExtendedStagedEffs` stack of
-- effects
type ExtendedStagedMockChain extraEff a = Sem (ExtendedStagedEffs extraEff) a

-- | The class of effects that can be interpreted on their own on top of an
-- arbitrary stack of effects
class InterpretAlone eff where
  runInterpretAlone :: Sem (eff : effs) a -> Sem effs a

instance (InterpretAlone extraEff) => RunnableMockChain (ExtendedStagedEffs extraEff) where
  runMockChain :: forall a.
MockChainState
-> Sem (ExtendedStagedEffs extraEff) a -> [RawMockChainReturn a]
runMockChain MockChainState
mcst =
    Sem '[] [RawMockChainReturn a] -> [RawMockChainReturn a]
forall a. Sem '[] a -> a
run
      (Sem '[] [RawMockChainReturn a] -> [RawMockChainReturn a])
-> (Sem (ExtendedStagedEffs extraEff) a
    -> Sem '[] [RawMockChainReturn a])
-> Sem (ExtendedStagedEffs extraEff) a
-> [RawMockChainReturn a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sem '[NonDet] (RawMockChainReturn a)
-> Sem '[] [RawMockChainReturn a]
forall (f :: * -> *) (r :: EffectRow) a.
Alternative f =>
Sem (NonDet : r) a -> Sem r (f a)
runNonDet
      (Sem '[NonDet] (RawMockChainReturn a)
 -> Sem '[] [RawMockChainReturn a])
-> (Sem (ExtendedStagedEffs extraEff) a
    -> Sem '[NonDet] (RawMockChainReturn a))
-> Sem (ExtendedStagedEffs extraEff) a
-> Sem '[] [RawMockChainReturn a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sem
  '[Writer MockChainJournal, NonDet]
  (MockChainState, Either MockChainError a)
-> Sem '[NonDet] (RawMockChainReturn a)
forall o (r :: EffectRow) a.
Monoid o =>
Sem (Writer o : r) a -> Sem r (o, a)
runWriter
      (Sem
   '[Writer MockChainJournal, NonDet]
   (MockChainState, Either MockChainError a)
 -> Sem '[NonDet] (RawMockChainReturn a))
-> (Sem (ExtendedStagedEffs extraEff) a
    -> Sem
         '[Writer MockChainJournal, NonDet]
         (MockChainState, Either MockChainError a))
-> Sem (ExtendedStagedEffs extraEff) a
-> Sem '[NonDet] (RawMockChainReturn a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (MockChainLogEntry -> MockChainJournal)
-> Sem
     '[MockChainLog, Writer MockChainJournal, NonDet]
     (MockChainState, Either MockChainError a)
-> Sem
     '[Writer MockChainJournal, NonDet]
     (MockChainState, Either MockChainError a)
forall j (effs :: EffectRow) a.
Member (Writer j) effs =>
(MockChainLogEntry -> j)
-> Sem (MockChainLog : effs) a -> Sem effs a
runMockChainLog MockChainLogEntry -> MockChainJournal
fromLogEntry
      (Sem
   '[MockChainLog, Writer MockChainJournal, NonDet]
   (MockChainState, Either MockChainError a)
 -> Sem
      '[Writer MockChainJournal, NonDet]
      (MockChainState, Either MockChainError a))
-> (Sem (ExtendedStagedEffs extraEff) a
    -> Sem
         '[MockChainLog, Writer MockChainJournal, NonDet]
         (MockChainState, Either MockChainError a))
-> Sem (ExtendedStagedEffs extraEff) a
-> Sem
     '[Writer MockChainJournal, NonDet]
     (MockChainState, Either MockChainError a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MockChainState
-> Sem
     '[State MockChainState, MockChainLog, Writer MockChainJournal,
       NonDet]
     (Either MockChainError a)
-> Sem
     '[MockChainLog, Writer MockChainJournal, NonDet]
     (MockChainState, Either MockChainError a)
forall s (r :: EffectRow) a.
s -> Sem (State s : r) a -> Sem r (s, a)
runState MockChainState
mcst
      (Sem
   '[State MockChainState, MockChainLog, Writer MockChainJournal,
     NonDet]
   (Either MockChainError a)
 -> Sem
      '[MockChainLog, Writer MockChainJournal, NonDet]
      (MockChainState, Either MockChainError a))
-> (Sem (ExtendedStagedEffs extraEff) a
    -> Sem
         '[State MockChainState, MockChainLog, Writer MockChainJournal,
           NonDet]
         (Either MockChainError a))
-> Sem (ExtendedStagedEffs extraEff) a
-> Sem
     '[MockChainLog, Writer MockChainJournal, NonDet]
     (MockChainState, Either MockChainError a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sem
  '[Error MockChainError, State MockChainState, MockChainLog,
    Writer MockChainJournal, NonDet]
  a
-> Sem
     '[State MockChainState, MockChainLog, Writer MockChainJournal,
       NonDet]
     (Either MockChainError a)
forall e (r :: EffectRow) a.
Sem (Error e : r) a -> Sem r (Either e a)
runError
      (Sem
   '[Error MockChainError, State MockChainState, MockChainLog,
     Writer MockChainJournal, NonDet]
   a
 -> Sem
      '[State MockChainState, MockChainLog, Writer MockChainJournal,
        NonDet]
      (Either MockChainError a))
-> (Sem (ExtendedStagedEffs extraEff) a
    -> Sem
         '[Error MockChainError, State MockChainState, MockChainLog,
           Writer MockChainJournal, NonDet]
         a)
-> Sem (ExtendedStagedEffs extraEff) a
-> Sem
     '[State MockChainState, MockChainLog, Writer MockChainJournal,
       NonDet]
     (Either MockChainError a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sem
  '[Error ToCardanoError, Error MockChainError, State MockChainState,
    MockChainLog, Writer MockChainJournal, NonDet]
  a
-> Sem
     '[Error MockChainError, State MockChainState, MockChainLog,
       Writer MockChainJournal, NonDet]
     a
forall (effs :: EffectRow) a.
Member (Error MockChainError) effs =>
Sem (Error ToCardanoError : effs) a -> Sem effs a
runToCardanoErrorInMockChainError
      (Sem
   '[Error ToCardanoError, Error MockChainError, State MockChainState,
     MockChainLog, Writer MockChainJournal, NonDet]
   a
 -> Sem
      '[Error MockChainError, State MockChainState, MockChainLog,
        Writer MockChainJournal, NonDet]
      a)
-> (Sem (ExtendedStagedEffs extraEff) a
    -> Sem
         '[Error ToCardanoError, Error MockChainError, State MockChainState,
           MockChainLog, Writer MockChainJournal, NonDet]
         a)
-> Sem (ExtendedStagedEffs extraEff) a
-> Sem
     '[Error MockChainError, State MockChainState, MockChainLog,
       Writer MockChainJournal, NonDet]
     a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sem
  '[Fail, Error ToCardanoError, Error MockChainError,
    State MockChainState, MockChainLog, Writer MockChainJournal,
    NonDet]
  a
-> Sem
     '[Error ToCardanoError, Error MockChainError, State MockChainState,
       MockChainLog, Writer MockChainJournal, NonDet]
     a
forall (effs :: EffectRow) a.
Member (Error MockChainError) effs =>
Sem (Fail : effs) a -> Sem effs a
runFailInMockChainError
      (Sem
   '[Fail, Error ToCardanoError, Error MockChainError,
     State MockChainState, MockChainLog, Writer MockChainJournal,
     NonDet]
   a
 -> Sem
      '[Error ToCardanoError, Error MockChainError, State MockChainState,
        MockChainLog, Writer MockChainJournal, NonDet]
      a)
-> (Sem (ExtendedStagedEffs extraEff) a
    -> Sem
         '[Fail, Error ToCardanoError, Error MockChainError,
           State MockChainState, MockChainLog, Writer MockChainJournal,
           NonDet]
         a)
-> Sem (ExtendedStagedEffs extraEff) a
-> Sem
     '[Error ToCardanoError, Error MockChainError, State MockChainState,
       MockChainLog, Writer MockChainJournal, NonDet]
     a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sem
  '[MockChainRead, Fail, Error ToCardanoError, Error MockChainError,
    State MockChainState, MockChainLog, Writer MockChainJournal,
    NonDet]
  a
-> Sem
     '[Fail, Error ToCardanoError, Error MockChainError,
       State MockChainState, MockChainLog, Writer MockChainJournal,
       NonDet]
     a
forall (effs :: EffectRow) a.
Members
  '[State MockChainState, Error ToCardanoError, Error MockChainError]
  effs =>
Sem (MockChainRead : effs) a -> Sem effs a
runMockChainRead
      (Sem
   '[MockChainRead, Fail, Error ToCardanoError, Error MockChainError,
     State MockChainState, MockChainLog, Writer MockChainJournal,
     NonDet]
   a
 -> Sem
      '[Fail, Error ToCardanoError, Error MockChainError,
        State MockChainState, MockChainLog, Writer MockChainJournal,
        NonDet]
      a)
-> (Sem (ExtendedStagedEffs extraEff) a
    -> Sem
         '[MockChainRead, Fail, Error ToCardanoError, Error MockChainError,
           State MockChainState, MockChainLog, Writer MockChainJournal,
           NonDet]
         a)
-> Sem (ExtendedStagedEffs extraEff) a
-> Sem
     '[Fail, Error ToCardanoError, Error MockChainError,
       State MockChainState, MockChainLog, Writer MockChainJournal,
       NonDet]
     a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String -> BuiltinByteString -> MockChainJournal)
-> ((PrettyCookedOpts -> DocCooked) -> MockChainJournal)
-> (String -> Bool -> MockChainJournal)
-> Sem
     '[MockChainMisc, MockChainRead, Fail, Error ToCardanoError,
       Error MockChainError, State MockChainState, MockChainLog,
       Writer MockChainJournal, NonDet]
     a
-> Sem
     '[MockChainRead, Fail, Error ToCardanoError, Error MockChainError,
       State MockChainState, MockChainLog, Writer MockChainJournal,
       NonDet]
     a
forall (effs :: EffectRow) a j.
Member (Writer j) effs =>
(String -> BuiltinByteString -> j)
-> ((PrettyCookedOpts -> DocCooked) -> j)
-> (String -> Bool -> j)
-> Sem (MockChainMisc : effs) a
-> Sem effs a
runMockChainMisc String -> BuiltinByteString -> MockChainJournal
fromAlias (PrettyCookedOpts -> DocCooked) -> MockChainJournal
fromNote String -> Bool -> MockChainJournal
fromAssert
      (Sem
   '[MockChainMisc, MockChainRead, Fail, Error ToCardanoError,
     Error MockChainError, State MockChainState, MockChainLog,
     Writer MockChainJournal, NonDet]
   a
 -> Sem
      '[MockChainRead, Fail, Error ToCardanoError, Error MockChainError,
        State MockChainState, MockChainLog, Writer MockChainJournal,
        NonDet]
      a)
-> (Sem (ExtendedStagedEffs extraEff) a
    -> Sem
         '[MockChainMisc, MockChainRead, Fail, Error ToCardanoError,
           Error MockChainError, State MockChainState, MockChainLog,
           Writer MockChainJournal, NonDet]
         a)
-> Sem (ExtendedStagedEffs extraEff) a
-> Sem
     '[MockChainRead, Fail, Error ToCardanoError, Error MockChainError,
       State MockChainState, MockChainLog, Writer MockChainJournal,
       NonDet]
     a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sem
  '[extraEff, MockChainMisc, MockChainRead, Fail,
    Error ToCardanoError, Error MockChainError, State MockChainState,
    MockChainLog, Writer MockChainJournal, NonDet]
  a
-> Sem
     '[MockChainMisc, MockChainRead, Fail, Error ToCardanoError,
       Error MockChainError, State MockChainState, MockChainLog,
       Writer MockChainJournal, NonDet]
     a
forall (effs :: EffectRow) a. Sem (extraEff : effs) a -> Sem effs a
forall (eff :: (* -> *) -> * -> *) (effs :: EffectRow) a.
InterpretAlone eff =>
Sem (eff : effs) a -> Sem effs a
runInterpretAlone
      (Sem
   '[extraEff, MockChainMisc, MockChainRead, Fail,
     Error ToCardanoError, Error MockChainError, State MockChainState,
     MockChainLog, Writer MockChainJournal, NonDet]
   a
 -> Sem
      '[MockChainMisc, MockChainRead, Fail, Error ToCardanoError,
        Error MockChainError, State MockChainState, MockChainLog,
        Writer MockChainJournal, NonDet]
      a)
-> (Sem (ExtendedStagedEffs extraEff) a
    -> Sem
         '[extraEff, MockChainMisc, MockChainRead, Fail,
           Error ToCardanoError, Error MockChainError, State MockChainState,
           MockChainLog, Writer MockChainJournal, NonDet]
         a)
-> Sem (ExtendedStagedEffs extraEff) a
-> Sem
     '[MockChainMisc, MockChainRead, Fail, Error ToCardanoError,
       Error MockChainError, State MockChainState, MockChainLog,
       Writer MockChainJournal, NonDet]
     a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Ltl (UntypedTweak (ExtendedStagedTweakEffs extraEff))]
-> Sem
     '[State [Ltl (UntypedTweak (ExtendedStagedTweakEffs extraEff))],
       extraEff, MockChainMisc, MockChainRead, Fail, Error ToCardanoError,
       Error MockChainError, State MockChainState, MockChainLog,
       Writer MockChainJournal, NonDet]
     a
-> Sem
     '[extraEff, MockChainMisc, MockChainRead, Fail,
       Error ToCardanoError, Error MockChainError, State MockChainState,
       MockChainLog, Writer MockChainJournal, NonDet]
     a
forall s (r :: EffectRow) a. s -> Sem (State s : r) a -> Sem r a
evalState []
      (Sem
   '[State [Ltl (UntypedTweak (ExtendedStagedTweakEffs extraEff))],
     extraEff, MockChainMisc, MockChainRead, Fail, Error ToCardanoError,
     Error MockChainError, State MockChainState, MockChainLog,
     Writer MockChainJournal, NonDet]
   a
 -> Sem
      '[extraEff, MockChainMisc, MockChainRead, Fail,
        Error ToCardanoError, Error MockChainError, State MockChainState,
        MockChainLog, Writer MockChainJournal, NonDet]
      a)
-> (Sem (ExtendedStagedEffs extraEff) a
    -> Sem
         '[State [Ltl (UntypedTweak (ExtendedStagedTweakEffs extraEff))],
           extraEff, MockChainMisc, MockChainRead, Fail, Error ToCardanoError,
           Error MockChainError, State MockChainState, MockChainLog,
           Writer MockChainJournal, NonDet]
         a)
-> Sem (ExtendedStagedEffs extraEff) a
-> Sem
     '[extraEff, MockChainMisc, MockChainRead, Fail,
       Error ToCardanoError, Error MockChainError, State MockChainState,
       MockChainLog, Writer MockChainJournal, NonDet]
     a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sem
  '[ModifyLocally (UntypedTweak (ExtendedStagedTweakEffs extraEff)),
    State [Ltl (UntypedTweak (ExtendedStagedTweakEffs extraEff))],
    extraEff, MockChainMisc, MockChainRead, Fail, Error ToCardanoError,
    Error MockChainError, State MockChainState, MockChainLog,
    Writer MockChainJournal, NonDet]
  a
-> Sem
     '[State [Ltl (UntypedTweak (ExtendedStagedTweakEffs extraEff))],
       extraEff, MockChainMisc, MockChainRead, Fail, Error ToCardanoError,
       Error MockChainError, State MockChainState, MockChainLog,
       Writer MockChainJournal, NonDet]
     a
forall modification (effs :: EffectRow) a.
Members '[State [Ltl modification], NonDet] effs =>
Sem (ModifyLocally modification : effs) a -> Sem effs a
runModifyLocally
      (Sem
   '[ModifyLocally (UntypedTweak (ExtendedStagedTweakEffs extraEff)),
     State [Ltl (UntypedTweak (ExtendedStagedTweakEffs extraEff))],
     extraEff, MockChainMisc, MockChainRead, Fail, Error ToCardanoError,
     Error MockChainError, State MockChainState, MockChainLog,
     Writer MockChainJournal, NonDet]
   a
 -> Sem
      '[State [Ltl (UntypedTweak (ExtendedStagedTweakEffs extraEff))],
        extraEff, MockChainMisc, MockChainRead, Fail, Error ToCardanoError,
        Error MockChainError, State MockChainState, MockChainLog,
        Writer MockChainJournal, NonDet]
      a)
-> (Sem (ExtendedStagedEffs extraEff) a
    -> Sem
         '[ModifyLocally (UntypedTweak (ExtendedStagedTweakEffs extraEff)),
           State [Ltl (UntypedTweak (ExtendedStagedTweakEffs extraEff))],
           extraEff, MockChainMisc, MockChainRead, Fail, Error ToCardanoError,
           Error MockChainError, State MockChainState, MockChainLog,
           Writer MockChainJournal, NonDet]
         a)
-> Sem (ExtendedStagedEffs extraEff) a
-> Sem
     '[State [Ltl (UntypedTweak (ExtendedStagedTweakEffs extraEff))],
       extraEff, MockChainMisc, MockChainRead, Fail, Error ToCardanoError,
       Error MockChainError, State MockChainState, MockChainLog,
       Writer MockChainJournal, NonDet]
     a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sem
  '[MockChainWrite,
    ModifyLocally (UntypedTweak (ExtendedStagedTweakEffs extraEff)),
    State [Ltl (UntypedTweak (ExtendedStagedTweakEffs extraEff))],
    extraEff, MockChainMisc, MockChainRead, Fail, Error ToCardanoError,
    Error MockChainError, State MockChainState, MockChainLog,
    Writer MockChainJournal, NonDet]
  a
-> Sem
     '[ModifyLocally (UntypedTweak (ExtendedStagedTweakEffs extraEff)),
       State [Ltl (UntypedTweak (ExtendedStagedTweakEffs extraEff))],
       extraEff, MockChainMisc, MockChainRead, Fail, Error ToCardanoError,
       Error MockChainError, State MockChainState, MockChainLog,
       Writer MockChainJournal, NonDet]
     a
forall (effs :: EffectRow) a.
Members
  '[State MockChainState, Error ToCardanoError, Error MockChainError,
    MockChainLog, MockChainRead, Fail]
  effs =>
Sem (MockChainWrite : effs) a -> Sem effs a
runMockChainWrite
      (Sem
   '[MockChainWrite,
     ModifyLocally (UntypedTweak (ExtendedStagedTweakEffs extraEff)),
     State [Ltl (UntypedTweak (ExtendedStagedTweakEffs extraEff))],
     extraEff, MockChainMisc, MockChainRead, Fail, Error ToCardanoError,
     Error MockChainError, State MockChainState, MockChainLog,
     Writer MockChainJournal, NonDet]
   a
 -> Sem
      '[ModifyLocally (UntypedTweak (ExtendedStagedTweakEffs extraEff)),
        State [Ltl (UntypedTweak (ExtendedStagedTweakEffs extraEff))],
        extraEff, MockChainMisc, MockChainRead, Fail, Error ToCardanoError,
        Error MockChainError, State MockChainState, MockChainLog,
        Writer MockChainJournal, NonDet]
      a)
-> (Sem (ExtendedStagedEffs extraEff) a
    -> Sem
         '[MockChainWrite,
           ModifyLocally (UntypedTweak (ExtendedStagedTweakEffs extraEff)),
           State [Ltl (UntypedTweak (ExtendedStagedTweakEffs extraEff))],
           extraEff, MockChainMisc, MockChainRead, Fail, Error ToCardanoError,
           Error MockChainError, State MockChainState, MockChainLog,
           Writer MockChainJournal, NonDet]
         a)
-> Sem (ExtendedStagedEffs extraEff) a
-> Sem
     '[ModifyLocally (UntypedTweak (ExtendedStagedTweakEffs extraEff)),
       State [Ltl (UntypedTweak (ExtendedStagedTweakEffs extraEff))],
       extraEff, MockChainMisc, MockChainRead, Fail, Error ToCardanoError,
       Error MockChainError, State MockChainState, MockChainLog,
       Writer MockChainJournal, NonDet]
     a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (index :: Nat) (inserted :: EffectRow) (head :: EffectRow)
       (oldTail :: EffectRow) (tail :: EffectRow) (old :: EffectRow)
       (full :: EffectRow) a.
(ListOfLength index head, WhenStuck index InsertAtUnprovidedIndex,
 old ~ Append head oldTail, tail ~ Append inserted oldTail,
 full ~ Append head tail,
 InsertAtIndex index head tail oldTail full inserted) =>
Sem old a -> Sem full a
insertAt @7
        @[ Error Ledger.ToCardanoError,
           Error MockChainError,
           State MockChainState,
           MockChainLog,
           Writer MockChainJournal
         ]
      (Sem
   (MockChainWrite
      : Append
          (ModifyLocally (UntypedTweak (ExtendedStagedTweakEffs extraEff))
             : State [Ltl (UntypedTweak (ExtendedStagedTweakEffs extraEff))]
             : ExtendedStagedTweakEffs extraEff)
          '[NonDet])
   a
 -> Sem
      '[MockChainWrite,
        ModifyLocally (UntypedTweak (ExtendedStagedTweakEffs extraEff)),
        State [Ltl (UntypedTweak (ExtendedStagedTweakEffs extraEff))],
        extraEff, MockChainMisc, MockChainRead, Fail, Error ToCardanoError,
        Error MockChainError, State MockChainState, MockChainLog,
        Writer MockChainJournal, NonDet]
      a)
-> (Sem (ExtendedStagedEffs extraEff) a
    -> Sem
         (MockChainWrite
            : Append
                (ModifyLocally (UntypedTweak (ExtendedStagedTweakEffs extraEff))
                   : State [Ltl (UntypedTweak (ExtendedStagedTweakEffs extraEff))]
                   : ExtendedStagedTweakEffs extraEff)
                '[NonDet])
         a)
-> Sem (ExtendedStagedEffs extraEff) a
-> Sem
     '[MockChainWrite,
       ModifyLocally (UntypedTweak (ExtendedStagedTweakEffs extraEff)),
       State [Ltl (UntypedTweak (ExtendedStagedTweakEffs extraEff))],
       extraEff, MockChainMisc, MockChainRead, Fail, Error ToCardanoError,
       Error MockChainError, State MockChainState, MockChainLog,
       Writer MockChainJournal, NonDet]
     a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (tweakEffs :: EffectRow) (effs :: EffectRow) a.
(Members '[ModifyLocally (UntypedTweak tweakEffs), NonDet] effs,
 Subsume tweakEffs effs) =>
Sem (MockChainWrite : effs) a -> Sem (MockChainWrite : effs) a
reinterpretMockChainWriteWithTweak @(ExtendedStagedTweakEffs extraEff)
      (Sem
   (MockChainWrite
      : Append
          (ModifyLocally (UntypedTweak (ExtendedStagedTweakEffs extraEff))
             : State [Ltl (UntypedTweak (ExtendedStagedTweakEffs extraEff))]
             : ExtendedStagedTweakEffs extraEff)
          '[NonDet])
   a
 -> Sem
      (MockChainWrite
         : Append
             (ModifyLocally (UntypedTweak (ExtendedStagedTweakEffs extraEff))
                : State [Ltl (UntypedTweak (ExtendedStagedTweakEffs extraEff))]
                : ExtendedStagedTweakEffs extraEff)
             '[NonDet])
      a)
-> (Sem (ExtendedStagedEffs extraEff) a
    -> Sem
         (MockChainWrite
            : Append
                (ModifyLocally (UntypedTweak (ExtendedStagedTweakEffs extraEff))
                   : State [Ltl (UntypedTweak (ExtendedStagedTweakEffs extraEff))]
                   : ExtendedStagedTweakEffs extraEff)
                '[NonDet])
         a)
-> Sem (ExtendedStagedEffs extraEff) a
-> Sem
     (MockChainWrite
        : Append
            (ModifyLocally (UntypedTweak (ExtendedStagedTweakEffs extraEff))
               : State [Ltl (UntypedTweak (ExtendedStagedTweakEffs extraEff))]
               : ExtendedStagedTweakEffs extraEff)
            '[NonDet])
     a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sem
  (ModifyGlobally (UntypedTweak (ExtendedStagedTweakEffs extraEff))
     : MockChainWrite
     : Append
         (ModifyLocally (UntypedTweak (ExtendedStagedTweakEffs extraEff))
            : State [Ltl (UntypedTweak (ExtendedStagedTweakEffs extraEff))]
            : ExtendedStagedTweakEffs extraEff)
         '[NonDet])
  a
-> Sem
     (MockChainWrite
        : Append
            (ModifyLocally (UntypedTweak (ExtendedStagedTweakEffs extraEff))
               : State [Ltl (UntypedTweak (ExtendedStagedTweakEffs extraEff))]
               : ExtendedStagedTweakEffs extraEff)
            '[NonDet])
     a
forall mod (effs :: EffectRow) a.
Members '[State [Ltl mod], NonDet] effs =>
Sem (ModifyGlobally mod : effs) a -> Sem effs a
runModifyGlobally
      (Sem
   (ModifyGlobally (UntypedTweak (ExtendedStagedTweakEffs extraEff))
      : MockChainWrite
      : Append
          (ModifyLocally (UntypedTweak (ExtendedStagedTweakEffs extraEff))
             : State [Ltl (UntypedTweak (ExtendedStagedTweakEffs extraEff))]
             : ExtendedStagedTweakEffs extraEff)
          '[NonDet])
   a
 -> Sem
      (MockChainWrite
         : Append
             (ModifyLocally (UntypedTweak (ExtendedStagedTweakEffs extraEff))
                : State [Ltl (UntypedTweak (ExtendedStagedTweakEffs extraEff))]
                : ExtendedStagedTweakEffs extraEff)
             '[NonDet])
      a)
-> (Sem (ExtendedStagedEffs extraEff) a
    -> Sem
         (ModifyGlobally (UntypedTweak (ExtendedStagedTweakEffs extraEff))
            : MockChainWrite
            : Append
                (ModifyLocally (UntypedTweak (ExtendedStagedTweakEffs extraEff))
                   : State [Ltl (UntypedTweak (ExtendedStagedTweakEffs extraEff))]
                   : ExtendedStagedTweakEffs extraEff)
                '[NonDet])
         a)
-> Sem (ExtendedStagedEffs extraEff) a
-> Sem
     (MockChainWrite
        : Append
            (ModifyLocally (UntypedTweak (ExtendedStagedTweakEffs extraEff))
               : State [Ltl (UntypedTweak (ExtendedStagedTweakEffs extraEff))]
               : ExtendedStagedTweakEffs extraEff)
            '[NonDet])
     a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (index :: Nat) (inserted :: EffectRow) (head :: EffectRow)
       (oldTail :: EffectRow) (tail :: EffectRow) (old :: EffectRow)
       (full :: EffectRow) a.
(ListOfLength index head, WhenStuck index InsertAtUnprovidedIndex,
 old ~ Append head oldTail, tail ~ Append inserted oldTail,
 full ~ Append head tail,
 InsertAtIndex index head tail oldTail full inserted) =>
Sem old a -> Sem full a
insertAt @2
        @[ ModifyLocally (UntypedTweak (ExtendedStagedTweakEffs extraEff)),
           State [Ltl (UntypedTweak (ExtendedStagedTweakEffs extraEff))]
         ]

-- | A stack of effects aimed at being used as modifications for a
-- `StagedMockChain` computation
type StagedTweakEffs = ExtendedStagedTweakEffs (Bundle '[])

-- | A tweak computation based on the `StagedTweakEffs` stack of effects
type StagedTweak a = TypedTweak StagedTweakEffs a

-- | A stack of effects which allows everything allowed by `DirectEffs` with the
-- addition of branching and `Ltl` modification with tweaks living in
-- `StagedTweakEffs`
type StagedEffs = ExtendedStagedEffs (Bundle '[])

-- | A mockchain computation built on top of the `StagedEffs` stack of effects
type StagedMockChain a = Sem StagedEffs a

instance InterpretAlone (Bundle '[]) where
  runInterpretAlone :: forall (effs :: EffectRow) a.
Sem (Bundle '[] : effs) a -> Sem effs a
runInterpretAlone = Sem (Bundle '[] : effs) a -> Sem effs a
Sem (Bundle '[] : effs) a -> Sem (Append '[] effs) a
forall (r' :: EffectRow) (r :: EffectRow) a.
KnownList r' =>
Sem (Bundle r' : r) a -> Sem (Append r' r) a
runBundle