Hpp.Types

The core types involved used by the pre-processor.

Documentation

type LineNum = Int

Line numbers are represented as Ints

type Env = Trie Macro

A macro binding environment.

Changing the underlying string type

type String = ByteString

type TOKEN = Token ByteString

Errors

data Error

Error conditions we may encounter.

Constructors

UnterminatedBranch

BadMacroDefinition LineNum

BadIfPredicate

BadLineArgument LineNum String

IncludeDoesNotExist LineNum FilePath

FailedInclude LineNum FilePath

UserError LineNum String

UnknownCommand LineNum String

TooFewArgumentsToMacro LineNum String

BadMacroArguments LineNum String

NoInputFile

BadCommandLine String

RanOutOfInput

Instances

Eq Error

Methods

(==) :: Error -> Error -> Bool

(/=) :: Error -> Error -> Bool

Ord Error

Methods

compare :: Error -> Error -> Ordering

(<) :: Error -> Error -> Bool

(<=) :: Error -> Error -> Bool

(>) :: Error -> Error -> Bool

(>=) :: Error -> Error -> Bool

max :: Error -> Error -> Error

min :: Error -> Error -> Error

Show Error

Methods

showsPrec :: Int -> Error -> ShowS

show :: Error -> String

showList :: [Error] -> ShowS

Exception Error

Methods

toException :: Error -> SomeException

fromException :: SomeException -> Maybe Error

displayException :: Error -> String

Monad m => HasError (ExceptT Error m)

Methods

throwError :: Error -> ExceptT Error m a

class HasError m where

Hpp can raise various parsing errors.

Minimal complete definition

throwError

Methods

throwError :: Error -> m a

Instances

(Monad m, HasError m) => HasError (StateT s m)

Methods

throwError :: Error -> StateT s m a

Monad m => HasError (ExceptT Error m)

Methods

throwError :: Error -> ExceptT Error m a

(Monad m, HasError m) => HasError (HppT t m)

Methods

throwError :: Error -> HppT t m a

Free Monad Transformers

data FreeF f a r

Base functor for a free monad transformer

Constructors

PureF a

FreeF (f r)

Instances

Functor f => Functor (FreeF f a)

Methods

fmap :: (a -> b) -> FreeF f a a -> FreeF f a b

(<$) :: a -> FreeF f a b -> FreeF f a a

Pre-processor Actions

data HppState

Dynamic state of the preprocessor engine.

Constructors

HppState

Fields

• hppConfig :: Config
• hppLineNum :: LineNum
• hppEnv :: Env

Instances

Monad m => HasEnv (StateT HppState m)

Methods

getEnv :: StateT HppState m Env

setEnv :: Env -> StateT HppState m ()

Monad m => HasHppState (StateT HppState m)

Methods

getState :: StateT HppState m HppState

setState :: HppState -> StateT HppState m ()

data HppF t r

A free monad construction to strictly delimit what capabilities we need to perform pre-processing.

Constructors

ReadFile Int FilePath (t -> r)

ReadNext Int FilePath (t -> r)

WriteOutput t r

Instances

Functor (HppF t)

Methods

fmap :: (a -> b) -> HppF t a -> HppF t b

(<$) :: a -> HppF t b -> HppF t a

Hpp Monad Transformer

newtype HppT t m a

A free monad transformer specialized to HppF as the base functor.

Constructors

HppT

Fields

• runHppT :: m (FreeF (HppF t) a (HppT t m a))

Instances

MonadTrans (HppT t)

Methods

lift :: Monad m => m a -> HppT t m a

Monad m => Monad (HppT t m)

Methods

(>>=) :: HppT t m a -> (a -> HppT t m b) -> HppT t m b

(>>) :: HppT t m a -> HppT t m b -> HppT t m b

return :: a -> HppT t m a

fail :: String -> HppT t m a

Functor m => Functor (HppT t m)

Methods

fmap :: (a -> b) -> HppT t m a -> HppT t m b

(<$) :: a -> HppT t m b -> HppT t m a

Monad m => Applicative (HppT t m)

Methods

pure :: a -> HppT t m a

(<*>) :: HppT t m (a -> b) -> HppT t m a -> HppT t m b

(*>) :: HppT t m a -> HppT t m b -> HppT t m b

(<*) :: HppT t m a -> HppT t m b -> HppT t m a

MonadIO m => MonadIO (HppT t m)

Methods

liftIO :: IO a -> HppT t m a

(Monad m, HasHppState m) => HasEnv (HppT t m)

Methods

getEnv :: HppT t m Env

setEnv :: Env -> HppT t m ()

(Monad m, HasHppState m) => HasHppState (HppT t m)

Methods

getState :: HppT t m HppState

setState :: HppState -> HppT t m ()

(Monad m, HasError m) => HasError (HppT t m)

Methods

throwError :: Error -> HppT t m a

writeOutput :: Monad m => t -> HppT t m ()

class HasHppState m where

An interpreter capability to modify dynamic state.

Minimal complete definition

getState, setState

Methods

getState :: m HppState

setState :: HppState -> m ()

Instances

(Monad m, HasHppState m) => HasHppState (StateT s m)

Methods

getState :: StateT s m HppState

setState :: HppState -> StateT s m ()

Monad m => HasHppState (StateT HppState m)

Methods

getState :: StateT HppState m HppState

setState :: HppState -> StateT HppState m ()

(Monad m, HasHppState m) => HasHppState (ExceptT e m)

Methods

getState :: ExceptT e m HppState

setState :: HppState -> ExceptT e m ()

(Monad m, HasHppState m) => HasHppState (HppT t m)

Methods

getState :: HppT t m HppState

setState :: HppState -> HppT t m ()

class HasEnv m where

An interpreter capability of threading a binding environment.

Minimal complete definition

getEnv, setEnv

Methods

getEnv :: m Env

setEnv :: Env -> m ()

Instances

Monad m => HasEnv (StateT HppState m)

Methods

getEnv :: StateT HppState m Env

setEnv :: Env -> StateT HppState m ()

Monad m => HasEnv (StateT Env m)

Methods

getEnv :: StateT Env m Env

setEnv :: Env -> StateT Env m ()

(HasEnv m, Monad m) => HasEnv (ExceptT e m)

Methods

getEnv :: ExceptT e m Env

setEnv :: Env -> ExceptT e m ()

(Monad m, HasHppState m) => HasEnv (HppT t m)

Methods

getEnv :: HppT t m Env

setEnv :: Env -> HppT t m ()

Expansion

data Scan

Macro expansion involves treating tokens differently if they appear in the original source or as the result of a previous macro expansion. This distinction is used to prevent divergence by masking out definitions that could be used recursively.

Things are made somewhat more complicated than one might expect due to the fact that the scope of this masking is not structurally recursive. A object-like macro can expand into a fragment of a macro function application, one of whose arguments is a token matching the original object-like macro. That argument should not be expanded.

Constructors

Unmask String

Mask String

Scan (Token String)

Rescan (Token String)

Instances

Eq Scan

Methods

(==) :: Scan -> Scan -> Bool

(/=) :: Scan -> Scan -> Bool

Show Scan

Methods

showsPrec :: Int -> Scan -> ShowS

show :: Scan -> String

showList :: [Scan] -> ShowS

Macros

data Macro

There are object-like macros and function-like macros.

Constructors

Object [Token String]

An object-like macro is replaced with its definition

Function Int ([([Scan], String)] -> [Scan])

A function-like macro of some arity taks macro-expanded and raw versions of its arguments, then substitutes them into a body producing a new set of tokens.

Instances

Show Macro

Methods

showsPrec :: Int -> Macro -> ShowS

show :: Macro -> String

showList :: [Macro] -> ShowS

Monad m => HasEnv (StateT Env m)

Methods

getEnv :: StateT Env m Env

setEnv :: Env -> StateT Env m ()

lookupMacro :: (HasEnv m, Monad m) => String -> m (Maybe Macro)

Looks up a Macro in the current environment. If the Macro is found, the environment is juggled so that subsequent lookups of the same Macro may evaluate more quickly.

Nano-lens

type Lens s a = forall f. Functor f => (a -> f a) -> s -> f s

setL :: Lens s a -> a -> s -> s

getL :: Lens s a -> s -> a

over :: Lens s a -> (a -> a) -> s -> s

State Lenses

emptyHppState :: Config -> HppState

config :: Lens HppState Config

lineNum :: Lens HppState LineNum

env :: Lens HppState Env

use :: (HasHppState m, Functor m) => Lens HppState a -> m a

(.=) :: (HasHppState m, Monad m) => Lens HppState a -> a -> m () infix 4

(%=) :: (HasHppState m, Monad m) => Lens HppState a -> (a -> a) -> m () infix 4