{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE BlockArguments #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE PolyKinds #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeOperators #-}

-- |
-- Module      : Polysemy.Extra
-- License     : MIT
-- Maintainer  : dan.firth@homotopic.tech
-- Stability   : experimental
--
-- Extra convenience functions for polysemy.
module Polysemy.Extra
  ( -- * Input
    contramapInput,
    contramapInputSem,
    contramapInput',
    runInputConstF,

    -- * Output
    mapOutput,
    mapOutputSem,
    mapOutput',
    runOutputMapAsKVStore,

    -- * Raise
    raise4Under,

    -- * Reinterpreters
    reinterpretUnder,
    reinterpretUnder2,
    reinterpret2Under,

    -- * Rotation
    rotateEffects2,
    rotateEffects3L,
    rotateEffects3R,
    rotateEffects4L,
    rotateEffects4R,

    -- * Reverse
    reverseEffects2,
    reverseEffects3,
    reverseEffects4,
  )
where

import Control.Arrow
import Data.Map as Map
import Polysemy
import Polysemy.Input
import Polysemy.Internal
import Polysemy.Internal.Union
import Polysemy.KVStore
import Polysemy.Output

-- | Run an `Output` (`Map` k v) as a `KVStore` by writing the values to
-- the keys.
--
-- @since 0.1.0.0
runOutputMapAsKVStore ::
  Members '[KVStore k v] r =>
  Sem (Output (Map k v) ': r) a ->
  Sem r a
runOutputMapAsKVStore :: Sem (Output (Map k v) : r) a -> Sem r a
runOutputMapAsKVStore = (forall (rInitial :: EffectRow) x.
 Output (Map k v) (Sem rInitial) x -> Sem r x)
-> Sem (Output (Map k v) : r) a -> Sem r a
forall (e :: (* -> *) -> * -> *) (r :: EffectRow) a.
FirstOrder e "interpret" =>
(forall (rInitial :: EffectRow) x. e (Sem rInitial) x -> Sem r x)
-> Sem (e : r) a -> Sem r a
interpret \case
  Output xs -> ((k, v) -> Sem r ()) -> [(k, v)] -> Sem r ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ ((k -> v -> Sem r ()) -> (k, v) -> Sem r ()
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry k -> v -> Sem r ()
forall k v (r :: EffectRow).
Member (KVStore k v) r =>
k -> v -> Sem r ()
writeKV) (Map k v -> [(k, v)]
forall k a. Map k a -> [(k, a)]
Map.toList Map k v
xs)
{-# INLINE runOutputMapAsKVStore #-}

-- | Map an `Output` covariantly.
--
-- @since 0.1.0.0
mapOutput ::
  Members '[Output o'] r =>
  -- | A function to map the old output to the new output.
  (o -> o') ->
  Sem (Output o ': r) a ->
  Sem r a
mapOutput :: (o -> o') -> Sem (Output o : r) a -> Sem r a
mapOutput o -> o'
f = (forall (rInitial :: EffectRow) x.
 Output o (Sem rInitial) x -> Sem r x)
-> Sem (Output o : r) a -> Sem r a
forall (e :: (* -> *) -> * -> *) (r :: EffectRow) a.
FirstOrder e "interpret" =>
(forall (rInitial :: EffectRow) x. e (Sem rInitial) x -> Sem r x)
-> Sem (e : r) a -> Sem r a
interpret \case
  Output o -> o' -> Sem r ()
forall o (r :: EffectRow).
MemberWithError (Output o) r =>
o -> Sem r ()
output (o -> o'
f o
o)
{-# INLINE mapOutput #-}

-- | Reinterpreting version of `mapOutput`.
--
-- @since 0.1.4.0
mapOutput' ::
  Members '[Output o'] r =>
  -- | A function to map the old output to the new output.
  (o -> o') ->
  Sem (Output o ': r) a ->
  Sem (Output o' ': r) a
mapOutput' :: (o -> o') -> Sem (Output o : r) a -> Sem (Output o' : r) a
mapOutput' o -> o'
f = Sem (Output o : r) a -> Sem (Output o : Output o' : r) a
forall (e2 :: (* -> *) -> * -> *) (e1 :: (* -> *) -> * -> *)
       (r :: EffectRow) a.
Sem (e1 : r) a -> Sem (e1 : e2 : r) a
raiseUnder (Sem (Output o : r) a -> Sem (Output o : Output o' : r) a)
-> (Sem (Output o : Output o' : r) a -> Sem (Output o' : r) a)
-> Sem (Output o : r) a
-> Sem (Output o' : r) a
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> (o -> o')
-> Sem (Output o : Output o' : r) a -> Sem (Output o' : r) a
forall o' (r :: EffectRow) o a.
Members '[Output o'] r =>
(o -> o') -> Sem (Output o : r) a -> Sem r a
mapOutput o -> o'
f
{-# INLINE mapOutput' #-}

-- | Map an `Output` covariantly through a monadic function.
--
-- @since 0.1.0.0
mapOutputSem ::
  forall o o' r a.
  Members '[Output o'] r =>
  -- | A function to map the old output to the new output.
  (o -> Sem r o') ->
  Sem (Output o ': r) a ->
  Sem r a
mapOutputSem :: (o -> Sem r o') -> Sem (Output o : r) a -> Sem r a
mapOutputSem o -> Sem r o'
f = (forall (rInitial :: EffectRow) x.
 Output o (Sem rInitial) x -> Sem r x)
-> Sem (Output o : r) a -> Sem r a
forall (e :: (* -> *) -> * -> *) (r :: EffectRow) a.
FirstOrder e "interpret" =>
(forall (rInitial :: EffectRow) x. e (Sem rInitial) x -> Sem r x)
-> Sem (e : r) a -> Sem r a
interpret \case
  Output o -> o -> Sem r o'
f o
o Sem r o' -> (o' -> Sem r ()) -> Sem r ()
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= o' -> Sem r ()
forall o (r :: EffectRow).
MemberWithError (Output o) r =>
o -> Sem r ()
output
{-# INLINE mapOutputSem #-}

-- | Map an `Input` contravariantly.
--
-- @since 0.1.0.0
contramapInput ::
  forall i i' r a.
  Members '[Input i'] r =>
  -- | A function to map the new input to the old input.
  (i' -> i) ->
  Sem (Input i ': r) a ->
  Sem r a
contramapInput :: (i' -> i) -> Sem (Input i : r) a -> Sem r a
contramapInput i' -> i
f = (forall (rInitial :: EffectRow) x.
 Input i (Sem rInitial) x -> Sem r x)
-> Sem (Input i : r) a -> Sem r a
forall (e :: (* -> *) -> * -> *) (r :: EffectRow) a.
FirstOrder e "interpret" =>
(forall (rInitial :: EffectRow) x. e (Sem rInitial) x -> Sem r x)
-> Sem (e : r) a -> Sem r a
interpret \case
  Input i (Sem rInitial) x
Input -> i' -> i
f (i' -> i) -> Sem r i' -> Sem r i
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (r :: EffectRow). MemberWithError (Input i') r => Sem r i'
forall i (r :: EffectRow). MemberWithError (Input i) r => Sem r i
input @i'
{-# INLINE contramapInput #-}

-- | Reinterpreting version of `contramapInput`.
--
-- @since 0.1.4.0
contramapInput' ::
  forall i i' r a.
  Members '[Input i'] r =>
  -- | A function to map the new input to the old input.
  (i' -> i) ->
  Sem (Input i ': r) a ->
  Sem (Input i' ': r) a
contramapInput' :: (i' -> i) -> Sem (Input i : r) a -> Sem (Input i' : r) a
contramapInput' i' -> i
f = Sem (Input i : r) a -> Sem (Input i : Input i' : r) a
forall (e2 :: (* -> *) -> * -> *) (e1 :: (* -> *) -> * -> *)
       (r :: EffectRow) a.
Sem (e1 : r) a -> Sem (e1 : e2 : r) a
raiseUnder (Sem (Input i : r) a -> Sem (Input i : Input i' : r) a)
-> (Sem (Input i : Input i' : r) a -> Sem (Input i' : r) a)
-> Sem (Input i : r) a
-> Sem (Input i' : r) a
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> (i' -> i) -> Sem (Input i : Input i' : r) a -> Sem (Input i' : r) a
forall i i' (r :: EffectRow) a.
Members '[Input i'] r =>
(i' -> i) -> Sem (Input i : r) a -> Sem r a
contramapInput i' -> i
f
{-# INLINE contramapInput' #-}

-- | Map an `Input` contravariantly through a monadic function.
-- @since 0.1.0.0
contramapInputSem ::
  forall i i' r a.
  Members '[Input i'] r =>
  -- | A function to map the new input to the old input.
  (i' -> Sem r i) ->
  Sem (Input i ': r) a ->
  Sem r a
contramapInputSem :: (i' -> Sem r i) -> Sem (Input i : r) a -> Sem r a
contramapInputSem i' -> Sem r i
f = (forall (rInitial :: EffectRow) x.
 Input i (Sem rInitial) x -> Sem r x)
-> Sem (Input i : r) a -> Sem r a
forall (e :: (* -> *) -> * -> *) (r :: EffectRow) a.
FirstOrder e "interpret" =>
(forall (rInitial :: EffectRow) x. e (Sem rInitial) x -> Sem r x)
-> Sem (e : r) a -> Sem r a
interpret \case
  Input i (Sem rInitial) x
Input -> i' -> Sem r i
f (i' -> Sem r i) -> Sem r i' -> Sem r i
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall (r :: EffectRow). MemberWithError (Input i') r => Sem r i'
forall i (r :: EffectRow). MemberWithError (Input i) r => Sem r i
input @i'
{-# INLINE contramapInputSem #-}

-- | Like `runInputConst`, except with a type parameter for the functor for abusing type applications.
--
-- @since 0.1.5.0
runInputConstF ::
  forall b f r a.
  f b ->
  Sem (Input (f b) ': r) a ->
  Sem r a
runInputConstF :: f b -> Sem (Input (f b) : r) a -> Sem r a
runInputConstF = forall (r :: EffectRow) a.
f b -> Sem (Input (f b) : r) a -> Sem r a
forall i (r :: EffectRow) a. i -> Sem (Input i : r) a -> Sem r a
runInputConst @(f b)
{-# INLINE runInputConstF #-}

-- | Reinterpret the second effect in the stack into a single effect.
--
-- @since 0.1.1.0
reinterpretUnder ::
  forall e1 e2 e3 r a.
  -- | A natural transformation from the handled effect to the new effects.
  (forall m x. Sem (e2 ': m) x -> Sem (e3 ': m) x) ->
  Sem (e1 ': e2 ': r) a ->
  Sem (e1 ': e3 ': r) a
reinterpretUnder :: (forall (m :: EffectRow) x. Sem (e2 : m) x -> Sem (e3 : m) x)
-> Sem (e1 : e2 : r) a -> Sem (e1 : e3 : r) a
reinterpretUnder forall (m :: EffectRow) x. Sem (e2 : m) x -> Sem (e3 : m) x
f =
  forall (r :: EffectRow) a.
Sem (e1 : e2 : r) a -> Sem (e1 : e2 : e1 : r) a
forall (e3 :: (* -> *) -> * -> *) (e1 :: (* -> *) -> * -> *)
       (e2 :: (* -> *) -> * -> *) (r :: EffectRow) a.
Sem (e1 : e2 : r) a -> Sem (e1 : e2 : e3 : r) a
raise2Under @e1 @e1 @e2
    (Sem (e1 : e2 : r) a -> Sem (e1 : e2 : e1 : r) a)
-> (Sem (e1 : e2 : e1 : r) a -> Sem (e1 : e3 : r) a)
-> Sem (e1 : e2 : r) a
-> Sem (e1 : e3 : r) a
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> ElemOf e1 (e2 : e1 : r)
-> Sem (e1 : e2 : e1 : r) a -> Sem (e2 : e1 : r) a
forall (e :: (* -> *) -> * -> *) (r :: EffectRow) a.
ElemOf e r -> Sem (e : r) a -> Sem r a
subsumeUsing @e1 (ElemOf e1 (e1 : r) -> ElemOf e1 (e2 : e1 : r)
forall a (e :: a) (r1 :: [a]) (e' :: a).
ElemOf e r1 -> ElemOf e (e' : r1)
There ElemOf e1 (e1 : r)
forall a (e :: a) (r1 :: [a]). ElemOf e (e : r1)
Here)
    (Sem (e1 : e2 : e1 : r) a -> Sem (e2 : e1 : r) a)
-> (Sem (e2 : e1 : r) a -> Sem (e1 : e3 : r) a)
-> Sem (e1 : e2 : e1 : r) a
-> Sem (e1 : e3 : r) a
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> Sem (e2 : e1 : r) a -> Sem (e3 : e1 : r) a
forall (m :: EffectRow) x. Sem (e2 : m) x -> Sem (e3 : m) x
f
    (Sem (e2 : e1 : r) a -> Sem (e3 : e1 : r) a)
-> (Sem (e3 : e1 : r) a -> Sem (e1 : e3 : r) a)
-> Sem (e2 : e1 : r) a
-> Sem (e1 : e3 : r) a
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> forall (r :: EffectRow) a.
Sem (e3 : e1 : r) a -> Sem (e3 : e1 : e3 : r) a
forall (e3 :: (* -> *) -> * -> *) (e1 :: (* -> *) -> * -> *)
       (e2 :: (* -> *) -> * -> *) (r :: EffectRow) a.
Sem (e1 : e2 : r) a -> Sem (e1 : e2 : e3 : r) a
raise2Under @e3 @e3 @e1
    (Sem (e3 : e1 : r) a -> Sem (e3 : e1 : e3 : r) a)
-> (Sem (e3 : e1 : e3 : r) a -> Sem (e1 : e3 : r) a)
-> Sem (e3 : e1 : r) a
-> Sem (e1 : e3 : r) a
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> ElemOf e3 (e1 : e3 : r)
-> Sem (e3 : e1 : e3 : r) a -> Sem (e1 : e3 : r) a
forall (e :: (* -> *) -> * -> *) (r :: EffectRow) a.
ElemOf e r -> Sem (e : r) a -> Sem r a
subsumeUsing @e3 (ElemOf e3 (e3 : r) -> ElemOf e3 (e1 : e3 : r)
forall a (e :: a) (r1 :: [a]) (e' :: a).
ElemOf e r1 -> ElemOf e (e' : r1)
There ElemOf e3 (e3 : r)
forall a (e :: a) (r1 :: [a]). ElemOf e (e : r1)
Here)
{-# INLINE reinterpretUnder #-}

-- | Reinterpret the third effect in the stack into a single effect.
--
-- @since 0.1.1.0
reinterpretUnder2 ::
  forall e1 e2 e3 e4 r a.
  -- | A natural transformation from the handled effect to the new effects.
  (forall m x. Sem (e3 ': m) x -> Sem (e4 ': m) x) ->
  Sem (e1 ': e2 ': e3 ': r) a ->
  Sem (e1 ': e2 ': e4 ': r) a
reinterpretUnder2 :: (forall (m :: EffectRow) x. Sem (e3 : m) x -> Sem (e4 : m) x)
-> Sem (e1 : e2 : e3 : r) a -> Sem (e1 : e2 : e4 : r) a
reinterpretUnder2 forall (m :: EffectRow) x. Sem (e3 : m) x -> Sem (e4 : m) x
f =
  forall (r :: EffectRow) a.
Sem (e1 : e2 : e3 : r) a -> Sem (e1 : e2 : e3 : e1 : r) a
forall (e4 :: (* -> *) -> * -> *) (e1 :: (* -> *) -> * -> *)
       (e2 :: (* -> *) -> * -> *) (e3 :: (* -> *) -> * -> *)
       (r :: EffectRow) a.
Sem (e1 : e2 : e3 : r) a -> Sem (e1 : e2 : e3 : e4 : r) a
raise3Under @e1 @e1 @e2 @e3
    (Sem (e1 : e2 : e3 : r) a -> Sem (e1 : e2 : e3 : e1 : r) a)
-> (Sem (e1 : e2 : e3 : e1 : r) a -> Sem (e1 : e2 : e4 : r) a)
-> Sem (e1 : e2 : e3 : r) a
-> Sem (e1 : e2 : e4 : r) a
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> ElemOf e1 (e2 : e3 : e1 : r)
-> Sem (e1 : e2 : e3 : e1 : r) a -> Sem (e2 : e3 : e1 : r) a
forall (e :: (* -> *) -> * -> *) (r :: EffectRow) a.
ElemOf e r -> Sem (e : r) a -> Sem r a
subsumeUsing @e1 (ElemOf e1 (e3 : e1 : r) -> ElemOf e1 (e2 : e3 : e1 : r)
forall a (e :: a) (r1 :: [a]) (e' :: a).
ElemOf e r1 -> ElemOf e (e' : r1)
There (ElemOf e1 (e3 : e1 : r) -> ElemOf e1 (e2 : e3 : e1 : r))
-> ElemOf e1 (e3 : e1 : r) -> ElemOf e1 (e2 : e3 : e1 : r)
forall a b. (a -> b) -> a -> b
$ ElemOf e1 (e1 : r) -> ElemOf e1 (e3 : e1 : r)
forall a (e :: a) (r1 :: [a]) (e' :: a).
ElemOf e r1 -> ElemOf e (e' : r1)
There ElemOf e1 (e1 : r)
forall a (e :: a) (r1 :: [a]). ElemOf e (e : r1)
Here)
    (Sem (e1 : e2 : e3 : e1 : r) a -> Sem (e2 : e3 : e1 : r) a)
-> (Sem (e2 : e3 : e1 : r) a -> Sem (e1 : e2 : e4 : r) a)
-> Sem (e1 : e2 : e3 : e1 : r) a
-> Sem (e1 : e2 : e4 : r) a
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> forall (r :: EffectRow) a.
Sem (e2 : e3 : e1 : r) a -> Sem (e2 : e3 : e1 : e2 : r) a
forall (e4 :: (* -> *) -> * -> *) (e1 :: (* -> *) -> * -> *)
       (e2 :: (* -> *) -> * -> *) (e3 :: (* -> *) -> * -> *)
       (r :: EffectRow) a.
Sem (e1 : e2 : e3 : r) a -> Sem (e1 : e2 : e3 : e4 : r) a
raise3Under @e2 @e2 @e3 @e1
    (Sem (e2 : e3 : e1 : r) a -> Sem (e2 : e3 : e1 : e2 : r) a)
-> (Sem (e2 : e3 : e1 : e2 : r) a -> Sem (e1 : e2 : e4 : r) a)
-> Sem (e2 : e3 : e1 : r) a
-> Sem (e1 : e2 : e4 : r) a
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> ElemOf e2 (e3 : e1 : e2 : r)
-> Sem (e2 : e3 : e1 : e2 : r) a -> Sem (e3 : e1 : e2 : r) a
forall (e :: (* -> *) -> * -> *) (r :: EffectRow) a.
ElemOf e r -> Sem (e : r) a -> Sem r a
subsumeUsing @e2 (ElemOf e2 (e1 : e2 : r) -> ElemOf e2 (e3 : e1 : e2 : r)
forall a (e :: a) (r1 :: [a]) (e' :: a).
ElemOf e r1 -> ElemOf e (e' : r1)
There (ElemOf e2 (e1 : e2 : r) -> ElemOf e2 (e3 : e1 : e2 : r))
-> ElemOf e2 (e1 : e2 : r) -> ElemOf e2 (e3 : e1 : e2 : r)
forall a b. (a -> b) -> a -> b
$ ElemOf e2 (e2 : r) -> ElemOf e2 (e1 : e2 : r)
forall a (e :: a) (r1 :: [a]) (e' :: a).
ElemOf e r1 -> ElemOf e (e' : r1)
There ElemOf e2 (e2 : r)
forall a (e :: a) (r1 :: [a]). ElemOf e (e : r1)
Here)
    (Sem (e2 : e3 : e1 : e2 : r) a -> Sem (e3 : e1 : e2 : r) a)
-> (Sem (e3 : e1 : e2 : r) a -> Sem (e1 : e2 : e4 : r) a)
-> Sem (e2 : e3 : e1 : e2 : r) a
-> Sem (e1 : e2 : e4 : r) a
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> Sem (e3 : e1 : e2 : r) a -> Sem (e4 : e1 : e2 : r) a
forall (m :: EffectRow) x. Sem (e3 : m) x -> Sem (e4 : m) x
f
    (Sem (e3 : e1 : e2 : r) a -> Sem (e4 : e1 : e2 : r) a)
-> (Sem (e4 : e1 : e2 : r) a -> Sem (e1 : e2 : e4 : r) a)
-> Sem (e3 : e1 : e2 : r) a
-> Sem (e1 : e2 : e4 : r) a
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> forall (r :: EffectRow) a.
Sem (e4 : e1 : e2 : r) a -> Sem (e4 : e1 : e2 : e4 : r) a
forall (e4 :: (* -> *) -> * -> *) (e1 :: (* -> *) -> * -> *)
       (e2 :: (* -> *) -> * -> *) (e3 :: (* -> *) -> * -> *)
       (r :: EffectRow) a.
Sem (e1 : e2 : e3 : r) a -> Sem (e1 : e2 : e3 : e4 : r) a
raise3Under @e4 @e4 @e1 @e2
    (Sem (e4 : e1 : e2 : r) a -> Sem (e4 : e1 : e2 : e4 : r) a)
-> (Sem (e4 : e1 : e2 : e4 : r) a -> Sem (e1 : e2 : e4 : r) a)
-> Sem (e4 : e1 : e2 : r) a
-> Sem (e1 : e2 : e4 : r) a
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> ElemOf e4 (e1 : e2 : e4 : r)
-> Sem (e4 : e1 : e2 : e4 : r) a -> Sem (e1 : e2 : e4 : r) a
forall (e :: (* -> *) -> * -> *) (r :: EffectRow) a.
ElemOf e r -> Sem (e : r) a -> Sem r a
subsumeUsing @e4 (ElemOf e4 (e2 : e4 : r) -> ElemOf e4 (e1 : e2 : e4 : r)
forall a (e :: a) (r1 :: [a]) (e' :: a).
ElemOf e r1 -> ElemOf e (e' : r1)
There (ElemOf e4 (e2 : e4 : r) -> ElemOf e4 (e1 : e2 : e4 : r))
-> ElemOf e4 (e2 : e4 : r) -> ElemOf e4 (e1 : e2 : e4 : r)
forall a b. (a -> b) -> a -> b
$ ElemOf e4 (e4 : r) -> ElemOf e4 (e2 : e4 : r)
forall a (e :: a) (r1 :: [a]) (e' :: a).
ElemOf e r1 -> ElemOf e (e' : r1)
There ElemOf e4 (e4 : r)
forall a (e :: a) (r1 :: [a]). ElemOf e (e : r1)
Here)
{-# INLINE reinterpretUnder2 #-}

-- | Reinterpret the second effect in the stack in terms of two effects.
--
-- @since 0.1.1.0
reinterpret2Under ::
  forall e1 e2 e3 e4 r a.
  -- | A natural transformation from the handled effect to the new effects.
  (forall m x. Sem (e2 ': m) x -> Sem (e3 ': e4 ': m) x) ->
  Sem (e1 ': e2 ': r) a ->
  Sem (e1 ': e3 ': e4 ': r) a
reinterpret2Under :: (forall (m :: EffectRow) x. Sem (e2 : m) x -> Sem (e3 : e4 : m) x)
-> Sem (e1 : e2 : r) a -> Sem (e1 : e3 : e4 : r) a
reinterpret2Under forall (m :: EffectRow) x. Sem (e2 : m) x -> Sem (e3 : e4 : m) x
f =
  forall (r :: EffectRow) a.
Sem (e1 : e2 : r) a -> Sem (e1 : e2 : e1 : r) a
forall (e3 :: (* -> *) -> * -> *) (e1 :: (* -> *) -> * -> *)
       (e2 :: (* -> *) -> * -> *) (r :: EffectRow) a.
Sem (e1 : e2 : r) a -> Sem (e1 : e2 : e3 : r) a
raise2Under @e1 @e1 @e2
    (Sem (e1 : e2 : r) a -> Sem (e1 : e2 : e1 : r) a)
-> (Sem (e1 : e2 : e1 : r) a -> Sem (e1 : e3 : e4 : r) a)
-> Sem (e1 : e2 : r) a
-> Sem (e1 : e3 : e4 : r) a
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> ElemOf e1 (e2 : e1 : r)
-> Sem (e1 : e2 : e1 : r) a -> Sem (e2 : e1 : r) a
forall (e :: (* -> *) -> * -> *) (r :: EffectRow) a.
ElemOf e r -> Sem (e : r) a -> Sem r a
subsumeUsing @e1 (ElemOf e1 (e1 : r) -> ElemOf e1 (e2 : e1 : r)
forall a (e :: a) (r1 :: [a]) (e' :: a).
ElemOf e r1 -> ElemOf e (e' : r1)
There ElemOf e1 (e1 : r)
forall a (e :: a) (r1 :: [a]). ElemOf e (e : r1)
Here)
    (Sem (e1 : e2 : e1 : r) a -> Sem (e2 : e1 : r) a)
-> (Sem (e2 : e1 : r) a -> Sem (e1 : e3 : e4 : r) a)
-> Sem (e1 : e2 : e1 : r) a
-> Sem (e1 : e3 : e4 : r) a
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> Sem (e2 : e1 : r) a -> Sem (e3 : e4 : e1 : r) a
forall (m :: EffectRow) x. Sem (e2 : m) x -> Sem (e3 : e4 : m) x
f
    (Sem (e2 : e1 : r) a -> Sem (e3 : e4 : e1 : r) a)
-> (Sem (e3 : e4 : e1 : r) a -> Sem (e1 : e3 : e4 : r) a)
-> Sem (e2 : e1 : r) a
-> Sem (e1 : e3 : e4 : r) a
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> forall (r :: EffectRow) a.
Sem (e3 : e4 : e1 : r) a -> Sem (e3 : e4 : e1 : e3 : r) a
forall (e4 :: (* -> *) -> * -> *) (e1 :: (* -> *) -> * -> *)
       (e2 :: (* -> *) -> * -> *) (e3 :: (* -> *) -> * -> *)
       (r :: EffectRow) a.
Sem (e1 : e2 : e3 : r) a -> Sem (e1 : e2 : e3 : e4 : r) a
raise3Under @e3 @e3 @e4 @e1
    (Sem (e3 : e4 : e1 : r) a -> Sem (e3 : e4 : e1 : e3 : r) a)
-> (Sem (e3 : e4 : e1 : e3 : r) a -> Sem (e1 : e3 : e4 : r) a)
-> Sem (e3 : e4 : e1 : r) a
-> Sem (e1 : e3 : e4 : r) a
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> ElemOf e3 (e4 : e1 : e3 : r)
-> Sem (e3 : e4 : e1 : e3 : r) a -> Sem (e4 : e1 : e3 : r) a
forall (e :: (* -> *) -> * -> *) (r :: EffectRow) a.
ElemOf e r -> Sem (e : r) a -> Sem r a
subsumeUsing @e3 (ElemOf e3 (e1 : e3 : r) -> ElemOf e3 (e4 : e1 : e3 : r)
forall a (e :: a) (r1 :: [a]) (e' :: a).
ElemOf e r1 -> ElemOf e (e' : r1)
There (ElemOf e3 (e1 : e3 : r) -> ElemOf e3 (e4 : e1 : e3 : r))
-> ElemOf e3 (e1 : e3 : r) -> ElemOf e3 (e4 : e1 : e3 : r)
forall a b. (a -> b) -> a -> b
$ ElemOf e3 (e3 : r) -> ElemOf e3 (e1 : e3 : r)
forall a (e :: a) (r1 :: [a]) (e' :: a).
ElemOf e r1 -> ElemOf e (e' : r1)
There ElemOf e3 (e3 : r)
forall a (e :: a) (r1 :: [a]). ElemOf e (e : r1)
Here)
    (Sem (e3 : e4 : e1 : e3 : r) a -> Sem (e4 : e1 : e3 : r) a)
-> (Sem (e4 : e1 : e3 : r) a -> Sem (e1 : e3 : e4 : r) a)
-> Sem (e3 : e4 : e1 : e3 : r) a
-> Sem (e1 : e3 : e4 : r) a
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> forall (r :: EffectRow) a.
Sem (e4 : e1 : e3 : r) a -> Sem (e4 : e1 : e3 : e4 : r) a
forall (e4 :: (* -> *) -> * -> *) (e1 :: (* -> *) -> * -> *)
       (e2 :: (* -> *) -> * -> *) (e3 :: (* -> *) -> * -> *)
       (r :: EffectRow) a.
Sem (e1 : e2 : e3 : r) a -> Sem (e1 : e2 : e3 : e4 : r) a
raise3Under @e4 @e4 @e1 @e3
    (Sem (e4 : e1 : e3 : r) a -> Sem (e4 : e1 : e3 : e4 : r) a)
-> (Sem (e4 : e1 : e3 : e4 : r) a -> Sem (e1 : e3 : e4 : r) a)
-> Sem (e4 : e1 : e3 : r) a
-> Sem (e1 : e3 : e4 : r) a
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> ElemOf e4 (e1 : e3 : e4 : r)
-> Sem (e4 : e1 : e3 : e4 : r) a -> Sem (e1 : e3 : e4 : r) a
forall (e :: (* -> *) -> * -> *) (r :: EffectRow) a.
ElemOf e r -> Sem (e : r) a -> Sem r a
subsumeUsing @e4 (ElemOf e4 (e3 : e4 : r) -> ElemOf e4 (e1 : e3 : e4 : r)
forall a (e :: a) (r1 :: [a]) (e' :: a).
ElemOf e r1 -> ElemOf e (e' : r1)
There (ElemOf e4 (e3 : e4 : r) -> ElemOf e4 (e1 : e3 : e4 : r))
-> ElemOf e4 (e3 : e4 : r) -> ElemOf e4 (e1 : e3 : e4 : r)
forall a b. (a -> b) -> a -> b
$ ElemOf e4 (e4 : r) -> ElemOf e4 (e3 : e4 : r)
forall a (e :: a) (r1 :: [a]) (e' :: a).
ElemOf e r1 -> ElemOf e (e' : r1)
There ElemOf e4 (e4 : r)
forall a (e :: a) (r1 :: [a]). ElemOf e (e : r1)
Here)
{-# INLINE reinterpret2Under #-}

-- | Like `raise`, but introduces an effect four levels underneath the head of the list.
--
-- @since 0.1.3.0
raise4Under :: forall e5 e1 e2 e3 e4 r a. Sem (e1 ': e2 ': e3 ': e4 ': r) a -> Sem (e1 ': e2 ': e3 ': e4 ': e5 ': r) a
raise4Under :: Sem (e1 : e2 : e3 : e4 : r) a -> Sem (e1 : e2 : e3 : e4 : e5 : r) a
raise4Under = (forall x.
 Union (e1 : e2 : e3 : e4 : r) (Sem (e1 : e2 : e3 : e4 : r)) x
 -> Union
      (e1 : e2 : e3 : e4 : e5 : r) (Sem (e1 : e2 : e3 : e4 : e5 : r)) x)
-> Sem (e1 : e2 : e3 : e4 : r) a
-> Sem (e1 : e2 : e3 : e4 : e5 : r) a
forall (r :: EffectRow) (r' :: EffectRow) a.
(forall x. Union r (Sem r) x -> Union r' (Sem r') x)
-> Sem r a -> Sem r' a
hoistSem ((forall x.
  Union (e1 : e2 : e3 : e4 : r) (Sem (e1 : e2 : e3 : e4 : r)) x
  -> Union
       (e1 : e2 : e3 : e4 : e5 : r) (Sem (e1 : e2 : e3 : e4 : e5 : r)) x)
 -> Sem (e1 : e2 : e3 : e4 : r) a
 -> Sem (e1 : e2 : e3 : e4 : e5 : r) a)
-> (forall x.
    Union (e1 : e2 : e3 : e4 : r) (Sem (e1 : e2 : e3 : e4 : r)) x
    -> Union
         (e1 : e2 : e3 : e4 : e5 : r) (Sem (e1 : e2 : e3 : e4 : e5 : r)) x)
-> Sem (e1 : e2 : e3 : e4 : r) a
-> Sem (e1 : e2 : e3 : e4 : e5 : r) a
forall a b. (a -> b) -> a -> b
$ (forall x.
 Sem (e1 : e2 : e3 : e4 : r) x
 -> Sem (e1 : e2 : e3 : e4 : e5 : r) x)
-> Union
     (e1 : e2 : e3 : e4 : e5 : r) (Sem (e1 : e2 : e3 : e4 : r)) x
-> Union
     (e1 : e2 : e3 : e4 : e5 : r) (Sem (e1 : e2 : e3 : e4 : e5 : r)) x
forall (m :: * -> *) (n :: * -> *) (r :: EffectRow) a.
(forall x. m x -> n x) -> Union r m a -> Union r n a
hoist forall x.
Sem (e1 : e2 : e3 : e4 : r) x -> Sem (e1 : e2 : e3 : e4 : e5 : r) x
forall (e5 :: (* -> *) -> * -> *) (e1 :: (* -> *) -> * -> *)
       (e2 :: (* -> *) -> * -> *) (e3 :: (* -> *) -> * -> *)
       (e4 :: (* -> *) -> * -> *) (r :: EffectRow) a.
Sem (e1 : e2 : e3 : e4 : r) a -> Sem (e1 : e2 : e3 : e4 : e5 : r) a
raise4Under (Union (e1 : e2 : e3 : e4 : e5 : r) (Sem (e1 : e2 : e3 : e4 : r)) x
 -> Union
      (e1 : e2 : e3 : e4 : e5 : r) (Sem (e1 : e2 : e3 : e4 : e5 : r)) x)
-> (Union (e1 : e2 : e3 : e4 : r) (Sem (e1 : e2 : e3 : e4 : r)) x
    -> Union
         (e1 : e2 : e3 : e4 : e5 : r) (Sem (e1 : e2 : e3 : e4 : r)) x)
-> Union (e1 : e2 : e3 : e4 : r) (Sem (e1 : e2 : e3 : e4 : r)) x
-> Union
     (e1 : e2 : e3 : e4 : e5 : r) (Sem (e1 : e2 : e3 : e4 : e5 : r)) x
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Union (e1 : e2 : e3 : e4 : r) (Sem (e1 : e2 : e3 : e4 : r)) x
-> Union
     (e1 : e2 : e3 : e4 : e5 : r) (Sem (e1 : e2 : e3 : e4 : r)) x
forall (m :: * -> *) x.
Union (e1 : e2 : e3 : e4 : r) m x
-> Union (e1 : e2 : e3 : e4 : e5 : r) m x
weaken4Under
  where
    weaken4Under :: forall m x. Union (e1 : e2 : e3 : e4 : r) m x -> Union (e1 : e2 : e3 : e4 : e5 : r) m x
    weaken4Under :: Union (e1 : e2 : e3 : e4 : r) m x
-> Union (e1 : e2 : e3 : e4 : e5 : r) m x
weaken4Under (Union ElemOf e (e1 : e2 : e3 : e4 : r)
Here Weaving e m x
a) = ElemOf e (e : e2 : e3 : e4 : e5 : r)
-> Weaving e m x -> Union (e : e2 : e3 : e4 : e5 : r) m x
forall (e :: (* -> *) -> * -> *) (r :: EffectRow)
       (mWoven :: * -> *) a.
ElemOf e r -> Weaving e mWoven a -> Union r mWoven a
Union ElemOf e (e : e2 : e3 : e4 : e5 : r)
forall a (e :: a) (r1 :: [a]). ElemOf e (e : r1)
Here Weaving e m x
a
    weaken4Under (Union (There ElemOf e r1
Here) Weaving e m x
a) = ElemOf e (e1 : e : e3 : e4 : e5 : r)
-> Weaving e m x -> Union (e1 : e : e3 : e4 : e5 : r) m x
forall (e :: (* -> *) -> * -> *) (r :: EffectRow)
       (mWoven :: * -> *) a.
ElemOf e r -> Weaving e mWoven a -> Union r mWoven a
Union (ElemOf e (e : e3 : e4 : e5 : r)
-> ElemOf e (e1 : e : e3 : e4 : e5 : r)
forall a (e :: a) (r1 :: [a]) (e' :: a).
ElemOf e r1 -> ElemOf e (e' : r1)
There ElemOf e (e : e3 : e4 : e5 : r)
forall a (e :: a) (r1 :: [a]). ElemOf e (e : r1)
Here) Weaving e m x
a
    weaken4Under (Union (There (There ElemOf e r1
Here)) Weaving e m x
a) = ElemOf e (e1 : e2 : e : e4 : e5 : r)
-> Weaving e m x -> Union (e1 : e2 : e : e4 : e5 : r) m x
forall (e :: (* -> *) -> * -> *) (r :: EffectRow)
       (mWoven :: * -> *) a.
ElemOf e r -> Weaving e mWoven a -> Union r mWoven a
Union (ElemOf e (e2 : e : e4 : e5 : r)
-> ElemOf e (e1 : e2 : e : e4 : e5 : r)
forall a (e :: a) (r1 :: [a]) (e' :: a).
ElemOf e r1 -> ElemOf e (e' : r1)
There (ElemOf e (e : e4 : e5 : r) -> ElemOf e (e2 : e : e4 : e5 : r)
forall a (e :: a) (r1 :: [a]) (e' :: a).
ElemOf e r1 -> ElemOf e (e' : r1)
There ElemOf e (e : e4 : e5 : r)
forall a (e :: a) (r1 :: [a]). ElemOf e (e : r1)
Here)) Weaving e m x
a
    weaken4Under (Union (There (There (There ElemOf e r1
Here))) Weaving e m x
a) = ElemOf e (e1 : e2 : e3 : e : e5 : r)
-> Weaving e m x -> Union (e1 : e2 : e3 : e : e5 : r) m x
forall (e :: (* -> *) -> * -> *) (r :: EffectRow)
       (mWoven :: * -> *) a.
ElemOf e r -> Weaving e mWoven a -> Union r mWoven a
Union (ElemOf e (e2 : e3 : e : e5 : r)
-> ElemOf e (e1 : e2 : e3 : e : e5 : r)
forall a (e :: a) (r1 :: [a]) (e' :: a).
ElemOf e r1 -> ElemOf e (e' : r1)
There (ElemOf e (e3 : e : e5 : r) -> ElemOf e (e2 : e3 : e : e5 : r)
forall a (e :: a) (r1 :: [a]) (e' :: a).
ElemOf e r1 -> ElemOf e (e' : r1)
There (ElemOf e (e : e5 : r) -> ElemOf e (e3 : e : e5 : r)
forall a (e :: a) (r1 :: [a]) (e' :: a).
ElemOf e r1 -> ElemOf e (e' : r1)
There ElemOf e (e : e5 : r)
forall a (e :: a) (r1 :: [a]). ElemOf e (e : r1)
Here))) Weaving e m x
a
    weaken4Under (Union (There (There (There (There ElemOf e r1
n)))) Weaving e m x
a) = ElemOf e (e1 : e2 : e3 : e4 : e5 : r1)
-> Weaving e m x -> Union (e1 : e2 : e3 : e4 : e5 : r1) m x
forall (e :: (* -> *) -> * -> *) (r :: EffectRow)
       (mWoven :: * -> *) a.
ElemOf e r -> Weaving e mWoven a -> Union r mWoven a
Union (ElemOf e (e2 : e3 : e4 : e5 : r1)
-> ElemOf e (e1 : e2 : e3 : e4 : e5 : r1)
forall a (e :: a) (r1 :: [a]) (e' :: a).
ElemOf e r1 -> ElemOf e (e' : r1)
There (ElemOf e (e3 : e4 : e5 : r1) -> ElemOf e (e2 : e3 : e4 : e5 : r1)
forall a (e :: a) (r1 :: [a]) (e' :: a).
ElemOf e r1 -> ElemOf e (e' : r1)
There (ElemOf e (e4 : e5 : r1) -> ElemOf e (e3 : e4 : e5 : r1)
forall a (e :: a) (r1 :: [a]) (e' :: a).
ElemOf e r1 -> ElemOf e (e' : r1)
There (ElemOf e (e5 : r1) -> ElemOf e (e4 : e5 : r1)
forall a (e :: a) (r1 :: [a]) (e' :: a).
ElemOf e r1 -> ElemOf e (e' : r1)
There (ElemOf e r1 -> ElemOf e (e5 : r1)
forall a (e :: a) (r1 :: [a]) (e' :: a).
ElemOf e r1 -> ElemOf e (e' : r1)
There ElemOf e r1
n))))) Weaving e m x
a
    {-# INLINE weaken4Under #-}
{-# INLINE raise4Under #-}

-- | Swap the positions of the first two effects in the stack.
--
-- @since 0.1.2.0
rotateEffects2 :: forall e1 e2 r a. Sem (e1 ': e2 ': r) a -> Sem (e2 ': e1 ': r) a
rotateEffects2 :: Sem (e1 : e2 : r) a -> Sem (e2 : e1 : r) a
rotateEffects2 = Sem (e1 : e2 : r) a -> Sem (e1 : e2 : e1 : r) a
forall (e3 :: (* -> *) -> * -> *) (e1 :: (* -> *) -> * -> *)
       (e2 :: (* -> *) -> * -> *) (r :: EffectRow) a.
Sem (e1 : e2 : r) a -> Sem (e1 : e2 : e3 : r) a
raise2Under (Sem (e1 : e2 : r) a -> Sem (e1 : e2 : e1 : r) a)
-> (Sem (e1 : e2 : e1 : r) a -> Sem (e2 : e1 : r) a)
-> Sem (e1 : e2 : r) a
-> Sem (e2 : e1 : r) a
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> ElemOf e1 (e2 : e1 : r)
-> Sem (e1 : e2 : e1 : r) a -> Sem (e2 : e1 : r) a
forall (e :: (* -> *) -> * -> *) (r :: EffectRow) a.
ElemOf e r -> Sem (e : r) a -> Sem r a
subsumeUsing (ElemOf e1 (e1 : r) -> ElemOf e1 (e2 : e1 : r)
forall a (e :: a) (r1 :: [a]) (e' :: a).
ElemOf e r1 -> ElemOf e (e' : r1)
There ElemOf e1 (e1 : r)
forall a (e :: a) (r1 :: [a]). ElemOf e (e : r1)
Here)
{-# INLINE rotateEffects2 #-}

-- | Rotate the first three effects in the stack to the left.
--
-- @since 0.1.2.0
rotateEffects3L :: forall e1 e2 e3 r a. Sem (e1 ': e2 ': e3 ': r) a -> Sem (e2 ': e3 ': e1 ': r) a
rotateEffects3L :: Sem (e1 : e2 : e3 : r) a -> Sem (e2 : e3 : e1 : r) a
rotateEffects3L = Sem (e1 : e2 : e3 : r) a -> Sem (e1 : e2 : e3 : e1 : r) a
forall (e4 :: (* -> *) -> * -> *) (e1 :: (* -> *) -> * -> *)
       (e2 :: (* -> *) -> * -> *) (e3 :: (* -> *) -> * -> *)
       (r :: EffectRow) a.
Sem (e1 : e2 : e3 : r) a -> Sem (e1 : e2 : e3 : e4 : r) a
raise3Under (Sem (e1 : e2 : e3 : r) a -> Sem (e1 : e2 : e3 : e1 : r) a)
-> (Sem (e1 : e2 : e3 : e1 : r) a -> Sem (e2 : e3 : e1 : r) a)
-> Sem (e1 : e2 : e3 : r) a
-> Sem (e2 : e3 : e1 : r) a
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> ElemOf e1 (e2 : e3 : e1 : r)
-> Sem (e1 : e2 : e3 : e1 : r) a -> Sem (e2 : e3 : e1 : r) a
forall (e :: (* -> *) -> * -> *) (r :: EffectRow) a.
ElemOf e r -> Sem (e : r) a -> Sem r a
subsumeUsing (ElemOf e1 (e3 : e1 : r) -> ElemOf e1 (e2 : e3 : e1 : r)
forall a (e :: a) (r1 :: [a]) (e' :: a).
ElemOf e r1 -> ElemOf e (e' : r1)
There (ElemOf e1 (e3 : e1 : r) -> ElemOf e1 (e2 : e3 : e1 : r))
-> ElemOf e1 (e3 : e1 : r) -> ElemOf e1 (e2 : e3 : e1 : r)
forall a b. (a -> b) -> a -> b
$ ElemOf e1 (e1 : r) -> ElemOf e1 (e3 : e1 : r)
forall a (e :: a) (r1 :: [a]) (e' :: a).
ElemOf e r1 -> ElemOf e (e' : r1)
There ElemOf e1 (e1 : r)
forall a (e :: a) (r1 :: [a]). ElemOf e (e : r1)
Here)
{-# INLINE rotateEffects3L #-}

-- | Rotate the first three effects in the stack to the right.
--
-- @since 0.1.2.0
rotateEffects3R :: forall e1 e2 e3 r a. Sem (e1 ': e2 ': e3 ': r) a -> Sem (e3 ': e1 ': e2 ': r) a
rotateEffects3R :: Sem (e1 : e2 : e3 : r) a -> Sem (e3 : e1 : e2 : r) a
rotateEffects3R = Sem (e1 : e2 : e3 : r) a -> Sem (e2 : e3 : e1 : r) a
forall (e1 :: (* -> *) -> * -> *) (e2 :: (* -> *) -> * -> *)
       (e3 :: (* -> *) -> * -> *) (r :: EffectRow) a.
Sem (e1 : e2 : e3 : r) a -> Sem (e2 : e3 : e1 : r) a
rotateEffects3L (Sem (e1 : e2 : e3 : r) a -> Sem (e2 : e3 : e1 : r) a)
-> (Sem (e2 : e3 : e1 : r) a -> Sem (e3 : e1 : e2 : r) a)
-> Sem (e1 : e2 : e3 : r) a
-> Sem (e3 : e1 : e2 : r) a
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> Sem (e2 : e3 : e1 : r) a -> Sem (e3 : e1 : e2 : r) a
forall (e1 :: (* -> *) -> * -> *) (e2 :: (* -> *) -> * -> *)
       (e3 :: (* -> *) -> * -> *) (r :: EffectRow) a.
Sem (e1 : e2 : e3 : r) a -> Sem (e2 : e3 : e1 : r) a
rotateEffects3L
{-# INLINE rotateEffects3R #-}

-- | Rotate the first four effects in the stack to the left.
--
-- @since 0.1.3.0
rotateEffects4L :: forall e1 e2 e3 e4 r a. Sem (e1 ': e2 ': e3 ': e4 ': r) a -> Sem (e2 ': e3 ': e4 ': e1 ': r) a
rotateEffects4L :: Sem (e1 : e2 : e3 : e4 : r) a -> Sem (e2 : e3 : e4 : e1 : r) a
rotateEffects4L = Sem (e1 : e2 : e3 : e4 : r) a -> Sem (e1 : e2 : e3 : e4 : e1 : r) a
forall (e5 :: (* -> *) -> * -> *) (e1 :: (* -> *) -> * -> *)
       (e2 :: (* -> *) -> * -> *) (e3 :: (* -> *) -> * -> *)
       (e4 :: (* -> *) -> * -> *) (r :: EffectRow) a.
Sem (e1 : e2 : e3 : e4 : r) a -> Sem (e1 : e2 : e3 : e4 : e5 : r) a
raise4Under (Sem (e1 : e2 : e3 : e4 : r) a
 -> Sem (e1 : e2 : e3 : e4 : e1 : r) a)
-> (Sem (e1 : e2 : e3 : e4 : e1 : r) a
    -> Sem (e2 : e3 : e4 : e1 : r) a)
-> Sem (e1 : e2 : e3 : e4 : r) a
-> Sem (e2 : e3 : e4 : e1 : r) a
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> ElemOf e1 (e2 : e3 : e4 : e1 : r)
-> Sem (e1 : e2 : e3 : e4 : e1 : r) a
-> Sem (e2 : e3 : e4 : e1 : r) a
forall (e :: (* -> *) -> * -> *) (r :: EffectRow) a.
ElemOf e r -> Sem (e : r) a -> Sem r a
subsumeUsing (ElemOf e1 (e3 : e4 : e1 : r) -> ElemOf e1 (e2 : e3 : e4 : e1 : r)
forall a (e :: a) (r1 :: [a]) (e' :: a).
ElemOf e r1 -> ElemOf e (e' : r1)
There (ElemOf e1 (e3 : e4 : e1 : r) -> ElemOf e1 (e2 : e3 : e4 : e1 : r))
-> ElemOf e1 (e3 : e4 : e1 : r)
-> ElemOf e1 (e2 : e3 : e4 : e1 : r)
forall a b. (a -> b) -> a -> b
$ ElemOf e1 (e4 : e1 : r) -> ElemOf e1 (e3 : e4 : e1 : r)
forall a (e :: a) (r1 :: [a]) (e' :: a).
ElemOf e r1 -> ElemOf e (e' : r1)
There (ElemOf e1 (e4 : e1 : r) -> ElemOf e1 (e3 : e4 : e1 : r))
-> ElemOf e1 (e4 : e1 : r) -> ElemOf e1 (e3 : e4 : e1 : r)
forall a b. (a -> b) -> a -> b
$ ElemOf e1 (e1 : r) -> ElemOf e1 (e4 : e1 : r)
forall a (e :: a) (r1 :: [a]) (e' :: a).
ElemOf e r1 -> ElemOf e (e' : r1)
There ElemOf e1 (e1 : r)
forall a (e :: a) (r1 :: [a]). ElemOf e (e : r1)
Here)
{-# INLINE rotateEffects4L #-}

-- | Rotate the first four effects in the stack to the right.
--
-- @since 0.1.3.0
rotateEffects4R :: forall e1 e2 e3 e4 r a. Sem (e1 ': e2 ': e3 ': e4 ': r) a -> Sem (e4 ': e1 ': e2 ': e3 ': r) a
rotateEffects4R :: Sem (e1 : e2 : e3 : e4 : r) a -> Sem (e4 : e1 : e2 : e3 : r) a
rotateEffects4R = Sem (e1 : e2 : e3 : e4 : r) a -> Sem (e2 : e3 : e4 : e1 : r) a
forall (e1 :: (* -> *) -> * -> *) (e2 :: (* -> *) -> * -> *)
       (e3 :: (* -> *) -> * -> *) (e4 :: (* -> *) -> * -> *)
       (r :: EffectRow) a.
Sem (e1 : e2 : e3 : e4 : r) a -> Sem (e2 : e3 : e4 : e1 : r) a
rotateEffects4L (Sem (e1 : e2 : e3 : e4 : r) a -> Sem (e2 : e3 : e4 : e1 : r) a)
-> (Sem (e2 : e3 : e4 : e1 : r) a -> Sem (e4 : e1 : e2 : e3 : r) a)
-> Sem (e1 : e2 : e3 : e4 : r) a
-> Sem (e4 : e1 : e2 : e3 : r) a
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> Sem (e2 : e3 : e4 : e1 : r) a -> Sem (e3 : e4 : e1 : e2 : r) a
forall (e1 :: (* -> *) -> * -> *) (e2 :: (* -> *) -> * -> *)
       (e3 :: (* -> *) -> * -> *) (e4 :: (* -> *) -> * -> *)
       (r :: EffectRow) a.
Sem (e1 : e2 : e3 : e4 : r) a -> Sem (e2 : e3 : e4 : e1 : r) a
rotateEffects4L (Sem (e2 : e3 : e4 : e1 : r) a -> Sem (e3 : e4 : e1 : e2 : r) a)
-> (Sem (e3 : e4 : e1 : e2 : r) a -> Sem (e4 : e1 : e2 : e3 : r) a)
-> Sem (e2 : e3 : e4 : e1 : r) a
-> Sem (e4 : e1 : e2 : e3 : r) a
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> Sem (e3 : e4 : e1 : e2 : r) a -> Sem (e4 : e1 : e2 : e3 : r) a
forall (e1 :: (* -> *) -> * -> *) (e2 :: (* -> *) -> * -> *)
       (e3 :: (* -> *) -> * -> *) (e4 :: (* -> *) -> * -> *)
       (r :: EffectRow) a.
Sem (e1 : e2 : e3 : e4 : r) a -> Sem (e2 : e3 : e4 : e1 : r) a
rotateEffects4L
{-# INLINE rotateEffects4R #-}

-- | Reverse the position of the first two effects in the stack, equivalent to `rotateEffects2`.
--
-- @since 0.1.3.0
reverseEffects2 :: forall e1 e2 r a. Sem (e1 ': e2 ': r) a -> Sem (e2 ': e1 ': r) a
reverseEffects2 :: Sem (e1 : e2 : r) a -> Sem (e2 : e1 : r) a
reverseEffects2 = Sem (e1 : e2 : r) a -> Sem (e2 : e1 : r) a
forall (e1 :: (* -> *) -> * -> *) (e2 :: (* -> *) -> * -> *)
       (r :: EffectRow) a.
Sem (e1 : e2 : r) a -> Sem (e2 : e1 : r) a
rotateEffects2
{-# INLINE reverseEffects2 #-}

-- | Reverse the position of the first three effects in the stack.
--
-- @since 0.1.3.0
reverseEffects3 :: forall e1 e2 e3 r a. Sem (e1 ': e2 ': e3 ': r) a -> Sem (e3 ': e2 ': e1 ': r) a
reverseEffects3 :: Sem (e1 : e2 : e3 : r) a -> Sem (e3 : e2 : e1 : r) a
reverseEffects3 = Sem (e1 : e2 : e3 : r) a -> Sem (e2 : e3 : e1 : r) a
forall (e1 :: (* -> *) -> * -> *) (e2 :: (* -> *) -> * -> *)
       (e3 :: (* -> *) -> * -> *) (r :: EffectRow) a.
Sem (e1 : e2 : e3 : r) a -> Sem (e2 : e3 : e1 : r) a
rotateEffects3L (Sem (e1 : e2 : e3 : r) a -> Sem (e2 : e3 : e1 : r) a)
-> (Sem (e2 : e3 : e1 : r) a -> Sem (e3 : e2 : e1 : r) a)
-> Sem (e1 : e2 : e3 : r) a
-> Sem (e3 : e2 : e1 : r) a
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> Sem (e2 : e3 : e1 : r) a -> Sem (e3 : e2 : e1 : r) a
forall (e1 :: (* -> *) -> * -> *) (e2 :: (* -> *) -> * -> *)
       (r :: EffectRow) a.
Sem (e1 : e2 : r) a -> Sem (e2 : e1 : r) a
rotateEffects2
{-# INLINE reverseEffects3 #-}

-- | Reverse the position of the first four effects in the stack.
--
-- @since 0.1.3.0
reverseEffects4 :: forall e1 e2 e3 e4 r a. Sem (e1 ': e2 ': e3 ': e4 ': r) a -> Sem (e4 ': e3 ': e2 ': e1 ': r) a
reverseEffects4 :: Sem (e1 : e2 : e3 : e4 : r) a -> Sem (e4 : e3 : e2 : e1 : r) a
reverseEffects4 = Sem (e1 : e2 : e3 : e4 : r) a -> Sem (e2 : e3 : e4 : e1 : r) a
forall (e1 :: (* -> *) -> * -> *) (e2 :: (* -> *) -> * -> *)
       (e3 :: (* -> *) -> * -> *) (e4 :: (* -> *) -> * -> *)
       (r :: EffectRow) a.
Sem (e1 : e2 : e3 : e4 : r) a -> Sem (e2 : e3 : e4 : e1 : r) a
rotateEffects4L (Sem (e1 : e2 : e3 : e4 : r) a -> Sem (e2 : e3 : e4 : e1 : r) a)
-> (Sem (e2 : e3 : e4 : e1 : r) a -> Sem (e4 : e3 : e2 : e1 : r) a)
-> Sem (e1 : e2 : e3 : e4 : r) a
-> Sem (e4 : e3 : e2 : e1 : r) a
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> Sem (e2 : e3 : e4 : e1 : r) a -> Sem (e3 : e4 : e2 : e1 : r) a
forall (e1 :: (* -> *) -> * -> *) (e2 :: (* -> *) -> * -> *)
       (e3 :: (* -> *) -> * -> *) (r :: EffectRow) a.
Sem (e1 : e2 : e3 : r) a -> Sem (e2 : e3 : e1 : r) a
rotateEffects3L (Sem (e2 : e3 : e4 : e1 : r) a -> Sem (e3 : e4 : e2 : e1 : r) a)
-> (Sem (e3 : e4 : e2 : e1 : r) a -> Sem (e4 : e3 : e2 : e1 : r) a)
-> Sem (e2 : e3 : e4 : e1 : r) a
-> Sem (e4 : e3 : e2 : e1 : r) a
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> Sem (e3 : e4 : e2 : e1 : r) a -> Sem (e4 : e3 : e2 : e1 : r) a
forall (e1 :: (* -> *) -> * -> *) (e2 :: (* -> *) -> * -> *)
       (r :: EffectRow) a.
Sem (e1 : e2 : r) a -> Sem (e2 : e1 : r) a
rotateEffects2
{-# INLINE reverseEffects4 #-}