Stg.Parser.Parser

A parser for the STG language, modeled after the grammar given in the description in the 1992 paper (link) with a couple of differences to enhance usability:

• Function application uses no parentheses or commas like in Haskell (f x y z), not with curly parentheses and commas like in the paper (f {x,y,z}).
• Comment syntax like in Haskell: -- inline, {- multiline -}.
• Constructors may end with a # to allow labelling primitive boxes e.g. with Int#.
• A lambda's head is written \(free) bound -> body, where free and bound are space-separated variable lists, instead of the paper's {free} \n {bound} -> body, which uses comma-separated lists. The update flag \u is signified using a double arrow => instead of the normal arrow ->.

General parsing

parse :: StgParser ast -> Text -> Either Doc ast

Parse STG source using a user-specified parser. To parse a full program, use parse program.

>>> parse program "id = \\x -> x"
Right (Program (Binds [(Var "id",LambdaForm [] NoUpdate [Var "x"] (AppF (Var "x") []))]))

data StgParser ast

A parser for an STG syntax element.

Instances

Monad StgParser

Functor StgParser

Applicative StgParser

Alternative StgParser

TokenParsing StgParser

CharParsing StgParser

Parsing StgParser

Parser rules

program :: (Monad parser, TokenParsing parser) => parser Program

Parse an STG program.

binds :: (Monad parser, TokenParsing parser) => parser Binds

Parse a collection of bindings, used by let(rec) expressions and at the top level of a program.

lambdaForm :: (Monad parser, TokenParsing parser) => parser LambdaForm

Parse a lambda form, consisting of a list of free variables, and update flag, a list of bound variables, and the function body.

expr :: (Monad parser, TokenParsing parser) => parser Expr

Parse an expression, which can be

• let, let(rec) ... in ...
• case, case ... of ...
• function application, f (...)
• constructor application, C (...)
• primitive application, p# (...)
• literal, 1#

alts :: (Monad parser, TokenParsing parser) => parser Alts

Parse the alternatives given in a case expression.

nonDefaultAlts :: (Monad parser, TokenParsing parser) => parser NonDefaultAlts

Parse non-default alternatives. The list of alternatives can be either empty, all algebraic, or all primitive.

Nil -> ...
Cons x xs -> ...

1# -> ...
2# -> ...

algebraicAlt :: (Monad parser, TokenParsing parser) => parser AlgebraicAlt

Parse a single algebraic alternative.

Cons x xs -> ...

primitiveAlt :: (Monad parser, TokenParsing parser) => parser PrimitiveAlt

Parse a single primitive alternative, such as 1#.

1# -> ...

defaultAlt :: (Monad parser, TokenParsing parser) => parser DefaultAlt

Parse the default alternative, taken if none of the other alternatives in a case expression match.

default -> ...

v -> ...

literal :: TokenParsing parser => parser Literal

primOp :: TokenParsing parser => parser PrimOp

Parse a primitive operation.

+#

atom :: (Monad parser, TokenParsing parser) => parser Atom

var :: (Monad parser, TokenParsing parser) => parser Var

Parse a variable identifier. Variables start with a lower-case letter or _, followed by a string consisting of alphanumeric characters or ', _.

con :: (Monad parser, TokenParsing parser) => parser Constr

Parse a constructor identifier. Constructors follow the same naming conventions as variables, but start with an upper-case character instead, and may end with a # symbol.