curry-base-0.4.2: Functions for manipulating Curry programs

Copyright(c) 1999 - 2004 Wolfgang Lux 2005 Martin Engelke 2011 - 2015 Björn Peemöller 2014 Jan Rasmus Tikovsky
LicenseBSD-3-clause
Maintainerbjp@informatik.uni-kiel.de
Stabilityexperimental
Portabilitynon-portable (DeriveDataTypeable)
Safe HaskellNone
LanguageHaskell2010

Curry.Syntax.Type

Contents

Description

This module provides the necessary data structures to maintain the parsed representation of a Curry pProgram.

Synopsis

Module header

data Module Source #

Curry module

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 #

Read Module Source # 
Show Module Source # 

Module pragmas

data ModulePragma Source #

Module pragma

Constructors

LanguagePragma Position [Extension]

language pragma

OptionsPragma Position (Maybe Tool) String

options pragma

Instances

Eq ModulePragma Source # 
Data ModulePragma Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ModulePragma -> c ModulePragma #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ModulePragma #

toConstr :: ModulePragma -> Constr #

dataTypeOf :: ModulePragma -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ModulePragma) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModulePragma) #

gmapT :: (forall b. Data b => b -> b) -> ModulePragma -> ModulePragma #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ModulePragma -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ModulePragma -> r #

gmapQ :: (forall d. Data d => d -> u) -> ModulePragma -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ModulePragma -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ModulePragma -> m ModulePragma #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ModulePragma -> m ModulePragma #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ModulePragma -> m ModulePragma #

Read ModulePragma Source # 
Show ModulePragma Source # 

data Extension Source #

Specified language extensions, either known or unknown.

Constructors

KnownExtension Position KnownExtension

a known extension

UnknownExtension Position String

an unknown extension

Instances

Eq Extension Source # 
Data Extension Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Extension -> c Extension #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Extension #

toConstr :: Extension -> Constr #

dataTypeOf :: Extension -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Extension) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Extension) #

gmapT :: (forall b. Data b => b -> b) -> Extension -> Extension #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Extension -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Extension -> r #

gmapQ :: (forall d. Data d => d -> u) -> Extension -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Extension -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Extension -> m Extension #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Extension -> m Extension #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Extension -> m Extension #

Read Extension Source # 
Show Extension Source # 
HasPosition Extension Source # 

data KnownExtension Source #

Known language extensions of Curry.

Constructors

AnonFreeVars

anonymous free variables

FunctionalPatterns

functional patterns

NegativeLiterals

negative literals

NoImplicitPrelude

no implicit import of the prelude

Instances

Bounded KnownExtension Source # 
Enum KnownExtension Source # 
Eq KnownExtension Source # 
Data KnownExtension Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> KnownExtension -> c KnownExtension #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c KnownExtension #

toConstr :: KnownExtension -> Constr #

dataTypeOf :: KnownExtension -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c KnownExtension) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c KnownExtension) #

gmapT :: (forall b. Data b => b -> b) -> KnownExtension -> KnownExtension #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> KnownExtension -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> KnownExtension -> r #

gmapQ :: (forall d. Data d => d -> u) -> KnownExtension -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> KnownExtension -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> KnownExtension -> m KnownExtension #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> KnownExtension -> m KnownExtension #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> KnownExtension -> m KnownExtension #

Read KnownExtension Source # 
Show KnownExtension Source # 

data Tool Source #

Different Curry tools which may accept compiler options.

Instances

Eq Tool Source # 

Methods

(==) :: Tool -> Tool -> Bool #

(/=) :: Tool -> Tool -> Bool #

Data Tool Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Tool -> c Tool #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Tool #

toConstr :: Tool -> Constr #

dataTypeOf :: Tool -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Tool) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Tool) #

gmapT :: (forall b. Data b => b -> b) -> Tool -> Tool #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tool -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tool -> r #

gmapQ :: (forall d. Data d => d -> u) -> Tool -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Tool -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Tool -> m Tool #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Tool -> m Tool #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Tool -> m Tool #

Read Tool Source # 
Show Tool Source # 

Methods

showsPrec :: Int -> Tool -> ShowS #

show :: Tool -> String #

showList :: [Tool] -> ShowS #

Export specification

data ExportSpec Source #

Export specification

Constructors

Exporting Position [Export] 

Instances

Eq ExportSpec Source # 
Data ExportSpec Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ExportSpec -> c ExportSpec #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ExportSpec #

toConstr :: ExportSpec -> Constr #

dataTypeOf :: ExportSpec -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ExportSpec) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ExportSpec) #

gmapT :: (forall b. Data b => b -> b) -> ExportSpec -> ExportSpec #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ExportSpec -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ExportSpec -> r #

gmapQ :: (forall d. Data d => d -> u) -> ExportSpec -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ExportSpec -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ExportSpec -> m ExportSpec #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ExportSpec -> m ExportSpec #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ExportSpec -> m ExportSpec #

Read ExportSpec Source # 
Show ExportSpec Source # 

data Export Source #

Single exported entity

Instances

Eq Export Source # 

Methods

(==) :: Export -> Export -> Bool #

(/=) :: Export -> Export -> Bool #

Data Export Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Export -> c Export #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Export #

toConstr :: Export -> Constr #

dataTypeOf :: Export -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Export) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Export) #

gmapT :: (forall b. Data b => b -> b) -> Export -> Export #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Export -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Export -> r #

gmapQ :: (forall d. Data d => d -> u) -> Export -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Export -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Export -> m Export #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Export -> m Export #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Export -> m Export #

Read Export Source # 
Show Export Source # 

Import declarations

data ImportDecl Source #

Import declaration

Instances

Eq ImportDecl Source # 
Data ImportDecl Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ImportDecl -> c ImportDecl #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ImportDecl #

toConstr :: ImportDecl -> Constr #

dataTypeOf :: ImportDecl -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ImportDecl) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ImportDecl) #

gmapT :: (forall b. Data b => b -> b) -> ImportDecl -> ImportDecl #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ImportDecl -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ImportDecl -> r #

gmapQ :: (forall d. Data d => d -> u) -> ImportDecl -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ImportDecl -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ImportDecl -> m ImportDecl #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportDecl -> m ImportDecl #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportDecl -> m ImportDecl #

Read ImportDecl Source # 
Show ImportDecl Source # 

data ImportSpec Source #

Import specification

Instances

Eq ImportSpec Source # 
Data ImportSpec Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ImportSpec -> c ImportSpec #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ImportSpec #

toConstr :: ImportSpec -> Constr #

dataTypeOf :: ImportSpec -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ImportSpec) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ImportSpec) #

gmapT :: (forall b. Data b => b -> b) -> ImportSpec -> ImportSpec #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ImportSpec -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ImportSpec -> r #

gmapQ :: (forall d. Data d => d -> u) -> ImportSpec -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ImportSpec -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ImportSpec -> m ImportSpec #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportSpec -> m ImportSpec #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportSpec -> m ImportSpec #

Read ImportSpec Source # 
Show ImportSpec Source # 

data Import Source #

Single imported entity

Instances

Eq Import Source # 

Methods

(==) :: Import -> Import -> Bool #

(/=) :: Import -> Import -> Bool #

Data Import Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Import -> c Import #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Import #

toConstr :: Import -> Constr #

dataTypeOf :: Import -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Import) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Import) #

gmapT :: (forall b. Data b => b -> b) -> Import -> Import #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Import -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Import -> r #

gmapQ :: (forall d. Data d => d -> u) -> Import -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Import -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Import -> m Import #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Import -> m Import #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Import -> m Import #

Read Import Source # 
Show Import Source # 

type Qualified = Bool Source #

Flag to signal qualified import

Interface

data Interface Source #

Module interface

Interface declarations are restricted to type declarations and signatures. Note that an interface function declaration additionaly contains the function arity (= number of parameters) in order to generate correct FlatCurry function applications.

Instances

Eq Interface Source # 
Data Interface Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Interface -> c Interface #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Interface #

toConstr :: Interface -> Constr #

dataTypeOf :: Interface -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Interface) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Interface) #

gmapT :: (forall b. Data b => b -> b) -> Interface -> Interface #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Interface -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Interface -> r #

gmapQ :: (forall d. Data d => d -> u) -> Interface -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Interface -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Interface -> m Interface #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Interface -> m Interface #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Interface -> m Interface #

Read Interface Source # 
Show Interface Source # 

data IImportDecl Source #

Interface import declaration

Instances

Eq IImportDecl Source # 
Data IImportDecl Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IImportDecl -> c IImportDecl #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c IImportDecl #

toConstr :: IImportDecl -> Constr #

dataTypeOf :: IImportDecl -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c IImportDecl) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IImportDecl) #

gmapT :: (forall b. Data b => b -> b) -> IImportDecl -> IImportDecl #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IImportDecl -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IImportDecl -> r #

gmapQ :: (forall d. Data d => d -> u) -> IImportDecl -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> IImportDecl -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> IImportDecl -> m IImportDecl #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IImportDecl -> m IImportDecl #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IImportDecl -> m IImportDecl #

Read IImportDecl Source # 
Show IImportDecl Source # 

type Arity = Int Source #

Arity of a function

data IDecl Source #

Interface declaration

Instances

Eq IDecl Source # 

Methods

(==) :: IDecl -> IDecl -> Bool #

(/=) :: IDecl -> IDecl -> Bool #

Data IDecl Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IDecl -> c IDecl #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c IDecl #

toConstr :: IDecl -> Constr #

dataTypeOf :: IDecl -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c IDecl) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IDecl) #

gmapT :: (forall b. Data b => b -> b) -> IDecl -> IDecl #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IDecl -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IDecl -> r #

gmapQ :: (forall d. Data d => d -> u) -> IDecl -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> IDecl -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> IDecl -> m IDecl #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IDecl -> m IDecl #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IDecl -> m IDecl #

Read IDecl Source # 
Show IDecl Source # 

Methods

showsPrec :: Int -> IDecl -> ShowS #

show :: IDecl -> String #

showList :: [IDecl] -> ShowS #

Declarations

data Decl Source #

Declaration in a module

Instances

Eq Decl Source # 

Methods

(==) :: Decl -> Decl -> Bool #

(/=) :: Decl -> Decl -> Bool #

Data Decl Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Decl -> c Decl #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Decl #

toConstr :: Decl -> Constr #

dataTypeOf :: Decl -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Decl) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Decl) #

gmapT :: (forall b. Data b => b -> b) -> Decl -> Decl #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Decl -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Decl -> r #

gmapQ :: (forall d. Data d => d -> u) -> Decl -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Decl -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Decl -> m Decl #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Decl -> m Decl #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Decl -> m Decl #

Read Decl Source # 
Show Decl Source # 

Methods

showsPrec :: Int -> Decl -> ShowS #

show :: Decl -> String #

showList :: [Decl] -> ShowS #

type Precedence = Integer Source #

Operator precedence

data Infix Source #

Fixity of operators

Constructors

InfixL

left-associative

InfixR

right-associative

Infix

no associativity

Instances

Eq Infix Source # 

Methods

(==) :: Infix -> Infix -> Bool #

(/=) :: Infix -> Infix -> Bool #

Data Infix Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Infix -> c Infix #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Infix #

toConstr :: Infix -> Constr #

dataTypeOf :: Infix -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Infix) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Infix) #

gmapT :: (forall b. Data b => b -> b) -> Infix -> Infix #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Infix -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Infix -> r #

gmapQ :: (forall d. Data d => d -> u) -> Infix -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Infix -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Infix -> m Infix #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Infix -> m Infix #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Infix -> m Infix #

Read Infix Source # 
Show Infix Source # 

Methods

showsPrec :: Int -> Infix -> ShowS #

show :: Infix -> String #

showList :: [Infix] -> ShowS #

data ConstrDecl Source #

Constructor declaration for algebraic data types

Instances

Eq ConstrDecl Source # 
Data ConstrDecl Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ConstrDecl -> c ConstrDecl #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ConstrDecl #

toConstr :: ConstrDecl -> Constr #

dataTypeOf :: ConstrDecl -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ConstrDecl) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ConstrDecl) #

gmapT :: (forall b. Data b => b -> b) -> ConstrDecl -> ConstrDecl #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ConstrDecl -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ConstrDecl -> r #

gmapQ :: (forall d. Data d => d -> u) -> ConstrDecl -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ConstrDecl -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ConstrDecl -> m ConstrDecl #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ConstrDecl -> m ConstrDecl #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ConstrDecl -> m ConstrDecl #

Read ConstrDecl Source # 
Show ConstrDecl Source # 

data NewConstrDecl Source #

Constructor declaration for renaming types (newtypes)

Instances

Eq NewConstrDecl Source # 
Data NewConstrDecl Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NewConstrDecl -> c NewConstrDecl #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NewConstrDecl #

toConstr :: NewConstrDecl -> Constr #

dataTypeOf :: NewConstrDecl -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c NewConstrDecl) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NewConstrDecl) #

gmapT :: (forall b. Data b => b -> b) -> NewConstrDecl -> NewConstrDecl #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NewConstrDecl -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NewConstrDecl -> r #

gmapQ :: (forall d. Data d => d -> u) -> NewConstrDecl -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> NewConstrDecl -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> NewConstrDecl -> m NewConstrDecl #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NewConstrDecl -> m NewConstrDecl #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NewConstrDecl -> m NewConstrDecl #

Read NewConstrDecl Source # 
Show NewConstrDecl Source # 

data FieldDecl Source #

Declaration for labelled fields

Instances

Eq FieldDecl Source # 
Data FieldDecl Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FieldDecl -> c FieldDecl #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FieldDecl #

toConstr :: FieldDecl -> Constr #

dataTypeOf :: FieldDecl -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c FieldDecl) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldDecl) #

gmapT :: (forall b. Data b => b -> b) -> FieldDecl -> FieldDecl #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FieldDecl -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FieldDecl -> r #

gmapQ :: (forall d. Data d => d -> u) -> FieldDecl -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FieldDecl -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FieldDecl -> m FieldDecl #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldDecl -> m FieldDecl #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldDecl -> m FieldDecl #

Read FieldDecl Source # 
Show FieldDecl Source # 

data CallConv Source #

Calling convention for C code

Instances

Eq CallConv Source # 
Data CallConv Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CallConv -> c CallConv #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CallConv #

toConstr :: CallConv -> Constr #

dataTypeOf :: CallConv -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c CallConv) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CallConv) #

gmapT :: (forall b. Data b => b -> b) -> CallConv -> CallConv #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CallConv -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CallConv -> r #

gmapQ :: (forall d. Data d => d -> u) -> CallConv -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> CallConv -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> CallConv -> m CallConv #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CallConv -> m CallConv #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CallConv -> m CallConv #

Read CallConv Source # 
Show CallConv Source # 

data TypeExpr Source #

Type expressions

Instances

Eq TypeExpr Source # 
Data TypeExpr Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TypeExpr -> c TypeExpr #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TypeExpr #

toConstr :: TypeExpr -> Constr #

dataTypeOf :: TypeExpr -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c TypeExpr) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeExpr) #

gmapT :: (forall b. Data b => b -> b) -> TypeExpr -> TypeExpr #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TypeExpr -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TypeExpr -> r #

gmapQ :: (forall d. Data d => d -> u) -> TypeExpr -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> TypeExpr -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TypeExpr -> m TypeExpr #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeExpr -> m TypeExpr #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeExpr -> m TypeExpr #

Read TypeExpr Source # 
Show TypeExpr Source # 

data Equation Source #

Function defining equation

Constructors

Equation Position Lhs Rhs 

Instances

Eq Equation Source # 
Data Equation Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Equation -> c Equation #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Equation #

toConstr :: Equation -> Constr #

dataTypeOf :: Equation -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Equation) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Equation) #

gmapT :: (forall b. Data b => b -> b) -> Equation -> Equation #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Equation -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Equation -> r #

gmapQ :: (forall d. Data d => d -> u) -> Equation -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Equation -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Equation -> m Equation #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Equation -> m Equation #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Equation -> m Equation #

Read Equation Source # 
Show Equation Source # 

data Lhs Source #

Left-hand-side of an Equation (function identifier and patterns)

Instances

Eq Lhs Source # 

Methods

(==) :: Lhs -> Lhs -> Bool #

(/=) :: Lhs -> Lhs -> Bool #

Data Lhs Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Lhs -> c Lhs #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Lhs #

toConstr :: Lhs -> Constr #

dataTypeOf :: Lhs -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Lhs) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Lhs) #

gmapT :: (forall b. Data b => b -> b) -> Lhs -> Lhs #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Lhs -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Lhs -> r #

gmapQ :: (forall d. Data d => d -> u) -> Lhs -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Lhs -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Lhs -> m Lhs #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Lhs -> m Lhs #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Lhs -> m Lhs #

Read Lhs Source # 
Show Lhs Source # 

Methods

showsPrec :: Int -> Lhs -> ShowS #

show :: Lhs -> String #

showList :: [Lhs] -> ShowS #

data Rhs Source #

Right-hand-side of an Equation

Instances

Eq Rhs Source # 

Methods

(==) :: Rhs -> Rhs -> Bool #

(/=) :: Rhs -> Rhs -> Bool #

Data Rhs Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Rhs -> c Rhs #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Rhs #

toConstr :: Rhs -> Constr #

dataTypeOf :: Rhs -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Rhs) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Rhs) #

gmapT :: (forall b. Data b => b -> b) -> Rhs -> Rhs #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rhs -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rhs -> r #

gmapQ :: (forall d. Data d => d -> u) -> Rhs -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Rhs -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Rhs -> m Rhs #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Rhs -> m Rhs #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Rhs -> m Rhs #

Read Rhs Source # 
Show Rhs Source # 

Methods

showsPrec :: Int -> Rhs -> ShowS #

show :: Rhs -> String #

showList :: [Rhs] -> ShowS #

data CondExpr Source #

Conditional expression (expression conditioned by a guard)

Instances

Eq CondExpr Source # 
Data CondExpr Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CondExpr -> c CondExpr #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CondExpr #

toConstr :: CondExpr -> Constr #

dataTypeOf :: CondExpr -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c CondExpr) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CondExpr) #

gmapT :: (forall b. Data b => b -> b) -> CondExpr -> CondExpr #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CondExpr -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CondExpr -> r #

gmapQ :: (forall d. Data d => d -> u) -> CondExpr -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> CondExpr -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> CondExpr -> m CondExpr #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CondExpr -> m CondExpr #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CondExpr -> m CondExpr #

Read CondExpr Source # 
Show CondExpr Source # 

data Literal Source #

Literal The Ident argument of an Int literal is used for supporting ad-hoc polymorphism on integer numbers. An integer literal can be used either as an integer number or as a floating-point number depending on its context. The compiler uses the identifier of the Int literal for maintaining its type.

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 #

Read Literal Source # 
Show Literal Source # 
SrcRefOf Literal Source # 

data Pattern Source #

Constructor term (used for patterns)

Instances

Eq Pattern Source # 

Methods

(==) :: Pattern -> Pattern -> Bool #

(/=) :: Pattern -> Pattern -> Bool #

Data Pattern Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Pattern -> c Pattern #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Pattern #

toConstr :: Pattern -> Constr #

dataTypeOf :: Pattern -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Pattern) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pattern) #

gmapT :: (forall b. Data b => b -> b) -> Pattern -> Pattern #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pattern -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pattern -> r #

gmapQ :: (forall d. Data d => d -> u) -> Pattern -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Pattern -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Pattern -> m Pattern #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Pattern -> m Pattern #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Pattern -> m Pattern #

Read Pattern Source # 
Show Pattern Source # 
SrcRefOf Pattern Source # 

data Expression Source #

Expression

Instances

Eq Expression Source # 
Data Expression Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Expression -> c Expression #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Expression #

toConstr :: Expression -> Constr #

dataTypeOf :: Expression -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Expression) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Expression) #

gmapT :: (forall b. Data b => b -> b) -> Expression -> Expression #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expression -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expression -> r #

gmapQ :: (forall d. Data d => d -> u) -> Expression -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Expression -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Expression -> m Expression #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Expression -> m Expression #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Expression -> m Expression #

Read Expression Source # 
Show Expression Source # 

data InfixOp Source #

Infix operation

Instances

Eq InfixOp Source # 

Methods

(==) :: InfixOp -> InfixOp -> Bool #

(/=) :: InfixOp -> InfixOp -> Bool #

Data InfixOp Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InfixOp -> c InfixOp #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c InfixOp #

toConstr :: InfixOp -> Constr #

dataTypeOf :: InfixOp -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c InfixOp) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c InfixOp) #

gmapT :: (forall b. Data b => b -> b) -> InfixOp -> InfixOp #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> InfixOp -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> InfixOp -> r #

gmapQ :: (forall d. Data d => d -> u) -> InfixOp -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> InfixOp -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> InfixOp -> m InfixOp #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InfixOp -> m InfixOp #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InfixOp -> m InfixOp #

Read InfixOp Source # 
Show InfixOp Source # 

data Statement Source #

Statement (used for do-sequence and list comprehensions)

Instances

Eq Statement Source # 
Data Statement Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Statement -> c Statement #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Statement #

toConstr :: Statement -> Constr #

dataTypeOf :: Statement -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Statement) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Statement) #

gmapT :: (forall b. Data b => b -> b) -> Statement -> Statement #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Statement -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Statement -> r #

gmapQ :: (forall d. Data d => d -> u) -> Statement -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Statement -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Statement -> m Statement #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Statement -> m Statement #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Statement -> m Statement #

Read Statement Source # 
Show Statement Source # 

data CaseType Source #

Type of case expressions

Constructors

Rigid 
Flex 

Instances

Eq CaseType Source # 
Data CaseType Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CaseType -> c CaseType #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CaseType #

toConstr :: CaseType -> Constr #

dataTypeOf :: CaseType -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c CaseType) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CaseType) #

gmapT :: (forall b. Data b => b -> b) -> CaseType -> CaseType #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CaseType -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CaseType -> r #

gmapQ :: (forall d. Data d => d -> u) -> CaseType -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> CaseType -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> CaseType -> m CaseType #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CaseType -> m CaseType #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CaseType -> m CaseType #

Read CaseType Source # 
Show CaseType Source # 

data Alt Source #

Single case alternative

Constructors

Alt Position Pattern Rhs 

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 #

Read Alt Source # 
Show Alt Source # 

Methods

showsPrec :: Int -> Alt -> ShowS #

show :: Alt -> String #

showList :: [Alt] -> ShowS #

data Field a Source #

Record field

Constructors

Field Position QualIdent a 

Instances

Eq a => Eq (Field a) Source # 

Methods

(==) :: Field a -> Field a -> Bool #

(/=) :: Field a -> Field a -> Bool #

Data a => Data (Field a) Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Field a -> c (Field a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Field a) #

toConstr :: Field a -> Constr #

dataTypeOf :: Field a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Field a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Field a)) #

gmapT :: (forall b. Data b => b -> b) -> Field a -> Field a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Field a -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Field a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Field a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Field a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Field a -> m (Field a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Field a -> m (Field a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Field a -> m (Field a) #

Read a => Read (Field a) Source # 
Show a => Show (Field a) Source # 

Methods

showsPrec :: Int -> Field a -> ShowS #

show :: Field a -> String #

showList :: [Field a] -> ShowS #

Goals

data Goal Source #

Goal in REPL (expression to evaluate)

Constructors

Goal Position Expression [Decl] 

Instances

Eq Goal Source # 

Methods

(==) :: Goal -> Goal -> Bool #

(/=) :: Goal -> Goal -> Bool #

Data Goal Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Goal -> c Goal #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Goal #

toConstr :: Goal -> Constr #

dataTypeOf :: Goal -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Goal) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Goal) #

gmapT :: (forall b. Data b => b -> b) -> Goal -> Goal #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Goal -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Goal -> r #

gmapQ :: (forall d. Data d => d -> u) -> Goal -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Goal -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Goal -> m Goal #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Goal -> m Goal #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Goal -> m Goal #

Read Goal Source # 
Show Goal Source # 

Methods

showsPrec :: Int -> Goal -> ShowS #

show :: Goal -> String #

showList :: [Goal] -> ShowS #