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, MonadFail 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, MonadFail 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, MonadFail 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 :: (MonadIO m, ErrorMonad 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

Instances

Binary Grammar

Defined in GF.Grammar.Binary

Methods

put :: Grammar -> Put

get :: Get Grammar

Pretty Grammar

Defined in GF.Grammar.Printer

Methods

pp :: Grammar -> Doc

ppList :: [Grammar] -> Doc

data ModuleName

Module names

Instances

Eq ModuleName

Defined in GF.Infra.Ident

Methods

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

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

Ord ModuleName

Defined in GF.Infra.Ident

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

Defined in GF.Infra.Ident

Methods

showsPrec :: Int -> ModuleName -> ShowS

show :: ModuleName -> String

showList :: [ModuleName] -> ShowS

Binary ModuleName

Defined in GF.Grammar.Binary

Methods

put :: ModuleName -> Put

get :: Get ModuleName

Pretty ModuleName

Defined in GF.Infra.Ident

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

Binary ModuleInfo

Defined in GF.Grammar.Binary

Methods

put :: ModuleInfo -> Put

get :: Get ModuleInfo

HasSourcePath ModuleInfo

Defined in GF.Grammar.Grammar

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

Defined in GF.Grammar.Grammar

Methods

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

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

Show ModuleType

Defined in GF.Grammar.Grammar

Methods

showsPrec :: Int -> ModuleType -> ShowS

show :: ModuleType -> String

showList :: [ModuleType] -> ShowS

Binary ModuleType

Defined in GF.Grammar.Binary

Methods

put :: ModuleType -> Put

get :: Get ModuleType

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

Defined in GF.Grammar.Grammar

Methods

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

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

Show MInclude

Defined in GF.Grammar.Grammar

Methods

showsPrec :: Int -> MInclude -> ShowS

show :: MInclude -> String

showList :: [MInclude] -> ShowS

Binary MInclude

Defined in GF.Grammar.Binary

Methods

put :: MInclude -> Put

get :: Get MInclude

data OpenSpec

Constructors

OSimple ModuleName

OQualif ModuleName ModuleName

Instances

Eq OpenSpec

Defined in GF.Grammar.Grammar

Methods

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

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

Show OpenSpec

Defined in GF.Grammar.Grammar

Methods

showsPrec :: Int -> OpenSpec -> ShowS

show :: OpenSpec -> String

showList :: [OpenSpec] -> ShowS

Binary OpenSpec

Defined in GF.Grammar.Binary

Methods

put :: OpenSpec -> Put

get :: Get OpenSpec

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

Defined in GF.Grammar.Grammar

Methods

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

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

Ord ModuleStatus

Defined in GF.Grammar.Grammar

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

Defined in GF.Grammar.Grammar

Methods

showsPrec :: Int -> ModuleStatus -> ShowS

show :: ModuleStatus -> String

showList :: [ModuleStatus] -> ShowS

Binary ModuleStatus

Defined in GF.Grammar.Binary

Methods

put :: ModuleStatus -> Put

get :: Get ModuleStatus

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

Defined in GF.Grammar.Grammar

Methods

showsPrec :: Int -> Info -> ShowS

show :: Info -> String

showList :: [Info] -> ShowS

Binary Info

Defined in GF.Grammar.Binary

Methods

put :: Info -> Put

get :: Get Info

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

Defined in GF.Grammar.Grammar

Methods

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

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

Ord Term

Defined in GF.Grammar.Grammar

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

Defined in GF.Grammar.Grammar

Methods

showsPrec :: Int -> Term -> ShowS

show :: Term -> String

showList :: [Term] -> ShowS

Binary Term

Defined in GF.Grammar.Binary

Methods

put :: Term -> Put

get :: Get Term

Pretty Term

Defined in GF.Grammar.Printer

Methods

pp :: Term -> Doc

ppList :: [Term] -> Doc

type Type = Term

type Cat = QIdent

type Fun = QIdent

type QIdent = (ModuleName, Ident)

data BindType

Constructors

Explicit

Implicit

Instances

Eq BindType

Defined in PGF.Expr

Methods

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

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

Ord BindType

Defined in PGF.Expr

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

Defined in PGF.Expr

Methods

showsPrec :: Int -> BindType -> ShowS

show :: BindType -> String

showList :: [BindType] -> ShowS

Binary BindType

Defined in PGF.Binary

Methods

put :: BindType -> Put

get :: Get BindType

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

Defined in GF.Grammar.Grammar

Methods

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

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

Ord Patt

Defined in GF.Grammar.Grammar

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

Defined in GF.Grammar.Grammar

Methods

showsPrec :: Int -> Patt -> ShowS

show :: Patt -> String

showList :: [Patt] -> ShowS

Binary Patt

Defined in GF.Grammar.Binary

Methods

put :: Patt -> Put

get :: Get Patt

Pretty Patt

Defined in GF.Grammar.Printer

Methods

pp :: Patt -> Doc

ppList :: [Patt] -> Doc

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

Defined in GF.Grammar.Grammar

Methods

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

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

Ord TInfo

Defined in GF.Grammar.Grammar

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

Defined in GF.Grammar.Grammar

Methods

showsPrec :: Int -> TInfo -> ShowS

show :: TInfo -> String

showList :: [TInfo] -> ShowS

Binary TInfo

Defined in GF.Grammar.Binary

Methods

put :: TInfo -> Put

get :: Get TInfo

data Label

record label

Constructors

LIdent RawIdent

LVar Int

Instances

Eq Label

Defined in GF.Grammar.Grammar

Methods

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

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

Ord Label

Defined in GF.Grammar.Grammar

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

Defined in GF.Grammar.Grammar

Methods

showsPrec :: Int -> Label -> ShowS

show :: Label -> String

showList :: [Label] -> ShowS

Binary Label

Defined in GF.Grammar.Binary

Methods

put :: Label -> Put

get :: Get Label

Pretty Label

Defined in GF.Grammar.Printer

Methods

pp :: Label -> Doc

ppList :: [Label] -> Doc

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

Defined in GF.Infra.Location

Methods

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

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

Ord Location

Defined in GF.Infra.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

Defined in GF.Infra.Location

Methods

showsPrec :: Int -> Location -> ShowS

show :: Location -> String

showList :: [Location] -> ShowS

Binary Location

Defined in GF.Grammar.Binary

Methods

put :: Location -> Put

get :: Get Location

Pretty Location

Defined in GF.Infra.Location

Methods

pp :: Location -> Doc

ppList :: [Location] -> Doc

data L a

Attaching location information

Constructors

L Location a

Instances

Functor L

Defined in GF.Infra.Location

Methods

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

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

Show a => Show (L a)

Defined in GF.Infra.Location

Methods

showsPrec :: Int -> L a -> ShowS

show :: L a -> String

showList :: [L a] -> ShowS

Binary a => Binary (L a)

Defined in GF.Grammar.Binary

Methods

put :: L a -> Put

get :: Get (L a)

Pretty a => Pretty (L a)

Defined in GF.Infra.Location

Methods

pp :: L a -> Doc

ppList :: [L a] -> Doc

unLoc :: L a -> a

noLoc :: a -> L a

ppLocation :: FilePath -> Location -> Doc

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

PMCFG

data PMCFG

Constructors

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

Instances

Eq PMCFG

Defined in GF.Grammar.Grammar

Methods

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

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

Show PMCFG

Defined in GF.Grammar.Grammar

Methods

showsPrec :: Int -> PMCFG -> ShowS

show :: PMCFG -> String

showList :: [PMCFG] -> ShowS

Binary PMCFG

Defined in GF.Grammar.Binary

Methods

put :: PMCFG -> Put

get :: Get PMCFG

data Production

Constructors

Production !FId !FunId [[FId]]

Instances

Eq Production

Defined in GF.Grammar.Grammar

Methods

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

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

Ord Production

Defined in GF.Grammar.Grammar

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

Defined in GF.Grammar.Grammar

Methods

showsPrec :: Int -> Production -> ShowS

show :: Production -> String

showList :: [Production] -> ShowS

Binary Production

Defined in GF.Grammar.Binary

Methods

put :: Production -> Put

get :: Get Production

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 :: MonadFail 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

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)]

normalize records and record types; put s first

Dependencies

allDependencies :: (ModuleName -> Bool) -> Map 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

Terse

Unqualified

Qualified

Internal

Instances

Eq TermPrintQual

Defined in GF.Grammar.Printer

Methods

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

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

ppModule :: TermPrintQual -> SourceModule -> Doc

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

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

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

ppPatt :: (Num a, Ord 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

Defined in GF.Infra.Ident

Methods

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

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

Ord ModuleName

Defined in GF.Infra.Ident

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

Defined in GF.Infra.Ident

Methods

showsPrec :: Int -> ModuleName -> ShowS

show :: ModuleName -> String

showList :: [ModuleName] -> ShowS

Binary ModuleName

Defined in GF.Grammar.Binary

Methods

put :: ModuleName -> Put

get :: Get ModuleName

Pretty ModuleName

Defined in GF.Infra.Ident

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

Defined in GF.Infra.Ident

Methods

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

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

Ord Ident

Defined in GF.Infra.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

Defined in GF.Infra.Ident

Methods

readsPrec :: Int -> ReadS Ident

readList :: ReadS [Ident]

readPrec :: ReadPrec Ident

readListPrec :: ReadPrec [Ident]

Show Ident

Defined in GF.Infra.Ident

Methods

showsPrec :: Int -> Ident -> ShowS

show :: Ident -> String

showList :: [Ident] -> ShowS

Binary Ident

Defined in GF.Grammar.Binary

Methods

put :: Ident -> Put

get :: Get Ident

Pretty Ident

Defined in GF.Infra.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

Defined in GF.Infra.Ident

Methods

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

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

Ord RawIdent

Defined in GF.Infra.Ident

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

Defined in GF.Infra.Ident

Methods

readsPrec :: Int -> ReadS RawIdent

readList :: ReadS [RawIdent]

readPrec :: ReadPrec RawIdent

readListPrec :: ReadPrec [RawIdent]

Show RawIdent

Defined in GF.Infra.Ident

Methods

showsPrec :: Int -> RawIdent -> ShowS

show :: RawIdent -> String

showList :: [RawIdent] -> ShowS

JSON RawIdent

Defined in GF.Grammar.CanonicalJSON

Methods

readJSON :: JSValue -> Result RawIdent

showJSON :: RawIdent -> JSValue

readJSONs :: JSValue -> Result [RawIdent]

showJSONs :: [RawIdent] -> JSValue

Binary RawIdent

Defined in GF.Infra.Ident

Methods

put :: RawIdent -> Put

get :: Get RawIdent

Pretty RawIdent

Defined in GF.Infra.Ident

Methods

pp :: RawIdent -> Doc

ppList :: [RawIdent] -> Doc

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

Defined in GF.Grammar.Binary

Methods

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

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

Binary a => Binary (VersionTagged a)

Defined in GF.Grammar.Binary

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 ()

Canonical GF

grammar2canonical :: Options -> ModuleName -> Grammar -> Grammar

Generate Canonical code for the named abstract syntax and all associated concrete syntaxes

abstract2canonical :: ModuleName -> Grammar -> Abstract

Generate Canonical code for the named abstract syntax

concretes2canonical :: Options -> ModuleName -> Grammar -> [(FilePath, Concrete)]

Generate Canonical code for the all concrete syntaxes associated with the named abstract syntax in given the grammar.

projection :: LinValue -> LabelId -> LinValue

Smart constructor for projections

selection :: LinValue -> LinValue -> LinValue

Smart constructor for selections