{-# OPTIONS_GHC -fglasgow-exts -cpp #-}
-----------------------------------------------------------------------------
-- |
-- Module : Language.Haskell.Syntax
-- Copyright : (c) The GHC Team, 1997-2000
-- License : BSD-style (see the file libraries/base/LICENSE)
--
-- Maintainer : libraries@haskell.org
-- Stability : experimental
-- Portability : portable
--
-- A suite of datatypes describing the abstract syntax of Haskell 98
-- <http://www.haskell.org/onlinereport/> plus a few extensions:
--
-- * multi-parameter type classes
--
-- * parameters of type class assertions are unrestricted
--
-- This module has been changed so that show is a real show.
-- For GHC, we also derive Typeable and Data for all types.
-----------------------------------------------------------------------------
module Language.Haskell.Syntax (
-- * Modules
HsModule(..), HsExportSpec(..),
HsImportDecl(..), HsImportSpec(..), HsAssoc(..),
-- * Declarations
HsDecl(..), HsConDecl(..), HsBangType(..),
HsMatch(..), HsRhs(..), HsGuardedRhs(..),
HsSafety(..),
-- * Class Assertions and Contexts
HsQualType(..), HsContext, HsAsst,
-- * Types
HsType(..),
-- * Expressions
HsExp(..), HsStmt(..), HsFieldUpdate(..),
HsAlt(..), HsGuardedAlts(..), HsGuardedAlt(..),
-- * Patterns
HsPat(..), HsPatField(..),
-- * Literals
HsLiteral(..),
-- * Variables, Constructors and Operators
Module(..), HsQName(..), HsName(..), HsQOp(..), HsOp(..),
HsSpecialCon(..), HsCName(..),
-- * Builtin names
-- ** Modules
prelude_mod, main_mod,
-- ** Main function of a program
main_name,
-- ** Constructors
unit_con_name, tuple_con_name, list_cons_name,
unit_con, tuple_con,
-- ** Type constructors
unit_tycon_name, fun_tycon_name, list_tycon_name, tuple_tycon_name,
unit_tycon, fun_tycon, list_tycon, tuple_tycon,
-- * Source coordinates
SrcLoc(..),
) where
#ifdef __GLASGOW_HASKELL__
import Data.Generics.Basics
import Data.Generics.Instances()
#endif
-- | A position in the source.
data SrcLoc = SrcLoc {
srcFilename :: String,
srcLine :: Int,
srcColumn :: Int
}
#ifdef __GLASGOW_HASKELL__
deriving (Eq,Ord,Show,Typeable,Data)
#else
deriving (Eq,Ord,Show)
#endif
-- | The name of a Haskell module.
newtype Module = Module String
#ifdef __GLASGOW_HASKELL__
deriving (Eq,Ord,Show,Typeable,Data)
#else
deriving (Eq,Ord,Show)
#endif
-- | Constructors with special syntax.
-- These names are never qualified, and always refer to builtin type or
-- data constructors.
data HsSpecialCon
= HsUnitCon -- ^ unit type and data constructor @()@
| HsListCon -- ^ list type constructor @[]@
| HsFunCon -- ^ function type constructor @->@
| HsTupleCon Int -- ^ /n/-ary tuple type and data
-- constructors @(,)@ etc
| HsCons -- ^ list data constructor @(:)@
#ifdef __GLASGOW_HASKELL__
deriving (Eq,Ord,Show,Typeable,Data)
#else
deriving (Eq,Ord,Show)
#endif
-- | This type is used to represent qualified variables, and also
-- qualified constructors.
data HsQName
= Qual Module HsName -- ^ name qualified with a module name
| UnQual HsName -- ^ unqualified name
| Special HsSpecialCon -- ^ built-in constructor with special syntax
#ifdef __GLASGOW_HASKELL__
deriving (Eq,Ord,Show,Typeable,Data)
#else
deriving (Eq,Ord,Show)
#endif
-- | This type is used to represent variables, and also constructors.
data HsName
= HsIdent String -- ^ /varid/ or /conid/
| HsSymbol String -- ^ /varsym/ or /consym/
#ifdef __GLASGOW_HASKELL__
deriving (Eq,Ord,Show,Typeable,Data)
#else
deriving (Eq,Ord,Show)
#endif
-- | Possibly qualified infix operators (/qop/), appearing in expressions.
data HsQOp
= HsQVarOp HsQName -- ^ variable operator (/qvarop/)
| HsQConOp HsQName -- ^ constructor operator (/qconop/)
#ifdef __GLASGOW_HASKELL__
deriving (Eq,Ord,Show,Typeable,Data)
#else
deriving (Eq,Ord,Show)
#endif
-- | Operators, appearing in @infix@ declarations.
data HsOp
= HsVarOp HsName -- ^ variable operator (/varop/)
| HsConOp HsName -- ^ constructor operator (/conop/)
#ifdef __GLASGOW_HASKELL__
deriving (Eq,Ord,Show,Typeable,Data)
#else
deriving (Eq,Ord,Show)
#endif
-- | A name (/cname/) of a component of a class or data type in an @import@
-- or export specification.
data HsCName
= HsVarName HsName -- ^ name of a method or field
| HsConName HsName -- ^ name of a data constructor
#ifdef __GLASGOW_HASKELL__
deriving (Eq,Ord,Show,Typeable,Data)
#else
deriving (Eq,Ord,Show)
#endif
-- | A Haskell source module.
data HsModule = HsModule SrcLoc Module (Maybe [HsExportSpec])
[HsImportDecl] [HsDecl]
#ifdef __GLASGOW_HASKELL__
deriving (Show,Typeable,Data)
#else
deriving (Show)
#endif
-- | Export specification.
data HsExportSpec
= HsEVar HsQName -- ^ variable
| HsEAbs HsQName -- ^ @T@:
-- a class or datatype exported abstractly,
-- or a type synonym.
| HsEThingAll HsQName -- ^ @T(..)@:
-- a class exported with all of its methods, or
-- a datatype exported with all of its constructors.
| HsEThingWith HsQName [HsCName] -- ^ @T(C_1,...,C_n)@:
-- a class exported with some of its methods, or
-- a datatype exported with some of its constructors.
| HsEModuleContents Module -- ^ @module M@:
-- re-export a module.
#ifdef __GLASGOW_HASKELL__
deriving (Eq,Show,Typeable,Data)
#else
deriving (Eq,Show)
#endif
-- | Import declaration.
data HsImportDecl = HsImportDecl
{ importLoc :: SrcLoc -- ^ position of the @import@ keyword.
, importModule :: Module -- ^ name of the module imported.
, importQualified :: Bool -- ^ imported @qualified@?
, importAs :: Maybe Module -- ^ optional alias name in an
-- @as@ clause.
, importSpecs :: Maybe (Bool,[HsImportSpec])
-- ^ optional list of import specifications.
-- The 'Bool' is 'True' if the names are excluded
-- by @hiding@.
}
#ifdef __GLASGOW_HASKELL__
deriving (Eq,Show,Typeable,Data)
#else
deriving (Eq,Show)
#endif
-- | Import specification.
data HsImportSpec
= HsIVar HsName -- ^ variable
| HsIAbs HsName -- ^ @T@:
-- the name of a class, datatype or type synonym.
| HsIThingAll HsName -- ^ @T(..)@:
-- a class imported with all of its methods, or
-- a datatype imported with all of its constructors.
| HsIThingWith HsName [HsCName] -- ^ @T(C_1,...,C_n)@:
-- a class imported with some of its methods, or
-- a datatype imported with some of its constructors.
#ifdef __GLASGOW_HASKELL__
deriving (Eq,Show,Typeable,Data)
#else
deriving (Eq,Show)
#endif
-- | Associativity of an operator.
data HsAssoc
= HsAssocNone -- ^ non-associative operator (declared with @infix@)
| HsAssocLeft -- ^ left-associative operator (declared with @infixl@).
| HsAssocRight -- ^ right-associative operator (declared with @infixr@)
#ifdef __GLASGOW_HASKELL__
deriving (Eq,Show,Typeable,Data)
#else
deriving (Eq,Show)
#endif
data HsDecl
= HsTypeDecl SrcLoc HsName [HsName] HsType
| HsDataDecl SrcLoc HsContext HsName [HsName] [HsConDecl] [HsQName]
| HsInfixDecl SrcLoc HsAssoc Int [HsOp]
| HsNewTypeDecl SrcLoc HsContext HsName [HsName] HsConDecl [HsQName]
| HsClassDecl SrcLoc HsContext HsName [HsName] [HsDecl]
| HsInstDecl SrcLoc HsContext HsQName [HsType] [HsDecl]
| HsDefaultDecl SrcLoc [HsType]
| HsTypeSig SrcLoc [HsName] HsQualType
| HsFunBind [HsMatch]
| HsPatBind SrcLoc HsPat HsRhs {-where-} [HsDecl]
| HsForeignImport SrcLoc String HsSafety String HsName HsType
| HsForeignExport SrcLoc String String HsName HsType
#ifdef __GLASGOW_HASKELL__
deriving (Eq,Show,Typeable,Data)
#else
deriving (Eq,Show)
#endif
-- | Clauses of a function binding.
data HsMatch
= HsMatch SrcLoc HsName [HsPat] HsRhs {-where-} [HsDecl]
#ifdef __GLASGOW_HASKELL__
deriving (Eq,Show,Typeable,Data)
#else
deriving (Eq,Show)
#endif
-- | Declaration of a data constructor.
data HsConDecl
= HsConDecl SrcLoc HsName [HsBangType]
-- ^ ordinary data constructor
| HsRecDecl SrcLoc HsName [([HsName],HsBangType)]
-- ^ record constructor
#ifdef __GLASGOW_HASKELL__
deriving (Eq,Show,Typeable,Data)
#else
deriving (Eq,Show)
#endif
-- | The type of a constructor argument or field, optionally including
-- a strictness annotation.
data HsBangType
= HsBangedTy HsType -- ^ strict component, marked with \"@!@\"
| HsUnBangedTy HsType -- ^ non-strict component
#ifdef __GLASGOW_HASKELL__
deriving (Eq,Show,Typeable,Data)
#else
deriving (Eq,Show)
#endif
-- | The right hand side of a function or pattern binding.
data HsRhs
= HsUnGuardedRhs HsExp -- ^ unguarded right hand side (/exp/)
| HsGuardedRhss [HsGuardedRhs]
-- ^ guarded right hand side (/gdrhs/)
#ifdef __GLASGOW_HASKELL__
deriving (Eq,Show,Typeable,Data)
#else
deriving (Eq,Show)
#endif
-- | A guarded right hand side @|@ /exp/ @=@ /exp/.
-- The first expression will be Boolean-valued.
data HsGuardedRhs
= HsGuardedRhs SrcLoc HsExp HsExp
#ifdef __GLASGOW_HASKELL__
deriving (Eq,Show,Typeable,Data)
#else
deriving (Eq,Show)
#endif
-- ^ Safety level for invoking a foreign entity
data HsSafety
= HsSafe -- ^ call may generate callbacks
| HsUnsafe -- ^ call will not generate callbacks
#ifdef __GLASGOW_HASKELL__
deriving (Eq,Ord,Show,Typeable,Data)
#else
deriving (Eq,Ord,Show)
#endif
-- | A type qualified with a context.
-- An unqualified type has an empty context.
data HsQualType
= HsQualType HsContext HsType
#ifdef __GLASGOW_HASKELL__
deriving (Eq,Show,Typeable,Data)
#else
deriving (Eq,Show)
#endif
-- | Haskell types and type constructors.
data HsType
= HsTyFun HsType HsType -- ^ function type
| HsTyTuple [HsType] -- ^ tuple type
| HsTyApp HsType HsType -- ^ application of a type constructor
| HsTyVar HsName -- ^ type variable
| HsTyCon HsQName -- ^ named type or type constructor
#ifdef __GLASGOW_HASKELL__
deriving (Eq,Show,Typeable,Data)
#else
deriving (Eq,Show)
#endif
type HsContext = [HsAsst]
-- | Class assertions.
-- In Haskell 98, the argument would be a /tyvar/, but this definition
-- allows multiple parameters, and allows them to be /type/s.
type HsAsst = (HsQName,[HsType])
-- | /literal/.
-- Values of this type hold the abstract value of the literal, not the
-- precise string representation used. For example, @10@, @0o12@ and @0xa@
-- have the same representation.
data HsLiteral
= HsChar Char -- ^ character literal
| HsString String -- ^ string literal
| HsInt Integer -- ^ integer literal
| HsFrac Rational -- ^ floating point literal
| HsCharPrim Char -- ^ GHC unboxed character literal
| HsStringPrim String -- ^ GHC unboxed string literal
| HsIntPrim Integer -- ^ GHC unboxed integer literal
| HsFloatPrim Rational -- ^ GHC unboxed float literal
| HsDoublePrim Rational -- ^ GHC unboxed double literal
#ifdef __GLASGOW_HASKELL__
deriving (Eq,Show,Typeable,Data)
#else
deriving (Eq,Show)
#endif
-- | Haskell expressions.
--
-- /Notes:/
--
-- * Because it is difficult for parsers to distinguish patterns from
-- expressions, they typically parse them in the same way and then check
-- that they have the appropriate form. Hence the expression type
-- includes some forms that are found only in patterns. After these
-- checks, these constructors should not be used.
--
-- * The parser does not take precedence and associativity into account,
-- so it will leave 'HsInfixApp's associated to the left.
--
-- * The 'Language.Haskell.Pretty.Pretty' instance for 'HsExp' does not
-- add parentheses in printing.
data HsExp
= HsVar HsQName -- ^ variable
| HsCon HsQName -- ^ data constructor
| HsLit HsLiteral -- ^ literal constant
| HsInfixApp HsExp HsQOp HsExp -- ^ infix application
| HsApp HsExp HsExp -- ^ ordinary application
| HsNegApp HsExp -- ^ negation expression @-@ /exp/
| HsLambda SrcLoc [HsPat] HsExp -- ^ lambda expression
| HsLet [HsDecl] HsExp -- ^ local declarations with @let@
| HsIf HsExp HsExp HsExp -- ^ @if@ /exp/ @then@ /exp/ @else@ /exp/
| HsCase HsExp [HsAlt] -- ^ @case@ /exp/ @of@ /alts/
| HsDo [HsStmt] -- ^ @do@-expression:
-- the last statement in the list
-- should be an expression.
| HsTuple [HsExp] -- ^ tuple expression
| HsList [HsExp] -- ^ list expression
| HsParen HsExp -- ^ parenthesized expression
| HsLeftSection HsExp HsQOp -- ^ left section @(@/exp/ /qop/@)@
| HsRightSection HsQOp HsExp -- ^ right section @(@/qop/ /exp/@)@
| HsRecConstr HsQName [HsFieldUpdate]
-- ^ record construction expression
| HsRecUpdate HsExp [HsFieldUpdate]
-- ^ record update expression
| HsEnumFrom HsExp -- ^ unbounded arithmetic sequence,
-- incrementing by 1
| HsEnumFromTo HsExp HsExp -- ^ bounded arithmetic sequence,
-- incrementing by 1
| HsEnumFromThen HsExp HsExp -- ^ unbounded arithmetic sequence,
-- with first two elements given
| HsEnumFromThenTo HsExp HsExp HsExp
-- ^ bounded arithmetic sequence,
-- with first two elements given
| HsListComp HsExp [HsStmt] -- ^ list comprehension
| HsExpTypeSig SrcLoc HsExp HsQualType
-- ^ expression type signature
| HsAsPat HsName HsExp -- ^ patterns only
| HsWildCard -- ^ patterns only
| HsIrrPat HsExp -- ^ patterns only
#ifdef __GLASGOW_HASKELL__
deriving (Eq,Show,Typeable,Data)
#else
deriving (Eq,Show)
#endif
-- | A pattern, to be matched against a value.
data HsPat
= HsPVar HsName -- ^ variable
| HsPLit HsLiteral -- ^ literal constant
| HsPNeg HsPat -- ^ negated pattern
| HsPInfixApp HsPat HsQName HsPat
-- ^ pattern with infix data constructor
| HsPApp HsQName [HsPat] -- ^ data constructor and argument
-- patterns
| HsPTuple [HsPat] -- ^ tuple pattern
| HsPList [HsPat] -- ^ list pattern
| HsPParen HsPat -- ^ parenthesized pattern
| HsPRec HsQName [HsPatField] -- ^ labelled pattern
| HsPAsPat HsName HsPat -- ^ @\@@-pattern
| HsPWildCard -- ^ wildcard pattern (@_@)
| HsPIrrPat HsPat -- ^ irrefutable pattern (@~@)
#ifdef __GLASGOW_HASKELL__
deriving (Eq,Show,Typeable,Data)
#else
deriving (Eq,Show)
#endif
-- | An /fpat/ in a labeled record pattern.
data HsPatField
= HsPFieldPat HsQName HsPat
#ifdef __GLASGOW_HASKELL__
deriving (Eq,Show,Typeable,Data)
#else
deriving (Eq,Show)
#endif
-- | This type represents both /stmt/ in a @do@-expression,
-- and /qual/ in a list comprehension.
data HsStmt
= HsGenerator SrcLoc HsPat HsExp
-- ^ a generator /pat/ @<-@ /exp/
| HsQualifier HsExp -- ^ an /exp/ by itself: in a @do@-expression,
-- an action whose result is discarded;
-- in a list comprehension, a guard expression
| HsLetStmt [HsDecl] -- ^ local bindings
#ifdef __GLASGOW_HASKELL__
deriving (Eq,Show,Typeable,Data)
#else
deriving (Eq,Show)
#endif
-- | An /fbind/ in a labeled record construction or update expression.
data HsFieldUpdate
= HsFieldUpdate HsQName HsExp
#ifdef __GLASGOW_HASKELL__
deriving (Eq,Show,Typeable,Data)
#else
deriving (Eq,Show)
#endif
-- | An /alt/ in a @case@ expression.
data HsAlt
= HsAlt SrcLoc HsPat HsGuardedAlts [HsDecl]
#ifdef __GLASGOW_HASKELL__
deriving (Eq,Show,Typeable,Data)
#else
deriving (Eq,Show)
#endif
data HsGuardedAlts
= HsUnGuardedAlt HsExp -- ^ @->@ /exp/
| HsGuardedAlts [HsGuardedAlt] -- ^ /gdpat/
#ifdef __GLASGOW_HASKELL__
deriving (Eq,Show,Typeable,Data)
#else
deriving (Eq,Show)
#endif
-- | A guarded alternative @|@ /exp/ @->@ /exp/.
-- The first expression will be Boolean-valued.
data HsGuardedAlt
= HsGuardedAlt SrcLoc HsExp HsExp
#ifdef __GLASGOW_HASKELL__
deriving (Eq,Show,Typeable,Data)
#else
deriving (Eq,Show)
#endif
-----------------------------------------------------------------------------
-- Builtin names.
prelude_mod, main_mod :: Module
prelude_mod = Module "Prelude"
main_mod = Module "Main"
main_name :: HsName
main_name = HsIdent "main"
unit_con_name :: HsQName
unit_con_name = Special HsUnitCon
tuple_con_name :: Int -> HsQName
tuple_con_name i = Special (HsTupleCon (i+1))
list_cons_name :: HsQName
list_cons_name = Special HsCons
unit_con :: HsExp
unit_con = HsCon unit_con_name
tuple_con :: Int -> HsExp
tuple_con i = HsCon (tuple_con_name i)
unit_tycon_name, fun_tycon_name, list_tycon_name :: HsQName
unit_tycon_name = unit_con_name
fun_tycon_name = Special HsFunCon
list_tycon_name = Special HsListCon
tuple_tycon_name :: Int -> HsQName
tuple_tycon_name i = tuple_con_name i
unit_tycon, fun_tycon, list_tycon :: HsType
unit_tycon = HsTyCon unit_tycon_name
fun_tycon = HsTyCon fun_tycon_name
list_tycon = HsTyCon list_tycon_name
tuple_tycon :: Int -> HsType
tuple_tycon i = HsTyCon (tuple_tycon_name i)
|
