Copyright	(c) The GHC Team 1997-2000 (c) Niklas Broberg 2004
License	BSD-style (see the file LICENSE.txt)
Maintainer	Niklas Broberg, d00nibro@chalmers.se
Stability	experimental
Portability	portable
Safe Haskell	Safe-Inferred
Language	Haskell98

Language.Haskell.Exts.Build

Contents

Syntax building functions
More advanced building

Description

This module contains combinators to use when building Haskell source trees programmatically, as opposed to parsing them from a string. The contents here are quite experimental and will likely receive a lot of attention when the rest has stabilised.

Synopsis

name :: String -> Name ()
sym :: String -> Name ()
var :: Name () -> Exp ()
op :: Name () -> QOp ()
qvar :: ModuleName () -> Name () -> Exp ()
pvar :: Name () -> Pat ()
app :: Exp () -> Exp () -> Exp ()
infixApp :: Exp () -> QOp () -> Exp () -> Exp ()
appFun :: Exp () -> [Exp ()] -> Exp ()
pApp :: Name () -> [Pat ()] -> Pat ()
tuple :: [Exp ()] -> Exp ()
pTuple :: [Pat ()] -> Pat ()
varTuple :: [Name ()] -> Exp ()
pvarTuple :: [Name ()] -> Pat ()
function :: String -> Exp ()
strE :: String -> Exp ()
charE :: Char -> Exp ()
intE :: Integer -> Exp ()
strP :: String -> Pat ()
charP :: Char -> Pat ()
intP :: Integer -> Pat ()
doE :: [Stmt ()] -> Exp ()
lamE :: [Pat ()] -> Exp () -> Exp ()
letE :: [Decl ()] -> Exp () -> Exp ()
caseE :: Exp () -> [Alt ()] -> Exp ()
alt :: Pat () -> Exp () -> Alt ()
altGW :: Pat () -> [Stmt ()] -> Exp () -> Binds () -> Alt ()
listE :: [Exp ()] -> Exp ()
eList :: Exp ()
peList :: Pat ()
paren :: Exp () -> Exp ()
pParen :: Pat () -> Pat ()
qualStmt :: Exp () -> Stmt ()
genStmt :: Pat () -> Exp () -> Stmt ()
letStmt :: [Decl ()] -> Stmt ()
binds :: [Decl ()] -> Binds ()
noBinds :: Maybe (Binds ())
wildcard :: Pat ()
genNames :: String -> Int -> [Name ()]
sfun :: Name () -> [Name ()] -> Rhs () -> Maybe (Binds ()) -> Decl ()
simpleFun :: Name () -> Name () -> Exp () -> Decl ()
patBind :: Pat () -> Exp () -> Decl ()
patBindWhere :: Pat () -> Exp () -> [Decl ()] -> Decl ()
nameBind :: Name () -> Exp () -> Decl ()
metaFunction :: String -> [Exp ()] -> Exp ()
metaConPat :: String -> [Pat ()] -> Pat ()

Syntax building functions

name :: String -> Name () #

An identifier with the given string as its name. The string should be a valid Haskell identifier.

sym :: String -> Name () #

A symbol identifier. The string should be a valid Haskell symbol identifier.

var :: Name () -> Exp () #

A local variable as expression.

op :: Name () -> QOp () #

Use the given identifier as an operator.

qvar :: ModuleName () -> Name () -> Exp () #

A qualified variable as expression.

pvar :: Name () -> Pat () #

A pattern variable.

app :: Exp () -> Exp () -> Exp () #

Application of expressions by juxtaposition.

infixApp :: Exp () -> QOp () -> Exp () -> Exp () #

Apply an operator infix.

appFun :: Exp () -> [Exp ()] -> Exp () #

Apply a function to a list of arguments.

pApp :: Name () -> [Pat ()] -> Pat () #

A constructor pattern, with argument patterns.

tuple :: [Exp ()] -> Exp () #

A tuple expression.

pTuple :: [Pat ()] -> Pat () #

A tuple pattern.

varTuple :: [Name ()] -> Exp () #

A tuple expression consisting of variables only.

pvarTuple :: [Name ()] -> Pat () #

A tuple pattern consisting of variables only.

function :: String -> Exp () #

A function with a given name.

strE :: String -> Exp () #

A literal string expression.

charE :: Char -> Exp () #

A literal character expression.

intE :: Integer -> Exp () #

A literal integer expression.

strP :: String -> Pat () #

A literal string pattern.

charP :: Char -> Pat () #

A literal character pattern.

intP :: Integer -> Pat () #

A literal integer pattern.

doE :: [Stmt ()] -> Exp () #

A do block formed by the given statements. The last statement in the list should be a Qualifier expression.

lamE :: [Pat ()] -> Exp () -> Exp () #

Lambda abstraction, given a list of argument patterns and an expression body.

letE :: [Decl ()] -> Exp () -> Exp () #

A let ... in block.

caseE :: Exp () -> [Alt ()] -> Exp () #

A case expression.

alt :: Pat () -> Exp () -> Alt () #

An unguarded alternative in a case expression.

altGW :: Pat () -> [Stmt ()] -> Exp () -> Binds () -> Alt () #

An alternative with a single guard in a case expression.

listE :: [Exp ()] -> Exp () #

A list expression.

eList :: Exp () #

The empty list expression.

peList :: Pat () #

The empty list pattern.

paren :: Exp () -> Exp () #

Put parentheses around an expression.

pParen :: Pat () -> Pat () #

Put parentheses around a pattern.

qualStmt :: Exp () -> Stmt () #

A qualifier expression statement.

genStmt :: Pat () -> Exp () -> Stmt () #

A generator statement: pat <- exp

letStmt :: [Decl ()] -> Stmt () #

A let binding group as a statement.

binds :: [Decl ()] -> Binds () #

Hoist a set of declarations to a binding group.

noBinds :: Maybe (Binds ()) #

An empty binding group.

wildcard :: Pat () #

The wildcard pattern: _

genNames :: String -> Int -> [Name ()] #

Generate k names by appending numbers 1 through k to a given string.

More advanced building

sfun :: Name () -> [Name ()] -> Rhs () -> Maybe (Binds ()) -> Decl () #

A function with a single clause

simpleFun :: Name () -> Name () -> Exp () -> Decl () #

A function with a single clause, a single argument, no guards and no where declarations

patBind :: Pat () -> Exp () -> Decl () #

A pattern bind where the pattern is a variable, and where there are no guards and no 'where' clause.

patBindWhere :: Pat () -> Exp () -> [Decl ()] -> Decl () #

A pattern bind where the pattern is a variable, and where there are no guards, but with a 'where' clause.

nameBind :: Name () -> Exp () -> Decl () #

Bind an identifier to an expression.

metaFunction :: String -> [Exp ()] -> Exp () #

Apply function of a given name to a list of arguments.

metaConPat :: String -> [Pat ()] -> Pat () #

Apply a constructor of a given name to a list of pattern arguments, forming a constructor pattern.