GF

GF, the Grammatical Framework, as a library

Command line interface

main :: IO ()

Run the GF main program, taking arguments from the command line. (It calls setConsoleEncoding and getOptions, then mainOpts.) Run gf --help for usage info.

getOptions :: IO (Options, [FilePath])

Get and parse GF command line arguments. Fix relative paths. Calls getArgs and parseOptions.

mainOpts :: Options -> [FilePath] -> IO ()

Run the GF main program with the given options and files. Depending on the options it invokes mainGFC, mainGFI, mainRunGFI, mainServerGFI, or it just prints version/usage info.

mainGFI :: Options -> [FilePath] -> IO ()

Run the interactive GF Shell

mainRunGFI :: Options -> [FilePath] -> IO ()

Run the GF Shell in quiet mode (gf -run).

mainServerGFI :: Options -> Int -> [FilePath] -> IO Server

Run the GF Server (gf -server). The Int argument is the port number for the HTTP service.

mainGFC :: Options -> [FilePath] -> IO ()

Compile the given GF grammar files. The result is a number of .gfo files and, depending on the options, a .pgf file. (gf -batch, gf -make)

linkGrammars :: Options -> (UTCTime, [(ModuleName, Grammar)]) -> IO ()

Create a .pgf file (and possibly files in other formats, if specified in the Options) from the output of parallelBatchCompile. If a .pgf file by the same name already exists and it is newer than the source grammar files (as indicated by the UTCTime argument), it is not recreated. Calls writePGF and writeOutputs.

writePGF :: Options -> PGF -> IOE ()

Write the result of compiling a grammar (e.g. with compileToPGF or link) to a .pgf file. A split PGF file is output if the -split-pgf option is used.

writeOutputs :: Options -> PGF -> IOE ()

Export the PGF to the OutputFormats specified in the Options. Calls exportPGF.

Compiling GF grammars

compileToPGF :: Options -> [FilePath] -> IOE PGF

Compiles a number of source files and builds a PGF structure for them. This is a composition of link and batchCompile.

link :: Options -> (ModuleName, Grammar) -> IOE PGF

Link a grammar into a PGF that can be used to linearize and parse with the PGF run-time system.

batchCompile :: Options -> [FilePath] -> IOE (UTCTime, (ModuleName, Grammar))

Compile the given grammar files and everything they depend on. Compiled modules are stored in .gfo files (unless the -tags option is used, in which case tags files are produced instead). Existing .gfo files are reused if they are up-to-date (unless the option -src aka -force-recomp is used).

srcAbsName :: Grammar -> ModuleName -> ModuleName

Returns the name of the abstract syntax corresponding to the named concrete syntax

parallelBatchCompile :: Maybe Int -> Options -> [FilePath] -> IO (UTCTime, [(ModuleName, Grammar)])

Compile the given grammar files and everything they depend on, like batchCompile. This function compiles modules in parallel. It keeps modules compiled in present and alltenses mode apart, storing the .gfo files in separate subdirectories to avoid creating the broken PGF files that can result from mixing different modes in the same concrete syntax.

The first argument controls the number of jobs to run in parallel. This works if GF was compiled with GHC>=7.6, otherwise you have to use the GHC run-time flag +RTS -N -RTS to enable parallelism.

exportPGF

Arguments

:: Options

-> OutputFormat

-> PGF

-> [(FilePath, String)]

List of recommended file names and contents.

Export a PGF to the given OutputFormat. For many output formats, additional Options can be used to control the output.

Compiling a single module

type OneOutput = (Maybe FullPath, CompiledModule)

type CompiledModule = Module

compileOne :: (Output m, ErrorMonad m, MonadIO m) => Options -> Grammar -> FullPath -> m OneOutput

Compile a given source file (or just load a .gfo file), given a Grammar containing everything it depends on. Calls reuseGFO or useTheSource.

reuseGFO :: (Output m, ErrorMonad m, MonadIO m) => Options -> Grammar -> FullPath -> m OneOutput

Read a compiled GF module. Also undo common subexp optimization, to enable normal computations.

useTheSource :: (Output m, ErrorMonad m, MonadIO m) => Options -> Grammar -> FullPath -> m OneOutput

Compile GF module from source. It both returns the result and stores it in a .gfo file (or a tags file, if running with the -tags option)

Abstract syntax, parsing, pretty printing and serialisation

getSourceModule :: (Output m, ErrorMonad m, MonadIO m) => Options -> FilePath -> m (ModuleName, ModuleInfo)

Read a source file and parse it (after applying preprocessors specified in the options)

getBNFCRules :: Options -> FilePath -> IOE [BNFCRule]

getEBNFRules :: Options -> FilePath -> IOE [ERule]

Grammar modules

data Grammar

A grammar is a self-contained collection of grammar modules

data ModuleName

Module names

Instances

Eq ModuleName

Methods

(==) :: ModuleName -> ModuleName -> Bool

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

Ord ModuleName

Methods

compare :: ModuleName -> ModuleName -> Ordering

(<) :: ModuleName -> ModuleName -> Bool

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

(>) :: ModuleName -> ModuleName -> Bool

(>=) :: ModuleName -> ModuleName -> Bool

max :: ModuleName -> ModuleName -> ModuleName

min :: ModuleName -> ModuleName -> ModuleName

Show ModuleName

Methods

showsPrec :: Int -> ModuleName -> ShowS

show :: ModuleName -> String

showList :: [ModuleName] -> ShowS

Pretty ModuleName

Methods

pp :: ModuleName -> Doc

ppList :: [ModuleName] -> Doc

type Module = (ModuleName, ModuleInfo)

Modules

data ModuleInfo

Constructors

ModInfo

Fields

• mtype :: ModuleType
• mstatus :: ModuleStatus
• mflags :: Options
• mextend :: [(ModuleName, MInclude)]
• mwith :: Maybe (ModuleName, MInclude, [(ModuleName, ModuleName)])
• mopens :: [OpenSpec]
• mexdeps :: [ModuleName]
• msrc :: FilePath
• mseqs :: Maybe (Array SeqId Sequence)
• jments :: Map Ident Info

Instances

HasSourcePath ModuleInfo

Methods

sourcePath :: ModuleInfo -> FilePath

type SourceGrammar = Grammar

type SourceModInfo = ModuleInfo

type SourceModule = Module

data ModuleType

encoding the type of the module

Constructors

MTAbstract

MTResource

MTConcrete ModuleName

MTInterface

MTInstance (ModuleName, MInclude)

Instances

Eq ModuleType

Methods

(==) :: ModuleType -> ModuleType -> Bool

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

Show ModuleType

Methods

showsPrec :: Int -> ModuleType -> ShowS

show :: ModuleType -> String

showList :: [ModuleType] -> ShowS

emptyGrammar :: Grammar

mGrammar :: [Module] -> Grammar

modules :: Grammar -> [Module]

prependModule :: Grammar -> Module -> Grammar

moduleMap :: Grammar -> Map ModuleName ModuleInfo

data MInclude

Constructors

MIAll

MIOnly [Ident]

MIExcept [Ident]

Instances

Eq MInclude

Methods

(==) :: MInclude -> MInclude -> Bool

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

Show MInclude

Methods

showsPrec :: Int -> MInclude -> ShowS

show :: MInclude -> String

showList :: [MInclude] -> ShowS

data OpenSpec

Constructors

OSimple ModuleName

OQualif ModuleName ModuleName

Instances

Eq OpenSpec

Methods

(==) :: OpenSpec -> OpenSpec -> Bool

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

Show OpenSpec

Methods

showsPrec :: Int -> OpenSpec -> ShowS

show :: OpenSpec -> String

showList :: [OpenSpec] -> ShowS

extends :: ModuleInfo -> [ModuleName]

isInherited :: MInclude -> Ident -> Bool

inheritAll :: ModuleName -> (ModuleName, MInclude)

openedModule :: OpenSpec -> ModuleName

allDepsModule :: Grammar -> ModuleInfo -> [OpenSpec]

all dependencies

partOfGrammar :: Grammar -> Module -> Grammar

select just those modules that a given one depends on, including itself

depPathModule :: ModuleInfo -> [OpenSpec]

initial dependency list

allExtends :: Grammar -> ModuleName -> [Module]

all modules that a module extends, directly or indirectly, with restricts

allExtendsPlus :: Grammar -> ModuleName -> [ModuleName]

the same as allExtends plus that an instance extends its interface

lookupModule :: ErrorMonad m => Grammar -> ModuleName -> m ModuleInfo

isModAbs :: ModuleInfo -> Bool

isModRes :: ModuleInfo -> Bool

isModCnc :: ModuleInfo -> Bool

sameMType :: ModuleType -> ModuleType -> Bool

isCompilableModule :: ModuleInfo -> Bool

don't generate code for interfaces and for incomplete modules

isCompleteModule :: ModuleInfo -> Bool

interface and "incomplete M" are not complete

allAbstracts :: Grammar -> [ModuleName]

all abstract modules sorted from least to most dependent

greatestAbstract :: Grammar -> Maybe ModuleName

the last abstract in dependency order (head of list)

allResources :: Grammar -> [ModuleName]

all resource modules

greatestResource :: Grammar -> Maybe ModuleName

the greatest resource in dependency order

allConcretes :: Grammar -> ModuleName -> [ModuleName]

all concretes for a given abstract

allConcreteModules :: Grammar -> [ModuleName]

all concrete modules for any abstract

abstractOfConcrete :: ErrorMonad m => Grammar -> ModuleName -> m ModuleName

we store the module type with the identifier

data ModuleStatus

Constructors

MSComplete

MSIncomplete

Instances

Eq ModuleStatus

Methods

(==) :: ModuleStatus -> ModuleStatus -> Bool

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

Ord ModuleStatus

Methods

compare :: ModuleStatus -> ModuleStatus -> Ordering

(<) :: ModuleStatus -> ModuleStatus -> Bool

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

(>) :: ModuleStatus -> ModuleStatus -> Bool

(>=) :: ModuleStatus -> ModuleStatus -> Bool

max :: ModuleStatus -> ModuleStatus -> ModuleStatus

min :: ModuleStatus -> ModuleStatus -> ModuleStatus

Show ModuleStatus

Methods

showsPrec :: Int -> ModuleStatus -> ShowS

show :: ModuleStatus -> String

showList :: [ModuleStatus] -> ShowS

Judgements

data Info

the constructors are judgements in

• abstract syntax (ABS)
• resource (RES)
• concrete syntax (CNC)

and indirection to module (INDIR)

Constructors

AbsCat (Maybe (L Context))

(ABS) context of a category

AbsFun (Maybe (L Type)) (Maybe Int) (Maybe [L Equation]) (Maybe Bool)

(ABS) type, arrity and definition of a function

ResParam (Maybe (L [Param])) (Maybe [Term])

(RES) the second parameter is list of all possible values

ResValue (L Type)

(RES) to mark parameter constructors for lookup

ResOper (Maybe (L Type)) (Maybe (L Term))

(RES)

ResOverload [ModuleName] [(L Type, L Term)]

(RES) idents: modules inherited

CncCat (Maybe (L Type)) (Maybe (L Term)) (Maybe (L Term)) (Maybe (L Term)) (Maybe PMCFG)

(CNC) lindef ini'zed,

CncFun (Maybe (Ident, Context, Type)) (Maybe (L Term)) (Maybe (L Term)) (Maybe PMCFG)

(CNC) type info added at TC

AnyInd Bool ModuleName

(INDIR) the Bool says if canonical

Instances

Show Info

Methods

showsPrec :: Int -> Info -> ShowS

show :: Info -> String

showList :: [Info] -> ShowS

Terms

data Term

Constructors

Vr Ident

variable

Cn Ident

constant

Con Ident

constructor

Sort Ident

basic type

EInt Int

integer literal

EFloat Double

floating point literal

K String

string literal or token: "foo"

Empty

the empty string []

App Term Term

application: f a

Abs BindType Ident Term

abstraction: x -> b

Meta !MetaId

metavariable: ?i (only parsable: ? = ?0)

ImplArg Term

placeholder for implicit argument {t}

Prod BindType Ident Term Term

function type: (x : A) -> B, A -> B, ({x} : A) -> B

Typed Term Term

type-annotated term

below this, the constructors are only for concrete syntax

Example Term String

example-based term: @in M.C "foo"

RecType [Labelling]

record type: { p : A ; ...}

R [Assign]

record: { p = a ; ...}

P Term Label

projection: r.p

ExtR Term Term

extension: R ** {x : A} (both types and terms)

Table Term Term

table type: P => A

T TInfo [Case]

table: table {p => c ; ...}

V Type [Term]

table given as course of values: table T [c1 ; ... ; cn]

S Term Term

selection: t ! p

Let LocalDef Term

local definition: let {t : T = a} in b

Q QIdent

qualified constant from a package

QC QIdent

qualified constructor from a package

C Term Term

concatenation: s ++ t

Glue Term Term

agglutination: s + t

EPatt Patt

pattern (in macro definition): # p

EPattType Term

pattern type: pattern T

ELincat Ident Term

boxed linearization type of Ident

ELin Ident Term

boxed linearization of type Ident

AdHocOverload [Term]

ad hoc overloading generated in Rename

FV [Term]

alternatives in free variation: variants { s ; ... }

Alts Term [(Term, Term)]

alternatives by prefix: pre {t ; s/c ; ...}

Strs [Term]

conditioning prefix strings: strs {s ; ...}

Error String

error values returned by Predef.error

Instances

Eq Term

Methods

(==) :: Term -> Term -> Bool

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

Ord Term

Methods

compare :: Term -> Term -> Ordering

(<) :: Term -> Term -> Bool

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

(>) :: Term -> Term -> Bool

(>=) :: Term -> Term -> Bool

max :: Term -> Term -> Term

min :: Term -> Term -> Term

Show Term

Methods

showsPrec :: Int -> Term -> ShowS

show :: Term -> String

showList :: [Term] -> ShowS

type Type = Term

type Cat = QIdent

type Fun = QIdent

type QIdent = (ModuleName, Ident)

data BindType

Constructors

Explicit

Implicit

Instances

Eq BindType

Methods

(==) :: BindType -> BindType -> Bool

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

Ord BindType

Methods

compare :: BindType -> BindType -> Ordering

(<) :: BindType -> BindType -> Bool

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

(>) :: BindType -> BindType -> Bool

(>=) :: BindType -> BindType -> Bool

max :: BindType -> BindType -> BindType

min :: BindType -> BindType -> BindType

Show BindType

Methods

showsPrec :: Int -> BindType -> ShowS

show :: BindType -> String

showList :: [BindType] -> ShowS

data Patt

Patterns

Constructors

PC Ident [Patt]

constructor pattern: C p1 ... pn C

PP QIdent [Patt]

package constructor pattern: P.C p1 ... pn P.C

PV Ident

variable pattern: x

PW

wild card pattern: _

PR [(Label, Patt)]

record pattern: {r = p ; ...} -- only concrete

PString String

string literal pattern: "foo" -- only abstract

PInt Int

integer literal pattern: 12 -- only abstract

PFloat Double

float literal pattern: 1.2 -- only abstract

PT Type Patt

type-annotated pattern

PAs Ident Patt

as-pattern: x@p

PImplArg Patt

placeholder for pattern for implicit argument {p}

PTilde Term

inaccessible pattern

PNeg Patt

negated pattern: -p

PAlt Patt Patt

disjunctive pattern: p1 | p2

PSeq Patt Patt

sequence of token parts: p + q

PMSeq MPatt MPatt

sequence of token parts: p + q

PRep Patt

repetition of token part: p*

PChar

string of length one: ?

PChars [Char]

character list: ["aeiou"]

PMacro Ident

PM QIdent

Instances

Eq Patt

Methods

(==) :: Patt -> Patt -> Bool

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

Ord Patt

Methods

compare :: Patt -> Patt -> Ordering

(<) :: Patt -> Patt -> Bool

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

(>) :: Patt -> Patt -> Bool

(>=) :: Patt -> Patt -> Bool

max :: Patt -> Patt -> Patt

min :: Patt -> Patt -> Patt

Show Patt

Methods

showsPrec :: Int -> Patt -> ShowS

show :: Patt -> String

showList :: [Patt] -> ShowS

data TInfo

to guide computation and type checking of tables

Constructors

TRaw

received from parser; can be anything

TTyped Type

type annontated, but can be anything

TComp Type

expanded

TWild Type

just one wild card pattern, no need to expand

Instances

Eq TInfo

Methods

(==) :: TInfo -> TInfo -> Bool

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

Ord TInfo

Methods

compare :: TInfo -> TInfo -> Ordering

(<) :: TInfo -> TInfo -> Bool

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

(>) :: TInfo -> TInfo -> Bool

(>=) :: TInfo -> TInfo -> Bool

max :: TInfo -> TInfo -> TInfo

min :: TInfo -> TInfo -> TInfo

Show TInfo

Methods

showsPrec :: Int -> TInfo -> ShowS

show :: TInfo -> String

showList :: [TInfo] -> ShowS

data Label

record label

Constructors

LIdent RawIdent

LVar Int

Instances

Eq Label

Methods

(==) :: Label -> Label -> Bool

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

Ord Label

Methods

compare :: Label -> Label -> Ordering

(<) :: Label -> Label -> Bool

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

(>) :: Label -> Label -> Bool

(>=) :: Label -> Label -> Bool

max :: Label -> Label -> Label

min :: Label -> Label -> Label

Show Label

Methods

showsPrec :: Int -> Label -> ShowS

show :: Label -> String

showList :: [Label] -> ShowS

type MetaId = Int

type Hypo = (BindType, Ident, Term)

type Context = [Hypo]

type Equation = ([Patt], Term)

type Labelling = (Label, Type)

type Assign = (Label, (Maybe Type, Term))

type Case = (Patt, Term)

type LocalDef = (Ident, (Maybe Type, Term))

type Param = (Ident, Context)

type Altern = (Term, [(Term, Term)])

type Substitution = [(Ident, Term)]

varLabel :: Int -> Label

tupleLabel :: Int -> Label

linLabel :: Int -> Label

theLinLabel :: Label

ident2label :: Ident -> Label

label2ident :: Label -> Ident

Source locations

data Location

Constructors

NoLoc

Local Int Int

External FilePath Location

Instances

Eq Location

Methods

(==) :: Location -> Location -> Bool

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

Ord Location

Methods

compare :: Location -> Location -> Ordering

(<) :: Location -> Location -> Bool

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

(>) :: Location -> Location -> Bool

(>=) :: Location -> Location -> Bool

max :: Location -> Location -> Location

min :: Location -> Location -> Location

Show Location

Methods

showsPrec :: Int -> Location -> ShowS

show :: Location -> String

showList :: [Location] -> ShowS

Pretty Location

Methods

pp :: Location -> Doc

ppList :: [Location] -> Doc

data L a

Attaching location information

Constructors

L Location a

Instances

Functor L

Methods

fmap :: (a -> b) -> L a -> L b

(<$) :: a -> L b -> L a

Show a => Show (L a)

Methods

showsPrec :: Int -> L a -> ShowS

show :: L a -> String

showList :: [L a] -> ShowS

Pretty a => Pretty (L a)

Methods

pp :: L a -> Doc

ppList :: [L a] -> Doc

unLoc :: L a -> a

noLoc :: a -> L a

ppLocation :: FilePath -> Location -> Doc

ppL :: (Pretty a2, Pretty a1) => L a2 -> a1 -> Doc

PMCFG

data PMCFG

Constructors

PMCFG [Production] (Array FunId (UArray LIndex SeqId))

Instances

Eq PMCFG

Methods

(==) :: PMCFG -> PMCFG -> Bool

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

Show PMCFG

Methods

showsPrec :: Int -> PMCFG -> ShowS

show :: PMCFG -> String

showList :: [PMCFG] -> ShowS

data Production

Constructors

Production !FId !FunId [[FId]]

Instances

Eq Production

Methods

(==) :: Production -> Production -> Bool

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

Ord Production

Methods

compare :: Production -> Production -> Ordering

(<) :: Production -> Production -> Bool

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

(>) :: Production -> Production -> Bool

(>=) :: Production -> Production -> Bool

max :: Production -> Production -> Production

min :: Production -> Production -> Production

Show Production

Methods

showsPrec :: Int -> Production -> ShowS

show :: Production -> String

showList :: [Production] -> ShowS

type FId = Int

type FunId = Int

type SeqId = Int

type LIndex = Int

type Sequence = Array DotPos Symbol

Functions for constructing and analysing source code terms.

typeForm :: Type -> (Context, Cat, [Term])

typeFormCnc :: Type -> (Context, Type)

valCat :: Type -> Cat

valType :: Type -> Type

valTypeCnc :: Type -> Type

typeSkeleton :: Type -> ([(Int, Cat)], Cat)

catSkeleton :: Type -> ([Cat], Cat)

funsToAndFrom :: Type -> (Cat, [(Cat, [Int])])

isRecursiveType :: Type -> Bool

isHigherOrderType :: Type -> Bool

contextOfType :: Monad m => Type -> m Context

termForm :: Monad m => Term -> m ([(BindType, Ident)], Term, [Term])

termFormCnc :: Term -> ([(BindType, Ident)], Term)

appForm :: Term -> (Term, [Term])

mkProdSimple :: Context -> Term -> Term

mkProd :: Context -> Term -> [Term] -> Term

mkTerm :: ([(BindType, Ident)], Term, [Term]) -> Term

mkApp :: Term -> [Term] -> Term

mkAbs :: [(BindType, Ident)] -> Term -> Term

appCons :: Ident -> [Term] -> Term

mkLet :: [LocalDef] -> Term -> Term

mkLetUntyped :: Context -> Term -> Term

isVariable :: Term -> Bool

uType :: Type

Assignment

assign :: Label -> Term -> Assign

assignT :: Label -> Type -> Term -> Assign

unzipR :: [Assign] -> ([Label], [Term])

mkAssign :: [(Label, Term)] -> [Assign]

projectRec :: Label -> [Assign] -> Term

zipAssign :: [Label] -> [Term] -> [Assign]

mapAssignM :: Monad m => (Term -> m c) -> [Assign] -> m [(Label, (Maybe c, c))]

Records

mkRecordN :: Int -> (Int -> Label) -> [Term] -> Term

mkRecord :: (Int -> Label) -> [Term] -> Term

mkRecTypeN :: Int -> (Int -> Label) -> [Type] -> Type

mkRecType :: (Int -> Label) -> [Type] -> Type

record2subst :: Term -> Err Substitution

Types

typeType :: Type

typePType :: Type

typeStr :: Type

typeTok :: Type

typeStrs :: Type

typeString :: Type

typeFloat :: Type

typeInt :: Type

typeInts :: Int -> Type

typePBool :: Type

typeError :: Type

isTypeInts :: Type -> Maybe Int

Terms

isPredefConstant :: Term -> Bool

checkPredefError :: Monad m => Term -> m Term

cnPredef :: Ident -> Term

mkSelects :: Term -> [Term] -> Term

mkTable :: [Term] -> Term -> Term

mkCTable :: [(BindType, Ident)] -> Term -> Term

mkHypo :: Term -> Hypo

eqStrIdent :: Ident -> Ident -> Bool

tuple2record :: [Term] -> [Assign]

tuple2recordType :: [Term] -> [Labelling]

tuple2recordPatt :: [Patt] -> [(Label, Patt)]

mkCases :: Ident -> Term -> Term

mkWildCases :: Term -> Term

mkFunType :: [Type] -> Type -> Type

plusRecType :: ErrorMonad m => Term -> Term -> m Term

plusRecord :: ErrorMonad m => Term -> Term -> m Term

defLinType :: Type

default linearization type

mkFreshVar :: [Ident] -> Ident

refreshing variables

mkFreshVarX :: [Ident] -> Ident -> Ident

trying to preserve a given symbol

maxVarIndex :: [Ident] -> Int

mkFreshVars :: Int -> [Ident] -> [Ident]

freshAsTerm :: String -> Term

quick hack for refining with var in editor

string2term :: String -> Term

create a terminal for concrete syntax

int2term :: Int -> Term

float2term :: Double -> Term

ident2terminal :: Ident -> Term

create a terminal from identifier

symbolOfIdent :: Ident -> String

symid :: Ident -> String

justIdentOf :: Term -> Maybe Ident

linTypeStr :: Type

linAsStr :: String -> Term

Term and pattern conversion

term2patt :: Term -> Err Patt

patt2term :: Patt -> Term

Almost compositional

composSafeOp :: (Term -> Term) -> Term -> Term

to define compositional term functions

composOp :: Monad m => (Term -> m Term) -> Term -> m Term

to define compositional term functions

composSafePattOp :: (Patt -> Patt) -> Patt -> Patt

composPattOp :: Monad m => (Patt -> m Patt) -> Patt -> m Patt

collectOp :: Monoid m => (Term -> m) -> Term -> m

mconcatMap :: Monoid c => (a -> c) -> [a] -> c

collectPattOp :: (Patt -> [a]) -> Patt -> [a]

Misc

redirectTerm :: ModuleName -> Term -> Term

allCaseValues :: Term -> [([Patt], Term)]

to gather ultimate cases in a table; preserves pattern list

strsFromTerm :: Term -> Err [Str]

to get a string from a term that represents a sequence of terminals

stringFromTerm :: Term -> String

to print an Str-denoting term as a string; if the term is of wrong type, the error msg

getTableType :: TInfo -> Err Type

changeTableType :: Monad m => (Type -> m Type) -> TInfo -> m TInfo

wordsInTerm :: Term -> [String]

to find the word items in a term

noExist :: Term

defaultLinType :: Type

sortRec :: [(Label, a)] -> [(Label, a)]

Dependencies

allDependencies :: (ModuleName -> Bool) -> BinTree Ident Info -> [(Ident, [Ident])]

dependency check, detecting circularities and returning topo-sorted list

topoSortJments :: ErrorMonad m => SourceModule -> m [(Ident, Info)]

topoSortJments2 :: ErrorMonad m => SourceModule -> m [[(Ident, Info)]]

Pretty printing

data TermPrintQual

Constructors

Unqualified

Qualified

Internal

Instances

Eq TermPrintQual

Methods

(==) :: TermPrintQual -> TermPrintQual -> Bool

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

ppModule :: TermPrintQual -> SourceModule -> Doc

ppJudgement :: Pretty a1 => TermPrintQual -> (a1, Info) -> Doc

ppParams :: Pretty a => TermPrintQual -> [(a, [(t, Ident, Term)])] -> Doc

ppTerm :: (Ord a, Num a) => TermPrintQual -> a -> Term -> Doc

ppPatt :: (Ord a, Num a) => TermPrintQual -> a -> Patt -> Doc

ppValue :: TermPrintQual -> Int -> Val -> Doc

ppConstrs :: Constraints -> [Doc]

ppQIdent :: TermPrintQual -> QIdent -> Doc

ppMeta :: MetaId -> Doc

getAbs :: Term -> ([(BindType, Ident)], Term)

Identifiers

newtype ModuleName

Module names

Constructors

MN Ident

Instances

Eq ModuleName

Methods

(==) :: ModuleName -> ModuleName -> Bool

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

Ord ModuleName

Methods

compare :: ModuleName -> ModuleName -> Ordering

(<) :: ModuleName -> ModuleName -> Bool

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

(>) :: ModuleName -> ModuleName -> Bool

(>=) :: ModuleName -> ModuleName -> Bool

max :: ModuleName -> ModuleName -> ModuleName

min :: ModuleName -> ModuleName -> ModuleName

Show ModuleName

Methods

showsPrec :: Int -> ModuleName -> ShowS

show :: ModuleName -> String

showList :: [ModuleName] -> ShowS

Pretty ModuleName

Methods

pp :: ModuleName -> Doc

ppList :: [ModuleName] -> Doc

moduleNameS :: String -> ModuleName

data Ident

the constructors labelled INTERNAL are internal representation never returned by the parser

Instances

Eq Ident

Methods

(==) :: Ident -> Ident -> Bool

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

Ord Ident

Methods

compare :: Ident -> Ident -> Ordering

(<) :: Ident -> Ident -> Bool

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

(>) :: Ident -> Ident -> Bool

(>=) :: Ident -> Ident -> Bool

max :: Ident -> Ident -> Ident

min :: Ident -> Ident -> Ident

Read Ident

Methods

readsPrec :: Int -> ReadS Ident

readList :: ReadS [Ident]

readPrec :: ReadPrec Ident

readListPrec :: ReadPrec [Ident]

Show Ident

Methods

showsPrec :: Int -> Ident -> ShowS

show :: Ident -> String

showList :: [Ident] -> ShowS

Pretty Ident

Methods

pp :: Ident -> Doc

ppList :: [Ident] -> Doc

ident2utf8 :: Ident -> ByteString

This function should be used with care, since the returned ByteString is UTF-8-encoded.

showIdent :: Ident -> String

prefixIdent :: String -> Ident -> Ident

Normal identifiers (returned by the parser)

identS :: String -> Ident

identC :: RawIdent -> Ident

identW :: Ident

Special identifiers for internal use

identV :: RawIdent -> Int -> Ident

identA :: RawIdent -> Int -> Ident

identAV :: RawIdent -> Int -> Int -> Ident

argIdent :: Int -> Ident -> Int -> Ident

to mark argument variables

isArgIdent :: Ident -> Bool

getArgIndex :: Ident -> Maybe Int

varStr :: Ident

used in lin defaults

varX :: Int -> Ident

refreshing variables

isWildIdent :: Ident -> Bool

varIndex :: Ident -> Int

Raw identifiers

data RawIdent

Identifiers are stored as UTF-8-encoded bytestrings. (It is also possible to use regular Haskell Strings, with somewhat reduced performance and increased memory use.)

Instances

Eq RawIdent

Methods

(==) :: RawIdent -> RawIdent -> Bool

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

Ord RawIdent

Methods

compare :: RawIdent -> RawIdent -> Ordering

(<) :: RawIdent -> RawIdent -> Bool

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

(>) :: RawIdent -> RawIdent -> Bool

(>=) :: RawIdent -> RawIdent -> Bool

max :: RawIdent -> RawIdent -> RawIdent

min :: RawIdent -> RawIdent -> RawIdent

Read RawIdent

Methods

readsPrec :: Int -> ReadS RawIdent

readList :: ReadS [RawIdent]

readPrec :: ReadPrec RawIdent

readListPrec :: ReadPrec [RawIdent]

Show RawIdent

Methods

showsPrec :: Int -> RawIdent -> ShowS

show :: RawIdent -> String

showList :: [RawIdent] -> ShowS

Binary RawIdent

Methods

put :: RawIdent -> Put

get :: Get RawIdent

rawIdentS :: String -> RawIdent

rawIdentC :: ByteString -> RawIdent

ident2raw :: Ident -> RawIdent

prefixRawIdent :: RawIdent -> RawIdent -> RawIdent

isPrefixOf :: RawIdent -> RawIdent -> Bool

showRawIdent :: RawIdent -> String

Binary serialisation

data VersionTagged a

Constructors

Tagged

Fields

• unV :: a

WrongVersion

Instances

Functor VersionTagged

Methods

fmap :: (a -> b) -> VersionTagged a -> VersionTagged b

(<$) :: a -> VersionTagged b -> VersionTagged a

Binary a => Binary (VersionTagged a)

Methods

put :: VersionTagged a -> Put

get :: Get (VersionTagged a)

decodeModuleHeader :: MonadIO io => FilePath -> io (VersionTagged Module)

Read just the module header, the returned Module will have an empty body

decodeModule :: MonadIO io => FilePath -> io SourceModule

encodeModule :: MonadIO io => FilePath -> SourceModule -> io ()