Disco.Parser

Parser to convert concrete Disco syntax into an (untyped, surface language) AST.

Parser type and utilities

data DiscoParseError

Constructors

ReservedVarName String

InvalidPattern OpaqueTerm

Instances

Eq DiscoParseError

Defined in Disco.Parser

Methods

(==) :: DiscoParseError -> DiscoParseError -> Bool

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

Ord DiscoParseError

Defined in Disco.Parser

Methods

compare :: DiscoParseError -> DiscoParseError -> Ordering

(<) :: DiscoParseError -> DiscoParseError -> Bool

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

(>) :: DiscoParseError -> DiscoParseError -> Bool

(>=) :: DiscoParseError -> DiscoParseError -> Bool

max :: DiscoParseError -> DiscoParseError -> DiscoParseError

min :: DiscoParseError -> DiscoParseError -> DiscoParseError

Show DiscoParseError

Defined in Disco.Parser

Methods

showsPrec :: Int -> DiscoParseError -> ShowS

show :: DiscoParseError -> String

showList :: [DiscoParseError] -> ShowS

ShowErrorComponent DiscoParseError

Defined in Disco.Parser

Methods

showErrorComponent :: DiscoParseError -> String

errorComponentLen :: DiscoParseError -> Int

type Parser = StateT ParserState (Parsec DiscoParseError String)

A parser is a megaparsec parser of strings, with an extra layer of state to keep track of the current indentation level and language extensions, and some custom error messages.

runParser :: Parser a -> FilePath -> String -> Either (ParseErrorBundle String DiscoParseError) a

Run a parser from the initial state.

withExts :: Set Ext -> Parser a -> Parser a

Locally set the enabled extensions within a subparser.

indented :: Parser a -> Parser a

indented p is just like p, except that every token must not start in the first column.

thenIndented :: Parser a -> Parser a

indented p is just like p, except that every token after the first must not start in the first column.

Lexer

Basic lexemes

sc :: Parser ()

Generically consume whitespace, including comments.

lexeme :: Parser a -> Parser a

Parse a lexeme, that is, a parser followed by consuming whitespace.

symbol :: String -> Parser String

Parse a given string as a lexeme.

reservedOp :: String -> Parser ()

Parse a reserved operator.

natural :: Parser Integer

Parse a natural number.

reserved :: String -> Parser ()

Parse a reserved word.

reservedWords :: [String]

The list of all reserved words.

ident :: Parser (Name Term)

Parse an identifier and turn it into a Name.

Punctuation

parens :: Parser a -> Parser a

braces :: Parser a -> Parser a

angles :: Parser a -> Parser a

brackets :: Parser a -> Parser a

semi :: Parser String

comma :: Parser String

colon :: Parser String

dot :: Parser String

pipe :: Parser String

lambda :: Parser String

The symbol that starts an anonymous function (either a backslash or a Greek λ).

Disco parser

Modules

wholeModule :: LoadingMode -> Parser Module

Parse the entire input as a module (with leading whitespace and no leftovers).

parseModule :: LoadingMode -> Parser Module

Parse an entire module (a list of declarations ended by semicolons). The LoadingMode parameter tells us whether to include or replace any language extensions enabled at the top level. We include them when parsing a module entered at the REPL, and replace them when parsing a standalone module.

parseExtName :: Parser Ext

Parse the name of a language extension (case-insensitive).

parseTopLevel :: Parser TopLevel

Parse a top level item (either documentation or a declaration), which must start at the left margin.

parseDecl :: Parser Decl

Parse a single top-level declaration (either a type declaration or single definition clause).

parseImport :: Parser String

Parse an import, of the form import modulename.

parseModuleName :: Parser String

Parse the name of a module.

Terms

term :: Parser Term

Parse the entire input as a term (with leading whitespace and no leftovers).

parseTerm :: Parser Term

Parse a term, consisting of a parseTerm' optionally followed by an ascription.

parseTerm' :: Parser Term

Parse a non-atomic, non-ascribed term.

parseExpr :: Parser Term

Parse an expression built out of unary and binary operators.

parseAtom :: Parser Term

Parse an atomic term.

parseContainer :: Container -> Parser Term

Parse a container, like a literal list, set, bag, or a comprehension (not including the square or curly brackets).

container
  ::= '[' container-contents ']'
    | '{' container-contents '}'

container-contents
  ::= empty | nonempty-container

nonempty-container
  ::= term [ ellipsis ]
    | term container-end

container-end
  ::= '|' comprehension
    | ',' [ term (',' item)* ] [ ellipsis ]

comprehension ::= qual [ ',' qual ]*

qual
  ::= ident 'in' term
    | term

ellipsis ::= '..' [ term ]

parseEllipsis :: Parser (Ellipsis Term)

Parse an ellipsis at the end of a literal list, of the form .. t. Any number > 1 of dots may be used, just for fun.

parseContainerComp :: Container -> Term -> Parser Term

Parse the part of a list comprehension after the | (without square brackets), i.e. a list of qualifiers.

q [,q]*

parseQual :: Parser Qual

Parse a qualifier in a comprehension: either a binder x in t or a guard t.

parseLet :: Parser Term

Parse a let expression (let x1 = t1, x2 = t2, ... in t).

parseTypeOp :: Parser Term

Case and patterns

parseCase :: Parser Term

Parse a case expression.

parseBranch :: Parser Branch

Parse one branch of a case expression.

parseGuards :: Parser (Telescope Guard)

Parse the list of guards in a branch. otherwise can be used interchangeably with an empty list of guards.

parseGuard :: Parser Guard

Parse a single guard (if, if ... is, or let)

parsePattern :: Parser Pattern

Parse a pattern, by parsing a term and then attempting to convert it to a pattern.

parseAtomicPattern :: Parser Pattern

Parse an atomic pattern, by parsing a term and then attempting to convert it to a pattern.

Types

parseType :: Parser Type

Parse a type expression built out of binary operators.

parseAtomicType :: Parser Type

Parse an atomic type.

parsePolyTy :: Parser PolyType