PGF2

This module is an Application Programming Interface to load and interpret grammars compiled in the Portable Grammar Format (PGF). The PGF format is produced as the final output from the GF compiler. The API is meant to be used for embedding GF grammars in Haskell programs

PGF

data PGF

An abstract data type representing multilingual grammar in Portable Grammar Format.

readPGF :: FilePath -> IO PGF

Reads file in Portable Grammar Format and produces PGF structure. The file is usually produced with:

$ gf -make <grammar file name>

showPGF :: PGF -> String

Identifiers

type CId = String

An data type that represents identifiers for functions and categories in PGF.

Abstract syntax

type AbsName

Arguments

 = CId

Name of abstract syntax

abstractName :: PGF -> AbsName

The abstract language name is the name of the top-level abstract module

Categories

type Cat

Arguments

 = CId

Name of syntactic category

categories :: PGF -> [Cat]

List of all categories defined in the grammar. The categories are defined in the abstract syntax with the 'cat' keyword.

categoryContext :: PGF -> Cat -> [Hypo]

Functions

type Fun

Arguments

 = CId

Name of function

functions :: PGF -> [Fun]

List of all functions defined in the abstract syntax

functionsByCat :: PGF -> Cat -> [Fun]

List of all functions defined for a category

functionType :: PGF -> Fun -> Maybe Type

The type of a function

functionIsConstructor :: PGF -> Fun -> Bool

The type of a function

hasLinearization :: Concr -> Fun -> Bool

Returns True if there is a linearization defined for that function in that language

Expressions

data Expr

Instances

Eq Expr

Methods

(==) :: Expr -> Expr -> Bool

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

Show Expr

Methods

showsPrec :: Int -> Expr -> ShowS

show :: Expr -> String

showList :: [Expr] -> ShowS

showExpr :: [CId] -> Expr -> String

renders an expression as a String. The list of identifiers is the list of all free variables in the expression in order reverse to the order of binding.

readExpr :: String -> Maybe Expr

parses a String as an expression

pExpr :: ReadS Expr

mkAbs :: BindType -> CId -> Expr -> Expr

Constructs an expression by lambda abstraction

unAbs :: Expr -> Maybe (BindType, CId, Expr)

Decomposes an expression into an abstraction and a body

mkApp :: Fun -> [Expr] -> Expr

Constructs an expression by applying a function to a list of expressions

unApp :: Expr -> Maybe (Fun, [Expr])

Decomposes an expression into an application of a function

mkStr :: String -> Expr

Constructs an expression from a string literal

unStr :: Expr -> Maybe String

Decomposes an expression into a string literal

mkInt :: Int -> Expr

Constructs an expression from an integer literal

unInt :: Expr -> Maybe Int

Decomposes an expression into an integer literal

mkFloat :: Double -> Expr

Constructs an expression from a real number

unFloat :: Expr -> Maybe Double

Decomposes an expression into a real number literal

mkMeta :: Int -> Expr

Constructs a meta variable as an expression

unMeta :: Expr -> Maybe Int

Decomposes an expression into a meta variable

mkCId :: t -> t

this functions is only for backward compatibility with the old Haskell runtime

exprHash :: Int32 -> Expr -> Int32

exprSize :: Expr -> Int

exprFunctions :: Expr -> [Fun]

exprSubstitute :: Expr -> [Expr] -> Expr

treeProbability :: PGF -> Expr -> Float

Types

data Type

Instances

Show Type

Methods

showsPrec :: Int -> Type -> ShowS

show :: Type -> String

showList :: [Type] -> ShowS

type Hypo = (BindType, CId, Type)

Hypo represents a hypothesis in a type i.e. in the type A -> B, A is the hypothesis

data BindType

Constructors

Explicit

Implicit

Instances

Show BindType

Methods

showsPrec :: Int -> BindType -> ShowS

show :: BindType -> String

showList :: [BindType] -> ShowS

startCat :: PGF -> Type

The start category is defined in the grammar with the 'startcat' flag. This is usually the sentence category but it is not necessary. Despite that there is a start category defined you can parse with any category. The start category definition is just for convenience.

readType :: String -> Maybe Type

parses a String as a type

showType :: [CId] -> Type -> String

renders a type as a String. The list of identifiers is the list of all free variables in the type in order reverse to the order of binding.

showContext :: [CId] -> [Hypo] -> String

renders a type as a String. The list of identifiers is the list of all free variables in the type in order reverse to the order of binding.

mkType :: [Hypo] -> CId -> [Expr] -> Type

creates a type from a list of hypothesises, a category and a list of arguments for the category. The operation mkType [h_1,...,h_n] C [e_1,...,e_m] will create h_1 -> ... -> h_n -> C e_1 ... e_m

unType :: Type -> ([Hypo], CId, [Expr])

Decomposes a type into a list of hypothesises, a category and a list of arguments for the category.

Type checking

checkExpr :: PGF -> Expr -> Type -> Either String Expr

Checks an expression against a specified type.

inferExpr :: PGF -> Expr -> Either String (Expr, Type)

Tries to infer the type of an expression. Note that even if the expression is type correct it is not always possible to infer its type in the GF type system. In this case the function returns an error.

checkType :: PGF -> Type -> Either String Type

Check whether a type is consistent with the abstract syntax of the grammar.

Computing

compute :: PGF -> Expr -> Expr

Concrete syntax

type ConcName

Arguments

 = CId

Name of concrete syntax

data Concr

languages :: PGF -> Map ConcName Concr

List of all languages available in the grammar.

concreteName :: Concr -> ConcName

The abstract language name is the name of the top-level abstract module

languageCode :: Concr -> String

Linearization

linearize :: Concr -> Expr -> String

Linearizes an expression as a string in the language

linearizeAll :: Concr -> Expr -> [String]

Generates all possible linearizations of an expression

tabularLinearize :: Concr -> Expr -> [(String, String)]

Generates a table of linearizations for an expression

tabularLinearizeAll :: Concr -> Expr -> [[(String, String)]]

Generates a table of linearizations for an expression

bracketedLinearize :: Concr -> Expr -> [BracketedString]

bracketedLinearizeAll :: Concr -> Expr -> [[BracketedString]]

type FId = Int

type LIndex = Int

data BracketedString

BracketedString represents a sentence that is linearized as usual but we also want to retain the 'brackets' that mark the beginning and the end of each constituent.

Constructors

Leaf String

this is the leaf i.e. a single token

BIND

the surrounding tokens must be bound together

Bracket CId !FId !LIndex CId [BracketedString]

this is a bracket. The CId is the category of the phrase. The FId is an unique identifier for every phrase in the sentence. For context-free grammars i.e. without discontinuous constituents this identifier is also unique for every bracket. When there are discontinuous phrases then the identifiers are unique for every phrase but not for every bracket since the bracket represents a constituent. The different constituents could still be distinguished by using the constituent index i.e. LIndex. If the grammar is reduplicating then the constituent indices will be the same for all brackets that represents the same constituent. The second CId is the name of the abstract function that generated this phrase.

showBracketedString :: BracketedString -> String

Renders the bracketed string as a string where the brackets are shown as (S ...) where S is the category.

flattenBracketedString :: BracketedString -> [String]

Extracts the sequence of tokens from the bracketed string

printName :: Concr -> Fun -> Maybe String

alignWords :: Concr -> Expr -> [(String, [Int])]

Parsing

data ParseOutput

This data type encodes the different outcomes which you could get from the parser.

Constructors

ParseFailed Int String

The integer is the position in number of unicode characters where the parser failed. The string is the token where the parser have failed.

ParseOk [(Expr, Float)]

If the parsing and the type checking are successful we get a list of abstract syntax trees. The list should be non-empty.

ParseIncomplete

The sentence is not complete.

parse :: Concr -> Type -> String -> ParseOutput

parseWithHeuristics

Arguments

:: Concr

the language with which we parse

-> Type

the start category

-> String

the input sentence

-> Double

the heuristic factor. A negative value tells the parser to lookup up the default from the grammar flags

-> [(Cat, Int -> Int -> Maybe (Expr, Float, Int))]

a list of callbacks for literal categories. The arguments of the callback are: the index of the constituent for the literal category; the input sentence; the current offset in the sentence. If a literal has been recognized then the output should be Just (expr,probability,end_offset)

-> ParseOutput

Sentence Lookup

lookupSentence

Arguments

:: Concr

the language with which we parse

-> Type

the start category

-> String

the input sentence

-> [(Expr, Float)]

Generation

generateAll :: PGF -> Type -> [(Expr, Float)]

Generates an exhaustive possibly infinite list of all abstract syntax expressions of the given type. The expressions are ordered by their probability.

Morphological Analysis

type MorphoAnalysis = (Fun, Cat, Float)

lookupMorpho :: Concr -> String -> [MorphoAnalysis]

fullFormLexicon :: Concr -> [(String, [MorphoAnalysis])]

Visualizations

data GraphvizOptions

Constructors

GraphvizOptions

Fields

• noLeaves :: Bool
• noFun :: Bool
• noCat :: Bool
• noDep :: Bool
• nodeFont :: String
• leafFont :: String
• nodeColor :: String
• leafColor :: String
• nodeEdgeStyle :: String
• leafEdgeStyle :: String

graphvizDefaults :: GraphvizOptions

graphvizAbstractTree :: PGF -> GraphvizOptions -> Expr -> String

Renders an abstract syntax tree in a Graphviz format.

graphvizParseTree :: Concr -> GraphvizOptions -> Expr -> String

graphvizWordAlignment :: [Concr] -> GraphvizOptions -> Expr -> String

Exceptions

newtype PGFError

Constructors

PGFError String

Instances

Show PGFError

Methods

showsPrec :: Int -> PGFError -> ShowS

show :: PGFError -> String

showList :: [PGFError] -> ShowS

Exception PGFError

Methods

toException :: PGFError -> SomeException

fromException :: SomeException -> Maybe PGFError

displayException :: PGFError -> String

Grammar specific callbacks

type LiteralCallback = PGF -> (ConcName, Concr) -> String -> Int -> Int -> Maybe (Expr, Float, Int)

literalCallbacks :: [(AbsName, [(Cat, LiteralCallback)])]

Callbacks for the App grammar