curry-frontend 0.2.5 → 0.2.6
raw patch · 3 files changed
+19/−205 lines, 3 filesdep +filepathdep ~curry-basePVP: major bump suggested
API removals or changes: PVP suggests a major version bump
Dependencies added: filepath
Dependency ranges changed: curry-base
API changes (from Hackage documentation)
- Arity: bindArities :: ArityEnv -> Module -> ArityEnv
- Base: AliasType :: QualIdent -> Int -> Type -> TypeInfo
- Base: ArityInfo :: QualIdent -> Int -> ArityInfo
- Base: Data :: Ident -> Int -> a -> Data a
- Base: DataConstructor :: QualIdent -> ExistTypeScheme -> ValueInfo
- Base: DataType :: QualIdent -> Int -> [Maybe (Data [Type])] -> TypeInfo
- Base: Label :: QualIdent -> QualIdent -> TypeScheme -> ValueInfo
- Base: NewtypeConstructor :: QualIdent -> ExistTypeScheme -> ValueInfo
- Base: OpPrec :: Infix -> Integer -> OpPrec
- Base: PrecInfo :: QualIdent -> OpPrec -> PrecInfo
- Base: RenamingType :: QualIdent -> Int -> (Data Type) -> TypeInfo
- Base: Value :: QualIdent -> TypeScheme -> ValueInfo
- Base: bindAlias :: Decl -> ImportEnv -> ImportEnv
- Base: bindArity :: ModuleIdent -> Ident -> Int -> ArityEnv -> ArityEnv
- Base: bindFun :: ModuleIdent -> Ident -> TypeScheme -> ValueEnv -> ValueEnv
- Base: bindGlobalInfo :: (QualIdent -> a -> ValueInfo) -> ModuleIdent -> Ident -> a -> ValueEnv -> ValueEnv
- Base: bindLabel :: Ident -> QualIdent -> TypeScheme -> ValueEnv -> ValueEnv
- Base: bindP :: ModuleIdent -> Ident -> OpPrec -> PEnv -> PEnv
- Base: bindTypeInfo :: (QualIdent -> Int -> a -> TypeInfo) -> ModuleIdent -> Ident -> [Ident] -> a -> TCEnv -> TCEnv
- Base: data ArityInfo
- Base: data Data a
- Base: data OpPrec
- Base: data PrecInfo
- Base: data TypeInfo
- Base: data ValueInfo
- Base: defaultP :: OpPrec
- Base: errorAt :: Position -> String -> a
- Base: errorAt' :: (Position, String) -> a
- Base: findDouble :: (Eq a) => [a] -> Maybe a
- Base: fromQualType :: ModuleIdent -> Type -> TypeExpr
- Base: fromType :: Type -> TypeExpr
- Base: initAEnv :: ArityEnv
- Base: initDCEnv :: ValueEnv
- Base: initIEnv :: ImportEnv
- Base: initPEnv :: PEnv
- Base: initTCEnv :: TCEnv
- Base: instance (Show a) => Show (Data a)
- Base: instance Entity ArityInfo
- Base: instance Entity PrecInfo
- Base: instance Entity TypeInfo
- Base: instance Entity ValueInfo
- Base: instance Eq OpPrec
- Base: instance Eq PrecInfo
- Base: instance Show ArityInfo
- Base: instance Show OpPrec
- Base: instance Show PrecInfo
- Base: instance Show TypeInfo
- Base: instance Show ValueInfo
- Base: internalError :: String -> a
- Base: lookupAlias :: ModuleIdent -> ImportEnv -> Maybe ModuleIdent
- Base: lookupArity :: Ident -> ArityEnv -> [ArityInfo]
- Base: lookupModule :: ModuleIdent -> ModuleEnv -> Maybe [IDecl]
- Base: lookupP :: Ident -> PEnv -> [PrecInfo]
- Base: lookupTC :: Ident -> TCEnv -> [TypeInfo]
- Base: lookupTuple :: Ident -> [ValueInfo]
- Base: lookupTupleArity :: Ident -> [ArityInfo]
- Base: lookupTupleTC :: Ident -> [TypeInfo]
- Base: lookupValue :: Ident -> ValueEnv -> [ValueInfo]
- Base: nameSupply :: [Ident]
- Base: predefTypes :: [(Type, [Data [Type]])]
- Base: qualLookupArity :: QualIdent -> ArityEnv -> [ArityInfo]
- Base: qualLookupCons :: QualIdent -> ValueEnv -> [ValueInfo]
- Base: qualLookupConsArity :: QualIdent -> ArityEnv -> [ArityInfo]
- Base: qualLookupP :: QualIdent -> PEnv -> [PrecInfo]
- Base: qualLookupTC :: QualIdent -> TCEnv -> [TypeInfo]
- Base: qualLookupValue :: QualIdent -> ValueEnv -> [ValueInfo]
- Base: rebindFun :: ModuleIdent -> Ident -> TypeScheme -> ValueEnv -> ValueEnv
- Base: sureLookupAlias :: ModuleIdent -> ImportEnv -> ModuleIdent
- Base: tcArity :: TypeInfo -> Int
- Base: toQualType :: ModuleIdent -> [Ident] -> TypeExpr -> Type
- Base: toQualTypes :: ModuleIdent -> [Ident] -> [TypeExpr] -> [Type]
- Base: toType :: [Ident] -> TypeExpr -> Type
- Base: toType' :: Map Ident Int -> TypeExpr -> Type
- Base: toTypes :: [Ident] -> [TypeExpr] -> [Type]
- Base: tupleDCs :: [ValueInfo]
- Base: tupleData :: [Data [Type]]
- Base: tupleTCs :: [TypeInfo]
- Base: type ArityEnv = TopEnv ArityInfo
- Base: type EvalEnv = Map Ident EvalAnnotation
- Base: type ImportEnv = Map ModuleIdent ModuleIdent
- Base: type ModuleEnv = Map ModuleIdent [IDecl]
- Base: type PEnv = TopEnv PrecInfo
- Base: type TCEnv = TopEnv TypeInfo
- Base: type ValueEnv = TopEnv ValueInfo
- CaseCompletion: completeCase :: ModuleEnv -> Module -> Module
- Curry.AbstractCurry: CApply :: CExpr -> CExpr -> CExpr
- Curry.AbstractCurry: CBranch :: CPattern -> CExpr -> CBranchExpr
- Curry.AbstractCurry: CCase :: CExpr -> [CBranchExpr] -> CExpr
- Curry.AbstractCurry: CCharc :: Char -> CLiteral
- Curry.AbstractCurry: CChoice :: CEvalAnnot
- Curry.AbstractCurry: CCons :: QName -> Int -> CVisibility -> [CTypeExpr] -> CConsDecl
- Curry.AbstractCurry: CDoExpr :: [CStatement] -> CExpr
- Curry.AbstractCurry: CExternal :: String -> CRules
- Curry.AbstractCurry: CFlex :: CEvalAnnot
- Curry.AbstractCurry: CFloatc :: Double -> CLiteral
- Curry.AbstractCurry: CFunc :: QName -> Int -> CVisibility -> CTypeExpr -> CRules -> CFuncDecl
- Curry.AbstractCurry: CFuncType :: CTypeExpr -> CTypeExpr -> CTypeExpr
- Curry.AbstractCurry: CInfixOp :: CFixity
- Curry.AbstractCurry: CInfixlOp :: CFixity
- Curry.AbstractCurry: CInfixrOp :: CFixity
- Curry.AbstractCurry: CIntc :: Integer -> CLiteral
- Curry.AbstractCurry: CLambda :: [CPattern] -> CExpr -> CExpr
- Curry.AbstractCurry: CLetDecl :: [CLocalDecl] -> CExpr -> CExpr
- Curry.AbstractCurry: CListComp :: CExpr -> [CStatement] -> CExpr
- Curry.AbstractCurry: CLit :: CLiteral -> CExpr
- Curry.AbstractCurry: CLocalFunc :: CFuncDecl -> CLocalDecl
- Curry.AbstractCurry: CLocalPat :: CPattern -> CExpr -> [CLocalDecl] -> CLocalDecl
- Curry.AbstractCurry: CLocalVar :: CVarIName -> CLocalDecl
- Curry.AbstractCurry: COp :: QName -> CFixity -> Integer -> COpDecl
- Curry.AbstractCurry: CPAs :: CVarIName -> CPattern -> CPattern
- Curry.AbstractCurry: CPComb :: QName -> [CPattern] -> CPattern
- Curry.AbstractCurry: CPFuncComb :: QName -> [CPattern] -> CPattern
- Curry.AbstractCurry: CPLazy :: CPattern -> CPattern
- Curry.AbstractCurry: CPLit :: CLiteral -> CPattern
- Curry.AbstractCurry: CPRecord :: [CField CPattern] -> (Maybe CPattern) -> CPattern
- Curry.AbstractCurry: CPVar :: CVarIName -> CPattern
- Curry.AbstractCurry: CRecConstr :: [CField CExpr] -> CExpr
- Curry.AbstractCurry: CRecSelect :: CExpr -> CLabel -> CExpr
- Curry.AbstractCurry: CRecUpdate :: [CField CExpr] -> CExpr -> CExpr
- Curry.AbstractCurry: CRecordType :: [CField CTypeExpr] -> (Maybe CTVarIName) -> CTypeExpr
- Curry.AbstractCurry: CRigid :: CEvalAnnot
- Curry.AbstractCurry: CRule :: [CPattern] -> [(CExpr, CExpr)] -> [CLocalDecl] -> CRule
- Curry.AbstractCurry: CRules :: CEvalAnnot -> [CRule] -> CRules
- Curry.AbstractCurry: CSExpr :: CExpr -> CStatement
- Curry.AbstractCurry: CSLet :: [CLocalDecl] -> CStatement
- Curry.AbstractCurry: CSPat :: CPattern -> CExpr -> CStatement
- Curry.AbstractCurry: CSymbol :: QName -> CExpr
- Curry.AbstractCurry: CTCons :: QName -> [CTypeExpr] -> CTypeExpr
- Curry.AbstractCurry: CTVar :: CTVarIName -> CTypeExpr
- Curry.AbstractCurry: CType :: QName -> CVisibility -> [CTVarIName] -> [CConsDecl] -> CTypeDecl
- Curry.AbstractCurry: CTypeSyn :: QName -> CVisibility -> [CTVarIName] -> CTypeExpr -> CTypeDecl
- Curry.AbstractCurry: CVar :: CVarIName -> CExpr
- Curry.AbstractCurry: CurryProg :: String -> [String] -> [CTypeDecl] -> [CFuncDecl] -> [COpDecl] -> CurryProg
- Curry.AbstractCurry: Private :: CVisibility
- Curry.AbstractCurry: Public :: CVisibility
- Curry.AbstractCurry: data CBranchExpr
- Curry.AbstractCurry: data CConsDecl
- Curry.AbstractCurry: data CEvalAnnot
- Curry.AbstractCurry: data CExpr
- Curry.AbstractCurry: data CFixity
- Curry.AbstractCurry: data CFuncDecl
- Curry.AbstractCurry: data CLiteral
- Curry.AbstractCurry: data CLocalDecl
- Curry.AbstractCurry: data COpDecl
- Curry.AbstractCurry: data CPattern
- Curry.AbstractCurry: data CRule
- Curry.AbstractCurry: data CRules
- Curry.AbstractCurry: data CStatement
- Curry.AbstractCurry: data CTypeDecl
- Curry.AbstractCurry: data CTypeExpr
- Curry.AbstractCurry: data CVisibility
- Curry.AbstractCurry: data CurryProg
- Curry.AbstractCurry: instance Eq CEvalAnnot
- Curry.AbstractCurry: instance Eq CFixity
- Curry.AbstractCurry: instance Eq CLiteral
- Curry.AbstractCurry: instance Eq CVisibility
- Curry.AbstractCurry: instance Read CBranchExpr
- Curry.AbstractCurry: instance Read CConsDecl
- Curry.AbstractCurry: instance Read CEvalAnnot
- Curry.AbstractCurry: instance Read CExpr
- Curry.AbstractCurry: instance Read CFixity
- Curry.AbstractCurry: instance Read CFuncDecl
- Curry.AbstractCurry: instance Read CLiteral
- Curry.AbstractCurry: instance Read CLocalDecl
- Curry.AbstractCurry: instance Read COpDecl
- Curry.AbstractCurry: instance Read CPattern
- Curry.AbstractCurry: instance Read CRule
- Curry.AbstractCurry: instance Read CRules
- Curry.AbstractCurry: instance Read CStatement
- Curry.AbstractCurry: instance Read CTypeDecl
- Curry.AbstractCurry: instance Read CTypeExpr
- Curry.AbstractCurry: instance Read CVisibility
- Curry.AbstractCurry: instance Read CurryProg
- Curry.AbstractCurry: instance Show CBranchExpr
- Curry.AbstractCurry: instance Show CConsDecl
- Curry.AbstractCurry: instance Show CEvalAnnot
- Curry.AbstractCurry: instance Show CExpr
- Curry.AbstractCurry: instance Show CFixity
- Curry.AbstractCurry: instance Show CFuncDecl
- Curry.AbstractCurry: instance Show CLiteral
- Curry.AbstractCurry: instance Show CLocalDecl
- Curry.AbstractCurry: instance Show COpDecl
- Curry.AbstractCurry: instance Show CPattern
- Curry.AbstractCurry: instance Show CRule
- Curry.AbstractCurry: instance Show CRules
- Curry.AbstractCurry: instance Show CStatement
- Curry.AbstractCurry: instance Show CTypeDecl
- Curry.AbstractCurry: instance Show CTypeExpr
- Curry.AbstractCurry: instance Show CVisibility
- Curry.AbstractCurry: instance Show CurryProg
- Curry.AbstractCurry: readCurry :: String -> IO CurryProg
- Curry.AbstractCurry: type CField a = (CLabel, a)
- Curry.AbstractCurry: type CLabel = String
- Curry.AbstractCurry: type CTVarIName = (Int, String)
- Curry.AbstractCurry: type CVarIName = (Int, String)
- Curry.AbstractCurry: type QName = (String, String)
- Curry.AbstractCurry: writeCurry :: String -> CurryProg -> IO ()
- Curry.Syntax: parseHeader :: FilePath -> String -> MsgMonad Module
- Curry.Syntax: parseModule :: Bool -> FilePath -> String -> MsgMonad Module
- Curry.Syntax.Frontend: fullParse :: [FilePath] -> FilePath -> String -> IO (MsgMonad Module)
- Curry.Syntax.Frontend: lex :: FilePath -> String -> MsgMonad [(Position, Token)]
- Curry.Syntax.Frontend: parse :: FilePath -> String -> MsgMonad Module
- Curry.Syntax.Frontend: typingParse :: [FilePath] -> FilePath -> String -> IO (MsgMonad Module)
- Curry.Syntax.LLParseComb: (<$->) :: (Symbol s) => a -> Parser s b c -> Parser s a c
- Curry.Syntax.LLParseComb: (<$>) :: (Symbol s) => (a -> b) -> Parser s a c -> Parser s b c
- Curry.Syntax.LLParseComb: (<**>) :: (Symbol s) => Parser s a c -> Parser s (a -> b) c -> Parser s b c
- Curry.Syntax.LLParseComb: (<*->) :: (Symbol s) => Parser s a c -> Parser s b c -> Parser s a c
- Curry.Syntax.LLParseComb: (<*>) :: (Symbol s) => Parser s (a -> b) c -> Parser s a c -> Parser s b c
- Curry.Syntax.LLParseComb: (<-*>) :: (Symbol s) => Parser s a c -> Parser s b c -> Parser s b c
- Curry.Syntax.LLParseComb: (<.>) :: (Symbol s) => Parser s (a -> b) d -> Parser s (b -> c) d -> Parser s (a -> c) d
- Curry.Syntax.LLParseComb: (<?>) :: (Symbol s) => Parser s a b -> String -> Parser s a b
- Curry.Syntax.LLParseComb: (<??>) :: (Symbol s) => Parser s a b -> Parser s (a -> a) b -> Parser s a b
- Curry.Syntax.LLParseComb: (<\>) :: (Symbol s) => Parser s a c -> Parser s b c -> Parser s a c
- Curry.Syntax.LLParseComb: (<\\>) :: (Symbol s) => Parser s a b -> [s] -> Parser s a b
- Curry.Syntax.LLParseComb: (<|>) :: (Symbol s) => Parser s a b -> Parser s a b -> Parser s a b
- Curry.Syntax.LLParseComb: (<|?>) :: (Symbol s) => Parser s a b -> Parser s a b -> Parser s a b
- Curry.Syntax.LLParseComb: applyParser :: (Symbol s) => Parser s a a -> Lexer s a -> FilePath -> String -> MsgMonad a
- Curry.Syntax.LLParseComb: bracket :: (Symbol s) => Parser s a c -> Parser s b c -> Parser s a c -> Parser s b c
- Curry.Syntax.LLParseComb: chainl :: (Symbol s) => Parser s a b -> Parser s (a -> a -> a) b -> a -> Parser s a b
- Curry.Syntax.LLParseComb: chainl1 :: (Symbol s) => Parser s a b -> Parser s (a -> a -> a) b -> Parser s a b
- Curry.Syntax.LLParseComb: chainr :: (Symbol s) => Parser s a b -> Parser s (a -> a -> a) b -> a -> Parser s a b
- Curry.Syntax.LLParseComb: chainr1 :: (Symbol s) => Parser s a b -> Parser s (a -> a -> a) b -> Parser s a b
- Curry.Syntax.LLParseComb: class (Ord s, Show s) => Symbol s
- Curry.Syntax.LLParseComb: data Parser s a b
- Curry.Syntax.LLParseComb: instance (Symbol s) => Show (Parser s a b)
- Curry.Syntax.LLParseComb: isEOF :: (Symbol s) => s -> Bool
- Curry.Syntax.LLParseComb: layoutEnd :: (Symbol s) => Parser s a b
- Curry.Syntax.LLParseComb: layoutOff :: (Symbol s) => Parser s a b
- Curry.Syntax.LLParseComb: layoutOn :: (Symbol s) => Parser s a b
- Curry.Syntax.LLParseComb: many :: (Symbol s) => Parser s a b -> Parser s [a] b
- Curry.Syntax.LLParseComb: many1 :: (Symbol s) => Parser s a b -> Parser s [a] b
- Curry.Syntax.LLParseComb: ops :: (Symbol s) => [(s, a)] -> Parser s a b
- Curry.Syntax.LLParseComb: opt :: (Symbol s) => Parser s a b -> a -> Parser s a b
- Curry.Syntax.LLParseComb: position :: (Symbol s) => Parser s Position b
- Curry.Syntax.LLParseComb: prefixParser :: (Symbol s) => Parser s a a -> Lexer s a -> FilePath -> String -> MsgMonad a
- Curry.Syntax.LLParseComb: sepBy :: (Symbol s) => Parser s a c -> Parser s b c -> Parser s [a] c
- Curry.Syntax.LLParseComb: sepBy1 :: (Symbol s) => Parser s a c -> Parser s b c -> Parser s [a] c
- Curry.Syntax.LLParseComb: succeed :: (Symbol s) => a -> Parser s a b
- Curry.Syntax.LLParseComb: symbol :: (Symbol s) => s -> Parser s s a
- Curry.Syntax.LexComb: closeP0 :: P a -> P (P a)
- Curry.Syntax.LexComb: closeP1 :: (a -> P b) -> P (a -> P b)
- Curry.Syntax.LexComb: convertFloating :: (Fractional a) => String -> String -> Int -> a
- Curry.Syntax.LexComb: convertIntegral :: (Num a) => a -> String -> a
- Curry.Syntax.LexComb: convertSignedFloating :: (Fractional a) => String -> String -> Int -> a
- Curry.Syntax.LexComb: convertSignedIntegral :: (Num a) => a -> String -> a
- Curry.Syntax.LexComb: failP :: Position -> String -> P a
- Curry.Syntax.LexComb: parse :: P a -> FilePath -> String -> MsgMonad a
- Curry.Syntax.LexComb: parseError :: Position -> String -> String
- Curry.Syntax.LexComb: popContext :: P a -> P a
- Curry.Syntax.LexComb: pushContext :: Int -> P a -> P a
- Curry.Syntax.LexComb: returnP :: a -> P a
- Curry.Syntax.LexComb: thenP :: P a -> (a -> P b) -> P b
- Curry.Syntax.LexComb: thenP_ :: P a -> P b -> P b
- Curry.Syntax.LexComb: type Context = [Indent]
- Curry.Syntax.LexComb: type Indent = Int
- Curry.Syntax.LexComb: type P a = Position -> String -> Bool -> Context -> MsgMonad a
- Curry.Syntax.Lexer: At :: Category
- Curry.Syntax.Lexer: Backquote :: Category
- Curry.Syntax.Lexer: Backslash :: Category
- Curry.Syntax.Lexer: Bar :: Category
- Curry.Syntax.Lexer: Binds :: Category
- Curry.Syntax.Lexer: CharAttributes :: Char -> String -> Attributes
- Curry.Syntax.Lexer: CharTok :: Category
- Curry.Syntax.Lexer: Colon :: Category
- Curry.Syntax.Lexer: Comma :: Category
- Curry.Syntax.Lexer: DotDot :: Category
- Curry.Syntax.Lexer: DoubleColon :: Category
- Curry.Syntax.Lexer: EOF :: Category
- Curry.Syntax.Lexer: Equals :: Category
- Curry.Syntax.Lexer: FloatAttributes :: Double -> String -> Attributes
- Curry.Syntax.Lexer: FloatTok :: Category
- Curry.Syntax.Lexer: Id :: Category
- Curry.Syntax.Lexer: Id_as :: Category
- Curry.Syntax.Lexer: Id_ccall :: Category
- Curry.Syntax.Lexer: Id_forall :: Category
- Curry.Syntax.Lexer: Id_hiding :: Category
- Curry.Syntax.Lexer: Id_interface :: Category
- Curry.Syntax.Lexer: Id_primitive :: Category
- Curry.Syntax.Lexer: Id_qualified :: Category
- Curry.Syntax.Lexer: IdentAttributes :: [String] -> String -> Attributes
- Curry.Syntax.Lexer: IntAttributes :: Int -> String -> Attributes
- Curry.Syntax.Lexer: IntTok :: Category
- Curry.Syntax.Lexer: IntegerAttributes :: Integer -> String -> Attributes
- Curry.Syntax.Lexer: IntegerTok :: Category
- Curry.Syntax.Lexer: KW_case :: Category
- Curry.Syntax.Lexer: KW_choice :: Category
- Curry.Syntax.Lexer: KW_data :: Category
- Curry.Syntax.Lexer: KW_do :: Category
- Curry.Syntax.Lexer: KW_else :: Category
- Curry.Syntax.Lexer: KW_eval :: Category
- Curry.Syntax.Lexer: KW_external :: Category
- Curry.Syntax.Lexer: KW_free :: Category
- Curry.Syntax.Lexer: KW_if :: Category
- Curry.Syntax.Lexer: KW_import :: Category
- Curry.Syntax.Lexer: KW_in :: Category
- Curry.Syntax.Lexer: KW_infix :: Category
- Curry.Syntax.Lexer: KW_infixl :: Category
- Curry.Syntax.Lexer: KW_infixr :: Category
- Curry.Syntax.Lexer: KW_let :: Category
- Curry.Syntax.Lexer: KW_module :: Category
- Curry.Syntax.Lexer: KW_newtype :: Category
- Curry.Syntax.Lexer: KW_of :: Category
- Curry.Syntax.Lexer: KW_rigid :: Category
- Curry.Syntax.Lexer: KW_then :: Category
- Curry.Syntax.Lexer: KW_type :: Category
- Curry.Syntax.Lexer: KW_where :: Category
- Curry.Syntax.Lexer: LeftArrow :: Category
- Curry.Syntax.Lexer: LeftBrace :: Category
- Curry.Syntax.Lexer: LeftBraceSemicolon :: Category
- Curry.Syntax.Lexer: LeftBracket :: Category
- Curry.Syntax.Lexer: LeftParen :: Category
- Curry.Syntax.Lexer: LineComment :: Category
- Curry.Syntax.Lexer: NestedComment :: Category
- Curry.Syntax.Lexer: NoAttributes :: Attributes
- Curry.Syntax.Lexer: QId :: Category
- Curry.Syntax.Lexer: QSym :: Category
- Curry.Syntax.Lexer: RightArrow :: Category
- Curry.Syntax.Lexer: RightBrace :: Category
- Curry.Syntax.Lexer: RightBracket :: Category
- Curry.Syntax.Lexer: RightParen :: Category
- Curry.Syntax.Lexer: Semicolon :: Category
- Curry.Syntax.Lexer: StringAttributes :: String -> String -> Attributes
- Curry.Syntax.Lexer: StringTok :: Category
- Curry.Syntax.Lexer: Sym :: Category
- Curry.Syntax.Lexer: Sym_Dot :: Category
- Curry.Syntax.Lexer: Sym_Minus :: Category
- Curry.Syntax.Lexer: Sym_MinusDot :: Category
- Curry.Syntax.Lexer: Tilde :: Category
- Curry.Syntax.Lexer: Token :: Category -> Attributes -> Token
- Curry.Syntax.Lexer: Underscore :: Category
- Curry.Syntax.Lexer: VRightBrace :: Category
- Curry.Syntax.Lexer: VSemicolon :: Category
- Curry.Syntax.Lexer: cval :: Attributes -> Char
- Curry.Syntax.Lexer: data Attributes
- Curry.Syntax.Lexer: data Category
- Curry.Syntax.Lexer: data Token
- Curry.Syntax.Lexer: fval :: Attributes -> Double
- Curry.Syntax.Lexer: instance Eq Category
- Curry.Syntax.Lexer: instance Eq Token
- Curry.Syntax.Lexer: instance Ord Category
- Curry.Syntax.Lexer: instance Ord Token
- Curry.Syntax.Lexer: instance Show Attributes
- Curry.Syntax.Lexer: instance Show Token
- Curry.Syntax.Lexer: intval :: Attributes -> Integer
- Curry.Syntax.Lexer: ival :: Attributes -> Int
- Curry.Syntax.Lexer: lexFile :: P [(Position, Token)]
- Curry.Syntax.Lexer: lexer :: SuccessP a -> FailP a -> P a
- Curry.Syntax.Lexer: modul :: Attributes -> [String]
- Curry.Syntax.Lexer: original :: Attributes -> String
- Curry.Syntax.Lexer: sval :: Attributes -> String
- Curry.Syntax.Parser: alt :: Bool -> Parser Token Alt a
- Curry.Syntax.Parser: alts :: Bool -> Parser Token [Alt] a
- Curry.Syntax.Parser: anonPattern :: Parser Token ConstrTerm a
- Curry.Syntax.Parser: anonType :: Parser Token TypeExpr a
- Curry.Syntax.Parser: backquote :: Parser Token Attributes a
- Curry.Syntax.Parser: backquotes :: Parser Token a b -> Parser Token a b
- Curry.Syntax.Parser: bar :: Parser Token Attributes a
- Curry.Syntax.Parser: binds :: Parser Token Attributes a
- Curry.Syntax.Parser: braces :: Parser Token a b -> Parser Token a b
- Curry.Syntax.Parser: brackets :: Parser Token a b -> Parser Token a b
- Curry.Syntax.Parser: caseExpr :: Bool -> Parser Token Expression a
- Curry.Syntax.Parser: char :: Parser Token Char a
- Curry.Syntax.Parser: checkBackquote :: Parser Token Attributes a
- Curry.Syntax.Parser: checkBar :: Parser Token Attributes a
- Curry.Syntax.Parser: checkBinds :: Parser Token Attributes a
- Curry.Syntax.Parser: checkEquals :: Parser Token Attributes a
- Curry.Syntax.Parser: checkFloat :: Parser Token Double a
- Curry.Syntax.Parser: checkInt :: Parser Token Int a
- Curry.Syntax.Parser: checkInteger :: Parser Token Integer a
- Curry.Syntax.Parser: colon :: Parser Token QualIdent a
- Curry.Syntax.Parser: comma :: Parser Token Attributes a
- Curry.Syntax.Parser: con :: Parser Token Ident a
- Curry.Syntax.Parser: conId :: Parser Token Ident a
- Curry.Syntax.Parser: conSym :: Parser Token Ident a
- Curry.Syntax.Parser: condExpr :: Bool -> Parser Token a b -> Parser Token CondExpr b
- Curry.Syntax.Parser: conop :: Parser Token Ident a
- Curry.Syntax.Parser: constant :: Parser Token Expression a
- Curry.Syntax.Parser: constrDecl :: Bool -> Parser Token ConstrDecl a
- Curry.Syntax.Parser: constrTerm0 :: Parser Token ConstrTerm a
- Curry.Syntax.Parser: constrTerm1 :: Parser Token ConstrTerm a
- Curry.Syntax.Parser: constrTerm2 :: Parser Token ConstrTerm a
- Curry.Syntax.Parser: curriedLhs :: Parser Token (Ident, Lhs) a
- Curry.Syntax.Parser: dataDecl :: Bool -> Parser Token Decl a
- Curry.Syntax.Parser: declRhs :: Bool -> Parser Token Rhs a
- Curry.Syntax.Parser: decls :: Bool -> Parser Token [Decl] a
- Curry.Syntax.Parser: doExpr :: Bool -> Parser Token Expression a
- Curry.Syntax.Parser: dot :: Parser Token Attributes a
- Curry.Syntax.Parser: equals :: Parser Token Attributes a
- Curry.Syntax.Parser: existVars :: Parser Token [Ident] a
- Curry.Syntax.Parser: export :: Parser Token Export a
- Curry.Syntax.Parser: exportSpec :: Parser Token ExportSpec a
- Curry.Syntax.Parser: expr :: Bool -> Parser Token Expression a
- Curry.Syntax.Parser: expr0 :: Bool -> Parser Token Expression a
- Curry.Syntax.Parser: expr1 :: Bool -> Parser Token Expression a
- Curry.Syntax.Parser: expr2 :: Bool -> Parser Token Expression a
- Curry.Syntax.Parser: expr3 :: Bool -> Parser Token Expression a
- Curry.Syntax.Parser: exprOrBindStmt :: Bool -> Parser Token (Statement -> a) b -> Parser Token (Expression -> a) b -> Parser Token a b
- Curry.Syntax.Parser: externalDecl :: Parser Token Decl a
- Curry.Syntax.Parser: float :: Parser Token Double a
- Curry.Syntax.Parser: fminus :: Parser Token Ident a
- Curry.Syntax.Parser: fun :: Parser Token Ident a
- Curry.Syntax.Parser: funDecl :: (Ident, Lhs) -> Rhs -> Position -> Decl
- Curry.Syntax.Parser: funId :: Parser Token Ident a
- Curry.Syntax.Parser: funLhs :: Parser Token (Ident, Lhs) a
- Curry.Syntax.Parser: funListDecl :: Bool -> Parser Token ([Ident] -> Position -> Decl) a
- Curry.Syntax.Parser: funSym :: Parser Token Ident a
- Curry.Syntax.Parser: functionDecl :: Bool -> Parser Token Decl a
- Curry.Syntax.Parser: funop :: Parser Token Ident a
- Curry.Syntax.Parser: gconId :: Parser Token QualIdent a
- Curry.Syntax.Parser: gconop :: Parser Token QualIdent a
- Curry.Syntax.Parser: globalDecls :: Bool -> Parser Token [Decl] a
- Curry.Syntax.Parser: ident :: Parser Token Ident a
- Curry.Syntax.Parser: identPattern :: Parser Token ConstrTerm a
- Curry.Syntax.Parser: identType :: Parser Token TypeExpr a
- Curry.Syntax.Parser: ifExpr :: Bool -> Parser Token Expression a
- Curry.Syntax.Parser: importDecl :: Parser Token Decl a
- Curry.Syntax.Parser: importSpec :: Parser Token ImportSpec a
- Curry.Syntax.Parser: infixDecl :: Parser Token Decl a
- Curry.Syntax.Parser: infixDeclLhs :: (Position -> Infix -> Integer -> a) -> Parser Token a b
- Curry.Syntax.Parser: infixOp :: Parser Token InfixOp a
- Curry.Syntax.Parser: instance Symbol Token
- Curry.Syntax.Parser: int :: Parser Token Int a
- Curry.Syntax.Parser: integer :: Parser Token Integer a
- Curry.Syntax.Parser: labId :: Parser Token Ident a
- Curry.Syntax.Parser: lambdaExpr :: Bool -> Parser Token Expression a
- Curry.Syntax.Parser: layout :: Parser Token a b -> Parser Token a b
- Curry.Syntax.Parser: lazyPattern :: Parser Token ConstrTerm a
- Curry.Syntax.Parser: leftArrow :: Parser Token Attributes a
- Curry.Syntax.Parser: leftBrace :: Parser Token Attributes a
- Curry.Syntax.Parser: leftBraceSemicolon :: Parser Token Attributes a
- Curry.Syntax.Parser: leftBracket :: Parser Token Attributes a
- Curry.Syntax.Parser: leftParen :: Parser Token Attributes a
- Curry.Syntax.Parser: letExpr :: Bool -> Parser Token Expression a
- Curry.Syntax.Parser: letStmt :: Bool -> Parser Token (Statement -> a) b -> Parser Token (Expression -> a) b -> Parser Token a b
- Curry.Syntax.Parser: listExpr :: Bool -> Parser Token Expression a
- Curry.Syntax.Parser: listPattern :: Parser Token ConstrTerm a
- Curry.Syntax.Parser: listType :: Parser Token TypeExpr a
- Curry.Syntax.Parser: literal :: Parser Token Literal a
- Curry.Syntax.Parser: literalPattern :: Parser Token ConstrTerm a
- Curry.Syntax.Parser: localDefs :: Bool -> Parser Token [Decl] a
- Curry.Syntax.Parser: mIdent :: Parser Token ModuleIdent a
- Curry.Syntax.Parser: minus :: Parser Token Ident a
- Curry.Syntax.Parser: mkIdentPosition :: Position -> String -> Ident
- Curry.Syntax.Parser: moduleHeader :: Parser Token ([Decl] -> Module) a
- Curry.Syntax.Parser: negFloat :: Parser Token (Ident -> ConstrTerm) a
- Curry.Syntax.Parser: negNum :: Parser Token (Ident -> ConstrTerm) a
- Curry.Syntax.Parser: newConstrDecl :: Parser Token NewConstrDecl a
- Curry.Syntax.Parser: newtypeDecl :: Parser Token Decl a
- Curry.Syntax.Parser: optAsPattern :: Parser Token (Ident -> ConstrTerm) a
- Curry.Syntax.Parser: optInfixPattern :: Parser Token (ConstrTerm -> ConstrTerm) a
- Curry.Syntax.Parser: optStmts :: Bool -> Parser Token (Expression -> ([Statement], Expression)) a
- Curry.Syntax.Parser: optTuplePattern :: Parser Token (ConstrTerm -> ConstrTerm) a
- Curry.Syntax.Parser: parenExpr :: Bool -> Parser Token Expression a
- Curry.Syntax.Parser: parenMinusPattern :: Parser Token (Ident -> ConstrTerm) a -> Parser Token (Ident -> ConstrTerm) a
- Curry.Syntax.Parser: parenPattern :: Parser Token ConstrTerm a
- Curry.Syntax.Parser: parenTuplePattern :: Parser Token ConstrTerm a
- Curry.Syntax.Parser: parenType :: Parser Token TypeExpr a
- Curry.Syntax.Parser: parens :: Parser Token a b -> Parser Token a b
- Curry.Syntax.Parser: parseHeader :: FilePath -> String -> MsgMonad Module
- Curry.Syntax.Parser: parseSource :: Bool -> FilePath -> String -> MsgMonad Module
- Curry.Syntax.Parser: patDecl :: ConstrTerm -> Rhs -> Position -> Decl
- Curry.Syntax.Parser: qConId :: Parser Token QualIdent a
- Curry.Syntax.Parser: qConSym :: Parser Token QualIdent a
- Curry.Syntax.Parser: qFunId :: Parser Token QualIdent a
- Curry.Syntax.Parser: qFunSym :: Parser Token QualIdent a
- Curry.Syntax.Parser: qIdent :: Parser Token QualIdent a
- Curry.Syntax.Parser: qLabId :: Parser Token QualIdent a
- Curry.Syntax.Parser: qSym :: Parser Token QualIdent a
- Curry.Syntax.Parser: qcon :: Parser Token QualIdent a
- Curry.Syntax.Parser: qconop :: Parser Token QualIdent a
- Curry.Syntax.Parser: qfun :: Parser Token QualIdent a
- Curry.Syntax.Parser: qfunop :: Parser Token QualIdent a
- Curry.Syntax.Parser: qtycon :: Parser Token QualIdent a
- Curry.Syntax.Parser: quals :: Bool -> Parser Token [Statement] a
- Curry.Syntax.Parser: recordExpr :: Bool -> Parser Token Expression a
- Curry.Syntax.Parser: recordPattern :: Parser Token ConstrTerm a
- Curry.Syntax.Parser: reqStmts :: Bool -> Parser Token (Statement -> ([Statement], Expression)) a
- Curry.Syntax.Parser: rhs :: Bool -> Parser Token a b -> Parser Token Rhs b
- Curry.Syntax.Parser: rightBrace :: Parser Token Attributes a
- Curry.Syntax.Parser: rightBracket :: Parser Token Attributes a
- Curry.Syntax.Parser: rightParen :: Parser Token Attributes a
- Curry.Syntax.Parser: semicolon :: Parser Token Attributes a
- Curry.Syntax.Parser: stmt :: Bool -> Parser Token (Statement -> a) b -> Parser Token (Expression -> a) b -> Parser Token a b
- Curry.Syntax.Parser: stmts :: Bool -> Parser Token ([Statement], Expression) a
- Curry.Syntax.Parser: string :: Parser Token String a
- Curry.Syntax.Parser: sym :: Parser Token Ident a
- Curry.Syntax.Parser: token :: Category -> Parser Token Attributes a
- Curry.Syntax.Parser: tokenOps :: [(Category, a)] -> Parser Token a b
- Curry.Syntax.Parser: tokens :: [Category] -> Parser Token Attributes a
- Curry.Syntax.Parser: topDecl :: Bool -> Parser Token Decl a
- Curry.Syntax.Parser: tupleCommas :: Parser Token QualIdent a
- Curry.Syntax.Parser: tupleType :: Parser Token TypeExpr a
- Curry.Syntax.Parser: tycon :: Parser Token Ident a
- Curry.Syntax.Parser: type0 :: Parser Token TypeExpr a
- Curry.Syntax.Parser: type1 :: Parser Token TypeExpr a
- Curry.Syntax.Parser: type2 :: Parser Token TypeExpr a
- Curry.Syntax.Parser: typeDecl :: Parser Token Decl a
- Curry.Syntax.Parser: typeDeclLhs :: (Position -> Ident -> [Ident] -> a) -> Category -> Parser Token a b
- Curry.Syntax.Parser: typeDeclRhs :: Parser Token TypeExpr a
- Curry.Syntax.Parser: tyvar :: Parser Token Ident a
- Curry.Syntax.Parser: valListDecl :: Bool -> Parser Token ([Ident] -> Position -> Decl) a
- Curry.Syntax.Parser: valueDecl :: Bool -> Parser Token Decl a
- Curry.Syntax.Parser: valueDecls :: Bool -> Parser Token [Decl] a
- Curry.Syntax.Parser: var :: Parser Token Ident a
- Curry.Syntax.Parser: varId :: Parser Token Ident a
- Curry.Syntax.Parser: variable :: Parser Token Expression a
- Curry.Syntax.Pretty: backQuote :: Doc
- Curry.Syntax.Pretty: backQuoteExp :: Bool -> Doc -> Doc
- Curry.Syntax.Pretty: backsl :: Doc
- Curry.Syntax.Pretty: braceList :: [Doc] -> Doc
- Curry.Syntax.Pretty: bracketList :: [Doc] -> Doc
- Curry.Syntax.Pretty: indent :: Doc -> Doc
- Curry.Syntax.Pretty: larrow :: Doc
- Curry.Syntax.Pretty: list :: [Doc] -> Doc
- Curry.Syntax.Pretty: maybePP :: (a -> Doc) -> Maybe a -> Doc
- Curry.Syntax.Pretty: parenExp :: Bool -> Doc -> Doc
- Curry.Syntax.Pretty: parenList :: [Doc] -> Doc
- Curry.Syntax.Pretty: ppAlt :: Alt -> Doc
- Curry.Syntax.Pretty: ppBlock :: [Decl] -> Doc
- Curry.Syntax.Pretty: ppCondExpr :: Doc -> CondExpr -> Doc
- Curry.Syntax.Pretty: ppConstr :: ConstrDecl -> Doc
- Curry.Syntax.Pretty: ppConstrTerm :: Int -> ConstrTerm -> Doc
- Curry.Syntax.Pretty: ppDecl :: Decl -> Doc
- Curry.Syntax.Pretty: ppEquation :: Equation -> Doc
- Curry.Syntax.Pretty: ppExistVars :: [Ident] -> Doc
- Curry.Syntax.Pretty: ppExport :: Export -> Doc
- Curry.Syntax.Pretty: ppExportSpec :: ExportSpec -> Doc
- Curry.Syntax.Pretty: ppExpr :: Int -> Expression -> Doc
- Curry.Syntax.Pretty: ppFieldExpr :: Doc -> Field Expression -> Doc
- Curry.Syntax.Pretty: ppFieldPatt :: Field ConstrTerm -> Doc
- Curry.Syntax.Pretty: ppIDecl :: IDecl -> Doc
- Curry.Syntax.Pretty: ppITypeDeclLhs :: String -> QualIdent -> [Ident] -> Doc
- Curry.Syntax.Pretty: ppIdent :: Ident -> Doc
- Curry.Syntax.Pretty: ppImport :: Import -> Doc
- Curry.Syntax.Pretty: ppImportSpec :: ImportSpec -> Doc
- Curry.Syntax.Pretty: ppInfixOp :: Ident -> Doc
- Curry.Syntax.Pretty: ppInterface :: Interface -> Doc
- Curry.Syntax.Pretty: ppLhs :: Lhs -> Doc
- Curry.Syntax.Pretty: ppLiteral :: Literal -> Doc
- Curry.Syntax.Pretty: ppLocalDefs :: [Decl] -> Doc
- Curry.Syntax.Pretty: ppMIdent :: ModuleIdent -> Doc
- Curry.Syntax.Pretty: ppModule :: Module -> Doc
- Curry.Syntax.Pretty: ppModuleHeader :: ModuleIdent -> Maybe ExportSpec -> Doc
- Curry.Syntax.Pretty: ppNewConstr :: NewConstrDecl -> Doc
- Curry.Syntax.Pretty: ppOp :: InfixOp -> Doc
- Curry.Syntax.Pretty: ppPrec :: Infix -> Integer -> Doc
- Curry.Syntax.Pretty: ppQIdent :: QualIdent -> Doc
- Curry.Syntax.Pretty: ppQInfixOp :: QualIdent -> Doc
- Curry.Syntax.Pretty: ppRule :: Doc -> Doc -> Rhs -> Doc
- Curry.Syntax.Pretty: ppStmt :: Statement -> Doc
- Curry.Syntax.Pretty: ppTypeDeclLhs :: String -> Ident -> [Ident] -> Doc
- Curry.Syntax.Pretty: ppTypeExpr :: Int -> TypeExpr -> Doc
- Curry.Syntax.Pretty: rarrow :: Doc
- Curry.Syntax.Pretty: vbar :: Doc
- Curry.Syntax.ShowModule: showModule :: Module -> String
- Curry.Syntax.Type: Alt :: Position -> ConstrTerm -> Rhs -> Alt
- Curry.Syntax.Type: ApLhs :: Lhs -> [ConstrTerm] -> Lhs
- Curry.Syntax.Type: Apply :: Expression -> Expression -> Expression
- Curry.Syntax.Type: ArrowType :: TypeExpr -> TypeExpr -> TypeExpr
- Curry.Syntax.Type: AsPattern :: Ident -> ConstrTerm -> ConstrTerm
- Curry.Syntax.Type: CallConvCCall :: CallConv
- Curry.Syntax.Type: CallConvPrimitive :: CallConv
- Curry.Syntax.Type: Case :: SrcRef -> Expression -> [Alt] -> Expression
- Curry.Syntax.Type: Char :: SrcRef -> Char -> Literal
- Curry.Syntax.Type: ConOpDecl :: Position -> [Ident] -> TypeExpr -> Ident -> TypeExpr -> ConstrDecl
- Curry.Syntax.Type: CondExpr :: Position -> Expression -> Expression -> CondExpr
- Curry.Syntax.Type: ConstrDecl :: Position -> [Ident] -> Ident -> [TypeExpr] -> ConstrDecl
- Curry.Syntax.Type: Constructor :: QualIdent -> Expression
- Curry.Syntax.Type: ConstructorPattern :: QualIdent -> [ConstrTerm] -> ConstrTerm
- Curry.Syntax.Type: ConstructorType :: QualIdent -> [TypeExpr] -> TypeExpr
- Curry.Syntax.Type: DataDecl :: Position -> Ident -> [Ident] -> [ConstrDecl] -> Decl
- Curry.Syntax.Type: Do :: [Statement] -> Expression -> Expression
- Curry.Syntax.Type: EnumFrom :: Expression -> Expression
- Curry.Syntax.Type: EnumFromThen :: Expression -> Expression -> Expression
- Curry.Syntax.Type: EnumFromThenTo :: Expression -> Expression -> Expression -> Expression
- Curry.Syntax.Type: EnumFromTo :: Expression -> Expression -> Expression
- Curry.Syntax.Type: Equation :: Position -> Lhs -> Rhs -> Equation
- Curry.Syntax.Type: EvalAnnot :: Position -> [Ident] -> EvalAnnotation -> Decl
- Curry.Syntax.Type: EvalChoice :: EvalAnnotation
- Curry.Syntax.Type: EvalRigid :: EvalAnnotation
- Curry.Syntax.Type: Export :: QualIdent -> Export
- Curry.Syntax.Type: ExportModule :: ModuleIdent -> Export
- Curry.Syntax.Type: ExportTypeAll :: QualIdent -> Export
- Curry.Syntax.Type: ExportTypeWith :: QualIdent -> [Ident] -> Export
- Curry.Syntax.Type: Exporting :: Position -> [Export] -> ExportSpec
- Curry.Syntax.Type: ExternalDecl :: Position -> CallConv -> (Maybe String) -> Ident -> TypeExpr -> Decl
- Curry.Syntax.Type: ExtraVariables :: Position -> [Ident] -> Decl
- Curry.Syntax.Type: Field :: Position -> Ident -> a -> Field a
- Curry.Syntax.Type: FlatExternalDecl :: Position -> [Ident] -> Decl
- Curry.Syntax.Type: Float :: SrcRef -> Double -> Literal
- Curry.Syntax.Type: FunLhs :: Ident -> [ConstrTerm] -> Lhs
- Curry.Syntax.Type: FunctionDecl :: Position -> Ident -> [Equation] -> Decl
- Curry.Syntax.Type: FunctionPattern :: QualIdent -> [ConstrTerm] -> ConstrTerm
- Curry.Syntax.Type: GuardedRhs :: [CondExpr] -> [Decl] -> Rhs
- Curry.Syntax.Type: Hiding :: Position -> [Import] -> ImportSpec
- Curry.Syntax.Type: HidingDataDecl :: Position -> Ident -> [Ident] -> IDecl
- Curry.Syntax.Type: IDataDecl :: Position -> QualIdent -> [Ident] -> [Maybe ConstrDecl] -> IDecl
- Curry.Syntax.Type: IFunctionDecl :: Position -> QualIdent -> Int -> TypeExpr -> IDecl
- Curry.Syntax.Type: IImportDecl :: Position -> ModuleIdent -> IDecl
- Curry.Syntax.Type: IInfixDecl :: Position -> Infix -> Integer -> QualIdent -> IDecl
- Curry.Syntax.Type: INewtypeDecl :: Position -> QualIdent -> [Ident] -> NewConstrDecl -> IDecl
- Curry.Syntax.Type: ITypeDecl :: Position -> QualIdent -> [Ident] -> TypeExpr -> IDecl
- Curry.Syntax.Type: IfThenElse :: SrcRef -> Expression -> Expression -> Expression -> Expression
- Curry.Syntax.Type: Import :: Ident -> Import
- Curry.Syntax.Type: ImportDecl :: Position -> ModuleIdent -> Qualified -> (Maybe ModuleIdent) -> (Maybe ImportSpec) -> Decl
- Curry.Syntax.Type: ImportTypeAll :: Ident -> Import
- Curry.Syntax.Type: ImportTypeWith :: Ident -> [Ident] -> Import
- Curry.Syntax.Type: Importing :: Position -> [Import] -> ImportSpec
- Curry.Syntax.Type: Infix :: Infix
- Curry.Syntax.Type: InfixApply :: Expression -> InfixOp -> Expression -> Expression
- Curry.Syntax.Type: InfixConstr :: QualIdent -> InfixOp
- Curry.Syntax.Type: InfixDecl :: Position -> Infix -> Integer -> [Ident] -> Decl
- Curry.Syntax.Type: InfixFuncPattern :: ConstrTerm -> QualIdent -> ConstrTerm -> ConstrTerm
- Curry.Syntax.Type: InfixL :: Infix
- Curry.Syntax.Type: InfixOp :: QualIdent -> InfixOp
- Curry.Syntax.Type: InfixPattern :: ConstrTerm -> QualIdent -> ConstrTerm -> ConstrTerm
- Curry.Syntax.Type: InfixR :: Infix
- Curry.Syntax.Type: Int :: Ident -> Integer -> Literal
- Curry.Syntax.Type: Interface :: ModuleIdent -> [IDecl] -> Interface
- Curry.Syntax.Type: Lambda :: SrcRef -> [ConstrTerm] -> Expression -> Expression
- Curry.Syntax.Type: LazyPattern :: SrcRef -> ConstrTerm -> ConstrTerm
- Curry.Syntax.Type: LeftSection :: Expression -> InfixOp -> Expression
- Curry.Syntax.Type: Let :: [Decl] -> Expression -> Expression
- Curry.Syntax.Type: List :: [SrcRef] -> [Expression] -> Expression
- Curry.Syntax.Type: ListCompr :: SrcRef -> Expression -> [Statement] -> Expression
- Curry.Syntax.Type: ListPattern :: [SrcRef] -> [ConstrTerm] -> ConstrTerm
- Curry.Syntax.Type: ListType :: TypeExpr -> TypeExpr
- Curry.Syntax.Type: Literal :: Literal -> Expression
- Curry.Syntax.Type: LiteralPattern :: Literal -> ConstrTerm
- Curry.Syntax.Type: Module :: ModuleIdent -> (Maybe ExportSpec) -> [Decl] -> Module
- Curry.Syntax.Type: NegativePattern :: Ident -> Literal -> ConstrTerm
- Curry.Syntax.Type: NewConstrDecl :: Position -> [Ident] -> Ident -> TypeExpr -> NewConstrDecl
- Curry.Syntax.Type: NewtypeDecl :: Position -> Ident -> [Ident] -> NewConstrDecl -> Decl
- Curry.Syntax.Type: OpLhs :: ConstrTerm -> Ident -> ConstrTerm -> Lhs
- Curry.Syntax.Type: Paren :: Expression -> Expression
- Curry.Syntax.Type: ParenPattern :: ConstrTerm -> ConstrTerm
- Curry.Syntax.Type: PatternDecl :: Position -> ConstrTerm -> Rhs -> Decl
- Curry.Syntax.Type: RecordConstr :: [Field Expression] -> Expression
- Curry.Syntax.Type: RecordPattern :: [Field ConstrTerm] -> (Maybe ConstrTerm) -> ConstrTerm
- Curry.Syntax.Type: RecordSelection :: Expression -> Ident -> Expression
- Curry.Syntax.Type: RecordType :: [([Ident], TypeExpr)] -> (Maybe TypeExpr) -> TypeExpr
- Curry.Syntax.Type: RecordUpdate :: [Field Expression] -> Expression -> Expression
- Curry.Syntax.Type: RightSection :: InfixOp -> Expression -> Expression
- Curry.Syntax.Type: SimpleRhs :: Position -> Expression -> [Decl] -> Rhs
- Curry.Syntax.Type: StmtBind :: SrcRef -> ConstrTerm -> Expression -> Statement
- Curry.Syntax.Type: StmtDecl :: [Decl] -> Statement
- Curry.Syntax.Type: StmtExpr :: SrcRef -> Expression -> Statement
- Curry.Syntax.Type: String :: SrcRef -> String -> Literal
- Curry.Syntax.Type: Tuple :: SrcRef -> [Expression] -> Expression
- Curry.Syntax.Type: TuplePattern :: SrcRef -> [ConstrTerm] -> ConstrTerm
- Curry.Syntax.Type: TupleType :: [TypeExpr] -> TypeExpr
- Curry.Syntax.Type: TypeDecl :: Position -> Ident -> [Ident] -> TypeExpr -> Decl
- Curry.Syntax.Type: TypeSig :: Position -> [Ident] -> TypeExpr -> Decl
- Curry.Syntax.Type: Typed :: Expression -> TypeExpr -> Expression
- Curry.Syntax.Type: UnaryMinus :: Ident -> Expression -> Expression
- Curry.Syntax.Type: Variable :: QualIdent -> Expression
- Curry.Syntax.Type: VariablePattern :: Ident -> ConstrTerm
- Curry.Syntax.Type: VariableType :: Ident -> TypeExpr
- Curry.Syntax.Type: addSrcRefs :: Module -> Module
- Curry.Syntax.Type: data Alt
- Curry.Syntax.Type: data CallConv
- Curry.Syntax.Type: data CondExpr
- Curry.Syntax.Type: data ConstrDecl
- Curry.Syntax.Type: data ConstrTerm
- Curry.Syntax.Type: data Decl
- Curry.Syntax.Type: data Equation
- Curry.Syntax.Type: data EvalAnnotation
- Curry.Syntax.Type: data Export
- Curry.Syntax.Type: data ExportSpec
- Curry.Syntax.Type: data Expression
- Curry.Syntax.Type: data Field a
- Curry.Syntax.Type: data IDecl
- Curry.Syntax.Type: data Import
- Curry.Syntax.Type: data ImportSpec
- Curry.Syntax.Type: data Infix
- Curry.Syntax.Type: data InfixOp
- Curry.Syntax.Type: data Interface
- Curry.Syntax.Type: data Lhs
- Curry.Syntax.Type: data Literal
- Curry.Syntax.Type: data Module
- Curry.Syntax.Type: data NewConstrDecl
- Curry.Syntax.Type: data Rhs
- Curry.Syntax.Type: data Statement
- Curry.Syntax.Type: data TypeExpr
- Curry.Syntax.Type: field2Tuple :: Field a -> (Ident, a)
- Curry.Syntax.Type: fieldLabel :: Field a -> Ident
- Curry.Syntax.Type: fieldTerm :: Field a -> a
- Curry.Syntax.Type: flatLhs :: Lhs -> (Ident, [ConstrTerm])
- Curry.Syntax.Type: instance (Data a) => Data (Field a)
- Curry.Syntax.Type: instance (Eq a) => Eq (Field a)
- Curry.Syntax.Type: instance (Read a) => Read (Field a)
- Curry.Syntax.Type: instance (Show a) => Show (Field a)
- Curry.Syntax.Type: instance Data Alt
- Curry.Syntax.Type: instance Data CallConv
- Curry.Syntax.Type: instance Data CondExpr
- Curry.Syntax.Type: instance Data ConstrDecl
- Curry.Syntax.Type: instance Data ConstrTerm
- Curry.Syntax.Type: instance Data Decl
- Curry.Syntax.Type: instance Data Equation
- Curry.Syntax.Type: instance Data EvalAnnotation
- Curry.Syntax.Type: instance Data Export
- Curry.Syntax.Type: instance Data ExportSpec
- Curry.Syntax.Type: instance Data Expression
- Curry.Syntax.Type: instance Data IDecl
- Curry.Syntax.Type: instance Data Import
- Curry.Syntax.Type: instance Data ImportSpec
- Curry.Syntax.Type: instance Data Infix
- Curry.Syntax.Type: instance Data InfixOp
- Curry.Syntax.Type: instance Data Interface
- Curry.Syntax.Type: instance Data Lhs
- Curry.Syntax.Type: instance Data Literal
- Curry.Syntax.Type: instance Data Module
- Curry.Syntax.Type: instance Data NewConstrDecl
- Curry.Syntax.Type: instance Data Rhs
- Curry.Syntax.Type: instance Data Statement
- Curry.Syntax.Type: instance Data TypeExpr
- Curry.Syntax.Type: instance Eq Alt
- Curry.Syntax.Type: instance Eq CallConv
- Curry.Syntax.Type: instance Eq CondExpr
- Curry.Syntax.Type: instance Eq ConstrDecl
- Curry.Syntax.Type: instance Eq ConstrTerm
- Curry.Syntax.Type: instance Eq Decl
- Curry.Syntax.Type: instance Eq Equation
- Curry.Syntax.Type: instance Eq EvalAnnotation
- Curry.Syntax.Type: instance Eq Export
- Curry.Syntax.Type: instance Eq ExportSpec
- Curry.Syntax.Type: instance Eq Expression
- Curry.Syntax.Type: instance Eq IDecl
- Curry.Syntax.Type: instance Eq Import
- Curry.Syntax.Type: instance Eq ImportSpec
- Curry.Syntax.Type: instance Eq Infix
- Curry.Syntax.Type: instance Eq InfixOp
- Curry.Syntax.Type: instance Eq Interface
- Curry.Syntax.Type: instance Eq Lhs
- Curry.Syntax.Type: instance Eq Literal
- Curry.Syntax.Type: instance Eq Module
- Curry.Syntax.Type: instance Eq NewConstrDecl
- Curry.Syntax.Type: instance Eq Rhs
- Curry.Syntax.Type: instance Eq Statement
- Curry.Syntax.Type: instance Eq TypeExpr
- Curry.Syntax.Type: instance Read Alt
- Curry.Syntax.Type: instance Read CallConv
- Curry.Syntax.Type: instance Read CondExpr
- Curry.Syntax.Type: instance Read ConstrDecl
- Curry.Syntax.Type: instance Read ConstrTerm
- Curry.Syntax.Type: instance Read Decl
- Curry.Syntax.Type: instance Read Equation
- Curry.Syntax.Type: instance Read EvalAnnotation
- Curry.Syntax.Type: instance Read Export
- Curry.Syntax.Type: instance Read ExportSpec
- Curry.Syntax.Type: instance Read Expression
- Curry.Syntax.Type: instance Read IDecl
- Curry.Syntax.Type: instance Read Import
- Curry.Syntax.Type: instance Read ImportSpec
- Curry.Syntax.Type: instance Read Infix
- Curry.Syntax.Type: instance Read InfixOp
- Curry.Syntax.Type: instance Read Interface
- Curry.Syntax.Type: instance Read Lhs
- Curry.Syntax.Type: instance Read Literal
- Curry.Syntax.Type: instance Read Module
- Curry.Syntax.Type: instance Read NewConstrDecl
- Curry.Syntax.Type: instance Read Rhs
- Curry.Syntax.Type: instance Read Statement
- Curry.Syntax.Type: instance Read TypeExpr
- Curry.Syntax.Type: instance Show Alt
- Curry.Syntax.Type: instance Show CallConv
- Curry.Syntax.Type: instance Show CondExpr
- Curry.Syntax.Type: instance Show ConstrDecl
- Curry.Syntax.Type: instance Show ConstrTerm
- Curry.Syntax.Type: instance Show Decl
- Curry.Syntax.Type: instance Show Equation
- Curry.Syntax.Type: instance Show EvalAnnotation
- Curry.Syntax.Type: instance Show Export
- Curry.Syntax.Type: instance Show ExportSpec
- Curry.Syntax.Type: instance Show Expression
- Curry.Syntax.Type: instance Show IDecl
- Curry.Syntax.Type: instance Show Import
- Curry.Syntax.Type: instance Show ImportSpec
- Curry.Syntax.Type: instance Show Infix
- Curry.Syntax.Type: instance Show InfixOp
- Curry.Syntax.Type: instance Show Interface
- Curry.Syntax.Type: instance Show Lhs
- Curry.Syntax.Type: instance Show Literal
- Curry.Syntax.Type: instance Show Module
- Curry.Syntax.Type: instance Show NewConstrDecl
- Curry.Syntax.Type: instance Show Rhs
- Curry.Syntax.Type: instance Show Statement
- Curry.Syntax.Type: instance Show TypeExpr
- Curry.Syntax.Type: instance SrcRefOf ConstrTerm
- Curry.Syntax.Type: instance SrcRefOf Literal
- Curry.Syntax.Type: instance Typeable Alt
- Curry.Syntax.Type: instance Typeable CallConv
- Curry.Syntax.Type: instance Typeable CondExpr
- Curry.Syntax.Type: instance Typeable ConstrDecl
- Curry.Syntax.Type: instance Typeable ConstrTerm
- Curry.Syntax.Type: instance Typeable Decl
- Curry.Syntax.Type: instance Typeable Equation
- Curry.Syntax.Type: instance Typeable EvalAnnotation
- Curry.Syntax.Type: instance Typeable Export
- Curry.Syntax.Type: instance Typeable ExportSpec
- Curry.Syntax.Type: instance Typeable Expression
- Curry.Syntax.Type: instance Typeable IDecl
- Curry.Syntax.Type: instance Typeable Import
- Curry.Syntax.Type: instance Typeable ImportSpec
- Curry.Syntax.Type: instance Typeable Infix
- Curry.Syntax.Type: instance Typeable InfixOp
- Curry.Syntax.Type: instance Typeable Interface
- Curry.Syntax.Type: instance Typeable Lhs
- Curry.Syntax.Type: instance Typeable Literal
- Curry.Syntax.Type: instance Typeable Module
- Curry.Syntax.Type: instance Typeable NewConstrDecl
- Curry.Syntax.Type: instance Typeable Rhs
- Curry.Syntax.Type: instance Typeable Statement
- Curry.Syntax.Type: instance Typeable TypeExpr
- Curry.Syntax.Type: instance Typeable1 Field
- Curry.Syntax.Type: mk :: (SrcRef -> a) -> a
- Curry.Syntax.Type: mk' :: ([SrcRef] -> a) -> a
- Curry.Syntax.Type: mkInt :: Integer -> Literal
- Curry.Syntax.Type: opName :: InfixOp -> QualIdent
- Curry.Syntax.Type: type M a = a -> State Int a
- Curry.Syntax.Type: type Qualified = Bool
- Curry.Syntax.Unlit: unlit :: FilePath -> String -> MsgMonad String
- Curry.Syntax.Utils: bv :: (QuantExpr e) => e -> [Ident]
- Curry.Syntax.Utils: class Expr e
- Curry.Syntax.Utils: class QuantExpr e
- Curry.Syntax.Utils: fv :: (Expr e) => e -> [Ident]
- Curry.Syntax.Utils: infixOp :: InfixOp -> Expression
- Curry.Syntax.Utils: instance (Expr e) => Expr [e]
- Curry.Syntax.Utils: instance (QualExpr a) => QualExpr (Field a)
- Curry.Syntax.Utils: instance (QualExpr e) => QualExpr [e]
- Curry.Syntax.Utils: instance (QuantExpr a) => QuantExpr (Field a)
- Curry.Syntax.Utils: instance (QuantExpr e) => QuantExpr [e]
- Curry.Syntax.Utils: instance Expr TypeExpr
- Curry.Syntax.Utils: instance QualExpr Alt
- Curry.Syntax.Utils: instance QualExpr CondExpr
- Curry.Syntax.Utils: instance QualExpr ConstrTerm
- Curry.Syntax.Utils: instance QualExpr Decl
- Curry.Syntax.Utils: instance QualExpr Equation
- Curry.Syntax.Utils: instance QualExpr Expression
- Curry.Syntax.Utils: instance QualExpr InfixOp
- Curry.Syntax.Utils: instance QualExpr Lhs
- Curry.Syntax.Utils: instance QualExpr Rhs
- Curry.Syntax.Utils: instance QualExpr Statement
- Curry.Syntax.Utils: instance QuantExpr ConstrTerm
- Curry.Syntax.Utils: instance QuantExpr Decl
- Curry.Syntax.Utils: instance QuantExpr Lhs
- Curry.Syntax.Utils: instance QuantExpr Statement
- Curry.Syntax.Utils: isEvalAnnot :: Decl -> Bool
- Curry.Syntax.Utils: isImportDecl :: Decl -> Bool
- Curry.Syntax.Utils: isInfixDecl :: Decl -> Bool
- Curry.Syntax.Utils: isTypeDecl :: Decl -> Bool
- Curry.Syntax.Utils: isTypeSig :: Decl -> Bool
- Curry.Syntax.Utils: isValueDecl :: Decl -> Bool
- Curry.Syntax.Utils: qfv :: (QualExpr e) => ModuleIdent -> e -> [Ident]
- CurryBuilder: buildCurry :: Options -> FilePath -> IO ()
- CurryBuilder: smake :: [FilePath] -> [FilePath] -> IO a -> IO a -> IO a
- CurryCompilerOpts: Abstract :: Option
- CurryCompilerOpts: Dump :: [Dump] -> Option
- CurryCompilerOpts: DumpCase :: Dump
- CurryCompilerOpts: DumpDesugared :: Dump
- CurryCompilerOpts: DumpIL :: Dump
- CurryCompilerOpts: DumpLifted :: Dump
- CurryCompilerOpts: DumpRenamed :: Dump
- CurryCompilerOpts: DumpSimplified :: Dump
- CurryCompilerOpts: DumpTypes :: Dump
- CurryCompilerOpts: ExtFlat :: Option
- CurryCompilerOpts: Flat :: Option
- CurryCompilerOpts: FlatXML :: Option
- CurryCompilerOpts: Force :: Option
- CurryCompilerOpts: Help :: Option
- CurryCompilerOpts: Html :: Option
- CurryCompilerOpts: ImportPath :: FilePath -> Option
- CurryCompilerOpts: NoInterface :: Option
- CurryCompilerOpts: NoOverlapWarn :: Option
- CurryCompilerOpts: NoVerb :: Option
- CurryCompilerOpts: NoWarn :: Option
- CurryCompilerOpts: Options :: Bool -> Bool -> [FilePath] -> Maybe FilePath -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> [Dump] -> Options
- CurryCompilerOpts: Output :: FilePath -> Option
- CurryCompilerOpts: ParseOnly :: Option
- CurryCompilerOpts: UntypedAbstract :: Option
- CurryCompilerOpts: WithExtensions :: Option
- CurryCompilerOpts: abstract :: Options -> Bool
- CurryCompilerOpts: data Dump
- CurryCompilerOpts: data Option
- CurryCompilerOpts: data Options
- CurryCompilerOpts: dump :: Options -> [Dump]
- CurryCompilerOpts: extendedFlat :: Options -> Bool
- CurryCompilerOpts: flat :: Options -> Bool
- CurryCompilerOpts: flatXml :: Options -> Bool
- CurryCompilerOpts: force :: Options -> Bool
- CurryCompilerOpts: html :: Options -> Bool
- CurryCompilerOpts: importPaths :: Options -> [FilePath]
- CurryCompilerOpts: instance Bounded Dump
- CurryCompilerOpts: instance Enum Dump
- CurryCompilerOpts: instance Eq Dump
- CurryCompilerOpts: instance Eq Option
- CurryCompilerOpts: instance Show Dump
- CurryCompilerOpts: instance Show Options
- CurryCompilerOpts: noInterface :: Options -> Bool
- CurryCompilerOpts: noOverlapWarn :: Options -> Bool
- CurryCompilerOpts: noVerb :: Options -> Bool
- CurryCompilerOpts: noWarn :: Options -> Bool
- CurryCompilerOpts: output :: Options -> Maybe FilePath
- CurryCompilerOpts: parseOnly :: Options -> Bool
- CurryCompilerOpts: selectOption :: Option -> Options -> Options
- CurryCompilerOpts: untypedAbstract :: Options -> Bool
- CurryCompilerOpts: withExtensions :: Options -> Bool
- CurryDeps: Interface :: FilePath -> Source
- CurryDeps: Source :: FilePath -> [ModuleIdent] -> Source
- CurryDeps: Unknown :: Source
- CurryDeps: data Source
- CurryDeps: deps :: [FilePath] -> [FilePath] -> SourceEnv -> FilePath -> IO SourceEnv
- CurryDeps: flattenDeps :: SourceEnv -> ([(ModuleIdent, Source)], [String])
- CurryDeps: instance Eq Source
- CurryDeps: instance Ord Source
- CurryDeps: instance Show Source
- CurryDeps: moduleDeps :: [FilePath] -> [FilePath] -> SourceEnv -> ModuleIdent -> IO SourceEnv
- CurryDeps: sourceDeps :: [FilePath] -> [FilePath] -> ModuleIdent -> SourceEnv -> FilePath -> IO SourceEnv
- CurryEnv: CurryEnv :: ModuleIdent -> [Export] -> [IDecl] -> [IDecl] -> [IDecl] -> [IDecl] -> CurryEnv
- CurryEnv: curryEnv :: ModuleEnv -> TCEnv -> Interface -> Module -> CurryEnv
- CurryEnv: data CurryEnv
- CurryEnv: exports :: CurryEnv -> [Export]
- CurryEnv: imports :: CurryEnv -> [IDecl]
- CurryEnv: infixDecls :: CurryEnv -> [IDecl]
- CurryEnv: instance Show CurryEnv
- CurryEnv: interface :: CurryEnv -> [IDecl]
- CurryEnv: moduleId :: CurryEnv -> ModuleIdent
- CurryEnv: typeSynonyms :: CurryEnv -> [IDecl]
- Desugar: desugar :: ValueEnv -> TCEnv -> Module -> (Module, ValueEnv)
- Eval: evalEnv :: [Decl] -> EvalEnv
- Exports: expandInterface :: Module -> TCEnv -> ValueEnv -> Module
- Exports: exportInterface :: Module -> PEnv -> TCEnv -> ValueEnv -> Interface
- GenAbstractCurry: genTypedAbstract :: ValueEnv -> TCEnv -> Module -> CurryProg
- GenAbstractCurry: genUntypedAbstract :: ValueEnv -> TCEnv -> Module -> CurryProg
- GenAbstractCurry: instance Eq AbstractType
- GenAbstractCurry: instance Show AbstractEnv
- GenAbstractCurry: instance Show AbstractType
- GenAbstractCurry: instance Show Partitions
- GenFlatCurry: genFlatCurry :: Options -> CurryEnv -> ModuleEnv -> ValueEnv -> TCEnv -> ArityEnv -> Module -> (Prog, [WarnMsg])
- GenFlatCurry: genFlatInterface :: Options -> CurryEnv -> ModuleEnv -> ValueEnv -> TCEnv -> ArityEnv -> Module -> (Prog, [WarnMsg])
- GetOpt: NoArg :: a -> ArgDescr a
- GetOpt: OptArg :: (Maybe String -> a) -> String -> ArgDescr a
- GetOpt: Option :: [Char] -> [String] -> (ArgDescr a) -> String -> OptDescr a
- GetOpt: Permute :: ArgOrder a
- GetOpt: ReqArg :: (String -> a) -> String -> ArgDescr a
- GetOpt: RequireOrder :: ArgOrder a
- GetOpt: ReturnInOrder :: (String -> a) -> ArgOrder a
- GetOpt: data ArgDescr a
- GetOpt: data ArgOrder a
- GetOpt: data OptDescr a
- GetOpt: getOpt :: ArgOrder a -> [OptDescr a] -> [String] -> ([a], [String], [String])
- GetOpt: usageInfo :: String -> [OptDescr a] -> String
- IL.CurryToIL: ilTrans :: Bool -> ValueEnv -> TCEnv -> EvalEnv -> Module -> Module
- IL.CurryToIL: ilTransIntf :: ValueEnv -> TCEnv -> Interface -> [Decl]
- IL.CurryToIL: instance Expr Alt
- IL.CurryToIL: instance Expr Expression
- IL.CurryToIL: instance Show NestedTerm
- IL.CurryToIL: translType :: Type -> Type
- IL.Pretty: ppModule :: Module -> Doc
- IL.Scope: getModuleScope :: Module -> ScopeEnv
- IL.Scope: insertAltScope :: ScopeEnv -> Alt -> ScopeEnv
- IL.Scope: insertBindingScope :: ScopeEnv -> Binding -> ScopeEnv
- IL.Scope: insertCallConvScope :: ScopeEnv -> CallConv -> ScopeEnv
- IL.Scope: insertConstrDeclScope :: ScopeEnv -> ConstrDecl [Type] -> ScopeEnv
- IL.Scope: insertConstrTermScope :: ScopeEnv -> ConstrTerm -> ScopeEnv
- IL.Scope: insertDeclScope :: ScopeEnv -> Decl -> ScopeEnv
- IL.Scope: insertExprScope :: ScopeEnv -> Expression -> ScopeEnv
- IL.Scope: insertLiteralScope :: ScopeEnv -> Literal -> ScopeEnv
- IL.Scope: insertTypeScope :: ScopeEnv -> Type -> ScopeEnv
- IL.Type: Alt :: ConstrTerm -> Expression -> Alt
- IL.Type: Apply :: Expression -> Expression -> Expression
- IL.Type: Binding :: Ident -> Expression -> Binding
- IL.Type: CCall :: CallConv
- IL.Type: Case :: SrcRef -> Eval -> Expression -> [Alt] -> Expression
- IL.Type: Char :: SrcRef -> Char -> Literal
- IL.Type: ConstrDecl :: QualIdent -> a -> ConstrDecl a
- IL.Type: Constructor :: QualIdent -> Int -> Expression
- IL.Type: ConstructorPattern :: QualIdent -> [Ident] -> ConstrTerm
- IL.Type: DataDecl :: QualIdent -> Int -> [ConstrDecl [Type]] -> Decl
- IL.Type: Exist :: Ident -> Expression -> Expression
- IL.Type: ExternalDecl :: QualIdent -> CallConv -> String -> Type -> Decl
- IL.Type: Flex :: Eval
- IL.Type: Float :: SrcRef -> Double -> Literal
- IL.Type: Function :: QualIdent -> Int -> Expression
- IL.Type: FunctionDecl :: QualIdent -> [Ident] -> Type -> Expression -> Decl
- IL.Type: Int :: SrcRef -> Integer -> Literal
- IL.Type: Let :: Binding -> Expression -> Expression
- IL.Type: Letrec :: [Binding] -> Expression -> Expression
- IL.Type: Literal :: Literal -> Expression
- IL.Type: LiteralPattern :: Literal -> ConstrTerm
- IL.Type: Module :: ModuleIdent -> [ModuleIdent] -> [Decl] -> Module
- IL.Type: NewtypeDecl :: QualIdent -> Int -> (ConstrDecl Type) -> Decl
- IL.Type: Or :: Expression -> Expression -> Expression
- IL.Type: Primitive :: CallConv
- IL.Type: Rigid :: Eval
- IL.Type: TypeArrow :: Type -> Type -> Type
- IL.Type: TypeConstructor :: QualIdent -> [Type] -> Type
- IL.Type: TypeVariable :: Int -> Type
- IL.Type: Variable :: Ident -> Expression
- IL.Type: VariablePattern :: Ident -> ConstrTerm
- IL.Type: data Alt
- IL.Type: data Binding
- IL.Type: data CallConv
- IL.Type: data ConstrDecl a
- IL.Type: data ConstrTerm
- IL.Type: data Decl
- IL.Type: data Eval
- IL.Type: data Expression
- IL.Type: data Literal
- IL.Type: data Module
- IL.Type: data Type
- IL.Type: instance (Eq a) => Eq (ConstrDecl a)
- IL.Type: instance (Show a) => Show (ConstrDecl a)
- IL.Type: instance Data Type
- IL.Type: instance Eq Alt
- IL.Type: instance Eq Binding
- IL.Type: instance Eq CallConv
- IL.Type: instance Eq ConstrTerm
- IL.Type: instance Eq Decl
- IL.Type: instance Eq Eval
- IL.Type: instance Eq Expression
- IL.Type: instance Eq Literal
- IL.Type: instance Eq Module
- IL.Type: instance Eq Type
- IL.Type: instance Show Alt
- IL.Type: instance Show Binding
- IL.Type: instance Show CallConv
- IL.Type: instance Show ConstrTerm
- IL.Type: instance Show Decl
- IL.Type: instance Show Eval
- IL.Type: instance Show Expression
- IL.Type: instance Show Literal
- IL.Type: instance Show Module
- IL.Type: instance Show Type
- IL.Type: instance SrcRefOf ConstrTerm
- IL.Type: instance SrcRefOf Literal
- IL.Type: instance Typeable Type
- IL.XML: level :: Int
- IL.XML: qualConstrDeclId :: ModuleIdent -> [QualIdent] -> ConstrDecl -> [QualIdent]
- IL.XML: qualIDeclId :: ModuleIdent -> [QualIdent] -> IDecl -> [QualIdent]
- IL.XML: qualNewConstrDeclId :: ModuleIdent -> [QualIdent] -> NewConstrDecl -> [QualIdent]
- IL.XML: splitDecls :: [Decl] -> ([Decl], [Decl])
- IL.XML: xmlAppArgs :: Expression -> (Expression, [Expression])
- IL.XML: xmlApply :: [(Int, Ident)] -> Expression -> (Expression, [Expression]) -> (Doc, [(Int, Ident)])
- IL.XML: xmlApplyFunctor :: [(Int, Ident)] -> QualIdent -> Int -> [Expression] -> Bool -> (Doc, [(Int, Ident)])
- IL.XML: xmlBeginFunction :: QualIdent -> Int -> Type -> Doc
- IL.XML: xmlBinding :: [(Int, Ident)] -> Binding -> (Doc, [(Int, Ident)])
- IL.XML: xmlBody :: CurryEnv -> Module -> Doc
- IL.XML: xmlBranch :: [(Int, Ident)] -> Alt -> (Doc, [(Int, Ident)])
- IL.XML: xmlBuildDicc :: [Ident] -> [(Int, Ident)]
- IL.XML: xmlCase :: [(Int, Ident)] -> Eval -> Expression -> [Alt] -> (Doc, [(Int, Ident)])
- IL.XML: xmlCombApply :: [(Int, Ident)] -> Doc -> Doc -> Int -> [Expression] -> (Doc, [(Int, Ident)])
- IL.XML: xmlCombHeading :: Doc -> Doc -> Bool -> Doc
- IL.XML: xmlConsPattern :: [(Int, Ident)] -> QualIdent -> [Ident] -> (Doc, [(Int, Ident)])
- IL.XML: xmlConstructor :: ConstrDecl [Type] -> Doc
- IL.XML: xmlConstructorBegin :: QualIdent -> Int -> Doc
- IL.XML: xmlElement :: (Eq a) => String -> (a -> Doc) -> [a] -> Doc
- IL.XML: xmlEndFunction :: Doc
- IL.XML: xmlExpr :: [(Int, Ident)] -> Expression -> (Doc, [(Int, Ident)])
- IL.XML: xmlExprVar :: [(Int, Ident)] -> Ident -> (Doc, [(Int, Ident)])
- IL.XML: xmlFixity :: Infix -> Doc
- IL.XML: xmlFloat :: Double -> Doc
- IL.XML: xmlFormat :: String -> String
- IL.XML: xmlFree :: [(Int, Ident)] -> Ident -> Expression -> (Doc, [(Int, Ident)])
- IL.XML: xmlFunctionArity :: Type -> Int
- IL.XML: xmlFunctionDecl :: Decl -> Doc
- IL.XML: xmlHeadingWithArity :: String -> QualIdent -> Int -> Bool -> Doc
- IL.XML: xmlIdent :: Ident -> Doc
- IL.XML: xmlImportDecl :: ModuleIdent -> Doc
- IL.XML: xmlInt :: Int -> Doc
- IL.XML: xmlInteger :: Integer -> Doc
- IL.XML: xmlLet :: [(Int, Ident)] -> Binding -> Expression -> (Doc, [(Int, Ident)])
- IL.XML: xmlLetrec :: [(Int, Ident)] -> [Binding] -> Expression -> (Doc, [(Int, Ident)])
- IL.XML: xmlLhs :: [Ident] -> Doc
- IL.XML: xmlLines :: (a -> Doc) -> [a] -> Doc
- IL.XML: xmlLit :: Literal -> Doc
- IL.XML: xmlLitPattern :: Doc -> Doc
- IL.XML: xmlLiteral :: Doc -> Doc
- IL.XML: xmlLookUp :: Ident -> [(Int, Ident)] -> Int
- IL.XML: xmlMapDicc :: [(Int, Ident)] -> ([(Int, Ident)] -> a -> (Doc, [(Int, Ident)])) -> [a] -> ([Doc], [(Int, Ident)])
- IL.XML: xmlModule :: CurryEnv -> Module -> Doc
- IL.XML: xmlModuleDecl :: ModuleIdent -> Doc
- IL.XML: xmlModuleIdent :: ModuleIdent -> Doc
- IL.XML: xmlNewVar :: [(Int, Ident)] -> Int
- IL.XML: xmlOperatorDecl :: IDecl -> Doc
- IL.XML: xmlOr :: [(Int, Ident)] -> Expression -> Expression -> (Doc, [(Int, Ident)])
- IL.XML: xmlPattern :: [(Int, Ident)] -> ConstrTerm -> (Doc, [(Int, Ident)])
- IL.XML: xmlQualIdent :: QualIdent -> Doc
- IL.XML: xmlRhs :: [Ident] -> Expression -> Doc
- IL.XML: xmlRule :: [Ident] -> Expression -> Doc
- IL.XML: xmlSingleApp :: QualIdent -> Int -> Bool -> Doc
- IL.XML: xmlTranslationDecl :: QualIdent -> Doc
- IL.XML: xmlType :: Type -> Doc
- IL.XML: xmlTypeConsBegin :: QualIdent -> Bool -> Doc
- IL.XML: xmlTypeDecl :: Decl -> Doc
- IL.XML: xmlTypeFun :: Type -> Type -> Doc
- IL.XML: xmlTypeParams :: Int -> Doc
- IL.XML: xmlTypeVar :: Int -> Doc
- IL.XML: xmlVar :: Int -> Doc
- Imports: importInterface :: Position -> ModuleIdent -> Bool -> Maybe ImportSpec -> Interface -> PEnv -> TCEnv -> ValueEnv -> ArityEnv -> (PEnv, TCEnv, ValueEnv, ArityEnv)
- Imports: importInterfaceIntf :: Interface -> PEnv -> TCEnv -> ValueEnv -> ArityEnv -> (PEnv, TCEnv, ValueEnv, ArityEnv)
- Imports: importUnifyData :: TCEnv -> TCEnv
- InterfaceCheck: checkConsDecls :: [ConsDecl] -> [ConsDecl] -> Bool
- InterfaceCheck: checkFuncDecls :: [FuncDecl] -> [FuncDecl] -> Bool
- InterfaceCheck: checkOpDecls :: [OpDecl] -> [OpDecl] -> Bool
- InterfaceCheck: checkRule :: Rule -> Rule -> Bool
- InterfaceCheck: checkTypeDecls :: [TypeDecl] -> [TypeDecl] -> Bool
- InterfaceCheck: extract :: (a -> Bool) -> [a] -> (Maybe a, [a])
- InterfaceCheck: interfaceCheck :: Prog -> Prog -> Bool
- InterfaceCheck: isCons :: QName -> ConsDecl -> Bool
- InterfaceCheck: isDataType :: QName -> TypeDecl -> Bool
- InterfaceCheck: isFunc :: QName -> FuncDecl -> Bool
- InterfaceCheck: isOp :: QName -> OpDecl -> Bool
- InterfaceCheck: isTypeSyn :: QName -> TypeDecl -> Bool
- KindCheck: kindCheck :: ModuleIdent -> TCEnv -> [Decl] -> [Decl]
- Lift: lift :: ValueEnv -> EvalEnv -> Module -> (Module, ValueEnv, EvalEnv)
- Modules: checkModule :: Options -> ModuleEnv -> Module -> IO (ValueEnv, TCEnv, ArityEnv, Module, Interface, [WarnMsg])
- Modules: compileModule :: Options -> FilePath -> IO (Maybe FilePath)
- Modules: importPrelude :: FilePath -> Module -> Module
- Modules: instance Show LabelInfo
- Modules: loadInterfaces :: [FilePath] -> Module -> IO ModuleEnv
- Modules: patchModuleId :: FilePath -> Module -> Module
- Modules: simpleCheckModule :: Options -> ModuleEnv -> Module -> IO (ValueEnv, TCEnv, ArityEnv, Module, Interface, [WarnMsg])
- Modules: transModule :: Bool -> Bool -> Bool -> ModuleEnv -> ValueEnv -> TCEnv -> ArityEnv -> Module -> (Module, ArityEnv, [(Dump, Doc)])
- NestEnv: bindNestEnv :: Ident -> a -> NestEnv a -> NestEnv a
- NestEnv: data NestEnv a
- NestEnv: globalEnv :: TopEnv a -> NestEnv a
- NestEnv: instance Functor NestEnv
- NestEnv: lookupNestEnv :: Ident -> NestEnv a -> [a]
- NestEnv: nestEnv :: NestEnv a -> NestEnv a
- NestEnv: qualBindNestEnv :: QualIdent -> a -> NestEnv a -> NestEnv a
- NestEnv: qualLookupNestEnv :: QualIdent -> NestEnv a -> [a]
- NestEnv: toplevelEnv :: NestEnv a -> TopEnv a
- OldScopeEnv: beginScope :: ScopeEnv -> ScopeEnv
- OldScopeEnv: endScope :: ScopeEnv -> ScopeEnv
- OldScopeEnv: genIdent :: String -> ScopeEnv -> Maybe Ident
- OldScopeEnv: genIdentList :: Int -> String -> ScopeEnv -> [Ident]
- OldScopeEnv: getIdentLevel :: Ident -> ScopeEnv -> Maybe Int
- OldScopeEnv: getLevel :: ScopeEnv -> Int
- OldScopeEnv: insertIdent :: Ident -> ScopeEnv -> ScopeEnv
- OldScopeEnv: instance Eq IdRep
- OldScopeEnv: instance Ord IdRep
- OldScopeEnv: isDeclared :: Ident -> ScopeEnv -> Bool
- OldScopeEnv: isVisible :: Ident -> ScopeEnv -> Bool
- OldScopeEnv: newScopeEnv :: ScopeEnv
- OldScopeEnv: type ScopeEnv = (IdEnv, [IdEnv], Int)
- PatchPrelude: patchPreludeFCY :: Prog -> Prog
- PatchPrelude: prelude_types_fcy :: [TypeDecl]
- PrecCheck: precCheck :: ModuleIdent -> PEnv -> [Decl] -> (PEnv, [Decl])
- Qual: qual :: ModuleIdent -> ValueEnv -> [Decl] -> [Decl]
- SCC: instance Eq (Node a b)
- SCC: instance Ord (Node b a)
- SCC: scc :: (Eq b) => (a -> [b]) -> (a -> [b]) -> [a] -> [[a]]
- ScopeEnv: beginScope :: (Ord a) => ScopeEnv a b -> ScopeEnv a b
- ScopeEnv: currentLevel :: (Ord a) => ScopeEnv a b -> Int
- ScopeEnv: data ScopeEnv a b
- ScopeEnv: endScope :: (Ord a) => ScopeEnv a b -> ScopeEnv a b
- ScopeEnv: endScopeUp :: (Ord a) => ScopeEnv a b -> ScopeEnv a b
- ScopeEnv: exists :: (Ord a) => a -> ScopeEnv a b -> Bool
- ScopeEnv: insert :: (Ord a) => a -> b -> ScopeEnv a b -> ScopeEnv a b
- ScopeEnv: instance (Show a, Show b) => Show (ScopeEnv a b)
- ScopeEnv: level :: (Ord a) => a -> ScopeEnv a b -> Int
- ScopeEnv: lookup :: (Ord a) => a -> ScopeEnv a b -> Maybe b
- ScopeEnv: modify :: (Ord a) => (b -> b) -> a -> ScopeEnv a b -> ScopeEnv a b
- ScopeEnv: new :: (Ord a) => ScopeEnv a b
- ScopeEnv: sureLookup :: (Ord a) => a -> b -> ScopeEnv a b -> b
- ScopeEnv: toLevelList :: (Ord a) => ScopeEnv a b -> [(a, b)]
- ScopeEnv: toList :: (Ord a) => ScopeEnv a b -> [(a, b)]
- ScopeEnv: update :: (Ord a) => a -> b -> ScopeEnv a b -> ScopeEnv a b
- Simplify: simplify :: SimplifyFlags -> ValueEnv -> EvalEnv -> Module -> (Module, ValueEnv)
- Subst: Subst :: Bool -> (Map a b) -> Subst a b
- Subst: bindSubst :: (Ord v) => v -> e -> Subst v e -> Subst v e
- Subst: class IntSubst e
- Subst: compose :: (Show v, Ord v, Show e) => Subst v e -> Subst v e -> Subst v e
- Subst: data Subst a b
- Subst: idSubst :: (Ord a) => Subst a b
- Subst: instance (Show a, Show b) => Show (Subst a b)
- Subst: isubst :: (IntSubst e) => Subst Int e -> e -> e
- Subst: isubstVar :: (IntSubst e) => Subst Int e -> Int -> e
- Subst: ivar :: (IntSubst e) => Int -> e
- Subst: restrictSubstTo :: (Ord v) => [v] -> Subst v e -> Subst v e
- Subst: substToList :: (Ord v) => Subst v e -> [(v, e)]
- Subst: substVar' :: (Ord v) => (v -> e) -> (Subst v e -> e -> e) -> Subst v e -> v -> e
- Subst: unbindSubst :: (Ord v) => v -> Subst v e -> Subst v e
- SyntaxCheck: instance Eq RenameInfo
- SyntaxCheck: instance Show RenameInfo
- SyntaxCheck: syntaxCheck :: Bool -> ModuleIdent -> ImportEnv -> ArityEnv -> ValueEnv -> TCEnv -> [Decl] -> [Decl]
- TopEnv: TopEnv :: Map QualIdent [(Source, a)] -> TopEnv a
- TopEnv: allImports :: TopEnv a -> [(QualIdent, a)]
- TopEnv: bindTopEnv :: String -> Ident -> a -> TopEnv a -> TopEnv a
- TopEnv: class Entity a
- TopEnv: emptyTopEnv :: TopEnv a
- TopEnv: importTopEnv :: (Entity a) => ModuleIdent -> Ident -> a -> TopEnv a -> TopEnv a
- TopEnv: instance (Show a) => Show (TopEnv a)
- TopEnv: instance Eq Source
- TopEnv: instance Functor TopEnv
- TopEnv: instance Show Source
- TopEnv: localBindings :: TopEnv a -> [(Ident, a)]
- TopEnv: lookupTopEnv :: Ident -> TopEnv a -> [a]
- TopEnv: merge :: (Entity a) => a -> a -> Maybe a
- TopEnv: moduleImports :: ModuleIdent -> TopEnv a -> [(Ident, a)]
- TopEnv: newtype TopEnv a
- TopEnv: origName :: (Entity a) => a -> QualIdent
- TopEnv: predefTopEnv :: (Entity a) => QualIdent -> a -> TopEnv a -> TopEnv a
- TopEnv: qualBindTopEnv :: String -> QualIdent -> a -> TopEnv a -> TopEnv a
- TopEnv: qualImportTopEnv :: (Entity a) => ModuleIdent -> Ident -> a -> TopEnv a -> TopEnv a
- TopEnv: qualLookupTopEnv :: QualIdent -> TopEnv a -> [a]
- TopEnv: qualRebindTopEnv :: QualIdent -> a -> TopEnv a -> TopEnv a
- TopEnv: rebindTopEnv :: Ident -> a -> TopEnv a -> TopEnv a
- TopEnv: topEnvMap :: TopEnv a -> Map QualIdent [(Source, a)]
- TopEnv: unbindTopEnv :: Ident -> TopEnv a -> TopEnv a
- TypeCheck: typeCheck :: ModuleIdent -> TCEnv -> ValueEnv -> [Decl] -> (TCEnv, ValueEnv)
- TypeSubst: bindSubst :: (Ord v) => v -> e -> Subst v e -> Subst v e
- TypeSubst: bindVar :: Int -> Type -> TypeSubst -> TypeSubst
- TypeSubst: class SubstType a
- TypeSubst: compose :: (Show v, Ord v, Show e) => Subst v e -> Subst v e -> Subst v e
- TypeSubst: expandAliasType :: [Type] -> Type -> Type
- TypeSubst: idSubst :: (Ord a) => Subst a b
- TypeSubst: instance (SubstType a) => SubstType (TopEnv a)
- TypeSubst: instance SubstType ExistTypeScheme
- TypeSubst: instance SubstType Type
- TypeSubst: instance SubstType TypeScheme
- TypeSubst: instance SubstType ValueInfo
- TypeSubst: normalize :: Type -> Type
- TypeSubst: subst :: (SubstType a) => TypeSubst -> a -> a
- TypeSubst: substVar :: TypeSubst -> Int -> Type
- TypeSubst: type TypeSubst = Subst Int Type
- Types: ForAll :: Int -> Type -> TypeScheme
- Types: ForAllExist :: Int -> Int -> Type -> ExistTypeScheme
- Types: TypeArrow :: Type -> Type -> Type
- Types: TypeConstrained :: [Type] -> Int -> Type
- Types: TypeConstructor :: QualIdent -> [Type] -> Type
- Types: TypeRecord :: [(Ident, Type)] -> (Maybe Int) -> Type
- Types: TypeSkolem :: Int -> Type
- Types: TypeVariable :: Int -> Type
- Types: arrowArgs :: Type -> [Type]
- Types: arrowArity :: Type -> Int
- Types: arrowBase :: Type -> Type
- Types: boolType :: Type
- Types: charType :: Type
- Types: data ExistTypeScheme
- Types: data Type
- Types: data TypeScheme
- Types: equTypes :: Type -> Type -> Bool
- Types: floatType :: Type
- Types: instance Eq ExistTypeScheme
- Types: instance Eq Type
- Types: instance Eq TypeScheme
- Types: instance Show ExistTypeScheme
- Types: instance Show Type
- Types: instance Show TypeScheme
- Types: intType :: Type
- Types: ioType :: Type -> Type
- Types: isArrowType :: Type -> Bool
- Types: listType :: Type -> Type
- Types: monoType :: Type -> TypeScheme
- Types: polyType :: Type -> TypeScheme
- Types: primType :: Ident -> [Type] -> Type
- Types: qualifyType :: ModuleIdent -> Type -> Type
- Types: stringType :: Type
- Types: successType :: Type
- Types: tupleType :: [Type] -> Type
- Types: typeConstrs :: Type -> [QualIdent]
- Types: typeSkolems :: Type -> [Int]
- Types: typeVar :: Int -> Type
- Types: typeVars :: Type -> [Int]
- Types: unitType :: Type
- Types: unqualifyType :: ModuleIdent -> Type -> Type
- Typing: class Typeable a
- Typing: instance Typeable ConstrTerm
- Typing: instance Typeable Expression
- Typing: instance Typeable Ident
- Typing: instance Typeable Rhs
- Typing: typeOf :: (Typeable a) => ValueEnv -> a -> Type
- Utils: (++!) :: [a] -> [a] -> [a]
- Utils: foldl2 :: (a -> b -> c -> a) -> a -> [b] -> [c] -> a
- Utils: foldr2 :: (a -> b -> c -> c) -> c -> [a] -> [b] -> c
- Utils: mapAccumM :: (Monad m) => (a -> b -> m (a, c)) -> a -> [b] -> m (a, [c])
- WarnCheck: instance Show IdInfo
- WarnCheck: warnCheck :: ModuleIdent -> ValueEnv -> [Decl] -> [Decl] -> [WarnMsg]
+ Curry.Files.CymakePath: cymakeVersion :: [Int]
+ Curry.Files.CymakePath: getCymake :: IO FilePath
Files
- curry-frontend.cabal +9/−3
- src/Curry/Files/CymakePath.hs +10/−0
- src/Curry/Syntax/Frontend.hs +0/−202
curry-frontend.cabal view
@@ -1,5 +1,5 @@ Name: curry-frontend-Version: 0.2.5+Version: 0.2.6 Cabal-Version: >= 1.6 Synopsis: Compile the functional logic language Curry to several intermediate formats Description: The Curry Frontend consists of the executable program "cymake".@@ -25,7 +25,9 @@ Executable cymake hs-source-dirs: src Main-is: cymake.hs- Build-Depends: base >= 3 && < 4, curry-base >= 0.2.2, mtl, old-time, containers, pretty+ Build-Depends: base >= 3 && < 4, + curry-base >= 0.2.5, + mtl, old-time, containers, pretty ghc-options: -fwarn-unused-binds -fwarn-unused-imports -auto-all Other-Modules: Curry.Syntax.Lexer, Curry.Syntax.LexComb Curry.Syntax.Parser, Curry.Syntax.LLParseComb@@ -53,4 +55,8 @@ Library hs-source-dirs: src- Exposed-Modules: Curry.Syntax.Frontend+ Build-Depends: filepath+ Exposed-Modules: + Curry.Files.CymakePath+ Other-Modules:+ Paths_curry_frontend
+ src/Curry/Files/CymakePath.hs view
@@ -0,0 +1,10 @@+module Curry.Files.CymakePath (getCymake,cymakeVersion) where++import Data.Version+import System.FilePath+import Paths_curry_frontend++cymakeVersion = versionBranch version+getCymake = do+ cymakeDir <- getBinDir+ return (cymakeDir </> "cymake")
− src/Curry/Syntax/Frontend.hs
@@ -1,202 +0,0 @@---------------------------------------------------------------------------------------------------------------------------------------------------------------------- Frontend - Provides an API for dealing with several kinds of Curry--- program representations------ December 2005,--- Martin Engelke (men@informatik.uni-kiel.de)----module Curry.Syntax.Frontend (lex, parse, fullParse, typingParse)where--import Data.Maybe-import qualified Data.Map as Map-import Control.Monad.Writer-import Control.Monad.Error-import Prelude hiding (lex)---import Curry.Base.MessageMonad-import Curry.Base.Ident-import Curry.Base.Position--import Curry.Files.Filenames-import Curry.Files.PathUtils--import qualified Curry.Syntax as CS-import Curry.Syntax.Lexer--import Modules-import CurryBuilder-import CurryCompilerOpts--import CurryDeps--import Base(ModuleEnv)--------------------------------------------------------------------------------------------------------------------------------------------------------------------- Returns the result of a lexical analysis of the source program 'src'.--- The result is a list of tuples consisting of a position and a token--- (see Modules "Position" and "CurryLexer")-lex :: FilePath -> String -> MsgMonad [(Position,Token)]-lex fn src = lexFile (first fn) src False []----- Returns the result of a syntactical analysis of the source program 'src'.--- The result is the syntax tree of the program (type 'Module'; see Module--- "CurrySyntax").-parse :: FilePath -> String -> MsgMonad CS.Module-parse fn src = CS.parseModule True fn src >>= genCurrySyntax fn----- Returns the syntax tree of the source program 'src' (type 'Module'; see--- Module "CurrySyntax") after resolving the category (i.e. function,--- constructor or variable) of an identifier. 'fullParse' always--- searches for standard Curry libraries in the path defined in the--- environment variable "PAKCSLIBPATH". Additional search paths can--- be defined using the argument 'paths'.-fullParse :: [FilePath] -> FilePath -> String -> IO (MsgMonad CS.Module)-fullParse paths fn src = -- liftM msgmonad2result $- genFullCurrySyntax simpleCheckModule paths fn (parse fn src)---- Behaves like 'fullParse', but Returns the syntax tree of the source --- program 'src' (type 'Module'; see Module "CurrySyntax") after inferring --- the types of identifiers.-typingParse :: [FilePath] -> FilePath -> String -> IO (MsgMonad CS.Module)-typingParse paths fn src = genFullCurrySyntax checkModule paths fn (parse fn src)--{---- Compiles the source programm 'src' to an AbstractCurry program.--- 'fullParse' always searches for standard Curry libraries in the path --- defined in the environment variable "PAKCSLIBPATH". Additional search --- paths can be defined using the argument 'paths'.--- Notes: Due to the lack of error handling in the current version of the--- front end, this function may fail when an error occurs-abstractIO :: [FilePath] -> FilePath -> String -> IO (MsgMonad ACY.CurryProg)-abstractIO paths fn src = genAbstractIO paths fn (parse fn src)---- Compiles the source program 'src' to a FlatCurry program.--- 'fullParse' always searches for standard Curry libraries in the path --- defined in the environment variable "PAKCSLIBPATH". Additional search --- paths can be defined using the argument 'paths'.--- Note: Due to the lack of error handling in the current version of the--- front end, this function may fail when an error occurs-flatIO :: [FilePath] -> FilePath -> String -> IO (MsgMonad FCY.Prog)-flatIO paths fn src = genFlatIO paths fn (parse fn src)--}-------------------------------------------------------------------------------------------------------------------------------------------------------------------- Privates...---opts paths = defaultOpts{ - importPaths = paths,- noVerb = True,- noWarn = True,- abstract = True- }------genCurrySyntax :: FilePath -> CS.Module -> MsgMonad (CS.Module)-genCurrySyntax fn mod- = let mod'@(CS.Module mid _ _) = patchModuleId fn (importPrelude fn mod)- in if isValidModuleId fn mid- then return mod'- else failWith $ err_invalidModuleName mid------genFullCurrySyntax :: (Options -> Base.ModuleEnv -> CS.Module -> IO (t1, t2, t3, CS.Module, t4, [WarnMsg]))- -> [FilePath] -> t -> MsgMonad CS.Module -> IO (MsgMonad CS.Module)-genFullCurrySyntax check paths fn m- = runMsgIO m $ \mod -> do errs <- makeInterfaces paths mod- if null errs- then do mEnv <- loadInterfaces paths mod- (_, _, _, mod', _, msgs') <- check (opts paths) mEnv mod- return (tell msgs' >> return mod')- else return (failWith (head errs))---{--genAbstractIO :: [FilePath] -> FilePath -> MsgMonad CS.Module- -> IO (MsgMonad ACY.CurryProg)-genAbstractIO paths fn m- = runMsgIO m $ \mod ->- do errs <- makeInterfaces paths mod- if null errs- then do mEnv <- loadInterfaces paths mod- (tyEnv, tcEnv, _, mod', _, msgs')- <- simpleCheckModule (opts paths) mEnv mod- return (tell msgs' >> return (genTypedAbstract tyEnv tcEnv mod'))- else return (failWith $ head errs)------genFlatIO :: [FilePath] -> FilePath -> MsgMonad CS.Module -> IO (MsgMonad FCY.Prog)-genFlatIO paths fn m- = runMsgIO m $ \ mod -> - do errs <- makeInterfaces paths mod- if null errs then- (do mEnv <- loadInterfaces paths mod- (tyEnv, tcEnv, aEnv, mod', intf, msgs') <- - checkModule (opts paths) mEnv mod- let (il, aEnv', _) - = transModule True True False mEnv tyEnv tcEnv aEnv mod'- il' = completeCase mEnv il- cEnv = curryEnv mEnv tcEnv intf mod'- (prog,msgs'') = genFlatCurry (opts paths) cEnv mEnv - tyEnv tcEnv aEnv' il'- return (tell msgs'' >> tell msgs' >> return prog)- )- else return (failWith $ head errs)--}-------------------------------------------------------------------------------------- Generates interface files for importes modules, if they don't exist or--- if they are not up-to-date.-makeInterfaces :: [FilePath] -> CS.Module -> IO [String]-makeInterfaces paths (CS.Module mid _ decls)- = do let imports = [preludeMIdent | mid /= preludeMIdent] - ++ [imp | CS.ImportDecl _ imp _ _ _ <- decls]- (deps, errs) <- fmap flattenDeps (foldM (moduleDeps paths []) Map.empty imports)- when (null errs) (mapM_ (compile deps . snd) deps)- return errs- where- compile deps (Source file' mods)- = do smake [flatName file', flatIntName file']- (file':mapMaybe (flatInterface deps) mods)- (compileModule (opts paths) file')- (return Nothing)- return ()- compile _ _ = return ()-- flatInterface deps mod - = case (lookup mod deps) of- Just (Source file _) -> Just (flatIntName (dropExtension file))- Just (Interface file) -> Just (flatIntName (dropExtension file))- _ -> Nothing----- Returns 'True', if file name and module name are equal.-isValidModuleId :: FilePath -> ModuleIdent -> Bool-isValidModuleId fn mid- = last (moduleQualifiers mid) == takeBaseName fn------------------------------------------------------------------------------------- Messages--err_invalidModuleName :: ModuleIdent -> String-err_invalidModuleName mid - = "module \"" ++ moduleName mid - ++ "\" must be in a file \"" ++ moduleName mid ++ ".curry\""------------------------------------------------------------------------------------------------------------------------------------------------------------------