curry-frontend-0.4.2: Lexer, parser, type checker, etc. for the Curry language

Copyright(c) 1999 - 2003 Wolfgang Lux Martin Engelke
LicenseBSD-3-clause
Maintainerbjp@informatik.uni-kiel.de
Stabilityexperimental
Portabilityportable
Safe HaskellNone
LanguageHaskell2010

IL.Type

Contents

Description

The module IL defines the intermediate language which will be compiled into abstract machine code. The intermediate language removes a lot of syntactic sugar from the Curry source language. Top-level declarations are restricted to data type and function definitions. A newtype definition serves mainly as a hint to the backend that it must provide an auxiliary function for partial applications of the constructor (Newtype constructors must not occur in patterns and may be used in expressions only as partial applications.).

Type declarations use a de-Bruijn indexing scheme (starting at 0) for type variables. In the type of a function, all type variables are numbered in the order of their occurence from left to right, i.e., a type '(Int -> b) -> (a,b) -> c -> (a,c)' is translated into the type (using integer numbers to denote the type variables) '(Int -> 0) -> (1,0) -> 2 -> (1,2)'.

Pattern matching in an equation is handled via flexible and rigid Case expressions. Overlapping rules are translated with the help of Or expressions. The intermediate language has three kinds of binding expressions, Exist expressions introduce a new logical variable, Let expression support a single non-recursive variable binding, and Letrec expressions introduce multiple variables with recursive initializer expressions. The intermediate language explicitly distinguishes (local) variables and (global) functions in expressions.

Note: this modified version uses haskell type Integer instead of Int for representing integer values. This provides an unlimited range of integer constants in Curry programs.

Synopsis

Data types

data Module Source #

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 #

Show Module Source # 

data Decl Source #

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 #

Show Decl Source # 

Methods

showsPrec :: Int -> Decl -> ShowS #

show :: Decl -> String #

showList :: [Decl] -> ShowS #

data ConstrDecl a Source #

Constructors

ConstrDecl QualIdent a 

Instances

Eq a => Eq (ConstrDecl a) Source # 

Methods

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

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

Data a => Data (ConstrDecl a) Source # 

Methods

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

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

toConstr :: ConstrDecl a -> Constr #

dataTypeOf :: ConstrDecl a -> DataType #

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

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

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

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

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

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

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

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

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

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

Show a => Show (ConstrDecl a) Source # 

data CallConv Source #

Constructors

Primitive 
CCall 

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 #

Show CallConv Source # 

data Type Source #

Instances

Eq Type Source # 

Methods

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

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

Data Type Source # 

Methods

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

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

toConstr :: Type -> Constr #

dataTypeOf :: Type -> DataType #

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

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

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

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

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

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

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

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

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

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

Show Type Source # 

Methods

showsPrec :: Int -> Type -> ShowS #

show :: Type -> String #

showList :: [Type] -> ShowS #

data Literal Source #

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 #

Show Literal Source # 
SrcRefOf Literal Source # 

data ConstrTerm Source #

Constructors

LiteralPattern Literal

literal patterns

ConstructorPattern QualIdent [Ident]

constructors

VariablePattern Ident

default

Instances

Eq ConstrTerm Source # 
Data ConstrTerm Source # 

Methods

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

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

toConstr :: ConstrTerm -> Constr #

dataTypeOf :: ConstrTerm -> DataType #

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

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

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

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

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

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

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

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

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

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

Show ConstrTerm Source # 
SrcRefOf ConstrTerm Source # 

data Expression Source #

Constructors

Literal Literal

literal constants

Variable Ident

variables

Function QualIdent Int

functions

Constructor QualIdent Int

constructors

Apply Expression Expression

applications

Case SrcRef Eval Expression [Alt]

case expressions

Or Expression Expression

non-deterministic or

Exist Ident Expression

exist binding (introduction of a free variable)

Let Binding Expression

let binding

Letrec [Binding] Expression

letrec binding

Typed Expression Type

typed 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 #

Show Expression Source # 
Expr Expression Source # 

Methods

fv :: Expression -> [Ident] Source #

data Eval Source #

Constructors

Rigid 
Flex 

Instances

Eq Eval Source # 

Methods

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

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

Data Eval Source # 

Methods

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

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

toConstr :: Eval -> Constr #

dataTypeOf :: Eval -> DataType #

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

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

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

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

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

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

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

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

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

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

Show Eval Source # 

Methods

showsPrec :: Int -> Eval -> ShowS #

show :: Eval -> String #

showList :: [Eval] -> ShowS #

data Alt Source #

Constructors

Alt ConstrTerm Expression 

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 #

Show Alt Source # 

Methods

showsPrec :: Int -> Alt -> ShowS #

show :: Alt -> String #

showList :: [Alt] -> ShowS #

Expr Alt Source # 

Methods

fv :: Alt -> [Ident] Source #

data Binding Source #

Constructors

Binding Ident Expression 

Instances

Eq Binding Source # 

Methods

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

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

Data Binding Source # 

Methods

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

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

toConstr :: Binding -> Constr #

dataTypeOf :: Binding -> DataType #

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

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

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

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

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

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

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

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

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

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

Show Binding Source #