{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE FunctionalDependencies #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE DerivingVia #-}
-- | MVP renderer for logging statements.
module Drasil.Shared.LanguageRenderer.LoggingFor (LoggingFor(..)) where

import Drasil.Shared.InterfaceCommon
import qualified Drasil.GProc.InterfaceProc as P
import qualified Drasil.GOOL.InterfaceGOOL as G
import Drasil.Shared.State

import Prelude hiding (print, break, pi, log, floor, sin, cos, tan, exp)
import Control.Lens (zoom)
import Data.Kind (Type)
import Control.Monad.State
import Data.Bifunctor (bimap)
import Drasil.Shared.CodeType (CodeType)

newtype LoggingFor (r :: Type -> Type) a = LC {forall (r :: * -> *) a. LoggingFor r a -> r a
unLC :: r a}
  deriving newtype ((forall a b. (a -> b) -> LoggingFor r a -> LoggingFor r b)
-> (forall a b. a -> LoggingFor r b -> LoggingFor r a)
-> Functor (LoggingFor r)
forall a b. a -> LoggingFor r b -> LoggingFor r a
forall a b. (a -> b) -> LoggingFor r a -> LoggingFor r b
forall (r :: * -> *) a b.
Functor r =>
a -> LoggingFor r b -> LoggingFor r a
forall (r :: * -> *) a b.
Functor r =>
(a -> b) -> LoggingFor r a -> LoggingFor r b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall (r :: * -> *) a b.
Functor r =>
(a -> b) -> LoggingFor r a -> LoggingFor r b
fmap :: forall a b. (a -> b) -> LoggingFor r a -> LoggingFor r b
$c<$ :: forall (r :: * -> *) a b.
Functor r =>
a -> LoggingFor r b -> LoggingFor r a
<$ :: forall a b. a -> LoggingFor r b -> LoggingFor r a
Functor, Functor (LoggingFor r)
Functor (LoggingFor r) =>
(forall a. a -> LoggingFor r a)
-> (forall a b.
    LoggingFor r (a -> b) -> LoggingFor r a -> LoggingFor r b)
-> (forall a b c.
    (a -> b -> c)
    -> LoggingFor r a -> LoggingFor r b -> LoggingFor r c)
-> (forall a b. LoggingFor r a -> LoggingFor r b -> LoggingFor r b)
-> (forall a b. LoggingFor r a -> LoggingFor r b -> LoggingFor r a)
-> Applicative (LoggingFor r)
forall a. a -> LoggingFor r a
forall a b. LoggingFor r a -> LoggingFor r b -> LoggingFor r a
forall a b. LoggingFor r a -> LoggingFor r b -> LoggingFor r b
forall a b.
LoggingFor r (a -> b) -> LoggingFor r a -> LoggingFor r b
forall a b c.
(a -> b -> c) -> LoggingFor r a -> LoggingFor r b -> LoggingFor r 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 (r :: * -> *). Applicative r => Functor (LoggingFor r)
forall (r :: * -> *) a. Applicative r => a -> LoggingFor r a
forall (r :: * -> *) a b.
Applicative r =>
LoggingFor r a -> LoggingFor r b -> LoggingFor r a
forall (r :: * -> *) a b.
Applicative r =>
LoggingFor r a -> LoggingFor r b -> LoggingFor r b
forall (r :: * -> *) a b.
Applicative r =>
LoggingFor r (a -> b) -> LoggingFor r a -> LoggingFor r b
forall (r :: * -> *) a b c.
Applicative r =>
(a -> b -> c) -> LoggingFor r a -> LoggingFor r b -> LoggingFor r c
$cpure :: forall (r :: * -> *) a. Applicative r => a -> LoggingFor r a
pure :: forall a. a -> LoggingFor r a
$c<*> :: forall (r :: * -> *) a b.
Applicative r =>
LoggingFor r (a -> b) -> LoggingFor r a -> LoggingFor r b
<*> :: forall a b.
LoggingFor r (a -> b) -> LoggingFor r a -> LoggingFor r b
$cliftA2 :: forall (r :: * -> *) a b c.
Applicative r =>
(a -> b -> c) -> LoggingFor r a -> LoggingFor r b -> LoggingFor r c
liftA2 :: forall a b c.
(a -> b -> c) -> LoggingFor r a -> LoggingFor r b -> LoggingFor r c
$c*> :: forall (r :: * -> *) a b.
Applicative r =>
LoggingFor r a -> LoggingFor r b -> LoggingFor r b
*> :: forall a b. LoggingFor r a -> LoggingFor r b -> LoggingFor r b
$c<* :: forall (r :: * -> *) a b.
Applicative r =>
LoggingFor r a -> LoggingFor r b -> LoggingFor r a
<* :: forall a b. LoggingFor r a -> LoggingFor r b -> LoggingFor r a
Applicative, Applicative (LoggingFor r)
Applicative (LoggingFor r) =>
(forall a b.
 LoggingFor r a -> (a -> LoggingFor r b) -> LoggingFor r b)
-> (forall a b. LoggingFor r a -> LoggingFor r b -> LoggingFor r b)
-> (forall a. a -> LoggingFor r a)
-> Monad (LoggingFor r)
forall a. a -> LoggingFor r a
forall a b. LoggingFor r a -> LoggingFor r b -> LoggingFor r b
forall a b.
LoggingFor r a -> (a -> LoggingFor r b) -> LoggingFor r b
forall (r :: * -> *). Monad r => Applicative (LoggingFor r)
forall (r :: * -> *) a. Monad r => a -> LoggingFor r a
forall (r :: * -> *) a b.
Monad r =>
LoggingFor r a -> LoggingFor r b -> LoggingFor r b
forall (r :: * -> *) a b.
Monad r =>
LoggingFor r a -> (a -> LoggingFor r b) -> LoggingFor r 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
$c>>= :: forall (r :: * -> *) a b.
Monad r =>
LoggingFor r a -> (a -> LoggingFor r b) -> LoggingFor r b
>>= :: forall a b.
LoggingFor r a -> (a -> LoggingFor r b) -> LoggingFor r b
$c>> :: forall (r :: * -> *) a b.
Monad r =>
LoggingFor r a -> LoggingFor r b -> LoggingFor r b
>> :: forall a b. LoggingFor r a -> LoggingFor r b -> LoggingFor r b
$creturn :: forall (r :: * -> *) a. Monad r => a -> LoggingFor r a
return :: forall a. a -> LoggingFor r a
Monad)

class LiftLogging u l | l -> u where
  liftLogging :: u -> l
  lowerLogging :: l -> u

instance (LiftLogging u1 l1, LiftLogging u2 l2) => LiftLogging (u1 -> u2) (l1 -> l2) where
  liftLogging :: (u1 -> u2) -> l1 -> l2
liftLogging u1 -> u2
k = u2 -> l2
forall u l. LiftLogging u l => u -> l
liftLogging (u2 -> l2) -> (l1 -> u2) -> l1 -> l2
forall b c a. (b -> c) -> (a -> b) -> a -> c
. u1 -> u2
k (u1 -> u2) -> (l1 -> u1) -> l1 -> u2
forall b c a. (b -> c) -> (a -> b) -> a -> c
. l1 -> u1
forall u l. LiftLogging u l => l -> u
lowerLogging
  lowerLogging :: (l1 -> l2) -> u1 -> u2
lowerLogging l1 -> l2
k = l2 -> u2
forall u l. LiftLogging u l => l -> u
lowerLogging (l2 -> u2) -> (u1 -> l2) -> u1 -> u2
forall b c a. (b -> c) -> (a -> b) -> a -> c
. l1 -> l2
k (l1 -> l2) -> (u1 -> l1) -> u1 -> l2
forall b c a. (b -> c) -> (a -> b) -> a -> c
. u1 -> l1
forall u l. LiftLogging u l => u -> l
liftLogging

instance LiftLogging (r a) (LoggingFor r a) where
  lowerLogging :: LoggingFor r a -> r a
lowerLogging = LoggingFor r a -> r a
forall (r :: * -> *) a. LoggingFor r a -> r a
unLC
  liftLogging :: r a -> LoggingFor r a
liftLogging = r a -> LoggingFor r a
forall (r :: * -> *) a. r a -> LoggingFor r a
LC

instance (LiftLogging u l) => LiftLogging (State s u) (State s l) where
  liftLogging :: State s u -> State s l
liftLogging = (u -> l) -> State s u -> State s l
forall a b. (a -> b) -> StateT s Identity a -> StateT s Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap u -> l
forall u l. LiftLogging u l => u -> l
liftLogging
  lowerLogging :: State s l -> State s u
lowerLogging = (l -> u) -> State s l -> State s u
forall a b. (a -> b) -> StateT s Identity a -> StateT s Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap l -> u
forall u l. LiftLogging u l => l -> u
lowerLogging

instance (LiftLogging u l) => LiftLogging (Maybe u) (Maybe l) where
  liftLogging :: Maybe u -> Maybe l
liftLogging = (u -> l) -> Maybe u -> Maybe l
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap u -> l
forall u l. LiftLogging u l => u -> l
liftLogging
  lowerLogging :: Maybe l -> Maybe u
lowerLogging = (l -> u) -> Maybe l -> Maybe u
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap l -> u
forall u l. LiftLogging u l => l -> u
lowerLogging

instance {-# OVERLAPPABLE #-} (LiftLogging u l) => LiftLogging [u] [l] where
  liftLogging :: [u] -> [l]
liftLogging = (u -> l) -> [u] -> [l]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap u -> l
forall u l. LiftLogging u l => u -> l
liftLogging
  lowerLogging :: [l] -> [u]
lowerLogging = (l -> u) -> [l] -> [u]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap l -> u
forall u l. LiftLogging u l => l -> u
lowerLogging

instance LiftLogging String String where
  liftLogging :: String -> String
liftLogging = String -> String
forall a. a -> a
id
  lowerLogging :: String -> String
lowerLogging = String -> String
forall a. a -> a
id

instance LiftLogging Integer Integer where
  liftLogging :: Integer -> Integer
liftLogging = Integer -> Integer
forall a. a -> a
id
  lowerLogging :: Integer -> Integer
lowerLogging = Integer -> Integer
forall a. a -> a
id

instance LiftLogging Char Char where
  liftLogging :: Char -> Char
liftLogging = Char -> Char
forall a. a -> a
id
  lowerLogging :: Char -> Char
lowerLogging = Char -> Char
forall a. a -> a
id

instance LiftLogging Double Double where
  liftLogging :: Double -> Double
liftLogging = Double -> Double
forall a. a -> a
id
  lowerLogging :: Double -> Double
lowerLogging = Double -> Double
forall a. a -> a
id

instance LiftLogging Float Float where
  liftLogging :: Float -> Float
liftLogging = Float -> Float
forall a. a -> a
id
  lowerLogging :: Float -> Float
lowerLogging = Float -> Float
forall a. a -> a
id

instance LiftLogging CodeType CodeType where
  liftLogging :: CodeType -> CodeType
liftLogging = CodeType -> CodeType
forall a. a -> a
id
  lowerLogging :: CodeType -> CodeType
lowerLogging = CodeType -> CodeType
forall a. a -> a
id

instance (LiftLogging u1 l1, LiftLogging u2 l2) => LiftLogging (u1, u2) (l1, l2) where
  liftLogging :: (u1, u2) -> (l1, l2)
liftLogging = (u1 -> l1) -> (u2 -> l2) -> (u1, u2) -> (l1, l2)
forall a b c d. (a -> b) -> (c -> d) -> (a, c) -> (b, d)
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap u1 -> l1
forall u l. LiftLogging u l => u -> l
liftLogging u2 -> l2
forall u l. LiftLogging u l => u -> l
liftLogging
  lowerLogging :: (l1, l2) -> (u1, u2)
lowerLogging = (l1 -> u1) -> (l2 -> u2) -> (l1, l2) -> (u1, u2)
forall a b c d. (a -> b) -> (c -> d) -> (a, c) -> (b, d)
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap l1 -> u1
forall u l. LiftLogging u l => l -> u
lowerLogging l2 -> u2
forall u l. LiftLogging u l => l -> u
lowerLogging

-- TODO [Brandon Bosman, 06/19/2026]: This should be passed down from drasil-code
varLogFile :: (TypeSym r typ, VariableSym r var typ) => VS (r var)
varLogFile :: forall {k} (r :: k -> *) (typ :: k) (var :: k).
(TypeSym r typ, VariableSym r var typ) =>
VS (r var)
varLogFile = String -> VS (r typ) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
String -> VS (r typ) -> VS (r var)
var String
"outfile" VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
outfile

valLogFile
  :: (TypeSym r typ, VariableSym r var typ, VariableValue r var val)
  => VS (r val)
valLogFile :: forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, VariableSym r var typ, VariableValue r var val) =>
VS (r val)
valLogFile = VS (r var) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k).
VariableValue r var val =>
VS (r var) -> VS (r val)
valueOf VS (r var)
forall {k} (r :: k -> *) (typ :: k) (var :: k).
(TypeSym r typ, VariableSym r var typ) =>
VS (r var)
varLogFile

-- TODO [Brandon Bosman, 06/19/2026]: This should be passed down from drasil-code
logName :: (Literal r val typ) => VS (r val)
logName :: forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
VS (r val)
logName = String -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
String -> VS (r val)
litString String
"log.txt"

logVarUpdate
  ::
    ( FileHandling r stmt var val
    , PrintFile r stmt val
    , TypeSym r typ
    , VariableSym r var typ
    , VariableValue r var val
    , VariableElim r var typ
    , Literal r val typ
    )
  => VS ((LoggingFor r) var) -> [MS (r stmt)]
logVarUpdate :: forall (r :: * -> *) stmt var val typ.
(FileHandling r stmt var val, PrintFile r stmt val, TypeSym r typ,
 VariableSym r var typ, VariableValue r var val,
 VariableElim r var typ, Literal r val typ) =>
VS (LoggingFor r var) -> [MS (r stmt)]
logVarUpdate VS (LoggingFor r var)
x =
  [ VS (r var) -> VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
FileHandling r stmt var val =>
VS (r var) -> VS (r val) -> MS (r stmt)
openFileA VS (r var)
forall {k} (r :: k -> *) (typ :: k) (var :: k).
(TypeSym r typ, VariableSym r var typ) =>
VS (r var)
varLogFile VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
VS (r val)
logName
  , do
      x' <- r var -> String
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableElim r var typ =>
r var -> String
variableName (r var -> String)
-> (LoggingFor r var -> r var) -> LoggingFor r var -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LoggingFor r var -> r var
forall u l. LiftLogging u l => l -> u
lowerLogging (LoggingFor r var -> String)
-> StateT MethodState Identity (LoggingFor r var)
-> StateT MethodState Identity String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> LensLike'
  (Zoomed (StateT ValueState Identity) (LoggingFor r var))
  MethodState
  ValueState
-> VS (LoggingFor r var)
-> StateT MethodState Identity (LoggingFor r var)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (LoggingFor r var))
  MethodState
  ValueState
(ValueState -> Focusing Identity (LoggingFor r var) ValueState)
-> MethodState -> Focusing Identity (LoggingFor r var) MethodState
Lens' MethodState ValueState
lensMStoVS VS (LoggingFor r var)
x
      printFileStr valLogFile $ "var '" <> x' <> "' assigned "
  , VS (r val) -> VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
PrintFile r stmt val =>
VS (r val) -> VS (r val) -> MS (r stmt)
printFile VS (r val)
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, VariableSym r var typ, VariableValue r var val) =>
VS (r val)
valLogFile (VS (r val) -> MS (r stmt)) -> VS (r val) -> MS (r stmt)
forall a b. (a -> b) -> a -> b
$ VS (r var) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k).
VariableValue r var val =>
VS (r var) -> VS (r val)
valueOf (VS (LoggingFor r var) -> VS (r var)
forall u l. LiftLogging u l => l -> u
lowerLogging VS (LoggingFor r var)
x)
  , do
      modName <- LensLike'
  (Zoomed (StateT FileState Identity) String) MethodState FileState
-> StateT FileState Identity String
-> StateT MethodState Identity String
forall c.
LensLike'
  (Zoomed (StateT FileState Identity) c) MethodState FileState
-> StateT FileState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT FileState Identity) String) MethodState FileState
(FileState -> Focusing Identity String FileState)
-> MethodState -> Focusing Identity String MethodState
Lens' MethodState FileState
lensMStoFS StateT FileState Identity String
getModuleName
      printFileStrLn valLogFile $ " in module " <> modName
  , VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
FileHandling r stmt var val =>
VS (r val) -> MS (r stmt)
closeFile VS (r val)
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, VariableSym r var typ, VariableValue r var val) =>
VS (r val)
valLogFile
  ]

instance
  ( MultiStatement r stmt
  , AssignStatement r stmt var val
  , FileHandling r stmt var val
  , PrintFile r stmt val
  , TypeSym r typ
  , VariableSym r var typ
  , VariableValue r var val
  , VariableElim r var typ
  , Literal r val typ
  ) => AssignStatement (LoggingFor r) stmt var val where
  &-= :: VS (LoggingFor r var)
-> VS (LoggingFor r val) -> MS (LoggingFor r stmt)
(&-=) = (VS (r var) -> VS (r val) -> MS (r stmt))
-> VS (LoggingFor r var)
-> VS (LoggingFor r val)
-> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r var) -> VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
AssignStatement r stmt var val =>
VS (r var) -> VS (r val) -> MS (r stmt)
(&-=)
  &+= :: VS (LoggingFor r var)
-> VS (LoggingFor r val) -> MS (LoggingFor r stmt)
(&+=) = (VS (r var) -> VS (r val) -> MS (r stmt))
-> VS (LoggingFor r var)
-> VS (LoggingFor r val)
-> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r var) -> VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
AssignStatement r stmt var val =>
VS (r var) -> VS (r val) -> MS (r stmt)
(&+=)
  &++ :: VS (LoggingFor r var) -> MS (LoggingFor r stmt)
(&++) = (VS (r var) -> MS (r stmt))
-> VS (LoggingFor r var) -> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r var) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
AssignStatement r stmt var val =>
VS (r var) -> MS (r stmt)
(&++)
  &-- :: VS (LoggingFor r var) -> MS (LoggingFor r stmt)
(&--) = (VS (r var) -> MS (r stmt))
-> VS (LoggingFor r var) -> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r var) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
AssignStatement r stmt var val =>
VS (r var) -> MS (r stmt)
(&--)
  assign :: VS (LoggingFor r var)
-> VS (LoggingFor r val) -> MS (LoggingFor r stmt)
assign VS (LoggingFor r var)
x VS (LoggingFor r val)
e = MS (r stmt) -> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging (MS (r stmt) -> MS (LoggingFor r stmt))
-> MS (r stmt) -> MS (LoggingFor r stmt)
forall a b. (a -> b) -> a -> b
$ [MS (r stmt)] -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k).
MultiStatement r stmt =>
[MS (r stmt)] -> MS (r stmt)
multi ([MS (r stmt)] -> MS (r stmt)) -> [MS (r stmt)] -> MS (r stmt)
forall a b. (a -> b) -> a -> b
$
    VS (r var) -> VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
AssignStatement r stmt var val =>
VS (r var) -> VS (r val) -> MS (r stmt)
assign (VS (LoggingFor r var) -> VS (r var)
forall u l. LiftLogging u l => l -> u
lowerLogging VS (LoggingFor r var)
x) (VS (LoggingFor r val) -> VS (r val)
forall u l. LiftLogging u l => l -> u
lowerLogging VS (LoggingFor r val)
e)
    MS (r stmt) -> [MS (r stmt)] -> [MS (r stmt)]
forall a. a -> [a] -> [a]
: VS (LoggingFor r var) -> [MS (r stmt)]
forall (r :: * -> *) stmt var val typ.
(FileHandling r stmt var val, PrintFile r stmt val, TypeSym r typ,
 VariableSym r var typ, VariableValue r var val,
 VariableElim r var typ, Literal r val typ) =>
VS (LoggingFor r var) -> [MS (r stmt)]
logVarUpdate VS (LoggingFor r var)
x

instance (List r val) => List (LoggingFor r) val where
  listSize :: VS (LoggingFor r val) -> VS (LoggingFor r val)
listSize = (VS (r val) -> VS (r val))
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
List r val =>
VS (r val) -> VS (r val)
listSize
  listAccess :: VS (LoggingFor r val)
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
listAccess = (VS (r val) -> VS (r val) -> VS (r val))
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
List r val =>
VS (r val) -> VS (r val) -> VS (r val)
listAccess
  indexOf :: VS (LoggingFor r val)
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
indexOf = (VS (r val) -> VS (r val) -> VS (r val))
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
List r val =>
VS (r val) -> VS (r val) -> VS (r val)
indexOf

instance (ListStatement r stmt val) => ListStatement (LoggingFor r) stmt val where
  listAdd :: VS (LoggingFor r val)
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
-> MS (LoggingFor r stmt)
listAdd = (VS (r val) -> VS (r val) -> VS (r val) -> MS (r stmt))
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
-> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val) -> VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
ListStatement r stmt val =>
VS (r val) -> VS (r val) -> VS (r val) -> MS (r stmt)
listAdd
  listAppend :: VS (LoggingFor r val)
-> VS (LoggingFor r val) -> MS (LoggingFor r stmt)
listAppend = (VS (r val) -> VS (r val) -> MS (r stmt))
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
-> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
ListStatement r stmt val =>
VS (r val) -> VS (r val) -> MS (r stmt)
listAppend
  listSet :: VS (LoggingFor r val)
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
-> MS (LoggingFor r stmt)
listSet = (VS (r val) -> VS (r val) -> VS (r val) -> MS (r stmt))
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
-> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val) -> VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
ListStatement r stmt val =>
VS (r val) -> VS (r val) -> VS (r val) -> MS (r stmt)
listSet -- TODO [Brandon Bosman, 06/23/2026]: Add logging
                                -- (Can't right now because RC.value isn't exposed)

instance
  ( MultiStatement r stmt
  , DeclStatement r bod stmt var scope val
  , FileHandling r stmt var val
  , PrintFile r stmt val
  , TypeSym r typ
  , VariableSym r var typ
  , VariableValue r var val
  , VariableElim r var typ
  , Literal r val typ
  ) => DeclStatement (LoggingFor r) bod stmt var scope val where
  varDec :: VS (LoggingFor r var)
-> LoggingFor r scope -> MS (LoggingFor r stmt)
varDec = (VS (r var) -> r scope -> MS (r stmt))
-> VS (LoggingFor r var)
-> LoggingFor r scope
-> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r var) -> r scope -> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k).
DeclStatement r bod stmt var scope val =>
VS (r var) -> r scope -> MS (r stmt)
varDec
  varDecDef :: VS (LoggingFor r var)
-> LoggingFor r scope
-> VS (LoggingFor r val)
-> MS (LoggingFor r stmt)
varDecDef VS (LoggingFor r var)
vr LoggingFor r scope
scp VS (LoggingFor r val)
vl = MS (r stmt) -> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging (MS (r stmt) -> MS (LoggingFor r stmt))
-> MS (r stmt) -> MS (LoggingFor r stmt)
forall a b. (a -> b) -> a -> b
$ [MS (r stmt)] -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k).
MultiStatement r stmt =>
[MS (r stmt)] -> MS (r stmt)
multi ([MS (r stmt)] -> MS (r stmt)) -> [MS (r stmt)] -> MS (r stmt)
forall a b. (a -> b) -> a -> b
$
    VS (r var) -> r scope -> VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k).
DeclStatement r bod stmt var scope val =>
VS (r var) -> r scope -> VS (r val) -> MS (r stmt)
varDecDef (VS (LoggingFor r var) -> VS (r var)
forall u l. LiftLogging u l => l -> u
lowerLogging VS (LoggingFor r var)
vr) (LoggingFor r scope -> r scope
forall u l. LiftLogging u l => l -> u
lowerLogging LoggingFor r scope
scp) (VS (LoggingFor r val) -> VS (r val)
forall u l. LiftLogging u l => l -> u
lowerLogging VS (LoggingFor r val)
vl)
    MS (r stmt) -> [MS (r stmt)] -> [MS (r stmt)]
forall a. a -> [a] -> [a]
: VS (LoggingFor r var) -> [MS (r stmt)]
forall (r :: * -> *) stmt var val typ.
(FileHandling r stmt var val, PrintFile r stmt val, TypeSym r typ,
 VariableSym r var typ, VariableValue r var val,
 VariableElim r var typ, Literal r val typ) =>
VS (LoggingFor r var) -> [MS (r stmt)]
logVarUpdate VS (LoggingFor r var)
vr
  listDec :: Integer
-> VS (LoggingFor r var)
-> LoggingFor r scope
-> MS (LoggingFor r stmt)
listDec = (Integer -> VS (r var) -> r scope -> MS (r stmt))
-> Integer
-> VS (LoggingFor r var)
-> LoggingFor r scope
-> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging Integer -> VS (r var) -> r scope -> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k).
DeclStatement r bod stmt var scope val =>
Integer -> VS (r var) -> r scope -> MS (r stmt)
listDec
  listDecDef :: VS (LoggingFor r var)
-> LoggingFor r scope
-> [VS (LoggingFor r val)]
-> MS (LoggingFor r stmt)
listDecDef VS (LoggingFor r var)
vr LoggingFor r scope
scp [VS (LoggingFor r val)]
vls = MS (r stmt) -> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging (MS (r stmt) -> MS (LoggingFor r stmt))
-> MS (r stmt) -> MS (LoggingFor r stmt)
forall a b. (a -> b) -> a -> b
$
    VS (r var) -> r scope -> [VS (r val)] -> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k).
DeclStatement r bod stmt var scope val =>
VS (r var) -> r scope -> [VS (r val)] -> MS (r stmt)
listDecDef (VS (LoggingFor r var) -> VS (r var)
forall u l. LiftLogging u l => l -> u
lowerLogging VS (LoggingFor r var)
vr) (LoggingFor r scope -> r scope
forall u l. LiftLogging u l => l -> u
lowerLogging LoggingFor r scope
scp) ([VS (LoggingFor r val)] -> [VS (r val)]
forall u l. LiftLogging u l => l -> u
lowerLogging [VS (LoggingFor r val)]
vls)
  setDec :: VS (LoggingFor r var)
-> LoggingFor r scope -> MS (LoggingFor r stmt)
setDec = (VS (r var) -> r scope -> MS (r stmt))
-> VS (LoggingFor r var)
-> LoggingFor r scope
-> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r var) -> r scope -> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k).
DeclStatement r bod stmt var scope val =>
VS (r var) -> r scope -> MS (r stmt)
setDec
  setDecDef :: VS (LoggingFor r var)
-> LoggingFor r scope
-> VS (LoggingFor r val)
-> MS (LoggingFor r stmt)
setDecDef VS (LoggingFor r var)
vr LoggingFor r scope
scp VS (LoggingFor r val)
vl = MS (r stmt) -> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging (MS (r stmt) -> MS (LoggingFor r stmt))
-> MS (r stmt) -> MS (LoggingFor r stmt)
forall a b. (a -> b) -> a -> b
$
    VS (r var) -> r scope -> VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k).
DeclStatement r bod stmt var scope val =>
VS (r var) -> r scope -> VS (r val) -> MS (r stmt)
setDecDef (VS (LoggingFor r var) -> VS (r var)
forall u l. LiftLogging u l => l -> u
lowerLogging VS (LoggingFor r var)
vr) (LoggingFor r scope -> r scope
forall u l. LiftLogging u l => l -> u
lowerLogging LoggingFor r scope
scp) (VS (LoggingFor r val) -> VS (r val)
forall u l. LiftLogging u l => l -> u
lowerLogging VS (LoggingFor r val)
vl)
  arrayDec :: Integer
-> VS (LoggingFor r val)
-> VS (LoggingFor r var)
-> LoggingFor r scope
-> MS (LoggingFor r stmt)
arrayDec = (Integer -> VS (r val) -> VS (r var) -> r scope -> MS (r stmt))
-> Integer
-> VS (LoggingFor r val)
-> VS (LoggingFor r var)
-> LoggingFor r scope
-> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging Integer -> VS (r val) -> VS (r var) -> r scope -> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k).
DeclStatement r bod stmt var scope val =>
Integer -> VS (r val) -> VS (r var) -> r scope -> MS (r stmt)
arrayDec
  arrayDecDef :: VS (LoggingFor r var)
-> LoggingFor r scope
-> [VS (LoggingFor r val)]
-> MS (LoggingFor r stmt)
arrayDecDef VS (LoggingFor r var)
vr LoggingFor r scope
scp [VS (LoggingFor r val)]
vls = MS (r stmt) -> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging (MS (r stmt) -> MS (LoggingFor r stmt))
-> MS (r stmt) -> MS (LoggingFor r stmt)
forall a b. (a -> b) -> a -> b
$
    VS (r var) -> r scope -> [VS (r val)] -> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k).
DeclStatement r bod stmt var scope val =>
VS (r var) -> r scope -> [VS (r val)] -> MS (r stmt)
arrayDecDef (VS (LoggingFor r var) -> VS (r var)
forall u l. LiftLogging u l => l -> u
lowerLogging VS (LoggingFor r var)
vr) (LoggingFor r scope -> r scope
forall u l. LiftLogging u l => l -> u
lowerLogging LoggingFor r scope
scp) ([VS (LoggingFor r val)] -> [VS (r val)]
forall u l. LiftLogging u l => l -> u
lowerLogging [VS (LoggingFor r val)]
vls)
  constDecDef :: VS (LoggingFor r var)
-> LoggingFor r scope
-> VS (LoggingFor r val)
-> MS (LoggingFor r stmt)
constDecDef VS (LoggingFor r var)
cnst LoggingFor r scope
scp VS (LoggingFor r val)
vl = MS (r stmt) -> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging (MS (r stmt) -> MS (LoggingFor r stmt))
-> MS (r stmt) -> MS (LoggingFor r stmt)
forall a b. (a -> b) -> a -> b
$ [MS (r stmt)] -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k).
MultiStatement r stmt =>
[MS (r stmt)] -> MS (r stmt)
multi ([MS (r stmt)] -> MS (r stmt)) -> [MS (r stmt)] -> MS (r stmt)
forall a b. (a -> b) -> a -> b
$
    VS (r var) -> r scope -> VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k).
DeclStatement r bod stmt var scope val =>
VS (r var) -> r scope -> VS (r val) -> MS (r stmt)
constDecDef (VS (LoggingFor r var) -> VS (r var)
forall u l. LiftLogging u l => l -> u
lowerLogging VS (LoggingFor r var)
cnst) (LoggingFor r scope -> r scope
forall u l. LiftLogging u l => l -> u
lowerLogging LoggingFor r scope
scp) (VS (LoggingFor r val) -> VS (r val)
forall u l. LiftLogging u l => l -> u
lowerLogging VS (LoggingFor r val)
vl)
    MS (r stmt) -> [MS (r stmt)] -> [MS (r stmt)]
forall a. a -> [a] -> [a]
: VS (LoggingFor r var) -> [MS (r stmt)]
forall (r :: * -> *) stmt var val typ.
(FileHandling r stmt var val, PrintFile r stmt val, TypeSym r typ,
 VariableSym r var typ, VariableValue r var val,
 VariableElim r var typ, Literal r val typ) =>
VS (LoggingFor r var) -> [MS (r stmt)]
logVarUpdate VS (LoggingFor r var)
cnst
  funcDecDef :: VS (LoggingFor r var)
-> LoggingFor r scope
-> [VS (LoggingFor r var)]
-> MS (LoggingFor r bod)
-> MS (LoggingFor r stmt)
funcDecDef = (VS (r var)
 -> r scope -> [VS (r var)] -> MS (r bod) -> MS (r stmt))
-> VS (LoggingFor r var)
-> LoggingFor r scope
-> [VS (LoggingFor r var)]
-> MS (LoggingFor r bod)
-> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r var) -> r scope -> [VS (r var)] -> MS (r bod) -> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k).
DeclStatement r bod stmt var scope val =>
VS (r var) -> r scope -> [VS (r var)] -> MS (r bod) -> MS (r stmt)
funcDecDef

instance (PrintConsole r stmt val) => PrintConsole (LoggingFor r) stmt val where
  print :: VS (LoggingFor r val) -> MS (LoggingFor r stmt)
print = (VS (r val) -> MS (r stmt))
-> VS (LoggingFor r val) -> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
PrintConsole r stmt val =>
VS (r val) -> MS (r stmt)
print
  printLn :: VS (LoggingFor r val) -> MS (LoggingFor r stmt)
printLn = (VS (r val) -> MS (r stmt))
-> VS (LoggingFor r val) -> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
PrintConsole r stmt val =>
VS (r val) -> MS (r stmt)
printLn
  printStr :: String -> MS (LoggingFor r stmt)
printStr = (String -> MS (r stmt)) -> String -> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging String -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
PrintConsole r stmt val =>
String -> MS (r stmt)
printStr
  printStrLn :: String -> MS (LoggingFor r stmt)
printStrLn = (String -> MS (r stmt)) -> String -> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging String -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
PrintConsole r stmt val =>
String -> MS (r stmt)
printStrLn

instance
  ( MultiStatement r stmt
  , FileHandling r stmt var val
  , PrintFile r stmt val
  , ReadConsole r stmt var
  , TypeSym r typ
  , VariableSym r var typ
  , VariableValue r var val
  , VariableElim r var typ
  , Literal r val typ
  ) => ReadConsole (LoggingFor r) stmt var where
  getInput :: VS (LoggingFor r var) -> MS (LoggingFor r stmt)
getInput VS (LoggingFor r var)
vr = MS (r stmt) -> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging (MS (r stmt) -> MS (LoggingFor r stmt))
-> MS (r stmt) -> MS (LoggingFor r stmt)
forall a b. (a -> b) -> a -> b
$ [MS (r stmt)] -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k).
MultiStatement r stmt =>
[MS (r stmt)] -> MS (r stmt)
multi ([MS (r stmt)] -> MS (r stmt)) -> [MS (r stmt)] -> MS (r stmt)
forall a b. (a -> b) -> a -> b
$
    VS (r var) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (var :: k).
ReadConsole r stmt var =>
VS (r var) -> MS (r stmt)
getInput (VS (LoggingFor r var) -> VS (r var)
forall u l. LiftLogging u l => l -> u
lowerLogging VS (LoggingFor r var)
vr) MS (r stmt) -> [MS (r stmt)] -> [MS (r stmt)]
forall a. a -> [a] -> [a]
: VS (LoggingFor r var) -> [MS (r stmt)]
forall (r :: * -> *) stmt var val typ.
(FileHandling r stmt var val, PrintFile r stmt val, TypeSym r typ,
 VariableSym r var typ, VariableValue r var val,
 VariableElim r var typ, Literal r val typ) =>
VS (LoggingFor r var) -> [MS (r stmt)]
logVarUpdate VS (LoggingFor r var)
vr
  discardInput :: MS (LoggingFor r stmt)
discardInput = MS (r stmt) -> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (var :: k).
ReadConsole r stmt var =>
MS (r stmt)
discardInput

instance (FileHandling r stmt var val) => FileHandling (LoggingFor r) stmt var val where
  openFileR :: VS (LoggingFor r var)
-> VS (LoggingFor r val) -> MS (LoggingFor r stmt)
openFileR = (VS (r var) -> VS (r val) -> MS (r stmt))
-> VS (LoggingFor r var)
-> VS (LoggingFor r val)
-> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r var) -> VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
FileHandling r stmt var val =>
VS (r var) -> VS (r val) -> MS (r stmt)
openFileR
  openFileW :: VS (LoggingFor r var)
-> VS (LoggingFor r val) -> MS (LoggingFor r stmt)
openFileW = (VS (r var) -> VS (r val) -> MS (r stmt))
-> VS (LoggingFor r var)
-> VS (LoggingFor r val)
-> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r var) -> VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
FileHandling r stmt var val =>
VS (r var) -> VS (r val) -> MS (r stmt)
openFileW
  openFileA :: VS (LoggingFor r var)
-> VS (LoggingFor r val) -> MS (LoggingFor r stmt)
openFileA = (VS (r var) -> VS (r val) -> MS (r stmt))
-> VS (LoggingFor r var)
-> VS (LoggingFor r val)
-> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r var) -> VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
FileHandling r stmt var val =>
VS (r var) -> VS (r val) -> MS (r stmt)
openFileA
  closeFile :: VS (LoggingFor r val) -> MS (LoggingFor r stmt)
closeFile = (VS (r val) -> MS (r stmt))
-> VS (LoggingFor r val) -> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
FileHandling r stmt var val =>
VS (r val) -> MS (r stmt)
closeFile

instance (PrintFile r stmt val) => PrintFile (LoggingFor r) stmt val where
  printFile :: VS (LoggingFor r val)
-> VS (LoggingFor r val) -> MS (LoggingFor r stmt)
printFile = (VS (r val) -> VS (r val) -> MS (r stmt))
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
-> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
PrintFile r stmt val =>
VS (r val) -> VS (r val) -> MS (r stmt)
printFile
  printFileLn :: VS (LoggingFor r val)
-> VS (LoggingFor r val) -> MS (LoggingFor r stmt)
printFileLn = (VS (r val) -> VS (r val) -> MS (r stmt))
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
-> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
PrintFile r stmt val =>
VS (r val) -> VS (r val) -> MS (r stmt)
printFileLn
  printFileStr :: VS (LoggingFor r val) -> String -> MS (LoggingFor r stmt)
printFileStr = (VS (r val) -> String -> MS (r stmt))
-> VS (LoggingFor r val) -> String -> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> String -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
PrintFile r stmt val =>
VS (r val) -> String -> MS (r stmt)
printFileStr
  printFileStrLn :: VS (LoggingFor r val) -> String -> MS (LoggingFor r stmt)
printFileStrLn = (VS (r val) -> String -> MS (r stmt))
-> VS (LoggingFor r val) -> String -> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> String -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
PrintFile r stmt val =>
VS (r val) -> String -> MS (r stmt)
printFileStrLn

instance
  ( MultiStatement r stmt
  , FileHandling r stmt var val
  , PrintFile r stmt val
  , ReadFile r stmt var val
  , TypeSym r typ
  , VariableSym r var typ
  , VariableValue r var val
  , VariableElim r var typ
  , Literal r val typ
  ) => ReadFile (LoggingFor r) stmt var val where
  getFileInput :: VS (LoggingFor r val)
-> VS (LoggingFor r var) -> MS (LoggingFor r stmt)
getFileInput VS (LoggingFor r val)
file VS (LoggingFor r var)
vr = MS (r stmt) -> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging (MS (r stmt) -> MS (LoggingFor r stmt))
-> MS (r stmt) -> MS (LoggingFor r stmt)
forall a b. (a -> b) -> a -> b
$ [MS (r stmt)] -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k).
MultiStatement r stmt =>
[MS (r stmt)] -> MS (r stmt)
multi ([MS (r stmt)] -> MS (r stmt)) -> [MS (r stmt)] -> MS (r stmt)
forall a b. (a -> b) -> a -> b
$
    VS (r val) -> VS (r var) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
ReadFile r stmt var val =>
VS (r val) -> VS (r var) -> MS (r stmt)
getFileInput (VS (LoggingFor r val) -> VS (r val)
forall u l. LiftLogging u l => l -> u
lowerLogging VS (LoggingFor r val)
file) (VS (LoggingFor r var) -> VS (r var)
forall u l. LiftLogging u l => l -> u
lowerLogging VS (LoggingFor r var)
vr)
    MS (r stmt) -> [MS (r stmt)] -> [MS (r stmt)]
forall a. a -> [a] -> [a]
: VS (LoggingFor r var) -> [MS (r stmt)]
forall (r :: * -> *) stmt var val typ.
(FileHandling r stmt var val, PrintFile r stmt val, TypeSym r typ,
 VariableSym r var typ, VariableValue r var val,
 VariableElim r var typ, Literal r val typ) =>
VS (LoggingFor r var) -> [MS (r stmt)]
logVarUpdate VS (LoggingFor r var)
vr
  discardFileInput :: VS (LoggingFor r val) -> MS (LoggingFor r stmt)
discardFileInput = (VS (r val) -> MS (r stmt))
-> VS (LoggingFor r val) -> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
ReadFile r stmt var val =>
VS (r val) -> MS (r stmt)
discardFileInput
  getFileInputLine :: VS (LoggingFor r val)
-> VS (LoggingFor r var) -> MS (LoggingFor r stmt)
getFileInputLine = (VS (r val) -> VS (r var) -> MS (r stmt))
-> VS (LoggingFor r val)
-> VS (LoggingFor r var)
-> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r var) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
ReadFile r stmt var val =>
VS (r val) -> VS (r var) -> MS (r stmt)
getFileInputLine
  discardFileLine :: VS (LoggingFor r val) -> MS (LoggingFor r stmt)
discardFileLine = (VS (r val) -> MS (r stmt))
-> VS (LoggingFor r val) -> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
ReadFile r stmt var val =>
VS (r val) -> MS (r stmt)
discardFileLine
  getFileInputAll :: VS (LoggingFor r val)
-> VS (LoggingFor r var) -> MS (LoggingFor r stmt)
getFileInputAll = (VS (r val) -> VS (r var) -> MS (r stmt))
-> VS (LoggingFor r val)
-> VS (LoggingFor r var)
-> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r var) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
ReadFile r stmt var val =>
VS (r val) -> VS (r var) -> MS (r stmt)
getFileInputAll

instance
  ( MultiStatement r stmt
  , StringStatement r stmt var val
  , FileHandling r stmt var val
  , PrintFile r stmt val
  , TypeSym r typ
  , VariableSym r var typ
  , VariableValue r var val
  , VariableElim r var typ
  , Literal r val typ
  ) => StringStatement (LoggingFor r) stmt var val where
  stringSplit :: Char
-> VS (LoggingFor r var)
-> VS (LoggingFor r val)
-> MS (LoggingFor r stmt)
stringSplit Char
chr VS (LoggingFor r var)
vr VS (LoggingFor r val)
str  = MS (r stmt) -> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging (MS (r stmt) -> MS (LoggingFor r stmt))
-> MS (r stmt) -> MS (LoggingFor r stmt)
forall a b. (a -> b) -> a -> b
$
    Char -> VS (r var) -> VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
StringStatement r stmt var val =>
Char -> VS (r var) -> VS (r val) -> MS (r stmt)
stringSplit (Char -> Char
forall u l. LiftLogging u l => l -> u
lowerLogging Char
chr) (VS (LoggingFor r var) -> VS (r var)
forall u l. LiftLogging u l => l -> u
lowerLogging VS (LoggingFor r var)
vr) (VS (LoggingFor r val) -> VS (r val)
forall u l. LiftLogging u l => l -> u
lowerLogging VS (LoggingFor r val)
str)
  stringListVals :: [VS (LoggingFor r var)]
-> VS (LoggingFor r val) -> MS (LoggingFor r stmt)
stringListVals [VS (LoggingFor r var)]
vrs VS (LoggingFor r val)
strs  = MS (r stmt) -> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging (MS (r stmt) -> MS (LoggingFor r stmt))
-> MS (r stmt) -> MS (LoggingFor r stmt)
forall a b. (a -> b) -> a -> b
$
    [VS (r var)] -> VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
StringStatement r stmt var val =>
[VS (r var)] -> VS (r val) -> MS (r stmt)
stringListVals ([VS (LoggingFor r var)] -> [VS (r var)]
forall u l. LiftLogging u l => l -> u
lowerLogging [VS (LoggingFor r var)]
vrs) (VS (LoggingFor r val) -> VS (r val)
forall u l. LiftLogging u l => l -> u
lowerLogging VS (LoggingFor r val)
strs)
  stringListLists :: [VS (LoggingFor r var)]
-> VS (LoggingFor r val) -> MS (LoggingFor r stmt)
stringListLists [VS (LoggingFor r var)]
vrs VS (LoggingFor r val)
strs = MS (r stmt) -> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging (MS (r stmt) -> MS (LoggingFor r stmt))
-> MS (r stmt) -> MS (LoggingFor r stmt)
forall a b. (a -> b) -> a -> b
$ [MS (r stmt)] -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k).
MultiStatement r stmt =>
[MS (r stmt)] -> MS (r stmt)
multi ([MS (r stmt)] -> MS (r stmt)) -> [MS (r stmt)] -> MS (r stmt)
forall a b. (a -> b) -> a -> b
$
    [VS (r var)] -> VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
StringStatement r stmt var val =>
[VS (r var)] -> VS (r val) -> MS (r stmt)
stringListLists ([VS (LoggingFor r var)] -> [VS (r var)]
forall u l. LiftLogging u l => l -> u
lowerLogging [VS (LoggingFor r var)]
vrs) (VS (LoggingFor r val) -> VS (r val)
forall u l. LiftLogging u l => l -> u
lowerLogging VS (LoggingFor r val)
strs)
    MS (r stmt) -> [MS (r stmt)] -> [MS (r stmt)]
forall a. a -> [a] -> [a]
: (VS (LoggingFor r var) -> [MS (r stmt)])
-> [VS (LoggingFor r var)] -> [MS (r stmt)]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap VS (LoggingFor r var) -> [MS (r stmt)]
forall (r :: * -> *) stmt var val typ.
(FileHandling r stmt var val, PrintFile r stmt val, TypeSym r typ,
 VariableSym r var typ, VariableValue r var val,
 VariableElim r var typ, Literal r val typ) =>
VS (LoggingFor r var) -> [MS (r stmt)]
logVarUpdate [VS (LoggingFor r var)]
vrs

-- SharedProg Boilerplate

instance (VariableSym r var typ) => VariableSym (LoggingFor r) var typ where
  var :: String -> VS (LoggingFor r typ) -> VS (LoggingFor r var)
var = (String -> VS (r typ) -> VS (r var))
-> String -> VS (LoggingFor r typ) -> VS (LoggingFor r var)
forall u l. LiftLogging u l => u -> l
liftLogging String -> VS (r typ) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
String -> VS (r typ) -> VS (r var)
var
  constant :: String -> VS (LoggingFor r typ) -> VS (LoggingFor r var)
constant = (String -> VS (r typ) -> VS (r var))
-> String -> VS (LoggingFor r typ) -> VS (LoggingFor r var)
forall u l. LiftLogging u l => u -> l
liftLogging String -> VS (r typ) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
String -> VS (r typ) -> VS (r var)
constant
  extVar :: String -> String -> VS (LoggingFor r typ) -> VS (LoggingFor r var)
extVar = (String -> String -> VS (r typ) -> VS (r var))
-> String
-> String
-> VS (LoggingFor r typ)
-> VS (LoggingFor r var)
forall u l. LiftLogging u l => u -> l
liftLogging String -> String -> VS (r typ) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
String -> String -> VS (r typ) -> VS (r var)
extVar

instance (TypeSym r typ) => TypeSym (LoggingFor r) typ where
  bool :: VS (LoggingFor r typ)
bool = VS (r typ) -> VS (LoggingFor r typ)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
bool
  int :: VS (LoggingFor r typ)
int = VS (r typ) -> VS (LoggingFor r typ)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
int
  float :: VS (LoggingFor r typ)
float = VS (r typ) -> VS (LoggingFor r typ)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
float
  double :: VS (LoggingFor r typ)
double = VS (r typ) -> VS (LoggingFor r typ)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
double
  char :: VS (LoggingFor r typ)
char = VS (r typ) -> VS (LoggingFor r typ)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
char
  string :: VS (LoggingFor r typ)
string = VS (r typ) -> VS (LoggingFor r typ)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
string
  infile :: VS (LoggingFor r typ)
infile = VS (r typ) -> VS (LoggingFor r typ)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
infile
  outfile :: VS (LoggingFor r typ)
outfile = VS (r typ) -> VS (LoggingFor r typ)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
outfile
  referenceType :: VS (LoggingFor r typ) -> VS (LoggingFor r typ)
referenceType = (VS (r typ) -> VS (r typ))
-> VS (LoggingFor r typ) -> VS (LoggingFor r typ)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r typ) -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
VS (r typ) -> VS (r typ)
referenceType
  listType :: VS (LoggingFor r typ) -> VS (LoggingFor r typ)
listType = (VS (r typ) -> VS (r typ))
-> VS (LoggingFor r typ) -> VS (LoggingFor r typ)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r typ) -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
VS (r typ) -> VS (r typ)
listType
  setType :: VS (LoggingFor r typ) -> VS (LoggingFor r typ)
setType = (VS (r typ) -> VS (r typ))
-> VS (LoggingFor r typ) -> VS (LoggingFor r typ)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r typ) -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
VS (r typ) -> VS (r typ)
setType
  arrayType :: VS (LoggingFor r typ) -> VS (LoggingFor r typ)
arrayType = (VS (r typ) -> VS (r typ))
-> VS (LoggingFor r typ) -> VS (LoggingFor r typ)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r typ) -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
VS (r typ) -> VS (r typ)
arrayType
  innerType :: VS (LoggingFor r typ) -> VS (LoggingFor r typ)
innerType = (VS (r typ) -> VS (r typ))
-> VS (LoggingFor r typ) -> VS (LoggingFor r typ)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r typ) -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
VS (r typ) -> VS (r typ)
innerType
  funcType :: [VS (LoggingFor r typ)]
-> VS (LoggingFor r typ) -> VS (LoggingFor r typ)
funcType = ([VS (r typ)] -> VS (r typ) -> VS (r typ))
-> [VS (LoggingFor r typ)]
-> VS (LoggingFor r typ)
-> VS (LoggingFor r typ)
forall u l. LiftLogging u l => u -> l
liftLogging [VS (r typ)] -> VS (r typ) -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
[VS (r typ)] -> VS (r typ) -> VS (r typ)
funcType
  void :: VS (LoggingFor r typ)
void = VS (r typ) -> VS (LoggingFor r typ)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
void

instance (TypeElim r typ) => TypeElim (LoggingFor r) typ where
  getCodeType :: LoggingFor r typ -> CodeType
getCodeType = (r typ -> CodeType) -> LoggingFor r typ -> CodeType
forall u l. LiftLogging u l => u -> l
liftLogging r typ -> CodeType
forall {k} (r :: k -> *) (typ :: k).
TypeElim r typ =>
r typ -> CodeType
getCodeType

instance (ValueSym r val typ) => ValueSym (LoggingFor r) val typ where
  valueType :: LoggingFor r val -> LoggingFor r typ
valueType = (r val -> r typ) -> LoggingFor r val -> LoggingFor r typ
forall u l. LiftLogging u l => u -> l
liftLogging r val -> r typ
forall {k} (r :: k -> *) (val :: k) (typ :: k).
ValueSym r val typ =>
r val -> r typ
valueType

instance EmptyStatement r stmt => EmptyStatement (LoggingFor r) stmt where
  emptyStmt :: MS (LoggingFor r stmt)
emptyStmt = MS (r stmt) -> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k).
EmptyStatement r stmt =>
MS (r stmt)
emptyStmt

instance MultiStatement r stmt => MultiStatement (LoggingFor r) stmt where
  multi :: [MS (LoggingFor r stmt)] -> MS (LoggingFor r stmt)
multi = ([MS (r stmt)] -> MS (r stmt))
-> [MS (LoggingFor r stmt)] -> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging [MS (r stmt)] -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k).
MultiStatement r stmt =>
[MS (r stmt)] -> MS (r stmt)
multi

instance ValueStatement r stmt val => ValueStatement (LoggingFor r) stmt val where
  valStmt :: VS (LoggingFor r val) -> MS (LoggingFor r stmt)
valStmt = (VS (r val) -> MS (r stmt))
-> VS (LoggingFor r val) -> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
ValueStatement r stmt val =>
VS (r val) -> MS (r stmt)
valStmt

instance (Argument r val) => Argument (LoggingFor r) val where
  pointerArg :: VS (LoggingFor r val) -> VS (LoggingFor r val)
pointerArg = (VS (r val) -> VS (r val))
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
Argument r val =>
VS (r val) -> VS (r val)
pointerArg

instance (Reference r val) => Reference (LoggingFor r) val where
  makeRef :: VS (LoggingFor r val) -> VS (LoggingFor r val)
makeRef = (VS (r val) -> VS (r val))
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
Reference r val =>
VS (r val) -> VS (r val)
makeRef
  maybeDeref :: VS (LoggingFor r val) -> VS (LoggingFor r val)
maybeDeref = (VS (r val) -> VS (r val))
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
Reference r val =>
VS (r val) -> VS (r val)
maybeDeref

instance (Array r var val) => Array (LoggingFor r) var val where
  arrayElem :: VS (LoggingFor r val)
-> VS (LoggingFor r val) -> VS (LoggingFor r var)
arrayElem = (VS (r val) -> VS (r val) -> VS (r var))
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
-> VS (LoggingFor r var)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (val :: k).
Array r var val =>
VS (r val) -> VS (r val) -> VS (r var)
arrayElem
  arrayLength :: VS (LoggingFor r val) -> VS (LoggingFor r val)
arrayLength = (VS (r val) -> VS (r val))
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k).
Array r var val =>
VS (r val) -> VS (r val)
arrayLength
  arrayCopy :: VS (LoggingFor r val) -> VS (LoggingFor r val)
arrayCopy = (VS (r val) -> VS (r val))
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k).
Array r var val =>
VS (r val) -> VS (r val)
arrayCopy

instance (BinderSym r binder typ) => BinderSym (LoggingFor r) binder typ where
  binder :: String -> VS (LoggingFor r typ) -> VS (LoggingFor r binder)
binder = (String -> VS (r typ) -> VS (r binder))
-> String -> VS (LoggingFor r typ) -> VS (LoggingFor r binder)
forall u l. LiftLogging u l => u -> l
liftLogging String -> VS (r typ) -> VS (r binder)
forall {k} (r :: k -> *) (binder :: k) (typ :: k).
BinderSym r binder typ =>
String -> VS (r typ) -> VS (r binder)
binder

instance (BooleanExpression r val) => BooleanExpression (LoggingFor r) val where
  ?! :: VS (LoggingFor r val) -> VS (LoggingFor r val)
(?!) = (VS (r val) -> VS (r val))
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
BooleanExpression r val =>
VS (r val) -> VS (r val)
(?!)
  ?&& :: VS (LoggingFor r val)
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
(?&&) = (VS (r val) -> VS (r val) -> VS (r val))
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
BooleanExpression r val =>
VS (r val) -> VS (r val) -> VS (r val)
(?&&)
  ?|| :: VS (LoggingFor r val)
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
(?||) = (VS (r val) -> VS (r val) -> VS (r val))
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
BooleanExpression r val =>
VS (r val) -> VS (r val) -> VS (r val)
(?||)

instance (CommandLineArgs r val) => CommandLineArgs (LoggingFor r) val where
  arg :: Integer -> VS (LoggingFor r val)
arg = (Integer -> VS (r val)) -> Integer -> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging Integer -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
CommandLineArgs r val =>
Integer -> VS (r val)
arg
  argsList :: VS (LoggingFor r val)
argsList = VS (r val) -> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val)
forall {k} (r :: k -> *) (val :: k).
CommandLineArgs r val =>
VS (r val)
argsList
  argExists :: Integer -> VS (LoggingFor r val)
argExists = (Integer -> VS (r val)) -> Integer -> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging Integer -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
CommandLineArgs r val =>
Integer -> VS (r val)
argExists

instance (CommentStatement r stmt) => CommentStatement (LoggingFor r) stmt where
  comment :: String -> MS (LoggingFor r stmt)
comment = (String -> MS (r stmt)) -> String -> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging String -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k).
CommentStatement r stmt =>
String -> MS (r stmt)
comment

instance (Comparison r val) => Comparison (LoggingFor r) val where
  ?< :: VS (LoggingFor r val)
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
(?<) = (VS (r val) -> VS (r val) -> VS (r val))
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
Comparison r val =>
VS (r val) -> VS (r val) -> VS (r val)
(?<)
  ?<= :: VS (LoggingFor r val)
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
(?<=) = (VS (r val) -> VS (r val) -> VS (r val))
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
Comparison r val =>
VS (r val) -> VS (r val) -> VS (r val)
(?<=)
  ?> :: VS (LoggingFor r val)
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
(?>) = (VS (r val) -> VS (r val) -> VS (r val))
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
Comparison r val =>
VS (r val) -> VS (r val) -> VS (r val)
(?>)
  ?>= :: VS (LoggingFor r val)
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
(?>=) = (VS (r val) -> VS (r val) -> VS (r val))
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
Comparison r val =>
VS (r val) -> VS (r val) -> VS (r val)
(?>=)
  ?== :: VS (LoggingFor r val)
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
(?==) = (VS (r val) -> VS (r val) -> VS (r val))
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
Comparison r val =>
VS (r val) -> VS (r val) -> VS (r val)
(?==)
  ?!= :: VS (LoggingFor r val)
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
(?!=) = (VS (r val) -> VS (r val) -> VS (r val))
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
Comparison r val =>
VS (r val) -> VS (r val) -> VS (r val)
(?!=)

instance (BlockSym r block stmt) => BlockSym (LoggingFor r) block stmt where
  block :: [MS (LoggingFor r stmt)] -> MS (LoggingFor r block)
block = ([MS (r stmt)] -> MS (r block))
-> [MS (LoggingFor r stmt)] -> MS (LoggingFor r block)
forall u l. LiftLogging u l => u -> l
liftLogging [MS (r stmt)] -> MS (r block)
forall {k} (r :: k -> *) (block :: k) (stmt :: k).
BlockSym r block stmt =>
[MS (r stmt)] -> MS (r block)
block

instance (BodySym r bod block) => BodySym (LoggingFor r) bod block where
  body :: [MS (LoggingFor r block)] -> MS (LoggingFor r bod)
body = ([MS (r block)] -> MS (r bod))
-> [MS (LoggingFor r block)] -> MS (LoggingFor r bod)
forall u l. LiftLogging u l => u -> l
liftLogging [MS (r block)] -> MS (r bod)
forall {k} (r :: k -> *) (bod :: k) (block :: k).
BodySym r bod block =>
[MS (r block)] -> MS (r bod)
body
  addComments :: String -> MS (LoggingFor r bod) -> MS (LoggingFor r bod)
addComments = (String -> MS (r bod) -> MS (r bod))
-> String -> MS (LoggingFor r bod) -> MS (LoggingFor r bod)
forall u l. LiftLogging u l => u -> l
liftLogging String -> MS (r bod) -> MS (r bod)
forall {k} (r :: k -> *) (bod :: k) (block :: k).
BodySym r bod block =>
String -> MS (r bod) -> MS (r bod)
addComments

instance (ControlStatement r bod stmt var val) => ControlStatement (LoggingFor r) bod stmt var val where
  break :: MS (LoggingFor r stmt)
break = MS (r stmt) -> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (val :: k).
ControlStatement r bod stmt var val =>
MS (r stmt)
break
  continue :: MS (LoggingFor r stmt)
continue = MS (r stmt) -> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (val :: k).
ControlStatement r bod stmt var val =>
MS (r stmt)
continue
  returnStmt :: VS (LoggingFor r val) -> MS (LoggingFor r stmt)
returnStmt = (VS (r val) -> MS (r stmt))
-> VS (LoggingFor r val) -> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (val :: k).
ControlStatement r bod stmt var val =>
VS (r val) -> MS (r stmt)
returnStmt
  throw :: String -> MS (LoggingFor r stmt)
throw = (String -> MS (r stmt)) -> String -> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging String -> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (val :: k).
ControlStatement r bod stmt var val =>
String -> MS (r stmt)
throw
  ifCond :: [(VS (LoggingFor r val), MS (LoggingFor r bod))]
-> MS (LoggingFor r bod) -> MS (LoggingFor r stmt)
ifCond = ([(VS (r val), MS (r bod))] -> MS (r bod) -> MS (r stmt))
-> [(VS (LoggingFor r val), MS (LoggingFor r bod))]
-> MS (LoggingFor r bod)
-> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging [(VS (r val), MS (r bod))] -> MS (r bod) -> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (val :: k).
ControlStatement r bod stmt var val =>
[(VS (r val), MS (r bod))] -> MS (r bod) -> MS (r stmt)
ifCond
  switch :: VS (LoggingFor r val)
-> [(VS (LoggingFor r val), MS (LoggingFor r bod))]
-> MS (LoggingFor r bod)
-> MS (LoggingFor r stmt)
switch = (VS (r val)
 -> [(VS (r val), MS (r bod))] -> MS (r bod) -> MS (r stmt))
-> VS (LoggingFor r val)
-> [(VS (LoggingFor r val), MS (LoggingFor r bod))]
-> MS (LoggingFor r bod)
-> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val)
-> [(VS (r val), MS (r bod))] -> MS (r bod) -> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (val :: k).
ControlStatement r bod stmt var val =>
VS (r val)
-> [(VS (r val), MS (r bod))] -> MS (r bod) -> MS (r stmt)
switch
  ifExists :: VS (LoggingFor r val)
-> MS (LoggingFor r bod)
-> MS (LoggingFor r bod)
-> MS (LoggingFor r stmt)
ifExists = (VS (r val) -> MS (r bod) -> MS (r bod) -> MS (r stmt))
-> VS (LoggingFor r val)
-> MS (LoggingFor r bod)
-> MS (LoggingFor r bod)
-> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> MS (r bod) -> MS (r bod) -> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (val :: k).
ControlStatement r bod stmt var val =>
VS (r val) -> MS (r bod) -> MS (r bod) -> MS (r stmt)
ifExists
  for :: MS (LoggingFor r stmt)
-> VS (LoggingFor r val)
-> MS (LoggingFor r stmt)
-> MS (LoggingFor r bod)
-> MS (LoggingFor r stmt)
for = (MS (r stmt)
 -> VS (r val) -> MS (r stmt) -> MS (r bod) -> MS (r stmt))
-> MS (LoggingFor r stmt)
-> VS (LoggingFor r val)
-> MS (LoggingFor r stmt)
-> MS (LoggingFor r bod)
-> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging MS (r stmt)
-> VS (r val) -> MS (r stmt) -> MS (r bod) -> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (val :: k).
ControlStatement r bod stmt var val =>
MS (r stmt)
-> VS (r val) -> MS (r stmt) -> MS (r bod) -> MS (r stmt)
for
  forRange :: VS (LoggingFor r var)
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
-> MS (LoggingFor r bod)
-> MS (LoggingFor r stmt)
forRange = (VS (r var)
 -> VS (r val)
 -> VS (r val)
 -> VS (r val)
 -> MS (r bod)
 -> MS (r stmt))
-> VS (LoggingFor r var)
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
-> MS (LoggingFor r bod)
-> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r var)
-> VS (r val)
-> VS (r val)
-> VS (r val)
-> MS (r bod)
-> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (val :: k).
ControlStatement r bod stmt var val =>
VS (r var)
-> VS (r val)
-> VS (r val)
-> VS (r val)
-> MS (r bod)
-> MS (r stmt)
forRange
  forEach :: VS (LoggingFor r var)
-> VS (LoggingFor r val)
-> MS (LoggingFor r bod)
-> MS (LoggingFor r stmt)
forEach = (VS (r var) -> VS (r val) -> MS (r bod) -> MS (r stmt))
-> VS (LoggingFor r var)
-> VS (LoggingFor r val)
-> MS (LoggingFor r bod)
-> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r var) -> VS (r val) -> MS (r bod) -> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (val :: k).
ControlStatement r bod stmt var val =>
VS (r var) -> VS (r val) -> MS (r bod) -> MS (r stmt)
forEach
  while :: VS (LoggingFor r val)
-> MS (LoggingFor r bod) -> MS (LoggingFor r stmt)
while = (VS (r val) -> MS (r bod) -> MS (r stmt))
-> VS (LoggingFor r val)
-> MS (LoggingFor r bod)
-> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> MS (r bod) -> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (val :: k).
ControlStatement r bod stmt var val =>
VS (r val) -> MS (r bod) -> MS (r stmt)
while
  tryCatch :: MS (LoggingFor r bod)
-> MS (LoggingFor r bod) -> MS (LoggingFor r stmt)
tryCatch = (MS (r bod) -> MS (r bod) -> MS (r stmt))
-> MS (LoggingFor r bod)
-> MS (LoggingFor r bod)
-> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging MS (r bod) -> MS (r bod) -> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (val :: k).
ControlStatement r bod stmt var val =>
MS (r bod) -> MS (r bod) -> MS (r stmt)
tryCatch
  assert :: VS (LoggingFor r val)
-> VS (LoggingFor r val) -> MS (LoggingFor r stmt)
assert = (VS (r val) -> VS (r val) -> MS (r stmt))
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
-> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (val :: k).
ControlStatement r bod stmt var val =>
VS (r val) -> VS (r val) -> MS (r stmt)
assert

instance (ScopeSym r scope) => ScopeSym (LoggingFor r) scope where
  global :: LoggingFor r scope
global = r scope -> LoggingFor r scope
forall u l. LiftLogging u l => u -> l
liftLogging r scope
forall {k} (r :: k -> *) (scope :: k). ScopeSym r scope => r scope
global
  mainFn :: LoggingFor r scope
mainFn = r scope -> LoggingFor r scope
forall u l. LiftLogging u l => u -> l
liftLogging r scope
forall {k} (r :: k -> *) (scope :: k). ScopeSym r scope => r scope
mainFn
  local :: LoggingFor r scope
local = r scope -> LoggingFor r scope
forall u l. LiftLogging u l => u -> l
liftLogging r scope
forall {k} (r :: k -> *) (scope :: k). ScopeSym r scope => r scope
local

instance (FuncAppStatement r stmt var val) => FuncAppStatement (LoggingFor r) stmt var val where
  inOutCall :: InOutCall (LoggingFor r) stmt var val
inOutCall = InOutCall r stmt var val -> InOutCall (LoggingFor r) stmt var val
forall u l. LiftLogging u l => u -> l
liftLogging InOutCall r stmt var val
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
FuncAppStatement r stmt var val =>
InOutCall r stmt var val
inOutCall
  extInOutCall :: String -> InOutCall (LoggingFor r) stmt var val
extInOutCall = (String -> InOutCall r stmt var val)
-> String -> InOutCall (LoggingFor r) stmt var val
forall u l. LiftLogging u l => u -> l
liftLogging String -> InOutCall r stmt var val
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
FuncAppStatement r stmt var val =>
String -> InOutCall r stmt var val
extInOutCall

instance (InternalList r block var val) => InternalList (LoggingFor r) block var val where
  listSlice' :: Maybe (VS (LoggingFor r val))
-> Maybe (VS (LoggingFor r val))
-> Maybe (VS (LoggingFor r val))
-> VS (LoggingFor r var)
-> VS (LoggingFor r val)
-> MS (LoggingFor r block)
listSlice' = (Maybe (VS (r val))
 -> Maybe (VS (r val))
 -> Maybe (VS (r val))
 -> VS (r var)
 -> VS (r val)
 -> MS (r block))
-> Maybe (VS (LoggingFor r val))
-> Maybe (VS (LoggingFor r val))
-> Maybe (VS (LoggingFor r val))
-> VS (LoggingFor r var)
-> VS (LoggingFor r val)
-> MS (LoggingFor r block)
forall u l. LiftLogging u l => u -> l
liftLogging Maybe (VS (r val))
-> Maybe (VS (r val))
-> Maybe (VS (r val))
-> VS (r var)
-> VS (r val)
-> MS (r block)
forall {k} (r :: k -> *) (block :: k) (var :: k) (val :: k).
InternalList r block var val =>
Maybe (VS (r val))
-> Maybe (VS (r val))
-> Maybe (VS (r val))
-> VS (r var)
-> VS (r val)
-> MS (r block)
listSlice'

instance (Literal r val typ) => Literal (LoggingFor r) val typ where
  litTrue :: VS (LoggingFor r val)
litTrue = VS (r val) -> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
VS (r val)
litTrue
  litFalse :: VS (LoggingFor r val)
litFalse = VS (r val) -> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
VS (r val)
litFalse
  litChar :: Char -> VS (LoggingFor r val)
litChar = (Char -> VS (r val)) -> Char -> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging Char -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Char -> VS (r val)
litChar
  litDouble :: Double -> VS (LoggingFor r val)
litDouble = (Double -> VS (r val)) -> Double -> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging Double -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Double -> VS (r val)
litDouble
  litFloat :: Float -> VS (LoggingFor r val)
litFloat = (Float -> VS (r val)) -> Float -> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging Float -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Float -> VS (r val)
litFloat
  litInt :: Integer -> VS (LoggingFor r val)
litInt = (Integer -> VS (r val)) -> Integer -> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging Integer -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
litInt
  litString :: String -> VS (LoggingFor r val)
litString = (String -> VS (r val)) -> String -> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging String -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
String -> VS (r val)
litString
  litArray :: VS (LoggingFor r typ)
-> [VS (LoggingFor r val)] -> VS (LoggingFor r val)
litArray = (VS (r typ) -> [VS (r val)] -> VS (r val))
-> VS (LoggingFor r typ)
-> [VS (LoggingFor r val)]
-> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r typ) -> [VS (r val)] -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
VS (r typ) -> [VS (r val)] -> VS (r val)
litArray
  litList :: VS (LoggingFor r typ)
-> [VS (LoggingFor r val)] -> VS (LoggingFor r val)
litList = (VS (r typ) -> [VS (r val)] -> VS (r val))
-> VS (LoggingFor r typ)
-> [VS (LoggingFor r val)]
-> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r typ) -> [VS (r val)] -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
VS (r typ) -> [VS (r val)] -> VS (r val)
litList
  litSet :: VS (LoggingFor r typ)
-> [VS (LoggingFor r val)] -> VS (LoggingFor r val)
litSet = (VS (r typ) -> [VS (r val)] -> VS (r val))
-> VS (LoggingFor r typ)
-> [VS (LoggingFor r val)]
-> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r typ) -> [VS (r val)] -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
VS (r typ) -> [VS (r val)] -> VS (r val)
litSet

instance (MathConstant r val) => MathConstant (LoggingFor r) val where
  pi :: VS (LoggingFor r val)
pi = VS (r val) -> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val)
forall {k} (r :: k -> *) (val :: k).
MathConstant r val =>
VS (r val)
pi

instance (ParameterSym r param var) => ParameterSym (LoggingFor r) param var where
  param :: VS (LoggingFor r var) -> MS (LoggingFor r param)
param = (VS (r var) -> MS (r param))
-> VS (LoggingFor r var) -> MS (LoggingFor r param)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r var) -> MS (r param)
forall {k} (r :: k -> *) (param :: k) (var :: k).
ParameterSym r param var =>
VS (r var) -> MS (r param)
param
  pointerParam :: VS (LoggingFor r var) -> MS (LoggingFor r param)
pointerParam = (VS (r var) -> MS (r param))
-> VS (LoggingFor r var) -> MS (LoggingFor r param)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r var) -> MS (r param)
forall {k} (r :: k -> *) (param :: k) (var :: k).
ParameterSym r param var =>
VS (r var) -> MS (r param)
pointerParam

instance (VisibilitySym r vis) => VisibilitySym (LoggingFor r) vis where
  private :: LoggingFor r vis
private = r vis -> LoggingFor r vis
forall u l. LiftLogging u l => u -> l
liftLogging r vis
forall {k} (r :: k -> *) (vis :: k). VisibilitySym r vis => r vis
private
  public :: LoggingFor r vis
public = r vis -> LoggingFor r vis
forall u l. LiftLogging u l => u -> l
liftLogging r vis
forall {k} (r :: k -> *) (vis :: k). VisibilitySym r vis => r vis
public

instance (MethodSym r mthd vis param bod var typ) => MethodSym (LoggingFor r) mthd vis param bod var typ where
  docMain :: MS (LoggingFor r bod) -> MS (LoggingFor r mthd)
docMain = (MS (r bod) -> MS (r mthd))
-> MS (LoggingFor r bod) -> MS (LoggingFor r mthd)
forall u l. LiftLogging u l => u -> l
liftLogging MS (r bod) -> MS (r mthd)
forall {k} (r :: k -> *) (mthd :: k) (vis :: k) (param :: k)
       (bod :: k) (var :: k) (typ :: k).
MethodSym r mthd vis param bod var typ =>
MS (r bod) -> MS (r mthd)
docMain
  function :: String
-> LoggingFor r vis
-> VS (LoggingFor r typ)
-> [MS (LoggingFor r param)]
-> MS (LoggingFor r bod)
-> MS (LoggingFor r mthd)
function = (String
 -> r vis
 -> VS (r typ)
 -> [MS (r param)]
 -> MS (r bod)
 -> MS (r mthd))
-> String
-> LoggingFor r vis
-> VS (LoggingFor r typ)
-> [MS (LoggingFor r param)]
-> MS (LoggingFor r bod)
-> MS (LoggingFor r mthd)
forall u l. LiftLogging u l => u -> l
liftLogging String
-> r vis
-> VS (r typ)
-> [MS (r param)]
-> MS (r bod)
-> MS (r mthd)
forall {k} (r :: k -> *) (mthd :: k) (vis :: k) (param :: k)
       (bod :: k) (var :: k) (typ :: k).
MethodSym r mthd vis param bod var typ =>
String
-> r vis
-> VS (r typ)
-> [MS (r param)]
-> MS (r bod)
-> MS (r mthd)
function
  mainFunction :: MS (LoggingFor r bod) -> MS (LoggingFor r mthd)
mainFunction = (MS (r bod) -> MS (r mthd))
-> MS (LoggingFor r bod) -> MS (LoggingFor r mthd)
forall u l. LiftLogging u l => u -> l
liftLogging MS (r bod) -> MS (r mthd)
forall {k} (r :: k -> *) (mthd :: k) (vis :: k) (param :: k)
       (bod :: k) (var :: k) (typ :: k).
MethodSym r mthd vis param bod var typ =>
MS (r bod) -> MS (r mthd)
mainFunction
  docFunc :: String
-> [String]
-> Maybe String
-> MS (LoggingFor r mthd)
-> MS (LoggingFor r mthd)
docFunc = (String -> [String] -> Maybe String -> MS (r mthd) -> MS (r mthd))
-> String
-> [String]
-> Maybe String
-> MS (LoggingFor r mthd)
-> MS (LoggingFor r mthd)
forall u l. LiftLogging u l => u -> l
liftLogging String -> [String] -> Maybe String -> MS (r mthd) -> MS (r mthd)
forall {k} (r :: k -> *) (mthd :: k) (vis :: k) (param :: k)
       (bod :: k) (var :: k) (typ :: k).
MethodSym r mthd vis param bod var typ =>
String -> [String] -> Maybe String -> MS (r mthd) -> MS (r mthd)
docFunc
  inOutFunc :: String -> LoggingFor r vis -> InOutFunc (LoggingFor r) mthd bod var
inOutFunc = (String -> r vis -> InOutFunc r mthd bod var)
-> String
-> LoggingFor r vis
-> InOutFunc (LoggingFor r) mthd bod var
forall u l. LiftLogging u l => u -> l
liftLogging String -> r vis -> InOutFunc r mthd bod var
forall {k} (r :: k -> *) (mthd :: k) (vis :: k) (param :: k)
       (bod :: k) (var :: k) (typ :: k).
MethodSym r mthd vis param bod var typ =>
String -> r vis -> InOutFunc r mthd bod var
inOutFunc
  docInOutFunc :: String
-> LoggingFor r vis -> DocInOutFunc (LoggingFor r) mthd bod var
docInOutFunc = (String -> r vis -> DocInOutFunc r mthd bod var)
-> String
-> LoggingFor r vis
-> DocInOutFunc (LoggingFor r) mthd bod var
forall u l. LiftLogging u l => u -> l
liftLogging String -> r vis -> DocInOutFunc r mthd bod var
forall {k} (r :: k -> *) (mthd :: k) (vis :: k) (param :: k)
       (bod :: k) (var :: k) (typ :: k).
MethodSym r mthd vis param bod var typ =>
String -> r vis -> DocInOutFunc r mthd bod var
docInOutFunc

instance (NumericExpression r val) => NumericExpression (LoggingFor r) val where
  #~ :: VS (LoggingFor r val) -> VS (LoggingFor r val)
(#~) = (VS (r val) -> VS (r val))
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val)
(#~)
  #/^ :: VS (LoggingFor r val) -> VS (LoggingFor r val)
(#/^) = (VS (r val) -> VS (r val))
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val)
(#/^)
  #| :: VS (LoggingFor r val) -> VS (LoggingFor r val)
(#|) = (VS (r val) -> VS (r val))
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val)
(#|)
  #+ :: VS (LoggingFor r val)
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
(#+) = (VS (r val) -> VS (r val) -> VS (r val))
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val) -> VS (r val)
(#+)
  #- :: VS (LoggingFor r val)
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
(#-) = (VS (r val) -> VS (r val) -> VS (r val))
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val) -> VS (r val)
(#-)
  #* :: VS (LoggingFor r val)
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
(#*) = (VS (r val) -> VS (r val) -> VS (r val))
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val) -> VS (r val)
(#*)
  #/ :: VS (LoggingFor r val)
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
(#/) = (VS (r val) -> VS (r val) -> VS (r val))
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val) -> VS (r val)
(#/)
  #% :: VS (LoggingFor r val)
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
(#%) = (VS (r val) -> VS (r val) -> VS (r val))
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val) -> VS (r val)
(#%)
  #^ :: VS (LoggingFor r val)
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
(#^) = (VS (r val) -> VS (r val) -> VS (r val))
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val) -> VS (r val)
(#^)
  log :: VS (LoggingFor r val) -> VS (LoggingFor r val)
log = (VS (r val) -> VS (r val))
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val)
log
  ln :: VS (LoggingFor r val) -> VS (LoggingFor r val)
ln = (VS (r val) -> VS (r val))
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val)
ln
  exp :: VS (LoggingFor r val) -> VS (LoggingFor r val)
exp = (VS (r val) -> VS (r val))
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val)
exp
  sin :: VS (LoggingFor r val) -> VS (LoggingFor r val)
sin = (VS (r val) -> VS (r val))
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val)
sin
  cos :: VS (LoggingFor r val) -> VS (LoggingFor r val)
cos = (VS (r val) -> VS (r val))
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val)
cos
  tan :: VS (LoggingFor r val) -> VS (LoggingFor r val)
tan = (VS (r val) -> VS (r val))
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val)
tan
  csc :: VS (LoggingFor r val) -> VS (LoggingFor r val)
csc = (VS (r val) -> VS (r val))
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val)
csc
  sec :: VS (LoggingFor r val) -> VS (LoggingFor r val)
sec = (VS (r val) -> VS (r val))
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val)
sec
  cot :: VS (LoggingFor r val) -> VS (LoggingFor r val)
cot = (VS (r val) -> VS (r val))
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val)
cot
  arcsin :: VS (LoggingFor r val) -> VS (LoggingFor r val)
arcsin = (VS (r val) -> VS (r val))
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val)
arcsin
  arccos :: VS (LoggingFor r val) -> VS (LoggingFor r val)
arccos = (VS (r val) -> VS (r val))
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val)
arccos
  arctan :: VS (LoggingFor r val) -> VS (LoggingFor r val)
arctan = (VS (r val) -> VS (r val))
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val)
arctan
  floor :: VS (LoggingFor r val) -> VS (LoggingFor r val)
floor = (VS (r val) -> VS (r val))
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val)
floor
  ceil :: VS (LoggingFor r val) -> VS (LoggingFor r val)
ceil = (VS (r val) -> VS (r val))
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val)
ceil

instance (Set r val) => Set (LoggingFor r) val where
  contains :: VS (LoggingFor r val)
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
contains = (VS (r val) -> VS (r val) -> VS (r val))
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
Set r val =>
VS (r val) -> VS (r val) -> VS (r val)
contains
  setAdd :: VS (LoggingFor r val)
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
setAdd = (VS (r val) -> VS (r val) -> VS (r val))
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
Set r val =>
VS (r val) -> VS (r val) -> VS (r val)
setAdd
  setRemove :: VS (LoggingFor r val)
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
setRemove = (VS (r val) -> VS (r val) -> VS (r val))
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
Set r val =>
VS (r val) -> VS (r val) -> VS (r val)
setRemove
  setUnion :: VS (LoggingFor r val)
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
setUnion = (VS (r val) -> VS (r val) -> VS (r val))
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
Set r val =>
VS (r val) -> VS (r val) -> VS (r val)
setUnion

instance (UnRepr r contents) => UnRepr (LoggingFor r) contents where
  unRepr :: LoggingFor r contents -> contents
unRepr = r contents -> contents
forall (repr :: * -> *) contents.
UnRepr repr contents =>
repr contents -> contents
unRepr (r contents -> contents)
-> (LoggingFor r contents -> r contents)
-> LoggingFor r contents
-> contents
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LoggingFor r contents -> r contents
forall (r :: * -> *) a. LoggingFor r a -> r a
unLC

instance (ValueExpression r var val binder typ) => ValueExpression (LoggingFor r) var val binder typ where
  inlineIf :: VS (LoggingFor r val)
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
inlineIf = (VS (r val) -> VS (r val) -> VS (r val) -> VS (r val))
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
VS (r val) -> VS (r val) -> VS (r val) -> VS (r val)
inlineIf
  funcAppMixedArgs :: MixedCall (LoggingFor r) var val typ
funcAppMixedArgs = MixedCall r var val typ -> MixedCall (LoggingFor r) var val typ
forall u l. LiftLogging u l => u -> l
liftLogging MixedCall r var val typ
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
MixedCall r var val typ
funcAppMixedArgs
  extFuncAppMixedArgs :: String -> MixedCall (LoggingFor r) var val typ
extFuncAppMixedArgs = (String -> MixedCall r var val typ)
-> String -> MixedCall (LoggingFor r) var val typ
forall u l. LiftLogging u l => u -> l
liftLogging String -> MixedCall r var val typ
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
String -> MixedCall r var val typ
extFuncAppMixedArgs
  libFuncAppMixedArgs :: String -> MixedCall (LoggingFor r) var val typ
libFuncAppMixedArgs = (String -> MixedCall r var val typ)
-> String -> MixedCall (LoggingFor r) var val typ
forall u l. LiftLogging u l => u -> l
liftLogging String -> MixedCall r var val typ
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
String -> MixedCall r var val typ
libFuncAppMixedArgs
  lambda :: [VS (LoggingFor r binder)]
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
lambda = ([VS (r binder)] -> VS (r val) -> VS (r val))
-> [VS (LoggingFor r binder)]
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging [VS (r binder)] -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
[VS (r binder)] -> VS (r val) -> VS (r val)
lambda
  notNull :: VS (LoggingFor r val) -> VS (LoggingFor r val)
notNull = (VS (r val) -> VS (r val))
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
VS (r val) -> VS (r val)
notNull

instance (VariableElim r var typ) => VariableElim (LoggingFor r) var typ where
  variableName :: LoggingFor r var -> String
variableName = (r var -> String) -> LoggingFor r var -> String
forall u l. LiftLogging u l => u -> l
liftLogging r var -> String
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableElim r var typ =>
r var -> String
variableName
  variableType :: LoggingFor r var -> LoggingFor r typ
variableType = (r var -> r typ) -> LoggingFor r var -> LoggingFor r typ
forall u l. LiftLogging u l => u -> l
liftLogging r var -> r typ
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableElim r var typ =>
r var -> r typ
variableType

instance (VariableValue r var val) => VariableValue (LoggingFor r) var val where
  valueOf :: VS (LoggingFor r var) -> VS (LoggingFor r val)
valueOf = (VS (r var) -> VS (r val))
-> VS (LoggingFor r var) -> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r var) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k).
VariableValue r var val =>
VS (r var) -> VS (r val)
valueOf

instance (IndexTranslator r val) => IndexTranslator (LoggingFor r) val where
  intToIndex :: VS (LoggingFor r val) -> VS (LoggingFor r val)
intToIndex = (VS (r val) -> VS (r val))
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
IndexTranslator r val =>
VS (r val) -> VS (r val)
intToIndex
  indexToInt :: VS (LoggingFor r val) -> VS (LoggingFor r val)
indexToInt = (VS (r val) -> VS (r val))
-> VS (LoggingFor r val) -> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
IndexTranslator r val =>
VS (r val) -> VS (r val)
indexToInt

instance (NativeVector lang val typ) => NativeVector (LoggingFor lang) val typ where
  vecType :: VS (LoggingFor lang typ) -> VS (LoggingFor lang typ)
vecType = (VS (lang typ) -> VS (lang typ))
-> VS (LoggingFor lang typ) -> VS (LoggingFor lang typ)
forall u l. LiftLogging u l => u -> l
liftLogging VS (lang typ) -> VS (lang typ)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
NativeVector r val typ =>
VS (r typ) -> VS (r typ)
vecType
  litVec :: VS (LoggingFor lang typ)
-> [VS (LoggingFor lang val)] -> VS (LoggingFor lang val)
litVec = (VS (lang typ) -> [VS (lang val)] -> VS (lang val))
-> VS (LoggingFor lang typ)
-> [VS (LoggingFor lang val)]
-> VS (LoggingFor lang val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (lang typ) -> [VS (lang val)] -> VS (lang val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
NativeVector r val typ =>
VS (r typ) -> [VS (r val)] -> VS (r val)
litVec
  vecScale :: VS (LoggingFor lang val)
-> VS (LoggingFor lang val) -> VS (LoggingFor lang val)
vecScale = (VS (lang val) -> VS (lang val) -> VS (lang val))
-> VS (LoggingFor lang val)
-> VS (LoggingFor lang val)
-> VS (LoggingFor lang val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (lang val) -> VS (lang val) -> VS (lang val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
NativeVector r val typ =>
VS (r val) -> VS (r val) -> VS (r val)
vecScale
  vecAdd :: VS (LoggingFor lang val)
-> VS (LoggingFor lang val) -> VS (LoggingFor lang val)
vecAdd = (VS (lang val) -> VS (lang val) -> VS (lang val))
-> VS (LoggingFor lang val)
-> VS (LoggingFor lang val)
-> VS (LoggingFor lang val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (lang val) -> VS (lang val) -> VS (lang val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
NativeVector r val typ =>
VS (r val) -> VS (r val) -> VS (r val)
vecAdd
  vecIndex :: VS (LoggingFor lang val)
-> VS (LoggingFor lang val) -> VS (LoggingFor lang val)
vecIndex = (VS (lang val) -> VS (lang val) -> VS (lang val))
-> VS (LoggingFor lang val)
-> VS (LoggingFor lang val)
-> VS (LoggingFor lang val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (lang val) -> VS (lang val) -> VS (lang val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
NativeVector r val typ =>
VS (r val) -> VS (r val) -> VS (r val)
vecIndex
  vecDot :: VS (LoggingFor lang val)
-> VS (LoggingFor lang val) -> VS (LoggingFor lang val)
vecDot = (VS (lang val) -> VS (lang val) -> VS (lang val))
-> VS (LoggingFor lang val)
-> VS (LoggingFor lang val)
-> VS (LoggingFor lang val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (lang val) -> VS (lang val) -> VS (lang val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
NativeVector r val typ =>
VS (r val) -> VS (r val) -> VS (r val)
vecDot
  vecMag :: VS (LoggingFor lang val) -> VS (LoggingFor lang val)
vecMag = (VS (lang val) -> VS (lang val))
-> VS (LoggingFor lang val) -> VS (LoggingFor lang val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (lang val) -> VS (lang val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
NativeVector r val typ =>
VS (r val) -> VS (r val)
vecMag
  vecUnit :: VS (LoggingFor lang val) -> VS (LoggingFor lang val)
vecUnit = (VS (lang val) -> VS (lang val))
-> VS (LoggingFor lang val) -> VS (LoggingFor lang val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (lang val) -> VS (lang val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
NativeVector r val typ =>
VS (r val) -> VS (r val)
vecUnit

-- GProc

instance (P.ProcProg r prg file mod mthd vis param bod block stmt var scope val binder typ) => P.ProcProg (LoggingFor r) prg file mod mthd vis param bod block stmt var scope val binder typ

instance (P.ModuleSym r mod mthd) => P.ModuleSym (LoggingFor r) mod mthd where
  buildModule :: String
-> [String] -> [MS (LoggingFor r mthd)] -> FS (LoggingFor r mod)
buildModule = (String -> [String] -> [MS (r mthd)] -> FS (r mod))
-> String
-> [String]
-> [MS (LoggingFor r mthd)]
-> FS (LoggingFor r mod)
forall u l. LiftLogging u l => u -> l
liftLogging String -> [String] -> [MS (r mthd)] -> FS (r mod)
forall {k} (r :: k -> *) (mod :: k) (mthd :: k).
ModuleSym r mod mthd =>
String -> [String] -> [MS (r mthd)] -> FS (r mod)
P.buildModule

instance (P.FileSym r file mod) => P.FileSym (LoggingFor r) file mod where
  fileDoc :: FS (LoggingFor r mod) -> FS (LoggingFor r file)
fileDoc = (FS (r mod) -> FS (r file))
-> FS (LoggingFor r mod) -> FS (LoggingFor r file)
forall u l. LiftLogging u l => u -> l
liftLogging FS (r mod) -> FS (r file)
forall {k} (r :: k -> *) (file :: k) (mod :: k).
FileSym r file mod =>
FS (r mod) -> FS (r file)
P.fileDoc
  docMod :: String
-> String
-> [String]
-> String
-> FS (LoggingFor r file)
-> FS (LoggingFor r file)
docMod = (String
 -> String -> [String] -> String -> FS (r file) -> FS (r file))
-> String
-> String
-> [String]
-> String
-> FS (LoggingFor r file)
-> FS (LoggingFor r file)
forall u l. LiftLogging u l => u -> l
liftLogging String
-> String -> [String] -> String -> FS (r file) -> FS (r file)
forall {k} (r :: k -> *) (file :: k) (mod :: k).
FileSym r file mod =>
String
-> String -> [String] -> String -> FS (r file) -> FS (r file)
P.docMod

instance (P.ProgramSym r prg file) => P.ProgramSym (LoggingFor r) prg file where
  prog :: String
-> String
-> [FS (LoggingFor r file)]
-> GSProgram (LoggingFor r) prg
prog = (String -> String -> [FS (r file)] -> GSProgram r prg)
-> String
-> String
-> [FS (LoggingFor r file)]
-> GSProgram (LoggingFor r) prg
forall u l. LiftLogging u l => u -> l
liftLogging String -> String -> [FS (r file)] -> GSProgram r prg
forall {k} (r :: k -> *) (prg :: k) (file :: k).
ProgramSym r prg file =>
String -> String -> [FS (r file)] -> GSProgram r prg
P.prog

-- GOOL

instance (G.OOProg r prg file mod cls stvr mthd attch vis param bod block stmt var scope val binder typ) => G.OOProg (LoggingFor r) prg file mod cls stvr mthd attch vis param bod block stmt var scope val binder typ

instance (G.GetSet r var val) => G.GetSet (LoggingFor r) var val where
  get :: VS (LoggingFor r val)
-> VS (LoggingFor r var) -> VS (LoggingFor r val)
get = (VS (r val) -> VS (r var) -> VS (r val))
-> VS (LoggingFor r val)
-> VS (LoggingFor r var)
-> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r var) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k).
GetSet r var val =>
VS (r val) -> VS (r var) -> VS (r val)
G.get
  set :: VS (LoggingFor r val)
-> VS (LoggingFor r var)
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
set = (VS (r val) -> VS (r var) -> VS (r val) -> VS (r val))
-> VS (LoggingFor r val)
-> VS (LoggingFor r var)
-> VS (LoggingFor r val)
-> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r var) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k).
GetSet r var val =>
VS (r val) -> VS (r var) -> VS (r val) -> VS (r val)
G.set

instance (G.InternalValueExp r var val typ) => G.InternalValueExp (LoggingFor r) var val typ where
  objMethodCallMixedArgs' :: String
-> VS (LoggingFor r typ)
-> VS (LoggingFor r val)
-> [VS (LoggingFor r val)]
-> NamedArgs (LoggingFor r) var val
-> VS (LoggingFor r val)
objMethodCallMixedArgs' = (String
 -> VS (r typ)
 -> VS (r val)
 -> [VS (r val)]
 -> NamedArgs r var val
 -> VS (r val))
-> String
-> VS (LoggingFor r typ)
-> VS (LoggingFor r val)
-> [VS (LoggingFor r val)]
-> NamedArgs (LoggingFor r) var val
-> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging String
-> VS (r typ)
-> VS (r val)
-> [VS (r val)]
-> NamedArgs r var val
-> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
InternalValueExp r var val typ =>
String
-> VS (r typ)
-> VS (r val)
-> [VS (r val)]
-> NamedArgs r var val
-> VS (r val)
G.objMethodCallMixedArgs'
  classMethodCallMixedArgs' :: String
-> VS (LoggingFor r typ)
-> VS (LoggingFor r typ)
-> [VS (LoggingFor r val)]
-> NamedArgs (LoggingFor r) var val
-> VS (LoggingFor r val)
classMethodCallMixedArgs' = (String
 -> VS (r typ)
 -> VS (r typ)
 -> [VS (r val)]
 -> NamedArgs r var val
 -> VS (r val))
-> String
-> VS (LoggingFor r typ)
-> VS (LoggingFor r typ)
-> [VS (LoggingFor r val)]
-> NamedArgs (LoggingFor r) var val
-> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging String
-> VS (r typ)
-> VS (r typ)
-> [VS (r val)]
-> NamedArgs r var val
-> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
InternalValueExp r var val typ =>
String
-> VS (r typ)
-> VS (r typ)
-> [VS (r val)]
-> NamedArgs r var val
-> VS (r val)
G.classMethodCallMixedArgs'

instance (G.OOTypeSym r typ) => G.OOTypeSym (LoggingFor r) typ where
  obj :: String -> VS (LoggingFor r typ)
obj = (String -> VS (r typ)) -> String -> VS (LoggingFor r typ)
forall u l. LiftLogging u l => u -> l
liftLogging String -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
OOTypeSym r typ =>
String -> VS (r typ)
G.obj

instance (G.OOVariableSym r var val typ) => G.OOVariableSym (LoggingFor r) var val typ where
  classVar :: String -> VS (LoggingFor r typ) -> VS (LoggingFor r var)
classVar = (String -> VS (r typ) -> VS (r var))
-> String -> VS (LoggingFor r typ) -> VS (LoggingFor r var)
forall u l. LiftLogging u l => u -> l
liftLogging String -> VS (r typ) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
OOVariableSym r var val typ =>
String -> VS (r typ) -> VS (r var)
G.classVar
  classConst :: String -> VS (LoggingFor r typ) -> VS (LoggingFor r var)
classConst = (String -> VS (r typ) -> VS (r var))
-> String -> VS (LoggingFor r typ) -> VS (LoggingFor r var)
forall u l. LiftLogging u l => u -> l
liftLogging String -> VS (r typ) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
OOVariableSym r var val typ =>
String -> VS (r typ) -> VS (r var)
G.classConst
  classVarAccess :: VS (LoggingFor r typ)
-> VS (LoggingFor r var) -> VS (LoggingFor r var)
classVarAccess = (VS (r typ) -> VS (r var) -> VS (r var))
-> VS (LoggingFor r typ)
-> VS (LoggingFor r var)
-> VS (LoggingFor r var)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r typ) -> VS (r var) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
OOVariableSym r var val typ =>
VS (r typ) -> VS (r var) -> VS (r var)
G.classVarAccess
  extClassVarAccess :: VS (LoggingFor r typ)
-> VS (LoggingFor r var) -> VS (LoggingFor r var)
extClassVarAccess = (VS (r typ) -> VS (r var) -> VS (r var))
-> VS (LoggingFor r typ)
-> VS (LoggingFor r var)
-> VS (LoggingFor r var)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r typ) -> VS (r var) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
OOVariableSym r var val typ =>
VS (r typ) -> VS (r var) -> VS (r var)
G.extClassVarAccess
  instanceVarAccess :: VS (LoggingFor r val)
-> VS (LoggingFor r var) -> VS (LoggingFor r var)
instanceVarAccess = (VS (r val) -> VS (r var) -> VS (r var))
-> VS (LoggingFor r val)
-> VS (LoggingFor r var)
-> VS (LoggingFor r var)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r var) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
OOVariableSym r var val typ =>
VS (r val) -> VS (r var) -> VS (r var)
G.instanceVarAccess

instance
  ( DeclStatement (LoggingFor r) bod stmt var scope val
  , G.OODeclStatement r stmt var scope val
  ) => G.OODeclStatement (LoggingFor r) stmt var scope val where
  objDecDef :: VS (LoggingFor r var)
-> LoggingFor r scope
-> VS (LoggingFor r val)
-> MS (LoggingFor r stmt)
objDecDef = (VS (r var) -> r scope -> VS (r val) -> MS (r stmt))
-> VS (LoggingFor r var)
-> LoggingFor r scope
-> VS (LoggingFor r val)
-> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r var) -> r scope -> VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (scope :: k)
       (val :: k).
OODeclStatement r stmt var scope val =>
VS (r var) -> r scope -> VS (r val) -> MS (r stmt)
G.objDecDef
  objDecNew :: VS (LoggingFor r var)
-> LoggingFor r scope
-> [VS (LoggingFor r val)]
-> MS (LoggingFor r stmt)
objDecNew = (VS (r var) -> r scope -> [VS (r val)] -> MS (r stmt))
-> VS (LoggingFor r var)
-> LoggingFor r scope
-> [VS (LoggingFor r val)]
-> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r var) -> r scope -> [VS (r val)] -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (scope :: k)
       (val :: k).
OODeclStatement r stmt var scope val =>
VS (r var) -> r scope -> [VS (r val)] -> MS (r stmt)
G.objDecNew
  extObjDecNew :: String
-> VS (LoggingFor r var)
-> LoggingFor r scope
-> [VS (LoggingFor r val)]
-> MS (LoggingFor r stmt)
extObjDecNew = (String -> VS (r var) -> r scope -> [VS (r val)] -> MS (r stmt))
-> String
-> VS (LoggingFor r var)
-> LoggingFor r scope
-> [VS (LoggingFor r val)]
-> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging String -> VS (r var) -> r scope -> [VS (r val)] -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (scope :: k)
       (val :: k).
OODeclStatement r stmt var scope val =>
String -> VS (r var) -> r scope -> [VS (r val)] -> MS (r stmt)
G.extObjDecNew

instance (G.OOFuncAppStatement r stmt var val) => G.OOFuncAppStatement (LoggingFor r) stmt var val where
  selfInOutCall :: InOutCall (LoggingFor r) stmt var val
selfInOutCall = InOutCall r stmt var val -> InOutCall (LoggingFor r) stmt var val
forall u l. LiftLogging u l => u -> l
liftLogging InOutCall r stmt var val
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
OOFuncAppStatement r stmt var val =>
InOutCall r stmt var val
G.selfInOutCall

instance (G.OOValueExpression r var val typ) => G.OOValueExpression (LoggingFor r) var val typ where
  newObjMixedArgs :: MixedCtorCall (LoggingFor r) var val typ
newObjMixedArgs = MixedCtorCall r var val typ
-> MixedCtorCall (LoggingFor r) var val typ
forall u l. LiftLogging u l => u -> l
liftLogging MixedCtorCall r var val typ
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
OOValueExpression r var val typ =>
MixedCtorCall r var val typ
G.newObjMixedArgs
  extNewObjMixedArgs :: String -> MixedCtorCall (LoggingFor r) var val typ
extNewObjMixedArgs = (String -> MixedCtorCall r var val typ)
-> String -> MixedCtorCall (LoggingFor r) var val typ
forall u l. LiftLogging u l => u -> l
liftLogging String -> MixedCtorCall r var val typ
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
OOValueExpression r var val typ =>
String -> MixedCtorCall r var val typ
G.extNewObjMixedArgs
  libNewObjMixedArgs :: String -> MixedCtorCall (LoggingFor r) var val typ
libNewObjMixedArgs = (String -> MixedCtorCall r var val typ)
-> String -> MixedCtorCall (LoggingFor r) var val typ
forall u l. LiftLogging u l => u -> l
liftLogging String -> MixedCtorCall r var val typ
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
OOValueExpression r var val typ =>
String -> MixedCtorCall r var val typ
G.libNewObjMixedArgs

instance (G.SelfSym r var) => G.SelfSym (LoggingFor r) var where
  self :: VS (LoggingFor r var)
self = VS (r var) -> VS (LoggingFor r var)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r var)
forall {k} (r :: k -> *) (var :: k). SelfSym r var => VS (r var)
G.self

instance (G.OOFunctionSym r val typ) => G.OOFunctionSym (LoggingFor r) val typ where
  func :: String
-> VS (LoggingFor r typ)
-> [VS (LoggingFor r val)]
-> VS (LoggingFor r FuncData)
func = (String -> VS (r typ) -> [VS (r val)] -> VS (r FuncData))
-> String
-> VS (LoggingFor r typ)
-> [VS (LoggingFor r val)]
-> VS (LoggingFor r FuncData)
forall u l. LiftLogging u l => u -> l
liftLogging String -> VS (r typ) -> [VS (r val)] -> VS (r FuncData)
forall (r :: * -> *) val typ.
OOFunctionSym r val typ =>
String -> VS (r typ) -> [VS (r val)] -> VS (r FuncData)
G.func
  objAccess :: VS (LoggingFor r val)
-> VS (LoggingFor r FuncData) -> VS (LoggingFor r val)
objAccess = (VS (r val) -> VS (r FuncData) -> VS (r val))
-> VS (LoggingFor r val)
-> VS (LoggingFor r FuncData)
-> VS (LoggingFor r val)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r val) -> VS (r FuncData) -> VS (r val)
forall (r :: * -> *) val typ.
OOFunctionSym r val typ =>
VS (r val) -> VS (r FuncData) -> VS (r val)
G.objAccess

instance (G.ObserverPattern r stmt typ) => G.ObserverPattern (LoggingFor r) stmt typ where
  notifyObservers :: VS (LoggingFor r FuncData)
-> VS (LoggingFor r typ) -> MS (LoggingFor r stmt)
notifyObservers = (VS (r FuncData) -> VS (r typ) -> MS (r stmt))
-> VS (LoggingFor r FuncData)
-> VS (LoggingFor r typ)
-> MS (LoggingFor r stmt)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r FuncData) -> VS (r typ) -> MS (r stmt)
forall (r :: * -> *) stmt typ.
ObserverPattern r stmt typ =>
VS (r FuncData) -> VS (r typ) -> MS (r stmt)
G.notifyObservers

instance (G.AttachmentSym r attch) => G.AttachmentSym (LoggingFor r) attch where
  classLevel :: LoggingFor r attch
classLevel = r attch -> LoggingFor r attch
forall u l. LiftLogging u l => u -> l
liftLogging r attch
forall {k} (r :: k -> *) (attch :: k).
AttachmentSym r attch =>
r attch
G.classLevel
  instanceLevel :: LoggingFor r attch
instanceLevel = r attch -> LoggingFor r attch
forall u l. LiftLogging u l => u -> l
liftLogging r attch
forall {k} (r :: k -> *) (attch :: k).
AttachmentSym r attch =>
r attch
G.instanceLevel

instance (G.OOMethodSym r mthd attch vis param bod var val typ) => G.OOMethodSym (LoggingFor r) mthd attch vis param bod var val typ where
  method :: String
-> LoggingFor r vis
-> LoggingFor r attch
-> VS (LoggingFor r typ)
-> [MS (LoggingFor r param)]
-> MS (LoggingFor r bod)
-> MS (LoggingFor r mthd)
method = (String
 -> r vis
 -> r attch
 -> VS (r typ)
 -> [MS (r param)]
 -> MS (r bod)
 -> MS (r mthd))
-> String
-> LoggingFor r vis
-> LoggingFor r attch
-> VS (LoggingFor r typ)
-> [MS (LoggingFor r param)]
-> MS (LoggingFor r bod)
-> MS (LoggingFor r mthd)
forall u l. LiftLogging u l => u -> l
liftLogging String
-> r vis
-> r attch
-> VS (r typ)
-> [MS (r param)]
-> MS (r bod)
-> MS (r mthd)
forall {k} (r :: k -> *) (mthd :: k) (attch :: k) (vis :: k)
       (param :: k) (bod :: k) (var :: k) (val :: k) (typ :: k).
OOMethodSym r mthd attch vis param bod var val typ =>
String
-> r vis
-> r attch
-> VS (r typ)
-> [MS (r param)]
-> MS (r bod)
-> MS (r mthd)
G.method
  getMethod :: VS (LoggingFor r var) -> MS (LoggingFor r mthd)
getMethod = (VS (r var) -> MS (r mthd))
-> VS (LoggingFor r var) -> MS (LoggingFor r mthd)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r var) -> MS (r mthd)
forall {k} (r :: k -> *) (mthd :: k) (attch :: k) (vis :: k)
       (param :: k) (bod :: k) (var :: k) (val :: k) (typ :: k).
OOMethodSym r mthd attch vis param bod var val typ =>
VS (r var) -> MS (r mthd)
G.getMethod
  setMethod :: VS (LoggingFor r var) -> MS (LoggingFor r mthd)
setMethod = (VS (r var) -> MS (r mthd))
-> VS (LoggingFor r var) -> MS (LoggingFor r mthd)
forall u l. LiftLogging u l => u -> l
liftLogging VS (r var) -> MS (r mthd)
forall {k} (r :: k -> *) (mthd :: k) (attch :: k) (vis :: k)
       (param :: k) (bod :: k) (var :: k) (val :: k) (typ :: k).
OOMethodSym r mthd attch vis param bod var val typ =>
VS (r var) -> MS (r mthd)
G.setMethod
  constructor :: [MS (LoggingFor r param)]
-> Initializers (LoggingFor r) var val
-> MS (LoggingFor r bod)
-> MS (LoggingFor r mthd)
constructor = ([MS (r param)]
 -> Initializers r var val -> MS (r bod) -> MS (r mthd))
-> [MS (LoggingFor r param)]
-> Initializers (LoggingFor r) var val
-> MS (LoggingFor r bod)
-> MS (LoggingFor r mthd)
forall u l. LiftLogging u l => u -> l
liftLogging [MS (r param)]
-> Initializers r var val -> MS (r bod) -> MS (r mthd)
forall {k} (r :: k -> *) (mthd :: k) (attch :: k) (vis :: k)
       (param :: k) (bod :: k) (var :: k) (val :: k) (typ :: k).
OOMethodSym r mthd attch vis param bod var val typ =>
[MS (r param)]
-> Initializers r var val -> MS (r bod) -> MS (r mthd)
G.constructor
  inOutMethod :: String
-> LoggingFor r vis
-> LoggingFor r attch
-> InOutFunc (LoggingFor r) mthd bod var
inOutMethod = (String -> r vis -> r attch -> InOutFunc r mthd bod var)
-> String
-> LoggingFor r vis
-> LoggingFor r attch
-> InOutFunc (LoggingFor r) mthd bod var
forall u l. LiftLogging u l => u -> l
liftLogging String -> r vis -> r attch -> InOutFunc r mthd bod var
forall {k} (r :: k -> *) (mthd :: k) (attch :: k) (vis :: k)
       (param :: k) (bod :: k) (var :: k) (val :: k) (typ :: k).
OOMethodSym r mthd attch vis param bod var val typ =>
String -> r vis -> r attch -> InOutFunc r mthd bod var
G.inOutMethod
  docInOutMethod :: String
-> LoggingFor r vis
-> LoggingFor r attch
-> DocInOutFunc (LoggingFor r) mthd bod var
docInOutMethod = (String -> r vis -> r attch -> DocInOutFunc r mthd bod var)
-> String
-> LoggingFor r vis
-> LoggingFor r attch
-> DocInOutFunc (LoggingFor r) mthd bod var
forall u l. LiftLogging u l => u -> l
liftLogging String -> r vis -> r attch -> DocInOutFunc r mthd bod var
forall {k} (r :: k -> *) (mthd :: k) (attch :: k) (vis :: k)
       (param :: k) (bod :: k) (var :: k) (val :: k) (typ :: k).
OOMethodSym r mthd attch vis param bod var val typ =>
String -> r vis -> r attch -> DocInOutFunc r mthd bod var
G.docInOutMethod

instance (G.StateVarSym r stvr attch vis var val) => G.StateVarSym (LoggingFor r) stvr attch vis var val where
  stateVar :: LoggingFor r vis
-> LoggingFor r attch
-> VS (LoggingFor r var)
-> CSStateVar (LoggingFor r) stvr
stateVar = (r vis -> r attch -> VS (r var) -> CSStateVar r stvr)
-> LoggingFor r vis
-> LoggingFor r attch
-> VS (LoggingFor r var)
-> CSStateVar (LoggingFor r) stvr
forall u l. LiftLogging u l => u -> l
liftLogging r vis -> r attch -> VS (r var) -> CSStateVar r stvr
forall {k} (r :: k -> *) (stvr :: k) (attch :: k) (vis :: k)
       (var :: k) (val :: k).
StateVarSym r stvr attch vis var val =>
r vis -> r attch -> VS (r var) -> CSStateVar r stvr
G.stateVar
  stateVarDef :: LoggingFor r vis
-> LoggingFor r attch
-> VS (LoggingFor r var)
-> VS (LoggingFor r val)
-> CSStateVar (LoggingFor r) stvr
stateVarDef = (r vis -> r attch -> VS (r var) -> VS (r val) -> CSStateVar r stvr)
-> LoggingFor r vis
-> LoggingFor r attch
-> VS (LoggingFor r var)
-> VS (LoggingFor r val)
-> CSStateVar (LoggingFor r) stvr
forall u l. LiftLogging u l => u -> l
liftLogging r vis -> r attch -> VS (r var) -> VS (r val) -> CSStateVar r stvr
forall {k} (r :: k -> *) (stvr :: k) (attch :: k) (vis :: k)
       (var :: k) (val :: k).
StateVarSym r stvr attch vis var val =>
r vis -> r attch -> VS (r var) -> VS (r val) -> CSStateVar r stvr
G.stateVarDef
  constVar :: LoggingFor r vis
-> VS (LoggingFor r var)
-> VS (LoggingFor r val)
-> CSStateVar (LoggingFor r) stvr
constVar = (r vis -> VS (r var) -> VS (r val) -> CSStateVar r stvr)
-> LoggingFor r vis
-> VS (LoggingFor r var)
-> VS (LoggingFor r val)
-> CSStateVar (LoggingFor r) stvr
forall u l. LiftLogging u l => u -> l
liftLogging r vis -> VS (r var) -> VS (r val) -> CSStateVar r stvr
forall {k} (r :: k -> *) (stvr :: k) (attch :: k) (vis :: k)
       (var :: k) (val :: k).
StateVarSym r stvr attch vis var val =>
r vis -> VS (r var) -> VS (r val) -> CSStateVar r stvr
G.constVar

instance (G.ClassSym r cls stvr mthd) => G.ClassSym (LoggingFor r) cls stvr mthd where
  buildClass :: Maybe String
-> [CSStateVar (LoggingFor r) stvr]
-> [MS (LoggingFor r mthd)]
-> [MS (LoggingFor r mthd)]
-> CS (LoggingFor r cls)
buildClass = (Maybe String
 -> [CSStateVar r stvr]
 -> [MS (r mthd)]
 -> [MS (r mthd)]
 -> CS (r cls))
-> Maybe String
-> [CSStateVar (LoggingFor r) stvr]
-> [MS (LoggingFor r mthd)]
-> [MS (LoggingFor r mthd)]
-> CS (LoggingFor r cls)
forall u l. LiftLogging u l => u -> l
liftLogging Maybe String
-> [CSStateVar r stvr]
-> [MS (r mthd)]
-> [MS (r mthd)]
-> CS (r cls)
forall {k} (r :: k -> *) (cls :: k) (stvr :: k) (mthd :: k).
ClassSym r cls stvr mthd =>
Maybe String
-> [CSStateVar r stvr]
-> [MS (r mthd)]
-> [MS (r mthd)]
-> CS (r cls)
G.buildClass
  extraClass :: String
-> Maybe String
-> [CSStateVar (LoggingFor r) stvr]
-> [MS (LoggingFor r mthd)]
-> [MS (LoggingFor r mthd)]
-> CS (LoggingFor r cls)
extraClass = (String
 -> Maybe String
 -> [CSStateVar r stvr]
 -> [MS (r mthd)]
 -> [MS (r mthd)]
 -> CS (r cls))
-> String
-> Maybe String
-> [CSStateVar (LoggingFor r) stvr]
-> [MS (LoggingFor r mthd)]
-> [MS (LoggingFor r mthd)]
-> CS (LoggingFor r cls)
forall u l. LiftLogging u l => u -> l
liftLogging String
-> Maybe String
-> [CSStateVar r stvr]
-> [MS (r mthd)]
-> [MS (r mthd)]
-> CS (r cls)
forall {k} (r :: k -> *) (cls :: k) (stvr :: k) (mthd :: k).
ClassSym r cls stvr mthd =>
String
-> Maybe String
-> [CSStateVar r stvr]
-> [MS (r mthd)]
-> [MS (r mthd)]
-> CS (r cls)
G.extraClass
  implementingClass :: String
-> [String]
-> [CSStateVar (LoggingFor r) stvr]
-> [MS (LoggingFor r mthd)]
-> [MS (LoggingFor r mthd)]
-> CS (LoggingFor r cls)
implementingClass = (String
 -> [String]
 -> [CSStateVar r stvr]
 -> [MS (r mthd)]
 -> [MS (r mthd)]
 -> CS (r cls))
-> String
-> [String]
-> [CSStateVar (LoggingFor r) stvr]
-> [MS (LoggingFor r mthd)]
-> [MS (LoggingFor r mthd)]
-> CS (LoggingFor r cls)
forall u l. LiftLogging u l => u -> l
liftLogging String
-> [String]
-> [CSStateVar r stvr]
-> [MS (r mthd)]
-> [MS (r mthd)]
-> CS (r cls)
forall {k} (r :: k -> *) (cls :: k) (stvr :: k) (mthd :: k).
ClassSym r cls stvr mthd =>
String
-> [String]
-> [CSStateVar r stvr]
-> [MS (r mthd)]
-> [MS (r mthd)]
-> CS (r cls)
G.implementingClass
  docClass :: String -> CS (LoggingFor r cls) -> CS (LoggingFor r cls)
docClass = (String -> CS (r cls) -> CS (r cls))
-> String -> CS (LoggingFor r cls) -> CS (LoggingFor r cls)
forall u l. LiftLogging u l => u -> l
liftLogging String -> CS (r cls) -> CS (r cls)
forall {k} (r :: k -> *) (cls :: k) (stvr :: k) (mthd :: k).
ClassSym r cls stvr mthd =>
String -> CS (r cls) -> CS (r cls)
G.docClass

instance (G.ModuleSym r mod cls mthd) => G.ModuleSym (LoggingFor r) mod cls mthd where
  buildModule :: String
-> [String]
-> [MS (LoggingFor r mthd)]
-> [CS (LoggingFor r cls)]
-> FS (LoggingFor r mod)
buildModule = (String -> [String] -> [MS (r mthd)] -> [CS (r cls)] -> FS (r mod))
-> String
-> [String]
-> [MS (LoggingFor r mthd)]
-> [CS (LoggingFor r cls)]
-> FS (LoggingFor r mod)
forall u l. LiftLogging u l => u -> l
liftLogging String -> [String] -> [MS (r mthd)] -> [CS (r cls)] -> FS (r mod)
forall {k} (r :: k -> *) (mod :: k) (cls :: k) (mthd :: k).
ModuleSym r mod cls mthd =>
String -> [String] -> [MS (r mthd)] -> [CS (r cls)] -> FS (r mod)
G.buildModule

instance (G.FileSym r file mod) => G.FileSym (LoggingFor r) file mod where
  fileDoc :: FS (LoggingFor r mod) -> FS (LoggingFor r file)
fileDoc = (FS (r mod) -> FS (r file))
-> FS (LoggingFor r mod) -> FS (LoggingFor r file)
forall u l. LiftLogging u l => u -> l
liftLogging FS (r mod) -> FS (r file)
forall {k} (r :: k -> *) (file :: k) (mod :: k).
FileSym r file mod =>
FS (r mod) -> FS (r file)
G.fileDoc
  docMod :: String
-> String
-> [String]
-> String
-> FS (LoggingFor r file)
-> FS (LoggingFor r file)
docMod = (String
 -> String -> [String] -> String -> FS (r file) -> FS (r file))
-> String
-> String
-> [String]
-> String
-> FS (LoggingFor r file)
-> FS (LoggingFor r file)
forall u l. LiftLogging u l => u -> l
liftLogging String
-> String -> [String] -> String -> FS (r file) -> FS (r file)
forall {k} (r :: k -> *) (file :: k) (mod :: k).
FileSym r file mod =>
String
-> String -> [String] -> String -> FS (r file) -> FS (r file)
G.docMod

instance (G.ProgramSym r prg file) => G.ProgramSym (LoggingFor r) prg file where
  prog :: String
-> String
-> [FS (LoggingFor r file)]
-> GSProgram (LoggingFor r) prg
prog = (String -> String -> [FS (r file)] -> GSProgram r prg)
-> String
-> String
-> [FS (LoggingFor r file)]
-> GSProgram (LoggingFor r) prg
forall u l. LiftLogging u l => u -> l
liftLogging String -> String -> [FS (r file)] -> GSProgram r prg
forall {k} (r :: k -> *) (prg :: k) (file :: k).
ProgramSym r prg file =>
String -> String -> [FS (r file)] -> GSProgram r prg
G.prog

instance (G.StrategyPattern r bod block var val) => G.StrategyPattern (LoggingFor r) bod block var val where
  runStrategy :: String
-> [(String, MS (LoggingFor r bod))]
-> Maybe (VS (LoggingFor r val))
-> Maybe (VS (LoggingFor r var))
-> MS (LoggingFor r block)
runStrategy = (String
 -> [(String, MS (r bod))]
 -> Maybe (VS (r val))
 -> Maybe (VS (r var))
 -> MS (r block))
-> String
-> [(String, MS (LoggingFor r bod))]
-> Maybe (VS (LoggingFor r val))
-> Maybe (VS (LoggingFor r var))
-> MS (LoggingFor r block)
forall u l. LiftLogging u l => u -> l
liftLogging String
-> [(String, MS (r bod))]
-> Maybe (VS (r val))
-> Maybe (VS (r var))
-> MS (r block)
forall {k} (r :: k -> *) (bod :: k) (block :: k) (var :: k)
       (val :: k).
StrategyPattern r bod block var val =>
String
-> [(String, MS (r bod))]
-> Maybe (VS (r val))
-> Maybe (VS (r var))
-> MS (r block)
G.runStrategy