{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE QuantifiedConstraints #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UndecidableInstances #-}

-- |
-- Module      :   Grisette.Unified.Internal.Class.UnifiedSimpleMergeable
-- Copyright   :   (c) Sirui Lu 2024
-- License     :   BSD-3-Clause (see the LICENSE file)
--
-- Maintainer  :   siruilu@cs.washington.edu
-- Stability   :   Experimental
-- Portability :   GHC only
module Grisette.Unified.Internal.Class.UnifiedSimpleMergeable
  ( UnifiedBranching (..),
    UnifiedSimpleMergeable (..),
    UnifiedSimpleMergeable1 (..),
    UnifiedSimpleMergeable2 (..),
    mrgIf,
    liftBaseMonad,
    mrgIte,
    mrgIte1,
    liftMrgIte,
    mrgIte2,
    liftMrgIte2,
    simpleMerge,
  )
where

import Control.Monad.Cont (ContT)
import Control.Monad.Except (ExceptT)
import Control.Monad.Identity (Identity (runIdentity), IdentityT)
import Control.Monad.Trans.Maybe (MaybeT)
import qualified Control.Monad.Trans.RWS.Lazy as RWSLazy
import qualified Control.Monad.Trans.RWS.Strict as RWSStrict
import Control.Monad.Trans.Reader (ReaderT)
import qualified Control.Monad.Trans.State.Lazy as StateLazy
import qualified Control.Monad.Trans.State.Strict as StateStrict
import qualified Control.Monad.Trans.Writer.Lazy as WriterLazy
import qualified Control.Monad.Trans.Writer.Strict as WriterStrict
import Data.Kind (Constraint)
import Data.Type.Bool (If)
import Data.Typeable (Typeable)
import Grisette.Internal.Core.Control.Exception (AssertionError)
import Grisette.Internal.Core.Control.Monad.Union (liftUnion)
import Grisette.Internal.Core.Data.Class.GenSym (FreshT)
import Grisette.Internal.Core.Data.Class.Mergeable (Mergeable)
import qualified Grisette.Internal.Core.Data.Class.PlainUnion as Grisette
import Grisette.Internal.Core.Data.Class.SimpleMergeable
  ( SimpleMergeable,
    SimpleMergeable1,
    SimpleMergeable2,
    SymBranching,
  )
import qualified Grisette.Internal.Core.Data.Class.SimpleMergeable
import qualified Grisette.Internal.Core.Data.Class.SimpleMergeable as Grisette
import Grisette.Internal.Core.Data.Class.TryMerge
  ( TryMerge,
    mrgSingle,
  )
import Grisette.Internal.TH.DeriveUnifiedInterface
  ( deriveFunctorArgUnifiedInterfaces,
    deriveUnifiedInterface1s,
  )
import Grisette.Unified.Internal.BaseMonad (BaseMonad)
import Grisette.Unified.Internal.EvalModeTag
  ( EvalModeTag,
    IsConMode,
  )
import Grisette.Unified.Internal.UnifiedBool (UnifiedBool (GetBool))
import Grisette.Unified.Internal.Util (withMode)

-- | Unified `Grisette.mrgIf`.
--
-- This function isn't able to infer the mode of the boolean variable, so you
-- need to provide the mode explicitly. For example:
--
-- > mrgIf @mode (a .== b) ...
-- > mrgIf (a .== b :: SymBool) ...
-- > mrgIf (a .== b :: GetBool mode) ...
mrgIf ::
  forall mode a m.
  (Typeable mode, Mergeable a, UnifiedBranching mode m) =>
  GetBool mode ->
  m a ->
  m a ->
  m a
mrgIf :: forall (mode :: EvalModeTag) a (m :: * -> *).
(Typeable mode, Mergeable a, UnifiedBranching mode m) =>
GetBool mode -> m a -> m a -> m a
mrgIf GetBool mode
c m a
t m a
e =
  forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
    (if Bool
GetBool mode
c then m a
t else m a
e)
    (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m ((If (IsConMode mode) (TryMerge m) (SymBranching m) => m a) -> m a)
-> (If (IsConMode mode) (TryMerge m) (SymBranching m) => m a)
-> m a
forall a b. (a -> b) -> a -> b
$ SymBool -> m a -> m a -> m a
forall (u :: * -> *) a.
(SymBranching u, Mergeable a) =>
SymBool -> u a -> u a -> u a
Grisette.mrgIf SymBool
GetBool mode
c m a
t m a
e)
{-# INLINE mrgIf #-}

-- | Unified lifting of a base monad.
liftBaseMonad ::
  forall mode a m.
  ( Applicative m,
    UnifiedBranching mode m,
    Mergeable a
  ) =>
  BaseMonad mode a ->
  m a
liftBaseMonad :: forall (mode :: EvalModeTag) a (m :: * -> *).
(Applicative m, UnifiedBranching mode m, Mergeable a) =>
BaseMonad mode a -> m a
liftBaseMonad BaseMonad mode a
b =
  forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
    (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m ((If (IsConMode mode) (TryMerge m) (SymBranching m) => m a) -> m a)
-> (If (IsConMode mode) (TryMerge m) (SymBranching m) => m a)
-> m a
forall a b. (a -> b) -> a -> b
$ a -> m a
forall (m :: * -> *) a.
(TryMerge m, Applicative m, Mergeable a) =>
a -> m a
mrgSingle (a -> m a) -> (BaseMonad mode a -> a) -> BaseMonad mode a -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Identity a -> a
BaseMonad mode a -> a
forall a. Identity a -> a
runIdentity (BaseMonad mode a -> m a) -> BaseMonad mode a -> m a
forall a b. (a -> b) -> a -> b
$ BaseMonad mode a
b)
    (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m ((If (IsConMode mode) (TryMerge m) (SymBranching m) => m a) -> m a)
-> (If (IsConMode mode) (TryMerge m) (SymBranching m) => m a)
-> m a
forall a b. (a -> b) -> a -> b
$ Union a -> m a
forall (u :: * -> *) a.
(Mergeable a, SymBranching u, Applicative u) =>
Union a -> u a
liftUnion Union a
BaseMonad mode a
b)
{-# INLINE liftBaseMonad #-}

-- | Unified merge of simply mergeable values in the base monad.
simpleMerge ::
  forall mode a.
  (Typeable mode, UnifiedSimpleMergeable mode a) =>
  BaseMonad mode a ->
  a
simpleMerge :: forall (mode :: EvalModeTag) a.
(Typeable mode, UnifiedSimpleMergeable mode a) =>
BaseMonad mode a -> a
simpleMerge =
  forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
    (mode ~ 'Con) => BaseMonad mode a -> a
Identity a -> a
BaseMonad mode a -> a
forall a. Identity a -> a
runIdentity
    (forall (mode :: EvalModeTag) a r.
UnifiedSimpleMergeable mode a =>
(If (IsConMode mode) (() :: Constraint) (SimpleMergeable a) => r)
-> r
withBaseSimpleMergeable @mode @a If (IsConMode mode) (() :: Constraint) (SimpleMergeable a) =>
BaseMonad mode a -> a
Union a -> a
BaseMonad mode a -> a
forall (u :: * -> *) a.
(SimpleMergeable a, PlainUnion u) =>
u a -> a
Grisette.simpleMerge)

-- | Unified `Grisette.mrgIte`.
mrgIte ::
  forall mode a.
  (Typeable mode, UnifiedSimpleMergeable mode a) =>
  GetBool mode ->
  a ->
  a ->
  a
mrgIte :: forall (mode :: EvalModeTag) a.
(Typeable mode, UnifiedSimpleMergeable mode a) =>
GetBool mode -> a -> a -> a
mrgIte GetBool mode
c a
t a
e =
  forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
    (if Bool
GetBool mode
c then a
t else a
e)
    ( forall (mode :: EvalModeTag) a r.
UnifiedSimpleMergeable mode a =>
(If (IsConMode mode) (() :: Constraint) (SimpleMergeable a) => r)
-> r
withBaseSimpleMergeable @mode @a ((If (IsConMode mode) (() :: Constraint) (SimpleMergeable a) => a)
 -> a)
-> (If (IsConMode mode) (() :: Constraint) (SimpleMergeable a) =>
    a)
-> a
forall a b. (a -> b) -> a -> b
$
        SymBool -> a -> a -> a
forall a. SimpleMergeable a => SymBool -> a -> a -> a
Grisette.Internal.Core.Data.Class.SimpleMergeable.mrgIte SymBool
GetBool mode
c a
t a
e
    )

-- | Unified `Grisette.mrgIte1`.
mrgIte1 ::
  forall mode f a.
  ( Typeable mode,
    UnifiedSimpleMergeable1 mode f,
    UnifiedSimpleMergeable mode a
  ) =>
  GetBool mode ->
  f a ->
  f a ->
  f a
mrgIte1 :: forall (mode :: EvalModeTag) (f :: * -> *) a.
(Typeable mode, UnifiedSimpleMergeable1 mode f,
 UnifiedSimpleMergeable mode a) =>
GetBool mode -> f a -> f a -> f a
mrgIte1 GetBool mode
c f a
t f a
e =
  forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
    (if Bool
GetBool mode
c then f a
t else f a
e)
    ( forall (mode :: EvalModeTag) a r.
UnifiedSimpleMergeable mode a =>
(If (IsConMode mode) (() :: Constraint) (SimpleMergeable a) => r)
-> r
withBaseSimpleMergeable @mode @a ((If (IsConMode mode) (() :: Constraint) (SimpleMergeable a) =>
  f a)
 -> f a)
-> (If (IsConMode mode) (() :: Constraint) (SimpleMergeable a) =>
    f a)
-> f a
forall a b. (a -> b) -> a -> b
$
        forall (mode :: EvalModeTag) (f :: * -> *) r.
UnifiedSimpleMergeable1 mode f =>
(If (IsConMode mode) (() :: Constraint) (SimpleMergeable1 f) => r)
-> r
withBaseSimpleMergeable1 @mode @f ((If (IsConMode mode) (() :: Constraint) (SimpleMergeable1 f) =>
  f a)
 -> f a)
-> (If (IsConMode mode) (() :: Constraint) (SimpleMergeable1 f) =>
    f a)
-> f a
forall a b. (a -> b) -> a -> b
$
          SymBool -> f a -> f a -> f a
forall (u :: * -> *) a.
(SimpleMergeable1 u, SimpleMergeable a) =>
SymBool -> u a -> u a -> u a
Grisette.Internal.Core.Data.Class.SimpleMergeable.mrgIte1 SymBool
GetBool mode
c f a
t f a
e
    )

-- | Unified `Grisette.liftMrgIte`.
liftMrgIte ::
  forall mode f a.
  ( Typeable mode,
    UnifiedSimpleMergeable1 mode f
  ) =>
  (GetBool mode -> a -> a -> a) ->
  GetBool mode ->
  f a ->
  f a ->
  f a
liftMrgIte :: forall (mode :: EvalModeTag) (f :: * -> *) a.
(Typeable mode, UnifiedSimpleMergeable1 mode f) =>
(GetBool mode -> a -> a -> a) -> GetBool mode -> f a -> f a -> f a
liftMrgIte GetBool mode -> a -> a -> a
f GetBool mode
c f a
t f a
e =
  forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
    (if Bool
GetBool mode
c then f a
t else f a
e)
    ( forall (mode :: EvalModeTag) (f :: * -> *) r.
UnifiedSimpleMergeable1 mode f =>
(If (IsConMode mode) (() :: Constraint) (SimpleMergeable1 f) => r)
-> r
withBaseSimpleMergeable1 @mode @f ((If (IsConMode mode) (() :: Constraint) (SimpleMergeable1 f) =>
  f a)
 -> f a)
-> (If (IsConMode mode) (() :: Constraint) (SimpleMergeable1 f) =>
    f a)
-> f a
forall a b. (a -> b) -> a -> b
$
        (SymBool -> a -> a -> a) -> SymBool -> f a -> f a -> f a
forall a. (SymBool -> a -> a -> a) -> SymBool -> f a -> f a -> f a
forall (u :: * -> *) a.
SimpleMergeable1 u =>
(SymBool -> a -> a -> a) -> SymBool -> u a -> u a -> u a
Grisette.Internal.Core.Data.Class.SimpleMergeable.liftMrgIte SymBool -> a -> a -> a
GetBool mode -> a -> a -> a
f SymBool
GetBool mode
c f a
t f a
e
    )

-- | Unified `Grisette.mrgIte2`.
mrgIte2 ::
  forall mode f a b.
  ( Typeable mode,
    UnifiedSimpleMergeable2 mode f,
    UnifiedSimpleMergeable mode a,
    UnifiedSimpleMergeable mode b
  ) =>
  GetBool mode ->
  f a b ->
  f a b ->
  f a b
mrgIte2 :: forall (mode :: EvalModeTag) (f :: * -> * -> *) a b.
(Typeable mode, UnifiedSimpleMergeable2 mode f,
 UnifiedSimpleMergeable mode a, UnifiedSimpleMergeable mode b) =>
GetBool mode -> f a b -> f a b -> f a b
mrgIte2 GetBool mode
c f a b
t f a b
e =
  forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
    (if Bool
GetBool mode
c then f a b
t else f a b
e)
    ( forall (mode :: EvalModeTag) a r.
UnifiedSimpleMergeable mode a =>
(If (IsConMode mode) (() :: Constraint) (SimpleMergeable a) => r)
-> r
withBaseSimpleMergeable @mode @a ((If (IsConMode mode) (() :: Constraint) (SimpleMergeable a) =>
  f a b)
 -> f a b)
-> (If (IsConMode mode) (() :: Constraint) (SimpleMergeable a) =>
    f a b)
-> f a b
forall a b. (a -> b) -> a -> b
$
        forall (mode :: EvalModeTag) a r.
UnifiedSimpleMergeable mode a =>
(If (IsConMode mode) (() :: Constraint) (SimpleMergeable a) => r)
-> r
withBaseSimpleMergeable @mode @b ((If (IsConMode mode) (() :: Constraint) (SimpleMergeable b) =>
  f a b)
 -> f a b)
-> (If (IsConMode mode) (() :: Constraint) (SimpleMergeable b) =>
    f a b)
-> f a b
forall a b. (a -> b) -> a -> b
$
          forall (mode :: EvalModeTag) (f :: * -> * -> *) r.
UnifiedSimpleMergeable2 mode f =>
(If (IsConMode mode) (() :: Constraint) (SimpleMergeable2 f) => r)
-> r
withBaseSimpleMergeable2 @mode @f ((If (IsConMode mode) (() :: Constraint) (SimpleMergeable2 f) =>
  f a b)
 -> f a b)
-> (If (IsConMode mode) (() :: Constraint) (SimpleMergeable2 f) =>
    f a b)
-> f a b
forall a b. (a -> b) -> a -> b
$
            SymBool -> f a b -> f a b -> f a b
forall (u :: * -> * -> *) a b.
(SimpleMergeable2 u, SimpleMergeable a, SimpleMergeable b) =>
SymBool -> u a b -> u a b -> u a b
Grisette.Internal.Core.Data.Class.SimpleMergeable.mrgIte2 SymBool
GetBool mode
c f a b
t f a b
e
    )

-- | Unified `Grisette.liftMrgIte2`.
liftMrgIte2 ::
  forall mode f a b.
  ( Typeable mode,
    UnifiedSimpleMergeable2 mode f
  ) =>
  (GetBool mode -> a -> a -> a) ->
  (GetBool mode -> b -> b -> b) ->
  GetBool mode ->
  f a b ->
  f a b ->
  f a b
liftMrgIte2 :: forall (mode :: EvalModeTag) (f :: * -> * -> *) a b.
(Typeable mode, UnifiedSimpleMergeable2 mode f) =>
(GetBool mode -> a -> a -> a)
-> (GetBool mode -> b -> b -> b)
-> GetBool mode
-> f a b
-> f a b
-> f a b
liftMrgIte2 GetBool mode -> a -> a -> a
f GetBool mode -> b -> b -> b
g GetBool mode
c f a b
t f a b
e =
  forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
    (if Bool
GetBool mode
c then f a b
t else f a b
e)
    ( forall (mode :: EvalModeTag) (f :: * -> * -> *) r.
UnifiedSimpleMergeable2 mode f =>
(If (IsConMode mode) (() :: Constraint) (SimpleMergeable2 f) => r)
-> r
withBaseSimpleMergeable2 @mode @f ((If (IsConMode mode) (() :: Constraint) (SimpleMergeable2 f) =>
  f a b)
 -> f a b)
-> (If (IsConMode mode) (() :: Constraint) (SimpleMergeable2 f) =>
    f a b)
-> f a b
forall a b. (a -> b) -> a -> b
$
        (SymBool -> a -> a -> a)
-> (SymBool -> b -> b -> b) -> SymBool -> f a b -> f a b -> f a b
forall a b.
(SymBool -> a -> a -> a)
-> (SymBool -> b -> b -> b) -> SymBool -> f a b -> f a b -> f a b
forall (u :: * -> * -> *) a b.
SimpleMergeable2 u =>
(SymBool -> a -> a -> a)
-> (SymBool -> b -> b -> b) -> SymBool -> u a b -> u a b -> u a b
Grisette.Internal.Core.Data.Class.SimpleMergeable.liftMrgIte2 SymBool -> a -> a -> a
GetBool mode -> a -> a -> a
f SymBool -> b -> b -> b
GetBool mode -> b -> b -> b
g SymBool
GetBool mode
c f a b
t f a b
e
    )

-- | A class that provides a unified simple merging.
--
-- We use this type class to help resolve the constraints for `SimpleMergeable`.
class UnifiedSimpleMergeable mode a where
  withBaseSimpleMergeable ::
    ((If (IsConMode mode) (() :: Constraint) (SimpleMergeable a)) => r) -> r

-- | A class that provides lifting of unified simple merging.
--
-- We use this type class to help resolve the constraints for
-- `SimpleMergeable1`.
class UnifiedSimpleMergeable1 mode f where
  withBaseSimpleMergeable1 ::
    ((If (IsConMode mode) (() :: Constraint) (SimpleMergeable1 f)) => r) -> r

-- | A class that provides lifting of unified simple merging.
--
-- We use this type class to help resolve the constraints for
-- `SimpleMergeable2`.
class UnifiedSimpleMergeable2 mode f where
  withBaseSimpleMergeable2 ::
    ((If (IsConMode mode) (() :: Constraint) (SimpleMergeable2 f)) => r) -> r

-- | A class that provides a unified branching operation.
--
-- We use this type class to help resolve the constraints for
-- `SymBranching`.
class
  (Typeable mode) =>
  UnifiedBranching (mode :: EvalModeTag) m
  where
  withBaseBranching ::
    ((If (IsConMode mode) (TryMerge m) (SymBranching m)) => r) -> r

instance
  {-# INCOHERENT #-}
  ( Typeable mode,
    If (IsConMode mode) ((TryMerge m) :: Constraint) (SymBranching m)
  ) =>
  UnifiedBranching mode m
  where
  withBaseBranching :: forall r.
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r = r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r
  {-# INLINE withBaseBranching #-}

instance
  {-# INCOHERENT #-}
  ( Typeable mode,
    If (IsConMode mode) (() :: Constraint) (SimpleMergeable m)
  ) =>
  UnifiedSimpleMergeable mode m
  where
  withBaseSimpleMergeable :: forall r.
(If (IsConMode mode) (() :: Constraint) (SimpleMergeable m) => r)
-> r
withBaseSimpleMergeable If (IsConMode mode) (() :: Constraint) (SimpleMergeable m) => r
r = r
If (IsConMode mode) (() :: Constraint) (SimpleMergeable m) => r
r
  {-# INLINE withBaseSimpleMergeable #-}

instance
  {-# INCOHERENT #-}
  ( Typeable mode,
    If (IsConMode mode) (() :: Constraint) (SimpleMergeable1 m)
  ) =>
  UnifiedSimpleMergeable1 mode m
  where
  withBaseSimpleMergeable1 :: forall r.
(If (IsConMode mode) (() :: Constraint) (SimpleMergeable1 m) => r)
-> r
withBaseSimpleMergeable1 If (IsConMode mode) (() :: Constraint) (SimpleMergeable1 m) => r
r = r
If (IsConMode mode) (() :: Constraint) (SimpleMergeable1 m) => r
r
  {-# INLINE withBaseSimpleMergeable1 #-}

instance
  {-# INCOHERENT #-}
  ( Typeable mode,
    If (IsConMode mode) (() :: Constraint) (SimpleMergeable2 m)
  ) =>
  UnifiedSimpleMergeable2 mode m
  where
  withBaseSimpleMergeable2 :: forall r.
(If (IsConMode mode) (() :: Constraint) (SimpleMergeable2 m) => r)
-> r
withBaseSimpleMergeable2 If (IsConMode mode) (() :: Constraint) (SimpleMergeable2 m) => r
r = r
If (IsConMode mode) (() :: Constraint) (SimpleMergeable2 m) => r
r
  {-# INLINE withBaseSimpleMergeable2 #-}

deriveFunctorArgUnifiedInterfaces
  ''UnifiedSimpleMergeable
  'withBaseSimpleMergeable
  ''UnifiedSimpleMergeable1
  'withBaseSimpleMergeable1
  [ ''(),
    ''(,),
    ''(,,),
    ''(,,,),
    ''(,,,,),
    ''(,,,,,),
    ''(,,,,,,),
    ''(,,,,,,,),
    ''(,,,,,,,,),
    ''(,,,,,,,,,),
    ''(,,,,,,,,,,),
    ''(,,,,,,,,,,,),
    ''(,,,,,,,,,,,,),
    ''(,,,,,,,,,,,,,),
    ''(,,,,,,,,,,,,,,),
    ''AssertionError,
    ''Identity
  ]

deriveUnifiedInterface1s
  ''UnifiedSimpleMergeable
  'withBaseSimpleMergeable
  ''UnifiedSimpleMergeable1
  'withBaseSimpleMergeable1
  [ ''(,),
    ''(,,),
    ''(,,,),
    ''(,,,,),
    ''(,,,,,),
    ''(,,,,,,),
    ''(,,,,,,,),
    ''(,,,,,,,,),
    ''(,,,,,,,,,),
    ''(,,,,,,,,,,),
    ''(,,,,,,,,,,,),
    ''(,,,,,,,,,,,,),
    ''(,,,,,,,,,,,,,),
    ''(,,,,,,,,,,,,,,),
    ''Identity
  ]

instance (Typeable mode) => UnifiedSimpleMergeable2 mode (,) where
  withBaseSimpleMergeable2 :: forall r.
(If (IsConMode mode) (() :: Constraint) (SimpleMergeable2 (,)) =>
 r)
-> r
withBaseSimpleMergeable2 If (IsConMode mode) (() :: Constraint) (SimpleMergeable2 (,)) => r
r = forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode r
(mode ~ 'Con) => r
If (IsConMode mode) (() :: Constraint) (SimpleMergeable2 (,)) => r
r r
(mode ~ 'Sym) => r
If (IsConMode mode) (() :: Constraint) (SimpleMergeable2 (,)) => r
r
  {-# INLINE withBaseSimpleMergeable2 #-}

instance
  (Typeable mode, UnifiedSimpleMergeable mode a) =>
  UnifiedSimpleMergeable2 mode ((,,) a)
  where
  withBaseSimpleMergeable2 :: forall r.
(If
   (IsConMode mode) (() :: Constraint) (SimpleMergeable2 ((,,) a)) =>
 r)
-> r
withBaseSimpleMergeable2 If
  (IsConMode mode) (() :: Constraint) (SimpleMergeable2 ((,,) a)) =>
r
r =
    forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
      (forall (mode :: EvalModeTag) a r.
UnifiedSimpleMergeable mode a =>
(If (IsConMode mode) (() :: Constraint) (SimpleMergeable a) => r)
-> r
withBaseSimpleMergeable @mode @a r
If
  (IsConMode mode) (() :: Constraint) (SimpleMergeable2 ((,,) a)) =>
r
If (IsConMode mode) (() :: Constraint) (SimpleMergeable a) => r
r)
      (forall (mode :: EvalModeTag) a r.
UnifiedSimpleMergeable mode a =>
(If (IsConMode mode) (() :: Constraint) (SimpleMergeable a) => r)
-> r
withBaseSimpleMergeable @mode @a r
If
  (IsConMode mode) (() :: Constraint) (SimpleMergeable2 ((,,) a)) =>
r
If (IsConMode mode) (() :: Constraint) (SimpleMergeable a) => r
r)
  {-# INLINE withBaseSimpleMergeable2 #-}

instance
  ( Typeable mode,
    UnifiedSimpleMergeable mode a,
    UnifiedSimpleMergeable mode b
  ) =>
  UnifiedSimpleMergeable2 mode ((,,,) a b)
  where
  withBaseSimpleMergeable2 :: forall r.
(If
   (IsConMode mode)
   (() :: Constraint)
   (SimpleMergeable2 ((,,,) a b)) =>
 r)
-> r
withBaseSimpleMergeable2 If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable2 ((,,,) a b)) =>
r
r =
    forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
      (forall (mode :: EvalModeTag) a r.
UnifiedSimpleMergeable mode a =>
(If (IsConMode mode) (() :: Constraint) (SimpleMergeable a) => r)
-> r
withBaseSimpleMergeable @mode @a ((If (IsConMode mode) (() :: Constraint) (SimpleMergeable a) => r)
 -> r)
-> (If (IsConMode mode) (() :: Constraint) (SimpleMergeable a) =>
    r)
-> r
forall a b. (a -> b) -> a -> b
$ forall (mode :: EvalModeTag) a r.
UnifiedSimpleMergeable mode a =>
(If (IsConMode mode) (() :: Constraint) (SimpleMergeable a) => r)
-> r
withBaseSimpleMergeable @mode @b r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable2 ((,,,) a b)) =>
r
If (IsConMode mode) (() :: Constraint) (SimpleMergeable b) => r
r)
      (forall (mode :: EvalModeTag) a r.
UnifiedSimpleMergeable mode a =>
(If (IsConMode mode) (() :: Constraint) (SimpleMergeable a) => r)
-> r
withBaseSimpleMergeable @mode @a ((If (IsConMode mode) (() :: Constraint) (SimpleMergeable a) => r)
 -> r)
-> (If (IsConMode mode) (() :: Constraint) (SimpleMergeable a) =>
    r)
-> r
forall a b. (a -> b) -> a -> b
$ forall (mode :: EvalModeTag) a r.
UnifiedSimpleMergeable mode a =>
(If (IsConMode mode) (() :: Constraint) (SimpleMergeable a) => r)
-> r
withBaseSimpleMergeable @mode @b r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable2 ((,,,) a b)) =>
r
If (IsConMode mode) (() :: Constraint) (SimpleMergeable b) => r
r)
  {-# INLINE withBaseSimpleMergeable2 #-}

instance
  (Typeable mode, UnifiedSimpleMergeable mode b) =>
  UnifiedSimpleMergeable mode (a -> b)
  where
  withBaseSimpleMergeable :: forall r.
(If
   (IsConMode mode) (() :: Constraint) (SimpleMergeable (a -> b)) =>
 r)
-> r
withBaseSimpleMergeable If
  (IsConMode mode) (() :: Constraint) (SimpleMergeable (a -> b)) =>
r
r =
    forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
      (forall (mode :: EvalModeTag) a r.
UnifiedSimpleMergeable mode a =>
(If (IsConMode mode) (() :: Constraint) (SimpleMergeable a) => r)
-> r
withBaseSimpleMergeable @mode @b r
If (IsConMode mode) (() :: Constraint) (SimpleMergeable b) => r
If
  (IsConMode mode) (() :: Constraint) (SimpleMergeable (a -> b)) =>
r
r)
      (forall (mode :: EvalModeTag) a r.
UnifiedSimpleMergeable mode a =>
(If (IsConMode mode) (() :: Constraint) (SimpleMergeable a) => r)
-> r
withBaseSimpleMergeable @mode @b r
If (IsConMode mode) (() :: Constraint) (SimpleMergeable b) => r
If
  (IsConMode mode) (() :: Constraint) (SimpleMergeable (a -> b)) =>
r
r)
  {-# INLINE withBaseSimpleMergeable #-}

instance (Typeable mode) => UnifiedSimpleMergeable1 mode ((->) a) where
  withBaseSimpleMergeable1 :: forall r.
(If
   (IsConMode mode) (() :: Constraint) (SimpleMergeable1 ((->) a)) =>
 r)
-> r
withBaseSimpleMergeable1 If
  (IsConMode mode) (() :: Constraint) (SimpleMergeable1 ((->) a)) =>
r
r = forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode r
(mode ~ 'Con) => r
If
  (IsConMode mode) (() :: Constraint) (SimpleMergeable1 ((->) a)) =>
r
r r
(mode ~ 'Sym) => r
If
  (IsConMode mode) (() :: Constraint) (SimpleMergeable1 ((->) a)) =>
r
r
  {-# INLINE withBaseSimpleMergeable1 #-}

instance (Typeable mode) => UnifiedSimpleMergeable2 mode (->) where
  withBaseSimpleMergeable2 :: forall r.
(If (IsConMode mode) (() :: Constraint) (SimpleMergeable2 (->)) =>
 r)
-> r
withBaseSimpleMergeable2 If (IsConMode mode) (() :: Constraint) (SimpleMergeable2 (->)) => r
r = forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode r
(mode ~ 'Con) => r
If (IsConMode mode) (() :: Constraint) (SimpleMergeable2 (->)) => r
r r
(mode ~ 'Sym) => r
If (IsConMode mode) (() :: Constraint) (SimpleMergeable2 (->)) => r
r
  {-# INLINE withBaseSimpleMergeable2 #-}

instance
  (Typeable mode, UnifiedBranching mode m, Mergeable a) =>
  UnifiedSimpleMergeable mode (FreshT m a)
  where
  withBaseSimpleMergeable :: forall r.
(If
   (IsConMode mode)
   (() :: Constraint)
   (SimpleMergeable (FreshT m a)) =>
 r)
-> r
withBaseSimpleMergeable If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable (FreshT m a)) =>
r
r =
    forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable (FreshT m a)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable (FreshT m a)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
  {-# INLINE withBaseSimpleMergeable #-}

instance
  (Typeable mode, UnifiedBranching mode m) =>
  UnifiedSimpleMergeable1 mode (FreshT m)
  where
  withBaseSimpleMergeable1 :: forall r.
(If
   (IsConMode mode)
   (() :: Constraint)
   (SimpleMergeable1 (FreshT m)) =>
 r)
-> r
withBaseSimpleMergeable1 If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable1 (FreshT m)) =>
r
r =
    forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable1 (FreshT m)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable1 (FreshT m)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
  {-# INLINE withBaseSimpleMergeable1 #-}

instance
  (Typeable mode, UnifiedBranching mode m) =>
  UnifiedBranching mode (FreshT m)
  where
  withBaseBranching :: forall r.
(If
   (IsConMode mode) (TryMerge (FreshT m)) (SymBranching (FreshT m)) =>
 r)
-> r
withBaseBranching If
  (IsConMode mode) (TryMerge (FreshT m)) (SymBranching (FreshT m)) =>
r
r =
    forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
If
  (IsConMode mode) (TryMerge (FreshT m)) (SymBranching (FreshT m)) =>
r
r)
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
If
  (IsConMode mode) (TryMerge (FreshT m)) (SymBranching (FreshT m)) =>
r
r)
  {-# INLINE withBaseBranching #-}

instance
  (Typeable mode, UnifiedBranching mode m, Mergeable a) =>
  UnifiedSimpleMergeable mode (MaybeT m a)
  where
  withBaseSimpleMergeable :: forall r.
(If
   (IsConMode mode)
   (() :: Constraint)
   (SimpleMergeable (MaybeT m a)) =>
 r)
-> r
withBaseSimpleMergeable If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable (MaybeT m a)) =>
r
r =
    forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable (MaybeT m a)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable (MaybeT m a)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
  {-# INLINE withBaseSimpleMergeable #-}

instance
  (Typeable mode, UnifiedBranching mode m) =>
  UnifiedSimpleMergeable1 mode (MaybeT m)
  where
  withBaseSimpleMergeable1 :: forall r.
(If
   (IsConMode mode)
   (() :: Constraint)
   (SimpleMergeable1 (MaybeT m)) =>
 r)
-> r
withBaseSimpleMergeable1 If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable1 (MaybeT m)) =>
r
r =
    forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable1 (MaybeT m)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable1 (MaybeT m)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
  {-# INLINE withBaseSimpleMergeable1 #-}

instance
  (Typeable mode, UnifiedBranching mode m) =>
  UnifiedBranching mode (MaybeT m)
  where
  withBaseBranching :: forall r.
(If
   (IsConMode mode) (TryMerge (MaybeT m)) (SymBranching (MaybeT m)) =>
 r)
-> r
withBaseBranching If
  (IsConMode mode) (TryMerge (MaybeT m)) (SymBranching (MaybeT m)) =>
r
r =
    forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
If
  (IsConMode mode) (TryMerge (MaybeT m)) (SymBranching (MaybeT m)) =>
r
r)
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
If
  (IsConMode mode) (TryMerge (MaybeT m)) (SymBranching (MaybeT m)) =>
r
r)
  {-# INLINE withBaseBranching #-}

instance
  (Typeable mode, UnifiedBranching mode m, Mergeable a) =>
  UnifiedSimpleMergeable mode (IdentityT m a)
  where
  withBaseSimpleMergeable :: forall r.
(If
   (IsConMode mode)
   (() :: Constraint)
   (SimpleMergeable (IdentityT m a)) =>
 r)
-> r
withBaseSimpleMergeable If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable (IdentityT m a)) =>
r
r =
    forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable (IdentityT m a)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable (IdentityT m a)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
  {-# INLINE withBaseSimpleMergeable #-}

instance
  (Typeable mode, UnifiedBranching mode m) =>
  UnifiedSimpleMergeable1 mode (IdentityT m)
  where
  withBaseSimpleMergeable1 :: forall r.
(If
   (IsConMode mode)
   (() :: Constraint)
   (SimpleMergeable1 (IdentityT m)) =>
 r)
-> r
withBaseSimpleMergeable1 If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable1 (IdentityT m)) =>
r
r =
    forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable1 (IdentityT m)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable1 (IdentityT m)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
  {-# INLINE withBaseSimpleMergeable1 #-}

instance
  (Typeable mode, UnifiedBranching mode m) =>
  UnifiedBranching mode (IdentityT m)
  where
  withBaseBranching :: forall r.
(If
   (IsConMode mode)
   (TryMerge (IdentityT m))
   (SymBranching (IdentityT m)) =>
 r)
-> r
withBaseBranching If
  (IsConMode mode)
  (TryMerge (IdentityT m))
  (SymBranching (IdentityT m)) =>
r
r =
    forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
If
  (IsConMode mode)
  (TryMerge (IdentityT m))
  (SymBranching (IdentityT m)) =>
r
r)
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
If
  (IsConMode mode)
  (TryMerge (IdentityT m))
  (SymBranching (IdentityT m)) =>
r
r)
  {-# INLINE withBaseBranching #-}

instance
  (Typeable mode, UnifiedBranching mode m, Mergeable a) =>
  UnifiedSimpleMergeable mode (ReaderT r m a)
  where
  withBaseSimpleMergeable :: forall r.
(If
   (IsConMode mode)
   (() :: Constraint)
   (SimpleMergeable (ReaderT r m a)) =>
 r)
-> r
withBaseSimpleMergeable If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable (ReaderT r m a)) =>
r
r =
    forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable (ReaderT r m a)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable (ReaderT r m a)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
  {-# INLINE withBaseSimpleMergeable #-}

instance
  (Typeable mode, UnifiedBranching mode m) =>
  UnifiedSimpleMergeable1 mode (ReaderT r m)
  where
  withBaseSimpleMergeable1 :: forall r.
(If
   (IsConMode mode)
   (() :: Constraint)
   (SimpleMergeable1 (ReaderT r m)) =>
 r)
-> r
withBaseSimpleMergeable1 If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable1 (ReaderT r m)) =>
r
r =
    forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable1 (ReaderT r m)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable1 (ReaderT r m)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
  {-# INLINE withBaseSimpleMergeable1 #-}

instance
  (Typeable mode, UnifiedBranching mode m) =>
  UnifiedBranching mode (ReaderT r m)
  where
  withBaseBranching :: forall r.
(If
   (IsConMode mode)
   (TryMerge (ReaderT r m))
   (SymBranching (ReaderT r m)) =>
 r)
-> r
withBaseBranching If
  (IsConMode mode)
  (TryMerge (ReaderT r m))
  (SymBranching (ReaderT r m)) =>
r
r =
    forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
If
  (IsConMode mode)
  (TryMerge (ReaderT r m))
  (SymBranching (ReaderT r m)) =>
r
r)
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
If
  (IsConMode mode)
  (TryMerge (ReaderT r m))
  (SymBranching (ReaderT r m)) =>
r
r)
  {-# INLINE withBaseBranching #-}

instance
  (Typeable mode, UnifiedBranching mode m, Mergeable s, Mergeable a) =>
  UnifiedSimpleMergeable mode (StateLazy.StateT s m a)
  where
  withBaseSimpleMergeable :: forall r.
(If
   (IsConMode mode)
   (() :: Constraint)
   (SimpleMergeable (StateT s m a)) =>
 r)
-> r
withBaseSimpleMergeable If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable (StateT s m a)) =>
r
r =
    forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable (StateT s m a)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable (StateT s m a)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
  {-# INLINE withBaseSimpleMergeable #-}

instance
  (Typeable mode, UnifiedBranching mode m, Mergeable s) =>
  UnifiedSimpleMergeable1 mode (StateLazy.StateT s m)
  where
  withBaseSimpleMergeable1 :: forall r.
(If
   (IsConMode mode)
   (() :: Constraint)
   (SimpleMergeable1 (StateT s m)) =>
 r)
-> r
withBaseSimpleMergeable1 If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable1 (StateT s m)) =>
r
r =
    forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable1 (StateT s m)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable1 (StateT s m)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
  {-# INLINE withBaseSimpleMergeable1 #-}

instance
  ( Typeable mode,
    UnifiedBranching mode m,
    Mergeable s
  ) =>
  UnifiedBranching mode (StateLazy.StateT s m)
  where
  withBaseBranching :: forall r.
(If
   (IsConMode mode)
   (TryMerge (StateT s m))
   (SymBranching (StateT s m)) =>
 r)
-> r
withBaseBranching If
  (IsConMode mode)
  (TryMerge (StateT s m))
  (SymBranching (StateT s m)) =>
r
r =
    forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
If
  (IsConMode mode)
  (TryMerge (StateT s m))
  (SymBranching (StateT s m)) =>
r
r)
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
If
  (IsConMode mode)
  (TryMerge (StateT s m))
  (SymBranching (StateT s m)) =>
r
r)
  {-# INLINE withBaseBranching #-}

instance
  (Typeable mode, UnifiedBranching mode m, Mergeable s, Mergeable a) =>
  UnifiedSimpleMergeable mode (StateStrict.StateT s m a)
  where
  withBaseSimpleMergeable :: forall r.
(If
   (IsConMode mode)
   (() :: Constraint)
   (SimpleMergeable (StateT s m a)) =>
 r)
-> r
withBaseSimpleMergeable If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable (StateT s m a)) =>
r
r =
    forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable (StateT s m a)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable (StateT s m a)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
  {-# INLINE withBaseSimpleMergeable #-}

instance
  (Typeable mode, UnifiedBranching mode m, Mergeable s) =>
  UnifiedSimpleMergeable1 mode (StateStrict.StateT s m)
  where
  withBaseSimpleMergeable1 :: forall r.
(If
   (IsConMode mode)
   (() :: Constraint)
   (SimpleMergeable1 (StateT s m)) =>
 r)
-> r
withBaseSimpleMergeable1 If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable1 (StateT s m)) =>
r
r =
    forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable1 (StateT s m)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable1 (StateT s m)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
  {-# INLINE withBaseSimpleMergeable1 #-}

instance
  ( Typeable mode,
    UnifiedBranching mode m,
    Mergeable s
  ) =>
  UnifiedBranching mode (StateStrict.StateT s m)
  where
  withBaseBranching :: forall r.
(If
   (IsConMode mode)
   (TryMerge (StateT s m))
   (SymBranching (StateT s m)) =>
 r)
-> r
withBaseBranching If
  (IsConMode mode)
  (TryMerge (StateT s m))
  (SymBranching (StateT s m)) =>
r
r =
    forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
If
  (IsConMode mode)
  (TryMerge (StateT s m))
  (SymBranching (StateT s m)) =>
r
r)
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
If
  (IsConMode mode)
  (TryMerge (StateT s m))
  (SymBranching (StateT s m)) =>
r
r)
  {-# INLINE withBaseBranching #-}

instance
  ( Typeable mode,
    UnifiedBranching mode m,
    Mergeable w,
    Mergeable a,
    Monoid w
  ) =>
  UnifiedSimpleMergeable mode (WriterLazy.WriterT w m a)
  where
  withBaseSimpleMergeable :: forall r.
(If
   (IsConMode mode)
   (() :: Constraint)
   (SimpleMergeable (WriterT w m a)) =>
 r)
-> r
withBaseSimpleMergeable If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable (WriterT w m a)) =>
r
r =
    forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable (WriterT w m a)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable (WriterT w m a)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
  {-# INLINE withBaseSimpleMergeable #-}

instance
  (Typeable mode, UnifiedBranching mode m, Mergeable w, Monoid w) =>
  UnifiedSimpleMergeable1 mode (WriterLazy.WriterT w m)
  where
  withBaseSimpleMergeable1 :: forall r.
(If
   (IsConMode mode)
   (() :: Constraint)
   (SimpleMergeable1 (WriterT w m)) =>
 r)
-> r
withBaseSimpleMergeable1 If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable1 (WriterT w m)) =>
r
r =
    forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable1 (WriterT w m)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable1 (WriterT w m)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
  {-# INLINE withBaseSimpleMergeable1 #-}

instance
  ( Typeable mode,
    UnifiedBranching mode m,
    Monoid w,
    Mergeable w
  ) =>
  UnifiedBranching mode (WriterLazy.WriterT w m)
  where
  withBaseBranching :: forall r.
(If
   (IsConMode mode)
   (TryMerge (WriterT w m))
   (SymBranching (WriterT w m)) =>
 r)
-> r
withBaseBranching If
  (IsConMode mode)
  (TryMerge (WriterT w m))
  (SymBranching (WriterT w m)) =>
r
r =
    forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
If
  (IsConMode mode)
  (TryMerge (WriterT w m))
  (SymBranching (WriterT w m)) =>
r
r)
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
If
  (IsConMode mode)
  (TryMerge (WriterT w m))
  (SymBranching (WriterT w m)) =>
r
r)
  {-# INLINE withBaseBranching #-}

instance
  ( Typeable mode,
    UnifiedBranching mode m,
    Mergeable w,
    Mergeable a,
    Monoid w
  ) =>
  UnifiedSimpleMergeable mode (WriterStrict.WriterT w m a)
  where
  withBaseSimpleMergeable :: forall r.
(If
   (IsConMode mode)
   (() :: Constraint)
   (SimpleMergeable (WriterT w m a)) =>
 r)
-> r
withBaseSimpleMergeable If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable (WriterT w m a)) =>
r
r =
    forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable (WriterT w m a)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable (WriterT w m a)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
  {-# INLINE withBaseSimpleMergeable #-}

instance
  (Typeable mode, UnifiedBranching mode m, Mergeable w, Monoid w) =>
  UnifiedSimpleMergeable1 mode (WriterStrict.WriterT w m)
  where
  withBaseSimpleMergeable1 :: forall r.
(If
   (IsConMode mode)
   (() :: Constraint)
   (SimpleMergeable1 (WriterT w m)) =>
 r)
-> r
withBaseSimpleMergeable1 If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable1 (WriterT w m)) =>
r
r =
    forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable1 (WriterT w m)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable1 (WriterT w m)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
  {-# INLINE withBaseSimpleMergeable1 #-}

instance
  ( Typeable mode,
    UnifiedBranching mode m,
    Monoid w,
    Mergeable w
  ) =>
  UnifiedBranching mode (WriterStrict.WriterT w m)
  where
  withBaseBranching :: forall r.
(If
   (IsConMode mode)
   (TryMerge (WriterT w m))
   (SymBranching (WriterT w m)) =>
 r)
-> r
withBaseBranching If
  (IsConMode mode)
  (TryMerge (WriterT w m))
  (SymBranching (WriterT w m)) =>
r
r =
    forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
If
  (IsConMode mode)
  (TryMerge (WriterT w m))
  (SymBranching (WriterT w m)) =>
r
r)
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
If
  (IsConMode mode)
  (TryMerge (WriterT w m))
  (SymBranching (WriterT w m)) =>
r
r)
  {-# INLINE withBaseBranching #-}

instance
  ( Typeable mode,
    UnifiedBranching mode m,
    Mergeable e,
    Mergeable a
  ) =>
  UnifiedSimpleMergeable mode (ExceptT e m a)
  where
  withBaseSimpleMergeable :: forall r.
(If
   (IsConMode mode)
   (() :: Constraint)
   (SimpleMergeable (ExceptT e m a)) =>
 r)
-> r
withBaseSimpleMergeable If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable (ExceptT e m a)) =>
r
r =
    forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable (ExceptT e m a)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable (ExceptT e m a)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
  {-# INLINE withBaseSimpleMergeable #-}

instance
  (Typeable mode, UnifiedBranching mode m, Mergeable e) =>
  UnifiedSimpleMergeable1 mode (ExceptT e m)
  where
  withBaseSimpleMergeable1 :: forall r.
(If
   (IsConMode mode)
   (() :: Constraint)
   (SimpleMergeable1 (ExceptT e m)) =>
 r)
-> r
withBaseSimpleMergeable1 If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable1 (ExceptT e m)) =>
r
r =
    forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable1 (ExceptT e m)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable1 (ExceptT e m)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
  {-# INLINE withBaseSimpleMergeable1 #-}

instance
  (Typeable mode, Mergeable e, UnifiedBranching mode m) =>
  UnifiedBranching mode (ExceptT e m)
  where
  withBaseBranching :: forall r.
(If
   (IsConMode mode)
   (TryMerge (ExceptT e m))
   (SymBranching (ExceptT e m)) =>
 r)
-> r
withBaseBranching If
  (IsConMode mode)
  (TryMerge (ExceptT e m))
  (SymBranching (ExceptT e m)) =>
r
r =
    forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
If
  (IsConMode mode)
  (TryMerge (ExceptT e m))
  (SymBranching (ExceptT e m)) =>
r
r)
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
If
  (IsConMode mode)
  (TryMerge (ExceptT e m))
  (SymBranching (ExceptT e m)) =>
r
r)
  {-# INLINE withBaseBranching #-}

instance
  ( Typeable mode,
    UnifiedBranching mode m,
    Mergeable r,
    Mergeable a
  ) =>
  UnifiedSimpleMergeable mode (ContT r m a)
  where
  withBaseSimpleMergeable :: forall r.
(If
   (IsConMode mode)
   (() :: Constraint)
   (SimpleMergeable (ContT r m a)) =>
 r)
-> r
withBaseSimpleMergeable If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable (ContT r m a)) =>
r
r =
    forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable (ContT r m a)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable (ContT r m a)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
  {-# INLINE withBaseSimpleMergeable #-}

instance
  (Typeable mode, UnifiedBranching mode m, Mergeable r) =>
  UnifiedSimpleMergeable1 mode (ContT r m)
  where
  withBaseSimpleMergeable1 :: forall r.
(If
   (IsConMode mode)
   (() :: Constraint)
   (SimpleMergeable1 (ContT r m)) =>
 r)
-> r
withBaseSimpleMergeable1 If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable1 (ContT r m)) =>
r
r =
    forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable1 (ContT r m)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable1 (ContT r m)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
  {-# INLINE withBaseSimpleMergeable1 #-}

instance
  (Typeable mode, Mergeable r, UnifiedBranching mode m) =>
  UnifiedBranching mode (ContT r m)
  where
  withBaseBranching :: forall r.
(If
   (IsConMode mode)
   (TryMerge (ContT r m))
   (SymBranching (ContT r m)) =>
 r)
-> r
withBaseBranching If
  (IsConMode mode)
  (TryMerge (ContT r m))
  (SymBranching (ContT r m)) =>
r
r =
    forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
If
  (IsConMode mode)
  (TryMerge (ContT r m))
  (SymBranching (ContT r m)) =>
r
r)
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
If
  (IsConMode mode)
  (TryMerge (ContT r m))
  (SymBranching (ContT r m)) =>
r
r)
  {-# INLINE withBaseBranching #-}

instance
  ( Typeable mode,
    UnifiedBranching mode m,
    Mergeable w,
    Monoid w,
    Mergeable s,
    Mergeable a
  ) =>
  UnifiedSimpleMergeable mode (RWSLazy.RWST r w s m a)
  where
  withBaseSimpleMergeable :: forall r.
(If
   (IsConMode mode)
   (() :: Constraint)
   (SimpleMergeable (RWST r w s m a)) =>
 r)
-> r
withBaseSimpleMergeable If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable (RWST r w s m a)) =>
r
r =
    forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable (RWST r w s m a)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable (RWST r w s m a)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
  {-# INLINE withBaseSimpleMergeable #-}

instance
  ( Typeable mode,
    UnifiedBranching mode m,
    Mergeable w,
    Monoid w,
    Mergeable s
  ) =>
  UnifiedSimpleMergeable1 mode (RWSLazy.RWST r w s m)
  where
  withBaseSimpleMergeable1 :: forall r.
(If
   (IsConMode mode)
   (() :: Constraint)
   (SimpleMergeable1 (RWST r w s m)) =>
 r)
-> r
withBaseSimpleMergeable1 If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable1 (RWST r w s m)) =>
r
r =
    forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable1 (RWST r w s m)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable1 (RWST r w s m)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
  {-# INLINE withBaseSimpleMergeable1 #-}

instance
  ( Typeable mode,
    UnifiedBranching mode m,
    Mergeable s,
    Monoid w,
    Mergeable w
  ) =>
  UnifiedBranching mode (RWSLazy.RWST r w s m)
  where
  withBaseBranching :: forall r.
(If
   (IsConMode mode)
   (TryMerge (RWST r w s m))
   (SymBranching (RWST r w s m)) =>
 r)
-> r
withBaseBranching If
  (IsConMode mode)
  (TryMerge (RWST r w s m))
  (SymBranching (RWST r w s m)) =>
r
r =
    forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
If
  (IsConMode mode)
  (TryMerge (RWST r w s m))
  (SymBranching (RWST r w s m)) =>
r
r)
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
If
  (IsConMode mode)
  (TryMerge (RWST r w s m))
  (SymBranching (RWST r w s m)) =>
r
r)
  {-# INLINE withBaseBranching #-}

instance
  ( Typeable mode,
    UnifiedBranching mode m,
    Mergeable w,
    Monoid w,
    Mergeable s,
    Mergeable a
  ) =>
  UnifiedSimpleMergeable mode (RWSStrict.RWST r w s m a)
  where
  withBaseSimpleMergeable :: forall r.
(If
   (IsConMode mode)
   (() :: Constraint)
   (SimpleMergeable (RWST r w s m a)) =>
 r)
-> r
withBaseSimpleMergeable If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable (RWST r w s m a)) =>
r
r =
    forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable (RWST r w s m a)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable (RWST r w s m a)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
  {-# INLINE withBaseSimpleMergeable #-}

instance
  ( Typeable mode,
    UnifiedBranching mode m,
    Mergeable w,
    Monoid w,
    Mergeable s
  ) =>
  UnifiedSimpleMergeable1 mode (RWSStrict.RWST r w s m)
  where
  withBaseSimpleMergeable1 :: forall r.
(If
   (IsConMode mode)
   (() :: Constraint)
   (SimpleMergeable1 (RWST r w s m)) =>
 r)
-> r
withBaseSimpleMergeable1 If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable1 (RWST r w s m)) =>
r
r =
    forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable1 (RWST r w s m)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If
  (IsConMode mode)
  (() :: Constraint)
  (SimpleMergeable1 (RWST r w s m)) =>
r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
r)
  {-# INLINE withBaseSimpleMergeable1 #-}

instance
  ( Typeable mode,
    UnifiedBranching mode m,
    Mergeable s,
    Monoid w,
    Mergeable w
  ) =>
  UnifiedBranching mode (RWSStrict.RWST r w s m)
  where
  withBaseBranching :: forall r.
(If
   (IsConMode mode)
   (TryMerge (RWST r w s m))
   (SymBranching (RWST r w s m)) =>
 r)
-> r
withBaseBranching If
  (IsConMode mode)
  (TryMerge (RWST r w s m))
  (SymBranching (RWST r w s m)) =>
r
r =
    forall (mode :: EvalModeTag) r.
Typeable mode =>
((mode ~ 'Con) => r) -> ((mode ~ 'Sym) => r) -> r
withMode @mode
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
If
  (IsConMode mode)
  (TryMerge (RWST r w s m))
  (SymBranching (RWST r w s m)) =>
r
r)
      (forall (mode :: EvalModeTag) (m :: * -> *) r.
UnifiedBranching mode m =>
(If (IsConMode mode) (TryMerge m) (SymBranching m) => r) -> r
withBaseBranching @mode @m r
If (IsConMode mode) (TryMerge m) (SymBranching m) => r
If
  (IsConMode mode)
  (TryMerge (RWST r w s m))
  (SymBranching (RWST r w s m)) =>
r
r)
  {-# INLINE withBaseBranching #-}