{-# LANGUAGE CPP #-}
{-# LANGUAGE FunctionalDependencies #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE Safe #-}
{-# LANGUAGE ScopedTypeVariables #-}
module Compilation.CompilerState (
CleanupBlock(..),
CompilerContext(..),
CompiledData(..),
CompilerState,
DeferVariable(..),
LoopSetup(..),
JumpType(..),
MemberValue(..),
ReturnVariable(..),
UsedVariable(..),
addDeferred,
autoSelfType,
branchDeferred,
checkDeferred,
concatM,
csAddRequired,
csAddTrace,
csAddUsed,
csAddVariable,
csAllFilters,
csCanForward,
csCheckValueInit,
csCheckVariableInit,
csClearOutput,
csCurrentScope,
csDelegateArgs,
csExprLookup,
csGetCategoryFunction,
csGetCleanup,
csGetLoop,
csGetNoTrace,
csGetOutput,
csGetParamScope,
csGetTestsOnly,
csGetTypeFunction,
csGetVariable,
csInheritDeferred,
csInheritStatic,
csInheritUsed,
csIsNamedReturns,
csIsUnreachable,
csPrimNamedReturns,
csPushCleanup,
csRegisterReturn,
csReleaseExprMacro,
csReserveExprMacro,
csResolver,
csSameType,
csSelfType,
csSetDeferred,
csSetHidden,
csSetJumpType,
csSetNoTrace,
csSetReadOnly,
csStartCleanup,
csStartLoop,
csUpdateAssigned,
csWrite,
emptyCleanupBlock,
emptyDeferred,
followDeferred,
getCleanContext,
removeDeferred,
runDataCompiler,
) where
import Control.Monad.Trans (lift)
import Control.Monad.Trans.State (StateT(..),execStateT,get,put)
import Data.Functor
import Prelude hiding (foldr)
import qualified Data.Map as Map
import qualified Data.Set as Set
#if MIN_VERSION_base(4,11,0)
#else
import Data.Semigroup
#endif
import Base.CompilerError
import Base.GeneralType
import Base.Positional
import Types.DefinedCategory
import Types.Procedure
import Types.TypeCategory
import Types.TypeInstance
type CompilerState a m = StateT a m
class (Functor m, Monad m) => CompilerContext c m s a | a -> c s where
ccCurrentScope :: a -> m SymbolScope
ccResolver :: a -> m AnyTypeResolver
ccSameType :: a -> TypeInstance -> m Bool
ccSelfType :: a -> m TypeInstance
ccAllFilters :: a -> m ParamFilters
ccGetParamScope :: a -> ParamName -> m SymbolScope
ccAddRequired :: a -> Set.Set CategoryName -> m a
ccGetRequired :: a -> m (Set.Set CategoryName)
ccGetCategoryFunction :: a -> [c] -> Maybe CategoryName -> FunctionName -> m (ScopedFunction c)
ccGetTypeFunction :: a -> [c] -> Maybe GeneralInstance -> FunctionName -> m (ScopedFunction c)
ccCheckValueInit :: a -> [c] -> TypeInstance -> ExpressionType -> m ()
ccGetVariable :: a -> UsedVariable c -> m (VariableValue c)
ccAddVariable :: a -> UsedVariable c -> VariableValue c -> m a
ccSetDeferred :: a -> UsedVariable c -> m a
ccSetReadOnly :: a -> UsedVariable c -> m a
ccSetHidden :: a -> UsedVariable c -> m a
ccCheckVariableInit :: a -> [UsedVariable c] -> m ()
ccWrite :: a -> s -> m a
ccGetOutput :: a -> m s
ccClearOutput :: a -> m a
ccUpdateAssigned :: a -> VariableName -> m a
ccAddUsed :: a -> UsedVariable c -> m a
ccInheritUsed :: a -> a -> m a
ccInheritStatic :: a -> [a] -> m a
ccInheritDeferred :: a -> DeferVariable c -> m a
ccRegisterReturn :: a -> [c] -> Maybe ExpressionType -> m a
ccPrimNamedReturns :: a -> m [ReturnVariable]
ccIsUnreachable :: a -> m Bool
ccIsNamedReturns :: a -> m Bool
ccSetJumpType :: a -> [c] -> JumpType -> m a
ccStartLoop :: a -> LoopSetup s -> m a
ccGetLoop :: a -> m (LoopSetup s)
ccStartCleanup :: a -> [c] -> m a
ccPushCleanup :: a -> a -> m a
ccGetCleanup :: a -> JumpType -> m (CleanupBlock c s)
ccExprLookup :: a -> [c] -> MacroName -> m (Expression c)
ccReserveExprMacro :: a -> [c] -> MacroName -> m a
ccReleaseExprMacro :: a -> [c] -> MacroName -> m a
ccSetNoTrace :: a -> Bool -> m a
ccGetNoTrace :: a -> m Bool
ccGetTestsOnly :: a -> m Bool
ccAddTrace :: a -> String -> m a
ccGetTraces :: a -> m [String]
ccCanForward :: a -> [ParamName] -> [VariableName] -> m Bool
ccDelegateArgs :: a -> m (Positional (Maybe (CallArgLabel c), VariableName))
data MemberValue c =
MemberValue {
forall c. MemberValue c -> [c]
mvContext :: [c],
forall c. MemberValue c -> VariableName
mvName :: VariableName,
forall c. MemberValue c -> ValueType
mvType :: ValueType
}
deriving (Int -> MemberValue c -> ShowS
[MemberValue c] -> ShowS
MemberValue c -> String
(Int -> MemberValue c -> ShowS)
-> (MemberValue c -> String)
-> ([MemberValue c] -> ShowS)
-> Show (MemberValue c)
forall c. Show c => Int -> MemberValue c -> ShowS
forall c. Show c => [MemberValue c] -> ShowS
forall c. Show c => MemberValue c -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall c. Show c => Int -> MemberValue c -> ShowS
showsPrec :: Int -> MemberValue c -> ShowS
$cshow :: forall c. Show c => MemberValue c -> String
show :: MemberValue c -> String
$cshowList :: forall c. Show c => [MemberValue c] -> ShowS
showList :: [MemberValue c] -> ShowS
Show)
data ReturnVariable =
ReturnVariable {
ReturnVariable -> Int
rvIndex :: Int,
ReturnVariable -> VariableName
rvName :: VariableName,
ReturnVariable -> ValueType
rvType :: ValueType
}
deriving (Int -> ReturnVariable -> ShowS
[ReturnVariable] -> ShowS
ReturnVariable -> String
(Int -> ReturnVariable -> ShowS)
-> (ReturnVariable -> String)
-> ([ReturnVariable] -> ShowS)
-> Show ReturnVariable
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ReturnVariable -> ShowS
showsPrec :: Int -> ReturnVariable -> ShowS
$cshow :: ReturnVariable -> String
show :: ReturnVariable -> String
$cshowList :: [ReturnVariable] -> ShowS
showList :: [ReturnVariable] -> ShowS
Show)
data LoopSetup s =
LoopSetup {
forall s. LoopSetup s -> s
lsUpdate :: s
} |
NotInLoop
data UsedVariable c =
UsedVariable {
forall c. UsedVariable c -> [c]
uvContext :: [c],
forall c. UsedVariable c -> VariableName
uvName :: VariableName
}
deriving (UsedVariable c -> UsedVariable c -> Bool
(UsedVariable c -> UsedVariable c -> Bool)
-> (UsedVariable c -> UsedVariable c -> Bool)
-> Eq (UsedVariable c)
forall c. Eq c => UsedVariable c -> UsedVariable c -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall c. Eq c => UsedVariable c -> UsedVariable c -> Bool
== :: UsedVariable c -> UsedVariable c -> Bool
$c/= :: forall c. Eq c => UsedVariable c -> UsedVariable c -> Bool
/= :: UsedVariable c -> UsedVariable c -> Bool
Eq,Eq (UsedVariable c)
Eq (UsedVariable c) =>
(UsedVariable c -> UsedVariable c -> Ordering)
-> (UsedVariable c -> UsedVariable c -> Bool)
-> (UsedVariable c -> UsedVariable c -> Bool)
-> (UsedVariable c -> UsedVariable c -> Bool)
-> (UsedVariable c -> UsedVariable c -> Bool)
-> (UsedVariable c -> UsedVariable c -> UsedVariable c)
-> (UsedVariable c -> UsedVariable c -> UsedVariable c)
-> Ord (UsedVariable c)
UsedVariable c -> UsedVariable c -> Bool
UsedVariable c -> UsedVariable c -> Ordering
UsedVariable c -> UsedVariable c -> UsedVariable c
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall c. Ord c => Eq (UsedVariable c)
forall c. Ord c => UsedVariable c -> UsedVariable c -> Bool
forall c. Ord c => UsedVariable c -> UsedVariable c -> Ordering
forall c.
Ord c =>
UsedVariable c -> UsedVariable c -> UsedVariable c
$ccompare :: forall c. Ord c => UsedVariable c -> UsedVariable c -> Ordering
compare :: UsedVariable c -> UsedVariable c -> Ordering
$c< :: forall c. Ord c => UsedVariable c -> UsedVariable c -> Bool
< :: UsedVariable c -> UsedVariable c -> Bool
$c<= :: forall c. Ord c => UsedVariable c -> UsedVariable c -> Bool
<= :: UsedVariable c -> UsedVariable c -> Bool
$c> :: forall c. Ord c => UsedVariable c -> UsedVariable c -> Bool
> :: UsedVariable c -> UsedVariable c -> Bool
$c>= :: forall c. Ord c => UsedVariable c -> UsedVariable c -> Bool
>= :: UsedVariable c -> UsedVariable c -> Bool
$cmax :: forall c.
Ord c =>
UsedVariable c -> UsedVariable c -> UsedVariable c
max :: UsedVariable c -> UsedVariable c -> UsedVariable c
$cmin :: forall c.
Ord c =>
UsedVariable c -> UsedVariable c -> UsedVariable c
min :: UsedVariable c -> UsedVariable c -> UsedVariable c
Ord,Int -> UsedVariable c -> ShowS
[UsedVariable c] -> ShowS
UsedVariable c -> String
(Int -> UsedVariable c -> ShowS)
-> (UsedVariable c -> String)
-> ([UsedVariable c] -> ShowS)
-> Show (UsedVariable c)
forall c. Show c => Int -> UsedVariable c -> ShowS
forall c. Show c => [UsedVariable c] -> ShowS
forall c. Show c => UsedVariable c -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall c. Show c => Int -> UsedVariable c -> ShowS
showsPrec :: Int -> UsedVariable c -> ShowS
$cshow :: forall c. Show c => UsedVariable c -> String
show :: UsedVariable c -> String
$cshowList :: forall c. Show c => [UsedVariable c] -> ShowS
showList :: [UsedVariable c] -> ShowS
Show)
data CleanupBlock c s =
CleanupBlock {
forall c s. CleanupBlock c s -> s
csCleanup :: s,
forall c s. CleanupBlock c s -> DeferVariable c
csDeferred :: DeferVariable c,
forall c s. CleanupBlock c s -> [UsedVariable c]
csUsesVars :: [UsedVariable c],
forall c s. CleanupBlock c s -> JumpType
csJumpType :: JumpType,
forall c s. CleanupBlock c s -> Set CategoryName
csRequires :: Set.Set CategoryName
}
deriving (Int -> CleanupBlock c s -> ShowS
[CleanupBlock c s] -> ShowS
CleanupBlock c s -> String
(Int -> CleanupBlock c s -> ShowS)
-> (CleanupBlock c s -> String)
-> ([CleanupBlock c s] -> ShowS)
-> Show (CleanupBlock c s)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall c s. (Show s, Show c) => Int -> CleanupBlock c s -> ShowS
forall c s. (Show s, Show c) => [CleanupBlock c s] -> ShowS
forall c s. (Show s, Show c) => CleanupBlock c s -> String
$cshowsPrec :: forall c s. (Show s, Show c) => Int -> CleanupBlock c s -> ShowS
showsPrec :: Int -> CleanupBlock c s -> ShowS
$cshow :: forall c s. (Show s, Show c) => CleanupBlock c s -> String
show :: CleanupBlock c s -> String
$cshowList :: forall c s. (Show s, Show c) => [CleanupBlock c s] -> ShowS
showList :: [CleanupBlock c s] -> ShowS
Show)
emptyCleanupBlock :: Monoid s => CleanupBlock c s
emptyCleanupBlock :: forall s c. Monoid s => CleanupBlock c s
emptyCleanupBlock = s
-> DeferVariable c
-> [UsedVariable c]
-> JumpType
-> Set CategoryName
-> CleanupBlock c s
forall c s.
s
-> DeferVariable c
-> [UsedVariable c]
-> JumpType
-> Set CategoryName
-> CleanupBlock c s
CleanupBlock s
forall a. Monoid a => a
mempty DeferVariable c
forall c. DeferVariable c
emptyDeferred [] JumpType
NextStatement Set CategoryName
forall a. Set a
Set.empty
data JumpType =
NextStatement |
JumpContinue |
JumpBreak |
JumpReturn |
JumpImmediateExit |
JumpMax
deriving (JumpType -> JumpType -> Bool
(JumpType -> JumpType -> Bool)
-> (JumpType -> JumpType -> Bool) -> Eq JumpType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JumpType -> JumpType -> Bool
== :: JumpType -> JumpType -> Bool
$c/= :: JumpType -> JumpType -> Bool
/= :: JumpType -> JumpType -> Bool
Eq,Eq JumpType
Eq JumpType =>
(JumpType -> JumpType -> Ordering)
-> (JumpType -> JumpType -> Bool)
-> (JumpType -> JumpType -> Bool)
-> (JumpType -> JumpType -> Bool)
-> (JumpType -> JumpType -> Bool)
-> (JumpType -> JumpType -> JumpType)
-> (JumpType -> JumpType -> JumpType)
-> Ord JumpType
JumpType -> JumpType -> Bool
JumpType -> JumpType -> Ordering
JumpType -> JumpType -> JumpType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: JumpType -> JumpType -> Ordering
compare :: JumpType -> JumpType -> Ordering
$c< :: JumpType -> JumpType -> Bool
< :: JumpType -> JumpType -> Bool
$c<= :: JumpType -> JumpType -> Bool
<= :: JumpType -> JumpType -> Bool
$c> :: JumpType -> JumpType -> Bool
> :: JumpType -> JumpType -> Bool
$c>= :: JumpType -> JumpType -> Bool
>= :: JumpType -> JumpType -> Bool
$cmax :: JumpType -> JumpType -> JumpType
max :: JumpType -> JumpType -> JumpType
$cmin :: JumpType -> JumpType -> JumpType
min :: JumpType -> JumpType -> JumpType
Ord,Int -> JumpType -> ShowS
[JumpType] -> ShowS
JumpType -> String
(Int -> JumpType -> ShowS)
-> (JumpType -> String) -> ([JumpType] -> ShowS) -> Show JumpType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> JumpType -> ShowS
showsPrec :: Int -> JumpType -> ShowS
$cshow :: JumpType -> String
show :: JumpType -> String
$cshowList :: [JumpType] -> ShowS
showList :: [JumpType] -> ShowS
Show)
newtype DeferVariable c =
DeferVariable {
forall c. DeferVariable c -> Map VariableName (PassedValue c)
dvDeferred :: Map.Map VariableName (PassedValue c)
}
deriving (Int -> DeferVariable c -> ShowS
[DeferVariable c] -> ShowS
DeferVariable c -> String
(Int -> DeferVariable c -> ShowS)
-> (DeferVariable c -> String)
-> ([DeferVariable c] -> ShowS)
-> Show (DeferVariable c)
forall c. Show c => Int -> DeferVariable c -> ShowS
forall c. Show c => [DeferVariable c] -> ShowS
forall c. Show c => DeferVariable c -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall c. Show c => Int -> DeferVariable c -> ShowS
showsPrec :: Int -> DeferVariable c -> ShowS
$cshow :: forall c. Show c => DeferVariable c -> String
show :: DeferVariable c -> String
$cshowList :: forall c. Show c => [DeferVariable c] -> ShowS
showList :: [DeferVariable c] -> ShowS
Show)
branchDeferred :: [DeferVariable c] -> DeferVariable c
branchDeferred :: forall c. [DeferVariable c] -> DeferVariable c
branchDeferred = Map VariableName (PassedValue c) -> DeferVariable c
forall c. Map VariableName (PassedValue c) -> DeferVariable c
DeferVariable (Map VariableName (PassedValue c) -> DeferVariable c)
-> ([DeferVariable c] -> Map VariableName (PassedValue c))
-> [DeferVariable c]
-> DeferVariable c
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Map VariableName (PassedValue c)]
-> Map VariableName (PassedValue c)
forall (f :: * -> *) k a.
(Foldable f, Ord k) =>
f (Map k a) -> Map k a
Map.unions ([Map VariableName (PassedValue c)]
-> Map VariableName (PassedValue c))
-> ([DeferVariable c] -> [Map VariableName (PassedValue c)])
-> [DeferVariable c]
-> Map VariableName (PassedValue c)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (DeferVariable c -> Map VariableName (PassedValue c))
-> [DeferVariable c] -> [Map VariableName (PassedValue c)]
forall a b. (a -> b) -> [a] -> [b]
map DeferVariable c -> Map VariableName (PassedValue c)
forall c. DeferVariable c -> Map VariableName (PassedValue c)
dvDeferred
followDeferred :: DeferVariable c -> DeferVariable c -> DeferVariable c
followDeferred :: forall c. DeferVariable c -> DeferVariable c -> DeferVariable c
followDeferred (DeferVariable Map VariableName (PassedValue c)
xa) (DeferVariable Map VariableName (PassedValue c)
ya) = Map VariableName (PassedValue c) -> DeferVariable c
forall c. Map VariableName (PassedValue c) -> DeferVariable c
DeferVariable (Map VariableName (PassedValue c) -> DeferVariable c)
-> Map VariableName (PassedValue c) -> DeferVariable c
forall a b. (a -> b) -> a -> b
$ Map VariableName (PassedValue c)
-> Map VariableName (PassedValue c)
-> Map VariableName (PassedValue c)
forall k a b. Ord k => Map k a -> Map k b -> Map k a
Map.intersection Map VariableName (PassedValue c)
xa Map VariableName (PassedValue c)
ya
emptyDeferred :: DeferVariable c
emptyDeferred :: forall c. DeferVariable c
emptyDeferred = Map VariableName (PassedValue c) -> DeferVariable c
forall c. Map VariableName (PassedValue c) -> DeferVariable c
DeferVariable Map VariableName (PassedValue c)
forall k a. Map k a
Map.empty
checkDeferred :: VariableName -> DeferVariable c -> Bool
checkDeferred :: forall c. VariableName -> DeferVariable c -> Bool
checkDeferred VariableName
n (DeferVariable Map VariableName (PassedValue c)
va) = VariableName
n VariableName -> Map VariableName (PassedValue c) -> Bool
forall k a. Ord k => k -> Map k a -> Bool
`Map.member` Map VariableName (PassedValue c)
va
removeDeferred :: VariableName -> DeferVariable c -> DeferVariable c
removeDeferred :: forall c. VariableName -> DeferVariable c -> DeferVariable c
removeDeferred VariableName
n (DeferVariable Map VariableName (PassedValue c)
va) = Map VariableName (PassedValue c) -> DeferVariable c
forall c. Map VariableName (PassedValue c) -> DeferVariable c
DeferVariable (VariableName
n VariableName
-> Map VariableName (PassedValue c)
-> Map VariableName (PassedValue c)
forall k a. Ord k => k -> Map k a -> Map k a
`Map.delete` Map VariableName (PassedValue c)
va)
addDeferred :: VariableName -> PassedValue c -> DeferVariable c -> DeferVariable c
addDeferred :: forall c.
VariableName -> PassedValue c -> DeferVariable c -> DeferVariable c
addDeferred VariableName
n PassedValue c
v (DeferVariable Map VariableName (PassedValue c)
va) = Map VariableName (PassedValue c) -> DeferVariable c
forall c. Map VariableName (PassedValue c) -> DeferVariable c
DeferVariable (VariableName
-> PassedValue c
-> Map VariableName (PassedValue c)
-> Map VariableName (PassedValue c)
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert VariableName
n PassedValue c
v Map VariableName (PassedValue c)
va)
csCurrentScope :: CompilerContext c m s a => CompilerState a m SymbolScope
csCurrentScope :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
CompilerState a m SymbolScope
csCurrentScope = (a -> m SymbolScope) -> StateT a m a -> StateT a m (m SymbolScope)
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> m SymbolScope
forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> m SymbolScope
ccCurrentScope StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m (m SymbolScope)
-> (m SymbolScope -> StateT a m SymbolScope)
-> StateT a m SymbolScope
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m SymbolScope -> StateT a m SymbolScope
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift
csResolver :: CompilerContext c m s a => CompilerState a m AnyTypeResolver
csResolver :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
CompilerState a m AnyTypeResolver
csResolver = (a -> m AnyTypeResolver)
-> StateT a m a -> StateT a m (m AnyTypeResolver)
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> m AnyTypeResolver
forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> m AnyTypeResolver
ccResolver StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m (m AnyTypeResolver)
-> (m AnyTypeResolver -> StateT a m AnyTypeResolver)
-> StateT a m AnyTypeResolver
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m AnyTypeResolver -> StateT a m AnyTypeResolver
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift
csSameType :: CompilerContext c m s a => TypeInstance -> CompilerState a m Bool
csSameType :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
TypeInstance -> CompilerState a m Bool
csSameType TypeInstance
t = (a -> m Bool) -> StateT a m a -> StateT a m (m Bool)
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> a -> TypeInstance -> m Bool
forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> TypeInstance -> m Bool
ccSameType a
x TypeInstance
t) StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m (m Bool)
-> (m Bool -> StateT a m Bool) -> StateT a m Bool
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m Bool -> StateT a m Bool
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift
csSelfType :: CompilerContext c m s a => CompilerState a m TypeInstance
csSelfType :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
CompilerState a m TypeInstance
csSelfType = (a -> m TypeInstance)
-> StateT a m a -> StateT a m (m TypeInstance)
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> m TypeInstance
forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> m TypeInstance
ccSelfType StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m (m TypeInstance)
-> (m TypeInstance -> StateT a m TypeInstance)
-> StateT a m TypeInstance
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m TypeInstance -> StateT a m TypeInstance
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift
csAllFilters :: CompilerContext c m s a => CompilerState a m ParamFilters
csAllFilters :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
CompilerState a m ParamFilters
csAllFilters = (a -> m ParamFilters)
-> StateT a m a -> StateT a m (m ParamFilters)
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> m ParamFilters
forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> m ParamFilters
ccAllFilters StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m (m ParamFilters)
-> (m ParamFilters -> StateT a m ParamFilters)
-> StateT a m ParamFilters
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m ParamFilters -> StateT a m ParamFilters
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift
csGetParamScope :: CompilerContext c m s a => ParamName -> CompilerState a m SymbolScope
csGetParamScope :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
ParamName -> CompilerState a m SymbolScope
csGetParamScope ParamName
n = (a -> m SymbolScope) -> StateT a m a -> StateT a m (m SymbolScope)
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> a -> ParamName -> m SymbolScope
forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> ParamName -> m SymbolScope
ccGetParamScope a
x ParamName
n) StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m (m SymbolScope)
-> (m SymbolScope -> StateT a m SymbolScope)
-> StateT a m SymbolScope
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m SymbolScope -> StateT a m SymbolScope
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift
csAddRequired :: CompilerContext c m s a => Set.Set CategoryName -> CompilerState a m ()
csAddRequired :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
Set CategoryName -> CompilerState a m ()
csAddRequired Set CategoryName
ns = (a -> m a) -> StateT a m a -> StateT a m (m a)
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> a -> Set CategoryName -> m a
forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> Set CategoryName -> m a
ccAddRequired a
x Set CategoryName
ns) StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m (m a) -> (m a -> StateT a m a) -> StateT a m a
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m a -> StateT a m a
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift StateT a m a -> (a -> StateT a m ()) -> StateT a m ()
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> StateT a m ()
forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put
csGetRequired :: CompilerContext c m s a => CompilerState a m (Set.Set CategoryName)
csGetRequired :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
CompilerState a m (Set CategoryName)
csGetRequired = (a -> m (Set CategoryName))
-> StateT a m a -> StateT a m (m (Set CategoryName))
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> m (Set CategoryName)
forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> m (Set CategoryName)
ccGetRequired StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m (m (Set CategoryName))
-> (m (Set CategoryName) -> StateT a m (Set CategoryName))
-> StateT a m (Set CategoryName)
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m (Set CategoryName) -> StateT a m (Set CategoryName)
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift
csGetCategoryFunction :: CompilerContext c m s a =>
[c] -> Maybe CategoryName -> FunctionName -> CompilerState a m (ScopedFunction c)
csGetCategoryFunction :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
[c]
-> Maybe CategoryName
-> FunctionName
-> CompilerState a m (ScopedFunction c)
csGetCategoryFunction [c]
c Maybe CategoryName
t FunctionName
n = (a -> m (ScopedFunction c))
-> StateT a m a -> StateT a m (m (ScopedFunction c))
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> a
-> [c]
-> Maybe CategoryName
-> FunctionName
-> m (ScopedFunction c)
forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a
-> [c]
-> Maybe CategoryName
-> FunctionName
-> m (ScopedFunction c)
ccGetCategoryFunction a
x [c]
c Maybe CategoryName
t FunctionName
n) StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m (m (ScopedFunction c))
-> (m (ScopedFunction c) -> StateT a m (ScopedFunction c))
-> StateT a m (ScopedFunction c)
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m (ScopedFunction c) -> StateT a m (ScopedFunction c)
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift
csGetTypeFunction :: CompilerContext c m s a =>
[c] -> Maybe GeneralInstance -> FunctionName -> CompilerState a m (ScopedFunction c)
csGetTypeFunction :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
[c]
-> Maybe GeneralInstance
-> FunctionName
-> CompilerState a m (ScopedFunction c)
csGetTypeFunction [c]
c Maybe GeneralInstance
t FunctionName
n = (a -> m (ScopedFunction c))
-> StateT a m a -> StateT a m (m (ScopedFunction c))
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> a
-> [c]
-> Maybe GeneralInstance
-> FunctionName
-> m (ScopedFunction c)
forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a
-> [c]
-> Maybe GeneralInstance
-> FunctionName
-> m (ScopedFunction c)
ccGetTypeFunction a
x [c]
c Maybe GeneralInstance
t FunctionName
n) StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m (m (ScopedFunction c))
-> (m (ScopedFunction c) -> StateT a m (ScopedFunction c))
-> StateT a m (ScopedFunction c)
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m (ScopedFunction c) -> StateT a m (ScopedFunction c)
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift
csCheckValueInit :: CompilerContext c m s a =>
[c] -> TypeInstance -> ExpressionType -> CompilerState a m ()
csCheckValueInit :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
[c] -> TypeInstance -> ExpressionType -> CompilerState a m ()
csCheckValueInit [c]
c TypeInstance
t ExpressionType
as = (a -> m ()) -> StateT a m a -> StateT a m (m ())
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> a -> [c] -> TypeInstance -> ExpressionType -> m ()
forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> [c] -> TypeInstance -> ExpressionType -> m ()
ccCheckValueInit a
x [c]
c TypeInstance
t ExpressionType
as) StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m (m ()) -> (m () -> StateT a m ()) -> StateT a m ()
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m () -> StateT a m ()
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift
csGetVariable :: CompilerContext c m s a =>
UsedVariable c -> CompilerState a m (VariableValue c)
csGetVariable :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
UsedVariable c -> CompilerState a m (VariableValue c)
csGetVariable UsedVariable c
v = (a -> m (VariableValue c))
-> StateT a m a -> StateT a m (m (VariableValue c))
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> a -> UsedVariable c -> m (VariableValue c)
forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> UsedVariable c -> m (VariableValue c)
ccGetVariable a
x UsedVariable c
v) StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m (m (VariableValue c))
-> (m (VariableValue c) -> StateT a m (VariableValue c))
-> StateT a m (VariableValue c)
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m (VariableValue c) -> StateT a m (VariableValue c)
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift
csAddVariable :: CompilerContext c m s a =>
UsedVariable c -> VariableValue c -> CompilerState a m ()
csAddVariable :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
UsedVariable c -> VariableValue c -> CompilerState a m ()
csAddVariable UsedVariable c
v VariableValue c
t = (a -> m a) -> StateT a m a -> StateT a m (m a)
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> a -> UsedVariable c -> VariableValue c -> m a
forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> UsedVariable c -> VariableValue c -> m a
ccAddVariable a
x UsedVariable c
v VariableValue c
t) StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m (m a) -> (m a -> StateT a m a) -> StateT a m a
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m a -> StateT a m a
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift StateT a m a -> (a -> StateT a m ()) -> StateT a m ()
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> StateT a m ()
forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put
csSetDeferred :: CompilerContext c m s a =>
UsedVariable c -> CompilerState a m ()
csSetDeferred :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
UsedVariable c -> CompilerState a m ()
csSetDeferred UsedVariable c
v = (a -> m a) -> StateT a m a -> StateT a m (m a)
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> a -> UsedVariable c -> m a
forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> UsedVariable c -> m a
ccSetDeferred a
x UsedVariable c
v) StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m (m a) -> (m a -> StateT a m a) -> StateT a m a
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m a -> StateT a m a
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift StateT a m a -> (a -> StateT a m ()) -> StateT a m ()
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> StateT a m ()
forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put
csSetReadOnly :: CompilerContext c m s a =>
UsedVariable c -> CompilerState a m ()
csSetReadOnly :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
UsedVariable c -> CompilerState a m ()
csSetReadOnly UsedVariable c
v = (a -> m a) -> StateT a m a -> StateT a m (m a)
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> a -> UsedVariable c -> m a
forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> UsedVariable c -> m a
ccSetReadOnly a
x UsedVariable c
v) StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m (m a) -> (m a -> StateT a m a) -> StateT a m a
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m a -> StateT a m a
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift StateT a m a -> (a -> StateT a m ()) -> StateT a m ()
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> StateT a m ()
forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put
csSetHidden :: CompilerContext c m s a =>
UsedVariable c -> CompilerState a m ()
csSetHidden :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
UsedVariable c -> CompilerState a m ()
csSetHidden UsedVariable c
v = (a -> m a) -> StateT a m a -> StateT a m (m a)
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> a -> UsedVariable c -> m a
forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> UsedVariable c -> m a
ccSetHidden a
x UsedVariable c
v) StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m (m a) -> (m a -> StateT a m a) -> StateT a m a
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m a -> StateT a m a
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift StateT a m a -> (a -> StateT a m ()) -> StateT a m ()
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> StateT a m ()
forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put
csCheckVariableInit :: CompilerContext c m s a =>
[UsedVariable c] -> CompilerState a m ()
csCheckVariableInit :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
[UsedVariable c] -> CompilerState a m ()
csCheckVariableInit [UsedVariable c]
vs = (a -> m ()) -> StateT a m a -> StateT a m (m ())
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> a -> [UsedVariable c] -> m ()
forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> [UsedVariable c] -> m ()
ccCheckVariableInit a
x [UsedVariable c]
vs) StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m (m ()) -> (m () -> StateT a m ()) -> StateT a m ()
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m () -> StateT a m ()
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift
csWrite :: CompilerContext c m s a => s -> CompilerState a m ()
csWrite :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
s -> CompilerState a m ()
csWrite s
o = (a -> m a) -> StateT a m a -> StateT a m (m a)
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> a -> s -> m a
forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> s -> m a
ccWrite a
x s
o) StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m (m a) -> (m a -> StateT a m a) -> StateT a m a
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m a -> StateT a m a
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift StateT a m a -> (a -> StateT a m ()) -> StateT a m ()
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> StateT a m ()
forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put
csClearOutput :: CompilerContext c m s a => CompilerState a m ()
csClearOutput :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
CompilerState a m ()
csClearOutput = (a -> m a) -> StateT a m a -> StateT a m (m a)
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> a -> m a
forall c (m :: * -> *) s a. CompilerContext c m s a => a -> m a
ccClearOutput a
x) StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m (m a) -> (m a -> StateT a m a) -> StateT a m a
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m a -> StateT a m a
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift StateT a m a -> (a -> StateT a m ()) -> StateT a m ()
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> StateT a m ()
forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put
csGetOutput :: CompilerContext c m s a => CompilerState a m s
csGetOutput :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
CompilerState a m s
csGetOutput = (a -> m s) -> StateT a m a -> StateT a m (m s)
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> m s
forall c (m :: * -> *) s a. CompilerContext c m s a => a -> m s
ccGetOutput StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m (m s) -> (m s -> StateT a m s) -> StateT a m s
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m s -> StateT a m s
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift
csUpdateAssigned :: CompilerContext c m s a => VariableName -> CompilerState a m ()
csUpdateAssigned :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
VariableName -> CompilerState a m ()
csUpdateAssigned VariableName
n = (a -> m a) -> StateT a m a -> StateT a m (m a)
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> a -> VariableName -> m a
forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> VariableName -> m a
ccUpdateAssigned a
x VariableName
n) StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m (m a) -> (m a -> StateT a m a) -> StateT a m a
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m a -> StateT a m a
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift StateT a m a -> (a -> StateT a m ()) -> StateT a m ()
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> StateT a m ()
forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put
csAddUsed :: CompilerContext c m s a => UsedVariable c -> CompilerState a m ()
csAddUsed :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
UsedVariable c -> CompilerState a m ()
csAddUsed UsedVariable c
n = (a -> m a) -> StateT a m a -> StateT a m (m a)
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> a -> UsedVariable c -> m a
forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> UsedVariable c -> m a
ccAddUsed a
x UsedVariable c
n) StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m (m a) -> (m a -> StateT a m a) -> StateT a m a
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m a -> StateT a m a
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift StateT a m a -> (a -> StateT a m ()) -> StateT a m ()
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> StateT a m ()
forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put
csInheritUsed :: CompilerContext c m s a => a -> CompilerState a m ()
csInheritUsed :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> CompilerState a m ()
csInheritUsed a
c = (a -> m a) -> StateT a m a -> StateT a m (m a)
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> a -> a -> m a
forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> a -> m a
ccInheritUsed a
x a
c) StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m (m a) -> (m a -> StateT a m a) -> StateT a m a
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m a -> StateT a m a
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift StateT a m a -> (a -> StateT a m ()) -> StateT a m ()
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> StateT a m ()
forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put
csInheritStatic :: CompilerContext c m s a => [a] -> CompilerState a m ()
csInheritStatic :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
[a] -> CompilerState a m ()
csInheritStatic [a]
xs = (a -> m a) -> StateT a m a -> StateT a m (m a)
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> a -> [a] -> m a
forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> [a] -> m a
ccInheritStatic a
x [a]
xs) StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m (m a) -> (m a -> StateT a m a) -> StateT a m a
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m a -> StateT a m a
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift StateT a m a -> (a -> StateT a m ()) -> StateT a m ()
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> StateT a m ()
forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put
csInheritDeferred :: CompilerContext c m s a => DeferVariable c -> CompilerState a m ()
csInheritDeferred :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
DeferVariable c -> CompilerState a m ()
csInheritDeferred DeferVariable c
xs = (a -> m a) -> StateT a m a -> StateT a m (m a)
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> a -> DeferVariable c -> m a
forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> DeferVariable c -> m a
ccInheritDeferred a
x DeferVariable c
xs) StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m (m a) -> (m a -> StateT a m a) -> StateT a m a
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m a -> StateT a m a
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift StateT a m a -> (a -> StateT a m ()) -> StateT a m ()
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> StateT a m ()
forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put
csRegisterReturn :: CompilerContext c m s a =>
[c] -> Maybe ExpressionType -> CompilerState a m ()
csRegisterReturn :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
[c] -> Maybe ExpressionType -> CompilerState a m ()
csRegisterReturn [c]
c Maybe ExpressionType
rs = (a -> m a) -> StateT a m a -> StateT a m (m a)
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> a -> [c] -> Maybe ExpressionType -> m a
forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> [c] -> Maybe ExpressionType -> m a
ccRegisterReturn a
x [c]
c Maybe ExpressionType
rs) StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m (m a) -> (m a -> StateT a m a) -> StateT a m a
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m a -> StateT a m a
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift StateT a m a -> (a -> StateT a m ()) -> StateT a m ()
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> StateT a m ()
forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put
csPrimNamedReturns :: CompilerContext c m s a => CompilerState a m [ReturnVariable]
csPrimNamedReturns :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
CompilerState a m [ReturnVariable]
csPrimNamedReturns = (a -> m [ReturnVariable])
-> StateT a m a -> StateT a m (m [ReturnVariable])
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> m [ReturnVariable]
forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> m [ReturnVariable]
ccPrimNamedReturns StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m (m [ReturnVariable])
-> (m [ReturnVariable] -> StateT a m [ReturnVariable])
-> StateT a m [ReturnVariable]
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m [ReturnVariable] -> StateT a m [ReturnVariable]
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift
csIsUnreachable :: CompilerContext c m s a => CompilerState a m Bool
csIsUnreachable :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
CompilerState a m Bool
csIsUnreachable = (a -> m Bool) -> StateT a m a -> StateT a m (m Bool)
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> m Bool
forall c (m :: * -> *) s a. CompilerContext c m s a => a -> m Bool
ccIsUnreachable StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m (m Bool)
-> (m Bool -> StateT a m Bool) -> StateT a m Bool
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m Bool -> StateT a m Bool
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift
csIsNamedReturns :: CompilerContext c m s a => CompilerState a m Bool
csIsNamedReturns :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
CompilerState a m Bool
csIsNamedReturns = (a -> m Bool) -> StateT a m a -> StateT a m (m Bool)
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> m Bool
forall c (m :: * -> *) s a. CompilerContext c m s a => a -> m Bool
ccIsNamedReturns StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m (m Bool)
-> (m Bool -> StateT a m Bool) -> StateT a m Bool
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m Bool -> StateT a m Bool
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift
csSetJumpType :: CompilerContext c m s a => [c] -> JumpType -> CompilerState a m ()
csSetJumpType :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
[c] -> JumpType -> CompilerState a m ()
csSetJumpType [c]
c JumpType
j = (a -> m a) -> StateT a m a -> StateT a m (m a)
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> a -> [c] -> JumpType -> m a
forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> [c] -> JumpType -> m a
ccSetJumpType a
x [c]
c JumpType
j) StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m (m a) -> (m a -> StateT a m a) -> StateT a m a
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m a -> StateT a m a
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift StateT a m a -> (a -> StateT a m ()) -> StateT a m ()
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> StateT a m ()
forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put
csStartLoop :: CompilerContext c m s a => LoopSetup s -> CompilerState a m ()
csStartLoop :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
LoopSetup s -> CompilerState a m ()
csStartLoop LoopSetup s
l = (a -> m a) -> StateT a m a -> StateT a m (m a)
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> a -> LoopSetup s -> m a
forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> LoopSetup s -> m a
ccStartLoop a
x LoopSetup s
l) StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m (m a) -> (m a -> StateT a m a) -> StateT a m a
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m a -> StateT a m a
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift StateT a m a -> (a -> StateT a m ()) -> StateT a m ()
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> StateT a m ()
forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put
csStartCleanup :: CompilerContext c m s a => [c] -> CompilerState a m ()
csStartCleanup :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
[c] -> CompilerState a m ()
csStartCleanup [c]
c = (a -> m a) -> StateT a m a -> StateT a m (m a)
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> a -> [c] -> m a
forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> [c] -> m a
ccStartCleanup a
x [c]
c) StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m (m a) -> (m a -> StateT a m a) -> StateT a m a
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m a -> StateT a m a
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift StateT a m a -> (a -> StateT a m ()) -> StateT a m ()
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> StateT a m ()
forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put
csGetLoop :: CompilerContext c m s a => CompilerState a m (LoopSetup s)
csGetLoop :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
CompilerState a m (LoopSetup s)
csGetLoop = (a -> m (LoopSetup s))
-> StateT a m a -> StateT a m (m (LoopSetup s))
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> m (LoopSetup s)
forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> m (LoopSetup s)
ccGetLoop StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m (m (LoopSetup s))
-> (m (LoopSetup s) -> StateT a m (LoopSetup s))
-> StateT a m (LoopSetup s)
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m (LoopSetup s) -> StateT a m (LoopSetup s)
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift
csPushCleanup :: CompilerContext c m s a => a -> CompilerState a m ()
csPushCleanup :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> CompilerState a m ()
csPushCleanup a
l = (a -> m a) -> StateT a m a -> StateT a m (m a)
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> a -> a -> m a
forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> a -> m a
ccPushCleanup a
x a
l) StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m (m a) -> (m a -> StateT a m a) -> StateT a m a
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m a -> StateT a m a
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift StateT a m a -> (a -> StateT a m ()) -> StateT a m ()
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> StateT a m ()
forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put
csGetCleanup :: CompilerContext c m s a => JumpType -> CompilerState a m (CleanupBlock c s)
csGetCleanup :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
JumpType -> CompilerState a m (CleanupBlock c s)
csGetCleanup JumpType
j = (a -> m (CleanupBlock c s))
-> StateT a m a -> StateT a m (m (CleanupBlock c s))
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> a -> JumpType -> m (CleanupBlock c s)
forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> JumpType -> m (CleanupBlock c s)
ccGetCleanup a
x JumpType
j) StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m (m (CleanupBlock c s))
-> (m (CleanupBlock c s) -> StateT a m (CleanupBlock c s))
-> StateT a m (CleanupBlock c s)
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m (CleanupBlock c s) -> StateT a m (CleanupBlock c s)
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift
csExprLookup :: CompilerContext c m s a => [c] -> MacroName -> CompilerState a m (Expression c)
csExprLookup :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
[c] -> MacroName -> CompilerState a m (Expression c)
csExprLookup [c]
c MacroName
n = (a -> m (Expression c))
-> StateT a m a -> StateT a m (m (Expression c))
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> a -> [c] -> MacroName -> m (Expression c)
forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> [c] -> MacroName -> m (Expression c)
ccExprLookup a
x [c]
c MacroName
n) StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m (m (Expression c))
-> (m (Expression c) -> StateT a m (Expression c))
-> StateT a m (Expression c)
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m (Expression c) -> StateT a m (Expression c)
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift
csReserveExprMacro :: CompilerContext c m s a => [c] -> MacroName -> CompilerState a m ()
csReserveExprMacro :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
[c] -> MacroName -> CompilerState a m ()
csReserveExprMacro [c]
c MacroName
n = (a -> m a) -> StateT a m a -> StateT a m (m a)
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> a -> [c] -> MacroName -> m a
forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> [c] -> MacroName -> m a
ccReserveExprMacro a
x [c]
c MacroName
n) StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m (m a) -> (m a -> StateT a m a) -> StateT a m a
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m a -> StateT a m a
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift StateT a m a -> (a -> StateT a m ()) -> StateT a m ()
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> StateT a m ()
forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put
csReleaseExprMacro :: CompilerContext c m s a => [c] -> MacroName -> CompilerState a m ()
csReleaseExprMacro :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
[c] -> MacroName -> CompilerState a m ()
csReleaseExprMacro [c]
c MacroName
n = (a -> m a) -> StateT a m a -> StateT a m (m a)
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> a -> [c] -> MacroName -> m a
forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> [c] -> MacroName -> m a
ccReleaseExprMacro a
x [c]
c MacroName
n) StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m (m a) -> (m a -> StateT a m a) -> StateT a m a
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m a -> StateT a m a
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift StateT a m a -> (a -> StateT a m ()) -> StateT a m ()
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> StateT a m ()
forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put
csSetNoTrace :: CompilerContext c m s a => Bool -> CompilerState a m ()
csSetNoTrace :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
Bool -> CompilerState a m ()
csSetNoTrace Bool
t = (a -> m a) -> StateT a m a -> StateT a m (m a)
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> a -> Bool -> m a
forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> Bool -> m a
ccSetNoTrace a
x Bool
t) StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m (m a) -> (m a -> StateT a m a) -> StateT a m a
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m a -> StateT a m a
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift StateT a m a -> (a -> StateT a m ()) -> StateT a m ()
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> StateT a m ()
forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put
csGetNoTrace :: CompilerContext c m s a => CompilerState a m Bool
csGetNoTrace :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
CompilerState a m Bool
csGetNoTrace = (a -> m Bool) -> StateT a m a -> StateT a m (m Bool)
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> m Bool
forall c (m :: * -> *) s a. CompilerContext c m s a => a -> m Bool
ccGetNoTrace StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m (m Bool)
-> (m Bool -> StateT a m Bool) -> StateT a m Bool
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m Bool -> StateT a m Bool
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift
csGetTestsOnly :: CompilerContext c m s a => CompilerState a m Bool
csGetTestsOnly :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
CompilerState a m Bool
csGetTestsOnly = (a -> m Bool) -> StateT a m a -> StateT a m (m Bool)
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> m Bool
forall c (m :: * -> *) s a. CompilerContext c m s a => a -> m Bool
ccGetTestsOnly StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m (m Bool)
-> (m Bool -> StateT a m Bool) -> StateT a m Bool
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m Bool -> StateT a m Bool
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift
csAddTrace :: CompilerContext c m s a => String -> CompilerState a m ()
csAddTrace :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
String -> CompilerState a m ()
csAddTrace String
t = (a -> m a) -> StateT a m a -> StateT a m (m a)
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> a -> String -> m a
forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> String -> m a
ccAddTrace a
x String
t) StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m (m a) -> (m a -> StateT a m a) -> StateT a m a
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m a -> StateT a m a
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift StateT a m a -> (a -> StateT a m ()) -> StateT a m ()
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> StateT a m ()
forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put
csCanForward :: CompilerContext c m s a => [ParamName] -> [VariableName] -> CompilerState a m Bool
csCanForward :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
[ParamName] -> [VariableName] -> CompilerState a m Bool
csCanForward [ParamName]
ps [VariableName]
as = (a -> m Bool) -> StateT a m a -> StateT a m (m Bool)
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> a -> [ParamName] -> [VariableName] -> m Bool
forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> [ParamName] -> [VariableName] -> m Bool
ccCanForward a
x [ParamName]
ps [VariableName]
as) StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m (m Bool)
-> (m Bool -> StateT a m Bool) -> StateT a m Bool
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m Bool -> StateT a m Bool
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift
csDelegateArgs :: CompilerContext c m s a => CompilerState a m (Positional (Maybe (CallArgLabel c), VariableName))
csDelegateArgs :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
CompilerState
a m (Positional (Maybe (CallArgLabel c), VariableName))
csDelegateArgs = (a -> m (Positional (Maybe (CallArgLabel c), VariableName)))
-> StateT a m a
-> StateT
a m (m (Positional (Maybe (CallArgLabel c), VariableName)))
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> m (Positional (Maybe (CallArgLabel c), VariableName))
forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> m (Positional (Maybe (CallArgLabel c), VariableName))
ccDelegateArgs StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m (m (Positional (Maybe (CallArgLabel c), VariableName)))
-> (m (Positional (Maybe (CallArgLabel c), VariableName))
-> StateT a m (Positional (Maybe (CallArgLabel c), VariableName)))
-> StateT a m (Positional (Maybe (CallArgLabel c), VariableName))
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m (Positional (Maybe (CallArgLabel c), VariableName))
-> StateT a m (Positional (Maybe (CallArgLabel c), VariableName))
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift
data CompiledData s =
CompiledData {
forall s. CompiledData s -> Set CategoryName
cdRequired :: Set.Set CategoryName,
forall s. CompiledData s -> Set String
cdTraces :: Set.Set String,
forall s. CompiledData s -> s
cdOutput :: s
}
instance Semigroup s => Semigroup (CompiledData s) where
(CompiledData Set CategoryName
r1 Set String
t1 s
s1) <> :: CompiledData s -> CompiledData s -> CompiledData s
<> (CompiledData Set CategoryName
r2 Set String
t2 s
s2) =
Set CategoryName -> Set String -> s -> CompiledData s
forall s. Set CategoryName -> Set String -> s -> CompiledData s
CompiledData (Set CategoryName
r1 Set CategoryName -> Set CategoryName -> Set CategoryName
forall a. Ord a => Set a -> Set a -> Set a
`Set.union` Set CategoryName
r2) (Set String
t1 Set String -> Set String -> Set String
forall a. Ord a => Set a -> Set a -> Set a
`Set.union` Set String
t2) (s
s1 s -> s -> s
forall a. Semigroup a => a -> a -> a
<> s
s2)
instance (Semigroup s, Monoid s) => Monoid (CompiledData s) where
mempty :: CompiledData s
mempty = Set CategoryName -> Set String -> s -> CompiledData s
forall s. Set CategoryName -> Set String -> s -> CompiledData s
CompiledData Set CategoryName
forall a. Set a
Set.empty Set String
forall a. Set a
Set.empty s
forall a. Monoid a => a
mempty
mappend :: CompiledData s -> CompiledData s -> CompiledData s
mappend = CompiledData s -> CompiledData s -> CompiledData s
forall a. Semigroup a => a -> a -> a
(<>)
runDataCompiler :: CompilerContext c m s a =>
CompilerState a m b -> a -> m (CompiledData s)
runDataCompiler :: forall c (m :: * -> *) s a b.
CompilerContext c m s a =>
CompilerState a m b -> a -> m (CompiledData s)
runDataCompiler CompilerState a m b
x a
ctx = do
a
ctx' <- CompilerState a m b -> a -> m a
forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m s
execStateT CompilerState a m b
x a
ctx
Set CategoryName
required <- a -> m (Set CategoryName)
forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> m (Set CategoryName)
ccGetRequired a
ctx'
s
output <- a -> m s
forall c (m :: * -> *) s a. CompilerContext c m s a => a -> m s
ccGetOutput a
ctx'
[String]
traces <- a -> m [String]
forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> m [String]
ccGetTraces a
ctx'
CompiledData s -> m (CompiledData s)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return CompiledData {
cdRequired :: Set CategoryName
cdRequired = Set CategoryName
required,
cdTraces :: Set String
cdTraces = [String] -> Set String
forall a. Ord a => [a] -> Set a
Set.fromList [String]
traces,
cdOutput :: s
cdOutput = s
output
}
concatM :: (Semigroup s, Monoid s, CollectErrorsM m) => [m (CompiledData s)] -> m (CompiledData s)
concatM :: forall s (m :: * -> *).
(Semigroup s, Monoid s, CollectErrorsM m) =>
[m (CompiledData s)] -> m (CompiledData s)
concatM = ([CompiledData s] -> CompiledData s)
-> m [CompiledData s] -> m (CompiledData s)
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [CompiledData s] -> CompiledData s
forall a. Monoid a => [a] -> a
mconcat (m [CompiledData s] -> m (CompiledData s))
-> ([m (CompiledData s)] -> m [CompiledData s])
-> [m (CompiledData s)]
-> m (CompiledData s)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [m (CompiledData s)] -> m [CompiledData s]
forall (m :: * -> *) (f :: * -> *) a.
(CollectErrorsM m, Foldable f) =>
f (m a) -> m [a]
forall (f :: * -> *) a. Foldable f => f (m a) -> m [a]
collectAllM
getCleanContext :: CompilerContext c m s a => CompilerState a m a
getCleanContext :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
CompilerState a m a
getCleanContext = StateT a m a
forall (m :: * -> *) s. Monad m => StateT s m s
get StateT a m a -> (a -> StateT a m a) -> StateT a m a
forall a b. StateT a m a -> (a -> StateT a m b) -> StateT a m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m a -> StateT a m a
forall (m :: * -> *) a. Monad m => m a -> StateT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> StateT a m a) -> (a -> m a) -> a -> StateT a m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> m a
forall c (m :: * -> *) s a. CompilerContext c m s a => a -> m a
ccClearOutput
autoSelfType :: CompilerContext c m s a => CompilerState a m GeneralInstance
autoSelfType :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
CompilerState a m GeneralInstance
autoSelfType = do
SymbolScope
scope <- CompilerState a m SymbolScope
forall c (m :: * -> *) s a.
CompilerContext c m s a =>
CompilerState a m SymbolScope
csCurrentScope
case SymbolScope
scope of
SymbolScope
CategoryScope -> GeneralInstance -> CompilerState a m GeneralInstance
forall a. a -> StateT a m a
forall (m :: * -> *) a. Monad m => a -> m a
return GeneralInstance
selfType
SymbolScope
_ -> (TypeInstance -> GeneralInstance)
-> StateT a m TypeInstance -> CompilerState a m GeneralInstance
forall a b. (a -> b) -> StateT a m a -> StateT a m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (TypeInstanceOrParam -> GeneralInstance
forall a. (Eq a, Ord a) => a -> GeneralType a
singleType (TypeInstanceOrParam -> GeneralInstance)
-> (TypeInstance -> TypeInstanceOrParam)
-> TypeInstance
-> GeneralInstance
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TypeInstance -> TypeInstanceOrParam
JustTypeInstance) StateT a m TypeInstance
forall c (m :: * -> *) s a.
CompilerContext c m s a =>
CompilerState a m TypeInstance
csSelfType