Copyright	(c) Henrique Ferreiro García 2008 (c) David Castro Pérez 2008
License	BSD-style (see the file LICENSE)
Maintainer	Alex Kropivny <alex.kropivny@gmail.com>
Stability	experimental
Portability	portable
Safe Haskell	Safe
Language	Haskell98

Language.CoreErlang.Syntax

Contents

Modules
Declarations
Expressions
Patterns
Literals
Variables
Annotations

Description

A suite of datatypes describing the abstract syntax of CoreErlang 1.0.3. http://www.it.uu.se/research/group/hipe/cerl/

Synopsis

Modules

data Module Source #

A CoreErlang source module.

Constructors

Module Atom [Function] [(Atom, Const)] [FunDef]

Instances

Eq Module Source #
Methods (==) :: Module -> Module -> Bool # (/=) :: Module -> Module -> Bool #
Data Module Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Module -> c Module # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Module # toConstr :: Module -> Constr # dataTypeOf :: Module -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Module) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module) # gmapT :: (forall b. Data b => b -> b) -> Module -> Module # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r # gmapQ :: (forall d. Data d => d -> u) -> Module -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Module -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Module -> m Module # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Module -> m Module # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Module -> m Module #
Ord Module Source #
Methods compare :: Module -> Module -> Ordering # (<) :: Module -> Module -> Bool # (<=) :: Module -> Module -> Bool # (>) :: Module -> Module -> Bool # (>=) :: Module -> Module -> Bool # max :: Module -> Module -> Module # min :: Module -> Module -> Module #
Show Module Source #
Methods showsPrec :: Int -> Module -> ShowS # show :: Module -> String # showList :: [Module] -> ShowS #
Pretty Module Source #
Methods pretty :: Module -> Doc prettyPrec :: Int -> Module -> Doc

Declarations

data FunDef Source #

This type is used to represent lambdas

Constructors

FunDef (Ann Function) (Ann Exp)

Instances

Eq FunDef Source #
Methods (==) :: FunDef -> FunDef -> Bool # (/=) :: FunDef -> FunDef -> Bool #
Data FunDef Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FunDef -> c FunDef # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FunDef # toConstr :: FunDef -> Constr # dataTypeOf :: FunDef -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c FunDef) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FunDef) # gmapT :: (forall b. Data b => b -> b) -> FunDef -> FunDef # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FunDef -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FunDef -> r # gmapQ :: (forall d. Data d => d -> u) -> FunDef -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> FunDef -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FunDef -> m FunDef # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FunDef -> m FunDef # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FunDef -> m FunDef #
Ord FunDef Source #
Methods compare :: FunDef -> FunDef -> Ordering # (<) :: FunDef -> FunDef -> Bool # (<=) :: FunDef -> FunDef -> Bool # (>) :: FunDef -> FunDef -> Bool # (>=) :: FunDef -> FunDef -> Bool # max :: FunDef -> FunDef -> FunDef # min :: FunDef -> FunDef -> FunDef #
Show FunDef Source #
Methods showsPrec :: Int -> FunDef -> ShowS # show :: FunDef -> String # showList :: [FunDef] -> ShowS #
Pretty FunDef Source #
Methods pretty :: FunDef -> Doc prettyPrec :: Int -> FunDef -> Doc

Expressions

data Exp Source #

CoreErlang expression.

Constructors

Var Var	variable
Lit Literal	literal constant
Fun Function	function name
App Exps [Exps]	application
ModCall (Exps, Exps) [Exps]	module call
Lambda [Var] Exps	lambda expression
Seq Exps Exps	sequencing
Let ([Var], Exps) Exps	local declaration
LetRec [FunDef] Exps	letrec expression
Case Exps [Ann Alt]	`case` exp `of` alts end
Tuple [Exps]	tuple expression
List (List Exps)	list expression
Binary [BitString Exps]	binary expression
Op Atom [Exps]	operator application
Try Exps ([Var], Exps) ([Var], Exps)	try expression
Rec [Ann Alt] TimeOut	receive expression
Catch Exps	catch expression

Instances

Eq Exp Source #
Methods (==) :: Exp -> Exp -> Bool # (/=) :: Exp -> Exp -> Bool #
Data Exp Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Exp -> c Exp # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Exp # toConstr :: Exp -> Constr # dataTypeOf :: Exp -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Exp) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Exp) # gmapT :: (forall b. Data b => b -> b) -> Exp -> Exp # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r # gmapQ :: (forall d. Data d => d -> u) -> Exp -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Exp -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Exp -> m Exp # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Exp -> m Exp # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Exp -> m Exp #
Ord Exp Source #
Methods compare :: Exp -> Exp -> Ordering # (<) :: Exp -> Exp -> Bool # (<=) :: Exp -> Exp -> Bool # (>) :: Exp -> Exp -> Bool # (>=) :: Exp -> Exp -> Bool # max :: Exp -> Exp -> Exp # min :: Exp -> Exp -> Exp #
Show Exp Source #
Methods showsPrec :: Int -> Exp -> ShowS # show :: Exp -> String # showList :: [Exp] -> ShowS #
Pretty Exp Source #
Methods pretty :: Exp -> Doc prettyPrec :: Int -> Exp -> Doc

data Exps Source #

CoreErlang expressions.

Constructors

Exp (Ann Exp)	single expression
Exps (Ann [Ann Exp])	list of expressions

Instances

Eq Exps Source #
Methods (==) :: Exps -> Exps -> Bool # (/=) :: Exps -> Exps -> Bool #
Data Exps Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Exps -> c Exps # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Exps # toConstr :: Exps -> Constr # dataTypeOf :: Exps -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Exps) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Exps) # gmapT :: (forall b. Data b => b -> b) -> Exps -> Exps # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Exps -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Exps -> r # gmapQ :: (forall d. Data d => d -> u) -> Exps -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Exps -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Exps -> m Exps # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Exps -> m Exps # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Exps -> m Exps #
Ord Exps Source #
Methods compare :: Exps -> Exps -> Ordering # (<) :: Exps -> Exps -> Bool # (<=) :: Exps -> Exps -> Bool # (>) :: Exps -> Exps -> Bool # (>=) :: Exps -> Exps -> Bool # max :: Exps -> Exps -> Exps # min :: Exps -> Exps -> Exps #
Show Exps Source #
Methods showsPrec :: Int -> Exps -> ShowS # show :: Exps -> String # showList :: [Exps] -> ShowS #
Pretty Exps Source #
Methods pretty :: Exps -> Doc prettyPrec :: Int -> Exps -> Doc

data Alt Source #

An alt in a case expression

Constructors

Alt Pats Guard Exps

Instances

Eq Alt Source #
Methods (==) :: Alt -> Alt -> Bool # (/=) :: Alt -> Alt -> Bool #
Data Alt Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Alt -> c Alt # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Alt # toConstr :: Alt -> Constr # dataTypeOf :: Alt -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Alt) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Alt) # gmapT :: (forall b. Data b => b -> b) -> Alt -> Alt # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alt -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Alt -> r # gmapQ :: (forall d. Data d => d -> u) -> Alt -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Alt -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Alt -> m Alt # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Alt -> m Alt # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Alt -> m Alt #
Ord Alt Source #
Methods compare :: Alt -> Alt -> Ordering # (<) :: Alt -> Alt -> Bool # (<=) :: Alt -> Alt -> Bool # (>) :: Alt -> Alt -> Bool # (>=) :: Alt -> Alt -> Bool # max :: Alt -> Alt -> Alt # min :: Alt -> Alt -> Alt #
Show Alt Source #
Methods showsPrec :: Int -> Alt -> ShowS # show :: Alt -> String # showList :: [Alt] -> ShowS #
Pretty Alt Source #
Methods pretty :: Alt -> Doc prettyPrec :: Int -> Alt -> Doc

data Guard Source #

A guarded alternative when exp -> exp. The first expression will be Boolean-valued.

Constructors

Guard Exps

Instances

Eq Guard Source #
Methods (==) :: Guard -> Guard -> Bool # (/=) :: Guard -> Guard -> Bool #
Data Guard Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Guard -> c Guard # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Guard # toConstr :: Guard -> Constr # dataTypeOf :: Guard -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Guard) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Guard) # gmapT :: (forall b. Data b => b -> b) -> Guard -> Guard # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Guard -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Guard -> r # gmapQ :: (forall d. Data d => d -> u) -> Guard -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Guard -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Guard -> m Guard # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Guard -> m Guard # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Guard -> m Guard #
Ord Guard Source #
Methods compare :: Guard -> Guard -> Ordering # (<) :: Guard -> Guard -> Bool # (<=) :: Guard -> Guard -> Bool # (>) :: Guard -> Guard -> Bool # (>=) :: Guard -> Guard -> Bool # max :: Guard -> Guard -> Guard # min :: Guard -> Guard -> Guard #
Show Guard Source #
Methods showsPrec :: Int -> Guard -> ShowS # show :: Guard -> String # showList :: [Guard] -> ShowS #
Pretty Guard Source #
Methods pretty :: Guard -> Doc prettyPrec :: Int -> Guard -> Doc

data List a Source #

A list of expressions

Constructors

L [a]
LL [a] a

Instances

Eq a => Eq (List a) Source #
Methods (==) :: List a -> List a -> Bool # (/=) :: List a -> List a -> Bool #
Data a => Data (List a) Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> List a -> c (List a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (List a) # toConstr :: List a -> Constr # dataTypeOf :: List a -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c (List a)) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (List a)) # gmapT :: (forall b. Data b => b -> b) -> List a -> List a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> List a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> List a -> r # gmapQ :: (forall d. Data d => d -> u) -> List a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> List a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> List a -> m (List a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> List a -> m (List a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> List a -> m (List a) #
Ord a => Ord (List a) Source #
Methods compare :: List a -> List a -> Ordering # (<) :: List a -> List a -> Bool # (<=) :: List a -> List a -> Bool # (>) :: List a -> List a -> Bool # (>=) :: List a -> List a -> Bool # max :: List a -> List a -> List a # min :: List a -> List a -> List a #
Show a => Show (List a) Source #
Methods showsPrec :: Int -> List a -> ShowS # show :: List a -> String # showList :: [List a] -> ShowS #
Pretty a => Pretty (List a) Source #
Methods pretty :: List a -> Doc prettyPrec :: Int -> List a -> Doc

data TimeOut Source #

The timeout of a receive expression

Constructors

TimeOut Exps Exps

Instances

Eq TimeOut Source #
Methods (==) :: TimeOut -> TimeOut -> Bool # (/=) :: TimeOut -> TimeOut -> Bool #
Data TimeOut Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TimeOut -> c TimeOut # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TimeOut # toConstr :: TimeOut -> Constr # dataTypeOf :: TimeOut -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c TimeOut) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TimeOut) # gmapT :: (forall b. Data b => b -> b) -> TimeOut -> TimeOut # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TimeOut -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TimeOut -> r # gmapQ :: (forall d. Data d => d -> u) -> TimeOut -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TimeOut -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TimeOut -> m TimeOut # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TimeOut -> m TimeOut # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TimeOut -> m TimeOut #
Ord TimeOut Source #
Methods compare :: TimeOut -> TimeOut -> Ordering # (<) :: TimeOut -> TimeOut -> Bool # (<=) :: TimeOut -> TimeOut -> Bool # (>) :: TimeOut -> TimeOut -> Bool # (>=) :: TimeOut -> TimeOut -> Bool # max :: TimeOut -> TimeOut -> TimeOut # min :: TimeOut -> TimeOut -> TimeOut #
Show TimeOut Source #
Methods showsPrec :: Int -> TimeOut -> ShowS # show :: TimeOut -> String # showList :: [TimeOut] -> ShowS #
Pretty TimeOut Source #
Methods pretty :: TimeOut -> Doc prettyPrec :: Int -> TimeOut -> Doc

data BitString a Source #

A bitstring.

Constructors

BitString a [Exps]

Instances

Eq a => Eq (BitString a) Source #
Methods (==) :: BitString a -> BitString a -> Bool # (/=) :: BitString a -> BitString a -> Bool #
Data a => Data (BitString a) Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> BitString a -> c (BitString a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (BitString a) # toConstr :: BitString a -> Constr # dataTypeOf :: BitString a -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c (BitString a)) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (BitString a)) # gmapT :: (forall b. Data b => b -> b) -> BitString a -> BitString a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BitString a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BitString a -> r # gmapQ :: (forall d. Data d => d -> u) -> BitString a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> BitString a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> BitString a -> m (BitString a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> BitString a -> m (BitString a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> BitString a -> m (BitString a) #
Ord a => Ord (BitString a) Source #
Methods compare :: BitString a -> BitString a -> Ordering # (<) :: BitString a -> BitString a -> Bool # (<=) :: BitString a -> BitString a -> Bool # (>) :: BitString a -> BitString a -> Bool # (>=) :: BitString a -> BitString a -> Bool # max :: BitString a -> BitString a -> BitString a # min :: BitString a -> BitString a -> BitString a #
Show a => Show (BitString a) Source #
Methods showsPrec :: Int -> BitString a -> ShowS # show :: BitString a -> String # showList :: [BitString a] -> ShowS #
Pretty a => Pretty (BitString a) Source #
Methods pretty :: BitString a -> Doc prettyPrec :: Int -> BitString a -> Doc

data Function Source #

This type is used to represent function names

Constructors

Function (Atom, Integer)

Instances

Eq Function Source #
Methods (==) :: Function -> Function -> Bool # (/=) :: Function -> Function -> Bool #
Data Function Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Function -> c Function # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Function # toConstr :: Function -> Constr # dataTypeOf :: Function -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Function) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Function) # gmapT :: (forall b. Data b => b -> b) -> Function -> Function # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Function -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Function -> r # gmapQ :: (forall d. Data d => d -> u) -> Function -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Function -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Function -> m Function # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Function -> m Function # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Function -> m Function #
Ord Function Source #
Methods compare :: Function -> Function -> Ordering # (<) :: Function -> Function -> Bool # (<=) :: Function -> Function -> Bool # (>) :: Function -> Function -> Bool # (>=) :: Function -> Function -> Bool # max :: Function -> Function -> Function # min :: Function -> Function -> Function #
Show Function Source #
Methods showsPrec :: Int -> Function -> ShowS # show :: Function -> String # showList :: [Function] -> ShowS #
Pretty Function Source #
Methods pretty :: Function -> Doc prettyPrec :: Int -> Function -> Doc

Patterns

data Pats Source #

Constructors

Pat Pat	single pattern
Pats [Pat]	list of patterns

Instances

Eq Pats Source #
Methods (==) :: Pats -> Pats -> Bool # (/=) :: Pats -> Pats -> Bool #
Data Pats Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Pats -> c Pats # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Pats # toConstr :: Pats -> Constr # dataTypeOf :: Pats -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Pats) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pats) # gmapT :: (forall b. Data b => b -> b) -> Pats -> Pats # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pats -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pats -> r # gmapQ :: (forall d. Data d => d -> u) -> Pats -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Pats -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Pats -> m Pats # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Pats -> m Pats # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Pats -> m Pats #
Ord Pats Source #
Methods compare :: Pats -> Pats -> Ordering # (<) :: Pats -> Pats -> Bool # (<=) :: Pats -> Pats -> Bool # (>) :: Pats -> Pats -> Bool # (>=) :: Pats -> Pats -> Bool # max :: Pats -> Pats -> Pats # min :: Pats -> Pats -> Pats #
Show Pats Source #
Methods showsPrec :: Int -> Pats -> ShowS # show :: Pats -> String # showList :: [Pats] -> ShowS #
Pretty Pats Source #
Methods pretty :: Pats -> Doc prettyPrec :: Int -> Pats -> Doc

data Pat Source #

A pattern, to be matched against a value.

Constructors

PVar Var	variable
PLit Literal	literal constant
PTuple [Pat]	tuple pattern
PList (List Pat)	list pattern
PBinary [BitString Pat]	list of bitstring patterns
PAlias Alias	alias pattern

Instances

Eq Pat Source #
Methods (==) :: Pat -> Pat -> Bool # (/=) :: Pat -> Pat -> Bool #
Data Pat Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Pat -> c Pat # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Pat # toConstr :: Pat -> Constr # dataTypeOf :: Pat -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Pat) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pat) # gmapT :: (forall b. Data b => b -> b) -> Pat -> Pat # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r # gmapQ :: (forall d. Data d => d -> u) -> Pat -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Pat -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Pat -> m Pat # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Pat -> m Pat # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Pat -> m Pat #
Ord Pat Source #
Methods compare :: Pat -> Pat -> Ordering # (<) :: Pat -> Pat -> Bool # (<=) :: Pat -> Pat -> Bool # (>) :: Pat -> Pat -> Bool # (>=) :: Pat -> Pat -> Bool # max :: Pat -> Pat -> Pat # min :: Pat -> Pat -> Pat #
Show Pat Source #
Methods showsPrec :: Int -> Pat -> ShowS # show :: Pat -> String # showList :: [Pat] -> ShowS #
Pretty Pat Source #
Methods pretty :: Pat -> Doc prettyPrec :: Int -> Pat -> Doc

data Alias Source #

An alias, used in patterns

Constructors

Alias Var Pat

Instances

Eq Alias Source #
Methods (==) :: Alias -> Alias -> Bool # (/=) :: Alias -> Alias -> Bool #
Data Alias Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Alias -> c Alias # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Alias # toConstr :: Alias -> Constr # dataTypeOf :: Alias -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Alias) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Alias) # gmapT :: (forall b. Data b => b -> b) -> Alias -> Alias # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alias -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Alias -> r # gmapQ :: (forall d. Data d => d -> u) -> Alias -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Alias -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Alias -> m Alias # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Alias -> m Alias # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Alias -> m Alias #
Ord Alias Source #
Methods compare :: Alias -> Alias -> Ordering # (<) :: Alias -> Alias -> Bool # (<=) :: Alias -> Alias -> Bool # (>) :: Alias -> Alias -> Bool # (>=) :: Alias -> Alias -> Bool # max :: Alias -> Alias -> Alias # min :: Alias -> Alias -> Alias #
Show Alias Source #
Methods showsPrec :: Int -> Alias -> ShowS # show :: Alias -> String # showList :: [Alias] -> ShowS #
Pretty Alias Source #
Methods pretty :: Alias -> Doc prettyPrec :: Int -> Alias -> Doc

Literals

data Literal Source #

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.

Constructors

LChar Char	character literal
LString String	string literal
LInt Integer	integer literal
LFloat Double	floating point literal
LAtom Atom	atom literal
LNil	empty list

Instances

Eq Literal Source #
Methods (==) :: Literal -> Literal -> Bool # (/=) :: Literal -> Literal -> Bool #
Data Literal Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Literal -> c Literal # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Literal # toConstr :: Literal -> Constr # dataTypeOf :: Literal -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Literal) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Literal) # gmapT :: (forall b. Data b => b -> b) -> Literal -> Literal # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Literal -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Literal -> r # gmapQ :: (forall d. Data d => d -> u) -> Literal -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Literal -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Literal -> m Literal # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Literal -> m Literal # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Literal -> m Literal #
Ord Literal Source #
Methods compare :: Literal -> Literal -> Ordering # (<) :: Literal -> Literal -> Bool # (<=) :: Literal -> Literal -> Bool # (>) :: Literal -> Literal -> Bool # (>=) :: Literal -> Literal -> Bool # max :: Literal -> Literal -> Literal # min :: Literal -> Literal -> Literal #
Show Literal Source #
Methods showsPrec :: Int -> Literal -> ShowS # show :: Literal -> String # showList :: [Literal] -> ShowS #
Pretty Literal Source #
Methods pretty :: Literal -> Doc prettyPrec :: Int -> Literal -> Doc

data Const Source #

This type is used to represent constants

Constructors

CLit Literal
CTuple [Const]
CList (List Const)

Instances

Eq Const Source #
Methods (==) :: Const -> Const -> Bool # (/=) :: Const -> Const -> Bool #
Data Const Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Const -> c Const # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Const # toConstr :: Const -> Constr # dataTypeOf :: Const -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Const) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Const) # gmapT :: (forall b. Data b => b -> b) -> Const -> Const # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Const -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Const -> r # gmapQ :: (forall d. Data d => d -> u) -> Const -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Const -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Const -> m Const # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Const -> m Const # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Const -> m Const #
Ord Const Source #
Methods compare :: Const -> Const -> Ordering # (<) :: Const -> Const -> Bool # (<=) :: Const -> Const -> Bool # (>) :: Const -> Const -> Bool # (>=) :: Const -> Const -> Bool # max :: Const -> Const -> Const # min :: Const -> Const -> Const #
Show Const Source #
Methods showsPrec :: Int -> Const -> ShowS # show :: Const -> String # showList :: [Const] -> ShowS #
Pretty Const Source #
Methods pretty :: Const -> Doc prettyPrec :: Int -> Const -> Doc

data Atom Source #

This type is used to represent atoms

Constructors

Atom String

Instances

Eq Atom Source #
Methods (==) :: Atom -> Atom -> Bool # (/=) :: Atom -> Atom -> Bool #
Data Atom Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Atom -> c Atom # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Atom # toConstr :: Atom -> Constr # dataTypeOf :: Atom -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Atom) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Atom) # gmapT :: (forall b. Data b => b -> b) -> Atom -> Atom # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Atom -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Atom -> r # gmapQ :: (forall d. Data d => d -> u) -> Atom -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Atom -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Atom -> m Atom # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Atom -> m Atom # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Atom -> m Atom #
Ord Atom Source #
Methods compare :: Atom -> Atom -> Ordering # (<) :: Atom -> Atom -> Bool # (<=) :: Atom -> Atom -> Bool # (>) :: Atom -> Atom -> Bool # (>=) :: Atom -> Atom -> Bool # max :: Atom -> Atom -> Atom # min :: Atom -> Atom -> Atom #
Show Atom Source #
Methods showsPrec :: Int -> Atom -> ShowS # show :: Atom -> String # showList :: [Atom] -> ShowS #
Pretty Atom Source #
Methods pretty :: Atom -> Doc prettyPrec :: Int -> Atom -> Doc

Variables

type Var = String Source #

This type is used to represent variables

Annotations

data Ann a Source #

An annotation for modules, variables, ...

Constructors

Constr a	core erlang construct
Ann a [Const]	core erlang annotated construct

Instances

Eq a => Eq (Ann a) Source #
Methods (==) :: Ann a -> Ann a -> Bool # (/=) :: Ann a -> Ann a -> Bool #
Data a => Data (Ann a) Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ann a -> c (Ann a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Ann a) # toConstr :: Ann a -> Constr # dataTypeOf :: Ann a -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c (Ann a)) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Ann a)) # gmapT :: (forall b. Data b => b -> b) -> Ann a -> Ann a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ann a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ann a -> r # gmapQ :: (forall d. Data d => d -> u) -> Ann a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Ann a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ann a -> m (Ann a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ann a -> m (Ann a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ann a -> m (Ann a) #
Ord a => Ord (Ann a) Source #
Methods compare :: Ann a -> Ann a -> Ordering # (<) :: Ann a -> Ann a -> Bool # (<=) :: Ann a -> Ann a -> Bool # (>) :: Ann a -> Ann a -> Bool # (>=) :: Ann a -> Ann a -> Bool # max :: Ann a -> Ann a -> Ann a # min :: Ann a -> Ann a -> Ann a #
Show a => Show (Ann a) Source #
Methods showsPrec :: Int -> Ann a -> ShowS # show :: Ann a -> String # showList :: [Ann a] -> ShowS #
Pretty a => Pretty (Ann a) Source #
Methods pretty :: Ann a -> Doc prettyPrec :: Int -> Ann a -> Doc