{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE ConstraintKinds #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE ExistentialQuantification #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE FunctionalDependencies #-}
{-# LANGUAGE GADTSyntax #-}
{-# LANGUAGE ImportQualifiedPost #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE PolyKinds #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneKindSignatures #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE UndecidableSuperClasses #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE BlockArguments #-}

module Dep.SimpleAdvice.Internal where

import Dep.Has
import Data.Coerce
import Control.Monad
import Control.Monad.Fix
import Data.Functor.Identity
import Data.Kind
import Data.List.NonEmpty qualified as N
import Data.SOP
import Data.SOP.Dict
import Data.SOP.NP
import Data.Typeable
import GHC.Generics qualified as G
import GHC.TypeLits
import Control.Applicative
import Control.Monad.Reader
import Control.Monad.Cont.Class
import Control.Monad.Error.Class
import Control.Monad.IO.Unlift
import Control.Monad.State.Class
import Control.Monad.Trans.Class
import Control.Monad.Trans.Identity
import Control.Monad.Writer.Class
import Control.Monad.Zip

-- | A generic transformation of 'AspectT'-effectful functions with 

-- base monad @m@ and return type @r@,

-- provided the functions satisfy certain constraint @ca@

-- on all of their arguments.

--

-- 'Advice's that don't care about the @ca@ constraint (because they don't

-- touch function arguments) can leave it polymorphic, and this facilitates

-- 'Advice' composition, but then the constraint must be given the catch-all

-- `Top` value (using a type application) at the moment of calling 'advise'.

--

-- See "Control.Monad.Dep.SimpleAdvice.Basic" for examples.

type Advice ::
  (Type -> Constraint) ->
  (Type -> Type) ->
  Type ->
  Type
data Advice (ca :: Type -> Constraint) m r where
  Advice ::
    forall ca m r.
    ( forall as.
      All ca as =>
      NP I as ->
      AspectT m (AspectT m r -> AspectT m r, NP I as)
    ) ->
    Advice ca m r


-- |

--    'Advice's compose \"sequentially\" when tweaking the arguments, and

--    \"concentrically\" when tweaking the final 'AspectT' action.

--

--    The first 'Advice' is the \"outer\" one. It tweaks the function arguments

--    first, and wraps around the execution of the second, \"inner\" 'Advice'.

instance Monad m => Semigroup (Advice ca m r) where
  Advice forall (as :: [*]).
All ca as =>
NP I as -> AspectT m (AspectT m r -> AspectT m r, NP I as)
outer <> :: Advice ca m r -> Advice ca m r -> Advice ca m r
<> Advice forall (as :: [*]).
All ca as =>
NP I as -> AspectT m (AspectT m r -> AspectT m r, NP I as)
inner = (forall (as :: [*]).
 All ca as =>
 NP I as -> AspectT m (AspectT m r -> AspectT m r, NP I as))
-> Advice ca m r
forall (ca :: * -> Constraint) (m :: * -> *) r.
(forall (as :: [*]).
 All ca as =>
 NP I as -> AspectT m (AspectT m r -> AspectT m r, NP I as))
-> Advice ca m r
Advice \NP I as
args -> do
    (AspectT m r -> AspectT m r
tweakOuter, NP I as
argsOuter) <- NP I as -> AspectT m (AspectT m r -> AspectT m r, NP I as)
forall (as :: [*]).
All ca as =>
NP I as -> AspectT m (AspectT m r -> AspectT m r, NP I as)
outer NP I as
args
    (AspectT m r -> AspectT m r
tweakInner, NP I as
argsInner) <- NP I as -> AspectT m (AspectT m r -> AspectT m r, NP I as)
forall (as :: [*]).
All ca as =>
NP I as -> AspectT m (AspectT m r -> AspectT m r, NP I as)
inner NP I as
argsOuter
    (AspectT m r -> AspectT m r, NP I as)
-> AspectT m (AspectT m r -> AspectT m r, NP I as)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (AspectT m r -> AspectT m r
tweakOuter (AspectT m r -> AspectT m r)
-> (AspectT m r -> AspectT m r) -> AspectT m r -> AspectT m r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AspectT m r -> AspectT m r
tweakInner, NP I as
argsInner)

instance Monad m => Monoid (Advice ca m r) where
  mappend :: Advice ca m r -> Advice ca m r -> Advice ca m r
mappend = Advice ca m r -> Advice ca m r -> Advice ca m r
forall a. Semigroup a => a -> a -> a
(<>)
  mempty :: Advice ca m r
mempty = (forall (as :: [*]).
 All ca as =>
 NP I as -> AspectT m (AspectT m r -> AspectT m r, NP I as))
-> Advice ca m r
forall (ca :: * -> Constraint) (m :: * -> *) r.
(forall (as :: [*]).
 All ca as =>
 NP I as -> AspectT m (AspectT m r -> AspectT m r, NP I as))
-> Advice ca m r
Advice \NP I as
args -> (AspectT m r -> AspectT m r, NP I as)
-> AspectT m (AspectT m r -> AspectT m r, NP I as)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (AspectT m r -> AspectT m r
forall a. a -> a
id, NP I as
args)


-- | This transformer is isomorphic to 'Control.Monad.Trans.Identity.IdentityT'.

--

-- It doesn't really do anything, it only helps the typeclass machinery.

type AspectT ::
  (Type -> Type) ->
  Type ->
  Type
newtype AspectT (m :: Type -> Type) (r :: Type) = AspectT {AspectT m r -> m r
runAspectT :: m r}
  deriving
    ( a -> AspectT m b -> AspectT m a
(a -> b) -> AspectT m a -> AspectT m b
(forall a b. (a -> b) -> AspectT m a -> AspectT m b)
-> (forall a b. a -> AspectT m b -> AspectT m a)
-> Functor (AspectT m)
forall a b. a -> AspectT m b -> AspectT m a
forall a b. (a -> b) -> AspectT m a -> AspectT m b
forall (m :: * -> *) a b.
Functor m =>
a -> AspectT m b -> AspectT m a
forall (m :: * -> *) a b.
Functor m =>
(a -> b) -> AspectT m a -> AspectT m b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> AspectT m b -> AspectT m a
$c<$ :: forall (m :: * -> *) a b.
Functor m =>
a -> AspectT m b -> AspectT m a
fmap :: (a -> b) -> AspectT m a -> AspectT m b
$cfmap :: forall (m :: * -> *) a b.
Functor m =>
(a -> b) -> AspectT m a -> AspectT m b
Functor,
      Functor (AspectT m)
a -> AspectT m a
Functor (AspectT m)
-> (forall a. a -> AspectT m a)
-> (forall a b. AspectT m (a -> b) -> AspectT m a -> AspectT m b)
-> (forall a b c.
    (a -> b -> c) -> AspectT m a -> AspectT m b -> AspectT m c)
-> (forall a b. AspectT m a -> AspectT m b -> AspectT m b)
-> (forall a b. AspectT m a -> AspectT m b -> AspectT m a)
-> Applicative (AspectT m)
AspectT m a -> AspectT m b -> AspectT m b
AspectT m a -> AspectT m b -> AspectT m a
AspectT m (a -> b) -> AspectT m a -> AspectT m b
(a -> b -> c) -> AspectT m a -> AspectT m b -> AspectT m c
forall a. a -> AspectT m a
forall a b. AspectT m a -> AspectT m b -> AspectT m a
forall a b. AspectT m a -> AspectT m b -> AspectT m b
forall a b. AspectT m (a -> b) -> AspectT m a -> AspectT m b
forall a b c.
(a -> b -> c) -> AspectT m a -> AspectT m b -> AspectT m c
forall (f :: * -> *).
Functor f
-> (forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
forall (m :: * -> *). Applicative m => Functor (AspectT m)
forall (m :: * -> *) a. Applicative m => a -> AspectT m a
forall (m :: * -> *) a b.
Applicative m =>
AspectT m a -> AspectT m b -> AspectT m a
forall (m :: * -> *) a b.
Applicative m =>
AspectT m a -> AspectT m b -> AspectT m b
forall (m :: * -> *) a b.
Applicative m =>
AspectT m (a -> b) -> AspectT m a -> AspectT m b
forall (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c) -> AspectT m a -> AspectT m b -> AspectT m c
<* :: AspectT m a -> AspectT m b -> AspectT m a
$c<* :: forall (m :: * -> *) a b.
Applicative m =>
AspectT m a -> AspectT m b -> AspectT m a
*> :: AspectT m a -> AspectT m b -> AspectT m b
$c*> :: forall (m :: * -> *) a b.
Applicative m =>
AspectT m a -> AspectT m b -> AspectT m b
liftA2 :: (a -> b -> c) -> AspectT m a -> AspectT m b -> AspectT m c
$cliftA2 :: forall (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c) -> AspectT m a -> AspectT m b -> AspectT m c
<*> :: AspectT m (a -> b) -> AspectT m a -> AspectT m b
$c<*> :: forall (m :: * -> *) a b.
Applicative m =>
AspectT m (a -> b) -> AspectT m a -> AspectT m b
pure :: a -> AspectT m a
$cpure :: forall (m :: * -> *) a. Applicative m => a -> AspectT m a
$cp1Applicative :: forall (m :: * -> *). Applicative m => Functor (AspectT m)
Applicative,
      Applicative (AspectT m)
AspectT m a
Applicative (AspectT m)
-> (forall a. AspectT m a)
-> (forall a. AspectT m a -> AspectT m a -> AspectT m a)
-> (forall a. AspectT m a -> AspectT m [a])
-> (forall a. AspectT m a -> AspectT m [a])
-> Alternative (AspectT m)
AspectT m a -> AspectT m a -> AspectT m a
AspectT m a -> AspectT m [a]
AspectT m a -> AspectT m [a]
forall a. AspectT m a
forall a. AspectT m a -> AspectT m [a]
forall a. AspectT m a -> AspectT m a -> AspectT m a
forall (f :: * -> *).
Applicative f
-> (forall a. f a)
-> (forall a. f a -> f a -> f a)
-> (forall a. f a -> f [a])
-> (forall a. f a -> f [a])
-> Alternative f
forall (m :: * -> *). Alternative m => Applicative (AspectT m)
forall (m :: * -> *) a. Alternative m => AspectT m a
forall (m :: * -> *) a.
Alternative m =>
AspectT m a -> AspectT m [a]
forall (m :: * -> *) a.
Alternative m =>
AspectT m a -> AspectT m a -> AspectT m a
many :: AspectT m a -> AspectT m [a]
$cmany :: forall (m :: * -> *) a.
Alternative m =>
AspectT m a -> AspectT m [a]
some :: AspectT m a -> AspectT m [a]
$csome :: forall (m :: * -> *) a.
Alternative m =>
AspectT m a -> AspectT m [a]
<|> :: AspectT m a -> AspectT m a -> AspectT m a
$c<|> :: forall (m :: * -> *) a.
Alternative m =>
AspectT m a -> AspectT m a -> AspectT m a
empty :: AspectT m a
$cempty :: forall (m :: * -> *) a. Alternative m => AspectT m a
$cp1Alternative :: forall (m :: * -> *). Alternative m => Applicative (AspectT m)
Alternative,
      Applicative (AspectT m)
a -> AspectT m a
Applicative (AspectT m)
-> (forall a b. AspectT m a -> (a -> AspectT m b) -> AspectT m b)
-> (forall a b. AspectT m a -> AspectT m b -> AspectT m b)
-> (forall a. a -> AspectT m a)
-> Monad (AspectT m)
AspectT m a -> (a -> AspectT m b) -> AspectT m b
AspectT m a -> AspectT m b -> AspectT m b
forall a. a -> AspectT m a
forall a b. AspectT m a -> AspectT m b -> AspectT m b
forall a b. AspectT m a -> (a -> AspectT m b) -> AspectT m b
forall (m :: * -> *). Monad m => Applicative (AspectT m)
forall (m :: * -> *) a. Monad m => a -> AspectT m a
forall (m :: * -> *) a b.
Monad m =>
AspectT m a -> AspectT m b -> AspectT m b
forall (m :: * -> *) a b.
Monad m =>
AspectT m a -> (a -> AspectT m b) -> AspectT m b
forall (m :: * -> *).
Applicative m
-> (forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
return :: a -> AspectT m a
$creturn :: forall (m :: * -> *) a. Monad m => a -> AspectT m a
>> :: AspectT m a -> AspectT m b -> AspectT m b
$c>> :: forall (m :: * -> *) a b.
Monad m =>
AspectT m a -> AspectT m b -> AspectT m b
>>= :: AspectT m a -> (a -> AspectT m b) -> AspectT m b
$c>>= :: forall (m :: * -> *) a b.
Monad m =>
AspectT m a -> (a -> AspectT m b) -> AspectT m b
$cp1Monad :: forall (m :: * -> *). Monad m => Applicative (AspectT m)
Monad,
      Monad (AspectT m)
Monad (AspectT m)
-> (forall a. (a -> AspectT m a) -> AspectT m a)
-> MonadFix (AspectT m)
(a -> AspectT m a) -> AspectT m a
forall a. (a -> AspectT m a) -> AspectT m a
forall (m :: * -> *).
Monad m -> (forall a. (a -> m a) -> m a) -> MonadFix m
forall (m :: * -> *). MonadFix m => Monad (AspectT m)
forall (m :: * -> *) a.
MonadFix m =>
(a -> AspectT m a) -> AspectT m a
mfix :: (a -> AspectT m a) -> AspectT m a
$cmfix :: forall (m :: * -> *) a.
MonadFix m =>
(a -> AspectT m a) -> AspectT m a
$cp1MonadFix :: forall (m :: * -> *). MonadFix m => Monad (AspectT m)
MonadFix,
      Monad (AspectT m)
Monad (AspectT m)
-> (forall a. String -> AspectT m a) -> MonadFail (AspectT m)
String -> AspectT m a
forall a. String -> AspectT m a
forall (m :: * -> *).
Monad m -> (forall a. String -> m a) -> MonadFail m
forall (m :: * -> *). MonadFail m => Monad (AspectT m)
forall (m :: * -> *) a. MonadFail m => String -> AspectT m a
fail :: String -> AspectT m a
$cfail :: forall (m :: * -> *) a. MonadFail m => String -> AspectT m a
$cp1MonadFail :: forall (m :: * -> *). MonadFail m => Monad (AspectT m)
MonadFail,
      Monad (AspectT m)
Monad (AspectT m)
-> (forall a b. AspectT m a -> AspectT m b -> AspectT m (a, b))
-> (forall a b c.
    (a -> b -> c) -> AspectT m a -> AspectT m b -> AspectT m c)
-> (forall a b. AspectT m (a, b) -> (AspectT m a, AspectT m b))
-> MonadZip (AspectT m)
AspectT m a -> AspectT m b -> AspectT m (a, b)
AspectT m (a, b) -> (AspectT m a, AspectT m b)
(a -> b -> c) -> AspectT m a -> AspectT m b -> AspectT m c
forall a b. AspectT m a -> AspectT m b -> AspectT m (a, b)
forall a b. AspectT m (a, b) -> (AspectT m a, AspectT m b)
forall a b c.
(a -> b -> c) -> AspectT m a -> AspectT m b -> AspectT m c
forall (m :: * -> *).
Monad m
-> (forall a b. m a -> m b -> m (a, b))
-> (forall a b c. (a -> b -> c) -> m a -> m b -> m c)
-> (forall a b. m (a, b) -> (m a, m b))
-> MonadZip m
forall (m :: * -> *). MonadZip m => Monad (AspectT m)
forall (m :: * -> *) a b.
MonadZip m =>
AspectT m a -> AspectT m b -> AspectT m (a, b)
forall (m :: * -> *) a b.
MonadZip m =>
AspectT m (a, b) -> (AspectT m a, AspectT m b)
forall (m :: * -> *) a b c.
MonadZip m =>
(a -> b -> c) -> AspectT m a -> AspectT m b -> AspectT m c
munzip :: AspectT m (a, b) -> (AspectT m a, AspectT m b)
$cmunzip :: forall (m :: * -> *) a b.
MonadZip m =>
AspectT m (a, b) -> (AspectT m a, AspectT m b)
mzipWith :: (a -> b -> c) -> AspectT m a -> AspectT m b -> AspectT m c
$cmzipWith :: forall (m :: * -> *) a b c.
MonadZip m =>
(a -> b -> c) -> AspectT m a -> AspectT m b -> AspectT m c
mzip :: AspectT m a -> AspectT m b -> AspectT m (a, b)
$cmzip :: forall (m :: * -> *) a b.
MonadZip m =>
AspectT m a -> AspectT m b -> AspectT m (a, b)
$cp1MonadZip :: forall (m :: * -> *). MonadZip m => Monad (AspectT m)
MonadZip,
      Monad (AspectT m)
Alternative (AspectT m)
AspectT m a
Alternative (AspectT m)
-> Monad (AspectT m)
-> (forall a. AspectT m a)
-> (forall a. AspectT m a -> AspectT m a -> AspectT m a)
-> MonadPlus (AspectT m)
AspectT m a -> AspectT m a -> AspectT m a
forall a. AspectT m a
forall a. AspectT m a -> AspectT m a -> AspectT m a
forall (m :: * -> *).
Alternative m
-> Monad m
-> (forall a. m a)
-> (forall a. m a -> m a -> m a)
-> MonadPlus m
forall (m :: * -> *). MonadPlus m => Monad (AspectT m)
forall (m :: * -> *). MonadPlus m => Alternative (AspectT m)
forall (m :: * -> *) a. MonadPlus m => AspectT m a
forall (m :: * -> *) a.
MonadPlus m =>
AspectT m a -> AspectT m a -> AspectT m a
mplus :: AspectT m a -> AspectT m a -> AspectT m a
$cmplus :: forall (m :: * -> *) a.
MonadPlus m =>
AspectT m a -> AspectT m a -> AspectT m a
mzero :: AspectT m a
$cmzero :: forall (m :: * -> *) a. MonadPlus m => AspectT m a
$cp2MonadPlus :: forall (m :: * -> *). MonadPlus m => Monad (AspectT m)
$cp1MonadPlus :: forall (m :: * -> *). MonadPlus m => Alternative (AspectT m)
MonadPlus,
      Monad (AspectT m)
Monad (AspectT m)
-> (forall a b. ((a -> AspectT m b) -> AspectT m a) -> AspectT m a)
-> MonadCont (AspectT m)
((a -> AspectT m b) -> AspectT m a) -> AspectT m a
forall a b. ((a -> AspectT m b) -> AspectT m a) -> AspectT m a
forall (m :: * -> *).
Monad m -> (forall a b. ((a -> m b) -> m a) -> m a) -> MonadCont m
forall (m :: * -> *). MonadCont m => Monad (AspectT m)
forall (m :: * -> *) a b.
MonadCont m =>
((a -> AspectT m b) -> AspectT m a) -> AspectT m a
callCC :: ((a -> AspectT m b) -> AspectT m a) -> AspectT m a
$ccallCC :: forall (m :: * -> *) a b.
MonadCont m =>
((a -> AspectT m b) -> AspectT m a) -> AspectT m a
$cp1MonadCont :: forall (m :: * -> *). MonadCont m => Monad (AspectT m)
MonadCont,
      Monad (AspectT m)
Monad (AspectT m)
-> (forall a. IO a -> AspectT m a) -> MonadIO (AspectT m)
IO a -> AspectT m a
forall a. IO a -> AspectT m a
forall (m :: * -> *).
Monad m -> (forall a. IO a -> m a) -> MonadIO m
forall (m :: * -> *). MonadIO m => Monad (AspectT m)
forall (m :: * -> *) a. MonadIO m => IO a -> AspectT m a
liftIO :: IO a -> AspectT m a
$cliftIO :: forall (m :: * -> *) a. MonadIO m => IO a -> AspectT m a
$cp1MonadIO :: forall (m :: * -> *). MonadIO m => Monad (AspectT m)
MonadIO,
      MonadIO (AspectT m)
MonadIO (AspectT m)
-> (forall b.
    ((forall a. AspectT m a -> IO a) -> IO b) -> AspectT m b)
-> MonadUnliftIO (AspectT m)
((forall a. AspectT m a -> IO a) -> IO b) -> AspectT m b
forall b. ((forall a. AspectT m a -> IO a) -> IO b) -> AspectT m b
forall (m :: * -> *).
MonadIO m
-> (forall b. ((forall a. m a -> IO a) -> IO b) -> m b)
-> MonadUnliftIO m
forall (m :: * -> *). MonadUnliftIO m => MonadIO (AspectT m)
forall (m :: * -> *) b.
MonadUnliftIO m =>
((forall a. AspectT m a -> IO a) -> IO b) -> AspectT m b
withRunInIO :: ((forall a. AspectT m a -> IO a) -> IO b) -> AspectT m b
$cwithRunInIO :: forall (m :: * -> *) b.
MonadUnliftIO m =>
((forall a. AspectT m a -> IO a) -> IO b) -> AspectT m b
$cp1MonadUnliftIO :: forall (m :: * -> *). MonadUnliftIO m => MonadIO (AspectT m)
MonadUnliftIO
    )

instance MonadTrans AspectT where
  lift :: m a -> AspectT m a
lift = m a -> AspectT m a
forall (m :: * -> *) r. m r -> AspectT m r
AspectT 

deriving newtype instance MonadReader env m => MonadReader env (AspectT m)
deriving newtype instance MonadState s m => MonadState s (AspectT m)
deriving newtype instance MonadWriter w m => MonadWriter w (AspectT m)
deriving newtype instance MonadError e m => MonadError e (AspectT m)

data Pair a b = Pair !a !b