{- -----------------------------------------------------------------------------
Copyright 2019-2023 Kevin P. Barry

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
----------------------------------------------------------------------------- -}

-- Author: Kevin P. Barry [ta0kira@gmail.com]

{-# 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  -- Max value for use as initial state in folds.
  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