Language.PureScript.Declarations

Data types for modules and declarations

Documentation

type Precedence = Integer

A precedence level for an infix operator

data Associativity

Associativity for infix operators

Constructors

Infixl

Infixr

Infix

Instances

Data Associativity

Show Associativity

Typeable * Associativity

data SourcePos

Source position information

Constructors

SourcePos

Fields

sourceName :: String

Source name

sourcePosLine :: Int

Line number

sourcePosColumn :: Int

Column number

Instances

Data SourcePos

Show SourcePos

Typeable * SourcePos

data Fixity

Fixity data for infix operators

Constructors

Fixity Associativity Precedence

Instances

Data Fixity

Show Fixity

Typeable * Fixity

data Module

A module declaration, consisting of a module name, a list of declarations, and a list of the declarations that are explicitly exported. If the export list is Nothing, everything is exported.

Constructors

Module ModuleName [Declaration] (Maybe [DeclarationRef])

Instances

Data Module

Show Module

Typeable * Module

data DeclarationRef

An item in a list of explicit imports or exports

Constructors

TypeRef ProperName (Maybe [ProperName])

A type constructor with data constructors

ValueRef Ident

A value

TypeClassRef ProperName

A type class

TypeInstanceRef Ident

A type class instance, created during typeclass desugaring (name, class name, instance types)

PositionedDeclarationRef SourcePos DeclarationRef

A declaration reference with source position information

Instances

Eq DeclarationRef

Data DeclarationRef

Show DeclarationRef

Typeable * DeclarationRef

data ImportDeclarationType

The data type which specifies type of import declaration

Constructors

Unqualified

Unqualified import

Qualifying [DeclarationRef]

Qualified import with a list of references to import

Hiding [DeclarationRef]

Import with hiding clause with a list of references to hide

Instances

Data ImportDeclarationType

Show ImportDeclarationType

Typeable * ImportDeclarationType

data Declaration

The data type of declarations

Constructors

DataDeclaration DataDeclType ProperName [String] [(ProperName, [Type])]

A data type declaration (data or newtype, name, arguments, data constructors)

DataBindingGroupDeclaration [Declaration]

A minimal mutually recursive set of data type declarations

TypeSynonymDeclaration ProperName [String] Type

A type synonym declaration (name, arguments, type)

TypeDeclaration Ident Type

A type declaration for a value (name, ty)

ValueDeclaration Ident NameKind [Binder] (Maybe Guard) Expr

A value declaration (name, top-level binders, optional guard, value)

BindingGroupDeclaration [(Ident, NameKind, Expr)]

A minimal mutually recursive set of value declarations

ExternDeclaration ForeignImportType Ident (Maybe JS) Type

A foreign import declaration (type, name, optional inline Javascript, type)

ExternDataDeclaration ProperName Kind

A data type foreign import (name, kind)

ExternInstanceDeclaration Ident [(Qualified ProperName, [Type])] (Qualified ProperName) [Type]

A type class instance foreign import

FixityDeclaration Fixity String

A fixity declaration (fixity data, operator name)

ImportDeclaration ModuleName ImportDeclarationType (Maybe ModuleName)

A module import (module name, optional set of identifiers to import, optional set of identifiers to hide, optional "qualified as" name)

TypeClassDeclaration ProperName [String] [(Qualified ProperName, [Type])] [Declaration]

A type class declaration (name, argument, implies, member declarations)

TypeInstanceDeclaration Ident [(Qualified ProperName, [Type])] (Qualified ProperName) [Type] [Declaration]

A type instance declaration (name, dependencies, class name, instance types, member declarations)

PositionedDeclaration SourcePos Declaration

A declaration with source position information

Instances

Data Declaration

Show Declaration

Typeable * Declaration

isValueDecl :: Declaration -> Bool

Test if a declaration is a value declaration

isDataDecl :: Declaration -> Bool

Test if a declaration is a data type or type synonym declaration

isImportDecl :: Declaration -> Bool

Test if a declaration is a module import

isExternDataDecl :: Declaration -> Bool

Test if a declaration is a data type foreign import

isExternInstanceDecl :: Declaration -> Bool

Test if a declaration is a type class instance foreign import

isFixityDecl :: Declaration -> Bool

Test if a declaration is a fixity declaration

isExternDecl :: Declaration -> Bool

Test if a declaration is a foreign import

isTypeClassDeclaration :: Declaration -> Bool

Test if a declaration is a type class or instance declaration

type Guard = Expr

A guard is just a boolean-valued expression that appears alongside a set of binders

data Expr

Data type for expressions and terms

Constructors

NumericLiteral (Either Integer Double)

A numeric literal

StringLiteral String

A string literal

BooleanLiteral Bool

A boolean literal

UnaryMinus Expr

A prefix -, will be desugared

BinaryNoParens (Qualified Ident) Expr Expr

Binary operator application. During the rebracketing phase of desugaring, this data constructor will be removed.

Parens Expr

Explicit parentheses. During the rebracketing phase of desugaring, this data constructor will be removed.

ArrayLiteral [Expr]

An array literal

ObjectLiteral [(String, Expr)]

An object literal

Accessor String Expr

An record property accessor expression

ObjectUpdate Expr [(String, Expr)]

Partial record update

Abs (Either Ident Binder) Expr

Function introduction

App Expr Expr

Function application

Var (Qualified Ident)

Variable

IfThenElse Expr Expr Expr

Conditional (if-then-else expression)

Constructor (Qualified ProperName)

A data constructor

Case [Expr] [CaseAlternative]

A case expression. During the case expansion phase of desugaring, top-level binders will get desugared into case expressions, hence the need for guards and multiple binders per branch here.

TypedValue Bool Expr Type

A value with a type annotation

Let [Declaration] Expr

A let binding

Do [DoNotationElement]

A do-notation block

TypeClassDictionaryConstructorApp (Qualified ProperName) Expr

An application of a typeclass dictionary constructor. The value should be an ObjectLiteral.

TypeClassDictionary Bool (Qualified ProperName, [Type]) [TypeClassDictionaryInScope]

A placeholder for a type class dictionary to be inserted later. At the end of type checking, these placeholders will be replaced with actual expressions representing type classes dictionaries which can be evaluated at runtime. The constructor arguments represent (in order): whether or not to look at superclass implementations when searching for a dictionary, the type class name and instance type, and the type class dictionaries in scope.

SuperClassDictionary (Qualified ProperName) [Type]

A placeholder for a superclass dictionary to be turned into a TypeClassDictionary during typechecking

PositionedValue SourcePos Expr

A value with source position information

Instances

Data Expr

Show Expr

Typeable * Expr

data CaseAlternative

An alternative in a case statement

Constructors

CaseAlternative

Fields

caseAlternativeBinders :: [Binder]

A collection of binders with which to match the inputs

caseAlternativeGuard :: Maybe Guard

An optional guard

caseAlternativeResult :: Expr

The result expression

Instances

Data CaseAlternative

Show CaseAlternative

Typeable * CaseAlternative

canonicalizeDictionary :: TypeClassDictionaryInScope -> Qualified Ident

Find the original dictionary which a type class dictionary in scope refers to

data DoNotationElement

A statement in a do-notation block

Constructors

DoNotationValue Expr

A monadic value without a binder

DoNotationBind Binder Expr

A monadic value with a binder

DoNotationLet [Declaration]

A let statement, i.e. a pure value with a binder

PositionedDoNotationElement SourcePos DoNotationElement

A do notation element with source position information

Instances

Data DoNotationElement

Show DoNotationElement

Typeable * DoNotationElement

data Binder

Data type for binders

Constructors

NullBinder

Wildcard binder

BooleanBinder Bool

A binder which matches a boolean literal

StringBinder String

A binder which matches a string literal

NumberBinder (Either Integer Double)

A binder which matches a numeric literal

VarBinder Ident

A binder which binds an identifier

ConstructorBinder (Qualified ProperName) [Binder]

A binder which matches a data constructor

ObjectBinder [(String, Binder)]

A binder which matches a record and binds its properties

ArrayBinder [Binder]

A binder which matches an array and binds its elements

ConsBinder Binder Binder

A binder which matches an array and binds its head and tail

NamedBinder Ident Binder

A binder which binds its input to an identifier

PositionedBinder SourcePos Binder

A binder with source position information

Instances

Data Binder

Show Binder

Typeable * Binder

binderNames :: Binder -> [Ident]

Collect all names introduced in binders in an expression

everywhereOnValues :: (Declaration -> Declaration) -> (Expr -> Expr) -> (Binder -> Binder) -> (Declaration -> Declaration, Expr -> Expr, Binder -> Binder)

everywhereOnValuesTopDownM :: (Functor m, Applicative m, Monad m) => (Declaration -> m Declaration) -> (Expr -> m Expr) -> (Binder -> m Binder) -> (Declaration -> m Declaration, Expr -> m Expr, Binder -> m Binder)

everywhereOnValuesM :: (Functor m, Applicative m, Monad m) => (Declaration -> m Declaration) -> (Expr -> m Expr) -> (Binder -> m Binder) -> (Declaration -> m Declaration, Expr -> m Expr, Binder -> m Binder)

everythingOnValues :: (r -> r -> r) -> (Declaration -> r) -> (Expr -> r) -> (Binder -> r) -> (CaseAlternative -> r) -> (DoNotationElement -> r) -> (Declaration -> r, Expr -> r, Binder -> r, CaseAlternative -> r, DoNotationElement -> r)

everythingWithContextOnValues :: s -> r -> (r -> r -> r) -> (s -> Declaration -> (s, r)) -> (s -> Expr -> (s, r)) -> (s -> Binder -> (s, r)) -> (s -> CaseAlternative -> (s, r)) -> (s -> DoNotationElement -> (s, r)) -> (Declaration -> r, Expr -> r, Binder -> r, CaseAlternative -> r, DoNotationElement -> r)

everywhereWithContextOnValuesM :: (Functor m, Applicative m, Monad m) => s -> (s -> Declaration -> m (s, Declaration)) -> (s -> Expr -> m (s, Expr)) -> (s -> Binder -> m (s, Binder)) -> (s -> CaseAlternative -> m (s, CaseAlternative)) -> (s -> DoNotationElement -> m (s, DoNotationElement)) -> (Declaration -> m Declaration, Expr -> m Expr, Binder -> m Binder, CaseAlternative -> m CaseAlternative, DoNotationElement -> m DoNotationElement)

accumTypes :: Monoid r => (Type -> r) -> (Declaration -> r, Expr -> r, Binder -> r, CaseAlternative -> r, DoNotationElement -> r)