Commit b52838bc authored by partain's avatar partain
Browse files

[project @ 1996-03-22 09:24:22 by partain]

Removing junk .hi files
parent 0596517a
This diff is collapsed.
{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
interface AbsSynFuns where
import HsBinds(Bind, Binds, MonoBinds)
import HsDecls(ClassDecl, FixityDecl, InstDecl)
import HsExpr(Expr, Qual)
import HsImpExp(IE)
import HsPat(InPat, TypecheckedPat)
import HsTypes(MonoType)
import Id(Id)
import Maybes(Labda)
import Name(Name)
import PreludePS(_PackedString)
import ProtoName(ProtoName)
import RenameAuxFuns(PreludeNameFun(..))
import SrcLoc(SrcLoc)
import TyVar(TyVar)
import UniType(UniType)
type PreludeNameFun = _PackedString -> Labda Name
cmpInstanceTypes :: MonoType ProtoName -> MonoType ProtoName -> Int#
collectBinders :: Bind a (InPat a) -> [a]
collectMonoBinders :: MonoBinds a (InPat a) -> [a]
collectMonoBindersAndLocs :: MonoBinds a (InPat a) -> [(a, SrcLoc)]
collectPatBinders :: InPat a -> [a]
collectQualBinders :: [Qual Name (InPat Name)] -> [Name]
collectTopLevelBinders :: Binds a (InPat a) -> [a]
collectTypedBinders :: Bind Id TypecheckedPat -> [Id]
collectTypedPatBinders :: TypecheckedPat -> [Id]
extractMonoTyNames :: (a -> a -> Bool) -> MonoType a -> [a]
getMentionedVars :: (_PackedString -> Labda Name) -> [IE] -> [FixityDecl ProtoName] -> [ClassDecl ProtoName (InPat ProtoName)] -> [InstDecl ProtoName (InPat ProtoName)] -> Binds ProtoName (InPat ProtoName) -> (Bool, [_PackedString])
getNonPrelOuterTyCon :: MonoType ProtoName -> Labda ProtoName
mkDictApp :: Expr Id TypecheckedPat -> [Id] -> Expr Id TypecheckedPat
mkDictLam :: [Id] -> Expr Id TypecheckedPat -> Expr Id TypecheckedPat
mkTyApp :: Expr Id TypecheckedPat -> [UniType] -> Expr Id TypecheckedPat
mkTyLam :: [TyVar] -> Expr Id TypecheckedPat -> Expr Id TypecheckedPat
{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
interface HsBinds where
import HsExpr(Expr)
import HsMatches(GRHSsAndBinds, Match)
import HsPat(InPat, TypecheckedPat)
import HsPragmas(ClassOpPragmas, GenPragmas)
import HsTypes(PolyType)
import Id(Id)
import Inst(Inst)
import Maybes(Labda)
import Name(Name)
import Outputable(NamedThing, Outputable)
import PreludePS(_PackedString)
import ProtoName(ProtoName)
import SimplEnv(UnfoldingGuidance)
import SrcLoc(SrcLoc)
import TyVar(TyVar)
data Bind a b = EmptyBind | NonRecBind (MonoBinds a b) | RecBind (MonoBinds a b)
data Binds a b = EmptyBinds | ThenBinds (Binds a b) (Binds a b) | SingleBind (Bind a b) | BindWith (Bind a b) [Sig a] | AbsBinds [TyVar] [Id] [(Id, Id)] [(Inst, Expr a b)] (Bind a b)
data MonoBinds a b = EmptyMonoBinds | AndMonoBinds (MonoBinds a b) (MonoBinds a b) | PatMonoBind b (GRHSsAndBinds a b) SrcLoc | VarMonoBind Id (Expr a b) | FunMonoBind a [Match a b] SrcLoc
type ProtoNameBind = Bind ProtoName (InPat ProtoName)
type ProtoNameBinds = Binds ProtoName (InPat ProtoName)
type ProtoNameClassOpSig = Sig ProtoName
type ProtoNameMonoBinds = MonoBinds ProtoName (InPat ProtoName)
type ProtoNameSig = Sig ProtoName
type RenamedBind = Bind Name (InPat Name)
type RenamedBinds = Binds Name (InPat Name)
type RenamedClassOpSig = Sig Name
type RenamedMonoBinds = MonoBinds Name (InPat Name)
type RenamedSig = Sig Name
data Sig a = Sig a (PolyType a) (GenPragmas a) SrcLoc | ClassOpSig a (PolyType a) (ClassOpPragmas a) SrcLoc | SpecSig a (PolyType a) (Labda a) SrcLoc | InlineSig a UnfoldingGuidance SrcLoc | DeforestSig a SrcLoc | MagicUnfoldingSig a _PackedString SrcLoc
type TypecheckedBind = Bind Id TypecheckedPat
type TypecheckedBinds = Binds Id TypecheckedPat
type TypecheckedMonoBinds = MonoBinds Id TypecheckedPat
bindIsRecursive :: Bind Id TypecheckedPat -> Bool
nullBind :: Bind a b -> Bool
nullBinds :: Binds a b -> Bool
nullMonoBinds :: MonoBinds a b -> Bool
instance (NamedThing a, Outputable a, NamedThing b, Outputable b) => Outputable (Bind a b)
instance (NamedThing a, Outputable a, NamedThing b, Outputable b) => Outputable (Binds a b)
instance (NamedThing a, Outputable a, NamedThing b, Outputable b) => Outputable (MonoBinds a b)
instance Outputable a => Outputable (Sig a)
{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
interface HsCore where
import BasicLit(BasicLit)
import HsTypes(MonoType, PolyType)
import Maybes(Labda)
import Outputable(Outputable)
import PreludePS(_PackedString)
import PrimOps(PrimOp)
import ProtoName(ProtoName)
data UfCostCentre a = UfPreludeDictsCC Bool | UfAllDictsCC _PackedString _PackedString Bool | UfUserCC _PackedString _PackedString _PackedString Bool Bool | UfAutoCC (UfId a) _PackedString _PackedString Bool Bool | UfDictCC (UfId a) _PackedString _PackedString Bool Bool
data UfId a = BoringUfId a | SuperDictSelUfId a a | ClassOpUfId a a | DictFunUfId a (PolyType a) | ConstMethodUfId a a (PolyType a) | DefaultMethodUfId a a | SpecUfId (UfId a) [Labda (MonoType a)] | WorkerUfId (UfId a)
data UnfoldingCoreAlts a = UfCoAlgAlts [(a, [(a, PolyType a)], UnfoldingCoreExpr a)] (UnfoldingCoreDefault a) | UfCoPrimAlts [(BasicLit, UnfoldingCoreExpr a)] (UnfoldingCoreDefault a)
data UnfoldingCoreAtom a = UfCoVarAtom (UfId a) | UfCoLitAtom BasicLit
data UnfoldingCoreBinding a = UfCoNonRec (a, PolyType a) (UnfoldingCoreExpr a) | UfCoRec [((a, PolyType a), UnfoldingCoreExpr a)]
data UnfoldingCoreDefault a = UfCoNoDefault | UfCoBindDefault (a, PolyType a) (UnfoldingCoreExpr a)
data UnfoldingCoreExpr a = UfCoVar (UfId a) | UfCoLit BasicLit | UfCoCon a [PolyType a] [UnfoldingCoreAtom a] | UfCoPrim (UnfoldingPrimOp a) [PolyType a] [UnfoldingCoreAtom a] | UfCoLam [(a, PolyType a)] (UnfoldingCoreExpr a) | UfCoTyLam a (UnfoldingCoreExpr a) | UfCoApp (UnfoldingCoreExpr a) (UnfoldingCoreAtom a) | UfCoTyApp (UnfoldingCoreExpr a) (PolyType a) | UfCoCase (UnfoldingCoreExpr a) (UnfoldingCoreAlts a) | UfCoLet (UnfoldingCoreBinding a) (UnfoldingCoreExpr a) | UfCoSCC (UfCostCentre a) (UnfoldingCoreExpr a)
data UnfoldingPrimOp a = UfCCallOp _PackedString Bool Bool [PolyType a] (PolyType a) | UfOtherOp PrimOp
type UnfoldingType a = PolyType a
eqUfExpr :: UnfoldingCoreExpr ProtoName -> UnfoldingCoreExpr ProtoName -> Bool
instance Outputable a => Outputable (UnfoldingCoreAtom a)
instance Outputable a => Outputable (UnfoldingCoreExpr a)
instance Outputable a => Outputable (UnfoldingPrimOp a)
{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
interface HsDecls where
import HsBinds(MonoBinds, Sig)
import HsPat(InPat)
import HsPragmas(ClassPragmas, DataPragmas, InstancePragmas, TypePragmas)
import HsTypes(MonoType)
import Name(Name)
import Outputable(NamedThing, Outputable)
import PreludePS(_PackedString)
import ProtoName(ProtoName)
import SrcLoc(SrcLoc)
data ClassDecl a b = ClassDecl [(a, a)] a a [Sig a] (MonoBinds a b) (ClassPragmas a) SrcLoc
data ConDecl a = ConDecl a [MonoType a] SrcLoc
data DataTypeSig a = AbstractTypeSig a SrcLoc | SpecDataSig a (MonoType a) SrcLoc
data DefaultDecl a = DefaultDecl [MonoType a] SrcLoc
data FixityDecl a = InfixL a Int | InfixR a Int | InfixN a Int
data InstDecl a b = InstDecl [(a, a)] a (MonoType a) (MonoBinds a b) Bool _PackedString _PackedString [Sig a] (InstancePragmas a) SrcLoc
type ProtoNameClassDecl = ClassDecl ProtoName (InPat ProtoName)
type ProtoNameConDecl = ConDecl ProtoName
type ProtoNameDataTypeSig = DataTypeSig ProtoName
type ProtoNameDefaultDecl = DefaultDecl ProtoName
type ProtoNameFixityDecl = FixityDecl ProtoName
type ProtoNameInstDecl = InstDecl ProtoName (InPat ProtoName)
type ProtoNameSpecialisedInstanceSig = SpecialisedInstanceSig ProtoName
type ProtoNameTyDecl = TyDecl ProtoName
type RenamedClassDecl = ClassDecl Name (InPat Name)
type RenamedConDecl = ConDecl Name
type RenamedDataTypeSig = DataTypeSig Name
type RenamedDefaultDecl = DefaultDecl Name
type RenamedFixityDecl = FixityDecl Name
type RenamedInstDecl = InstDecl Name (InPat Name)
type RenamedSpecialisedInstanceSig = SpecialisedInstanceSig Name
type RenamedTyDecl = TyDecl Name
data SpecialisedInstanceSig a = InstSpecSig a (MonoType a) SrcLoc
data TyDecl a = TyData [(a, a)] a [a] [ConDecl a] [a] (DataPragmas a) SrcLoc | TySynonym a [a] (MonoType a) TypePragmas SrcLoc
eqConDecls :: [ConDecl ProtoName] -> [ConDecl ProtoName] -> Bool
instance (NamedThing a, Outputable a, NamedThing b, Outputable b) => Outputable (ClassDecl a b)
instance (NamedThing a, Outputable a) => Outputable (ConDecl a)
instance (NamedThing a, Outputable a) => Outputable (DataTypeSig a)
instance (NamedThing a, Outputable a) => Outputable (DefaultDecl a)
instance (NamedThing a, Outputable a) => Outputable (FixityDecl a)
instance (NamedThing a, Outputable a, NamedThing b, Outputable b) => Outputable (InstDecl a b)
instance (NamedThing a, Outputable a) => Outputable (SpecialisedInstanceSig a)
instance (NamedThing a, Outputable a) => Outputable (TyDecl a)
{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
interface HsExpr where
import HsBinds(Binds)
import HsLit(Literal)
import HsMatches(Match)
import HsPat(InPat, TypecheckedPat)
import HsTypes(PolyType)
import Id(Id)
import Name(Name)
import Outputable(NamedThing, Outputable)
import PreludePS(_PackedString)
import Pretty(PprStyle, PrettyRep)
import ProtoName(ProtoName)
import TyVar(TyVar)
import UniType(UniType)
data ArithSeqInfo a b = From (Expr a b) | FromThen (Expr a b) (Expr a b) | FromTo (Expr a b) (Expr a b) | FromThenTo (Expr a b) (Expr a b) (Expr a b)
data Expr a b = Var a | Lit Literal | Lam (Match a b) | App (Expr a b) (Expr a b) | OpApp (Expr a b) (Expr a b) (Expr a b) | SectionL (Expr a b) (Expr a b) | SectionR (Expr a b) (Expr a b) | CCall _PackedString [Expr a b] Bool Bool UniType | SCC _PackedString (Expr a b) | Case (Expr a b) [Match a b] | If (Expr a b) (Expr a b) (Expr a b) | Let (Binds a b) (Expr a b) | ListComp (Expr a b) [Qual a b] | ExplicitList [Expr a b] | ExplicitListOut UniType [Expr a b] | ExplicitTuple [Expr a b] | ExprWithTySig (Expr a b) (PolyType a) | ArithSeqIn (ArithSeqInfo a b) | ArithSeqOut (Expr a b) (ArithSeqInfo a b) | TyLam [TyVar] (Expr a b) | TyApp (Expr a b) [UniType] | DictLam [Id] (Expr a b) | DictApp (Expr a b) [Id] | ClassDictLam [Id] [Id] (Expr a b) | Dictionary [Id] [Id] | SingleDict Id
type ProtoNameArithSeqInfo = ArithSeqInfo ProtoName (InPat ProtoName)
type ProtoNameExpr = Expr ProtoName (InPat ProtoName)
type ProtoNameQual = Qual ProtoName (InPat ProtoName)
data Qual a b = GeneratorQual b (Expr a b) | FilterQual (Expr a b)
type RenamedArithSeqInfo = ArithSeqInfo Name (InPat Name)
type RenamedExpr = Expr Name (InPat Name)
type RenamedQual = Qual Name (InPat Name)
type TypecheckedArithSeqInfo = ArithSeqInfo Id TypecheckedPat
type TypecheckedExpr = Expr Id TypecheckedPat
type TypecheckedQual = Qual Id TypecheckedPat
pprExpr :: (NamedThing a, Outputable a, NamedThing b, Outputable b) => PprStyle -> Expr a b -> Int -> Bool -> PrettyRep
pprParendExpr :: (NamedThing a, Outputable a, NamedThing b, Outputable b) => PprStyle -> Expr a b -> Int -> Bool -> PrettyRep
instance (NamedThing a, Outputable a, NamedThing b, Outputable b) => Outputable (ArithSeqInfo a b)
instance (NamedThing a, Outputable a, NamedThing b, Outputable b) => Outputable (Expr a b)
instance (NamedThing a, Outputable a, NamedThing b, Outputable b) => Outputable (Qual a b)
{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
interface HsImpExp where
import FiniteMap(FiniteMap)
import HsBinds(Sig)
import HsDecls(ClassDecl, FixityDecl, InstDecl, TyDecl)
import HsPat(InPat)
import Name(Name)
import Outputable(ExportFlag, NamedThing, Outputable)
import PreludePS(_PackedString)
import Pretty(PprStyle, PrettyRep)
import ProtoName(ProtoName)
import SrcLoc(SrcLoc)
data IE = IEVar _PackedString | IEThingAbs _PackedString | IEThingAll _PackedString | IEConWithCons _PackedString [_PackedString] | IEClsWithOps _PackedString [_PackedString] | IEModuleContents _PackedString
data IfaceImportDecl = IfaceImportDecl _PackedString [IE] [Renaming] SrcLoc
type ImExportListInfo = (FiniteMap _PackedString ExportFlag, FiniteMap _PackedString ())
data ImportedInterface a b = ImportAll (Interface a b) [Renaming] | ImportSome (Interface a b) [IE] [Renaming] | ImportButHide (Interface a b) [IE] [Renaming]
data Interface a b = MkInterface _PackedString [IfaceImportDecl] [FixityDecl a] [TyDecl a] [ClassDecl a b] [InstDecl a b] [Sig a] SrcLoc
type ProtoNameImportedInterface = ImportedInterface ProtoName (InPat ProtoName)
type ProtoNameInterface = Interface ProtoName (InPat ProtoName)
type RenamedImportedInterface = ImportedInterface Name (InPat Name)
type RenamedInterface = Interface Name (InPat Name)
data Renaming = MkRenaming _PackedString _PackedString
getIEStrings :: [IE] -> (FiniteMap _PackedString ExportFlag, FiniteMap _PackedString ())
getRawIEStrings :: [IE] -> ([(_PackedString, ExportFlag)], [_PackedString])
pprRenamings :: PprStyle -> [Renaming] -> Int -> Bool -> PrettyRep
instance Outputable IE
instance Outputable IfaceImportDecl
instance (NamedThing a, Outputable a, NamedThing b, Outputable b) => Outputable (ImportedInterface a b)
instance (NamedThing a, Outputable a, NamedThing b, Outputable b) => Outputable (Interface a b)
instance Outputable Renaming
{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
interface HsLit where
import Outputable(Outputable)
import PreludePS(_PackedString)
import PreludeRatio(Ratio(..))
import UniType(UniType)
data Literal = CharLit Char | CharPrimLit Char | StringLit _PackedString | StringPrimLit _PackedString | IntLit Integer | FracLit (Ratio Integer) | LitLitLitIn _PackedString | LitLitLit _PackedString UniType | IntPrimLit Integer | FloatPrimLit (Ratio Integer) | DoublePrimLit (Ratio Integer)
negLiteral :: Literal -> Literal
instance Outputable Literal
{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
interface HsMatches where
import HsBinds(Binds)
import HsExpr(Expr)
import HsPat(InPat, TypecheckedPat)
import Id(Id)
import Name(Name)
import Outputable(NamedThing, Outputable)
import Pretty(PprStyle, PrettyRep)
import ProtoName(ProtoName)
import SrcLoc(SrcLoc)
import UniType(UniType)
data GRHS a b = GRHS (Expr a b) (Expr a b) SrcLoc | OtherwiseGRHS (Expr a b) SrcLoc
data GRHSsAndBinds a b = GRHSsAndBindsIn [GRHS a b] (Binds a b) | GRHSsAndBindsOut [GRHS a b] (Binds a b) UniType
data Match a b = PatMatch b (Match a b) | GRHSMatch (GRHSsAndBinds a b)
type ProtoNameGRHS = GRHS ProtoName (InPat ProtoName)
type ProtoNameGRHSsAndBinds = GRHSsAndBinds ProtoName (InPat ProtoName)
type ProtoNameMatch = Match ProtoName (InPat ProtoName)
type RenamedGRHS = GRHS Name (InPat Name)
type RenamedGRHSsAndBinds = GRHSsAndBinds Name (InPat Name)
type RenamedMatch = Match Name (InPat Name)
type TypecheckedGRHS = GRHS Id TypecheckedPat
type TypecheckedGRHSsAndBinds = GRHSsAndBinds Id TypecheckedPat
type TypecheckedMatch = Match Id TypecheckedPat
pprGRHS :: (NamedThing a, Outputable a, NamedThing b, Outputable b) => PprStyle -> Bool -> GRHS a b -> Int -> Bool -> PrettyRep
pprGRHSsAndBinds :: (NamedThing a, Outputable a, NamedThing b, Outputable b) => PprStyle -> Bool -> GRHSsAndBinds a b -> Int -> Bool -> PrettyRep
pprMatch :: (NamedThing a, Outputable a, NamedThing b, Outputable b) => PprStyle -> Bool -> Match a b -> Int -> Bool -> PrettyRep
pprMatches :: (NamedThing a, Outputable a, NamedThing b, Outputable b) => PprStyle -> (Bool, Int -> Bool -> PrettyRep) -> [Match a b] -> Int -> Bool -> PrettyRep
instance (NamedThing a, Outputable a, NamedThing b, Outputable b) => Outputable (GRHS a b)
instance (NamedThing a, Outputable a, NamedThing b, Outputable b) => Outputable (GRHSsAndBinds a b)
instance (NamedThing a, Outputable a, NamedThing b, Outputable b) => Outputable (Match a b)
{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
interface HsPat where
import HsExpr(Expr)
import HsLit(Literal)
import Id(Id)
import Name(Name)
import Outputable(NamedThing, Outputable)
import Pretty(PprStyle, PrettyRep)
import ProtoName(ProtoName)
import UniType(UniType)
data InPat a = WildPatIn | VarPatIn a | LitPatIn Literal | LazyPatIn (InPat a) | AsPatIn a (InPat a) | ConPatIn a [InPat a] | ConOpPatIn (InPat a) a (InPat a) | ListPatIn [InPat a] | TuplePatIn [InPat a] | NPlusKPatIn a Literal
type ProtoNamePat = InPat ProtoName
type RenamedPat = InPat Name
data TypecheckedPat = WildPat UniType | VarPat Id | LazyPat TypecheckedPat | AsPat Id TypecheckedPat | ConPat Id UniType [TypecheckedPat] | ConOpPat TypecheckedPat Id TypecheckedPat UniType | ListPat UniType [TypecheckedPat] | TuplePat [TypecheckedPat] | LitPat Literal UniType | NPat Literal UniType (Expr Id TypecheckedPat) | NPlusKPat Id Literal UniType (Expr Id TypecheckedPat) (Expr Id TypecheckedPat) (Expr Id TypecheckedPat)
irrefutablePat :: TypecheckedPat -> Bool
isConPat :: TypecheckedPat -> Bool
isLitPat :: TypecheckedPat -> Bool
only_con :: Id -> Bool
patsAreAllCons :: [TypecheckedPat] -> Bool
patsAreAllLits :: [TypecheckedPat] -> Bool
pprConPatTy :: PprStyle -> UniType -> Int -> Bool -> PrettyRep
pprInPat :: Outputable a => PprStyle -> InPat a -> Int -> Bool -> PrettyRep
pprTypecheckedPat :: PprStyle -> TypecheckedPat -> Int -> Bool -> PrettyRep
typeOfPat :: TypecheckedPat -> UniType
unfailablePat :: TypecheckedPat -> Bool
unfailablePats :: [TypecheckedPat] -> Bool
instance NamedThing a => NamedThing (InPat a)
instance NamedThing TypecheckedPat
instance Outputable a => Outputable (InPat a)
instance Outputable TypecheckedPat
{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
interface HsPragmas where
import HsCore(UnfoldingCoreExpr)
import HsDecls(ConDecl)
import HsTypes(MonoType)
import IdInfo(DeforestInfo, Demand, UpdateInfo)
import Maybes(Labda)
import Name(Name)
import Outputable(Outputable)
import PreludePS(_PackedString)
import ProtoName(ProtoName)
import SimplEnv(UnfoldingGuidance)
data ClassOpPragmas a = NoClassOpPragmas | ClassOpPragmas (GenPragmas a) (GenPragmas a)
data ClassPragmas a = NoClassPragmas | SuperDictPragmas [GenPragmas a]
data DataPragmas a = DataPragmas [ConDecl a] [[Labda (MonoType a)]]
data GenPragmas a = NoGenPragmas | GenPragmas (Labda Int) (Labda UpdateInfo) DeforestInfo (ImpStrictness a) (ImpUnfolding a) [([Labda (MonoType a)], Int, GenPragmas a)]
data ImpStrictness a = NoImpStrictness | ImpStrictness Bool [Demand] (GenPragmas a)
data ImpUnfolding a = NoImpUnfolding | ImpMagicUnfolding _PackedString | ImpUnfolding UnfoldingGuidance (UnfoldingCoreExpr a)
data InstancePragmas a = NoInstancePragmas | SimpleInstancePragma (GenPragmas a) | ConstantInstancePragma (GenPragmas a) [(a, GenPragmas a)] | SpecialisedInstancePragma (GenPragmas a) [([Labda (MonoType a)], Int, InstancePragmas a)]
type ProtoNameClassOpPragmas = ClassOpPragmas ProtoName
type ProtoNameClassPragmas = ClassPragmas ProtoName
type ProtoNameDataPragmas = DataPragmas ProtoName
type ProtoNameGenPragmas = GenPragmas ProtoName
type ProtoNameInstancePragmas = InstancePragmas ProtoName
type ProtoNameUnfoldingCoreExpr = UnfoldingCoreExpr ProtoName
type RenamedClassOpPragmas = ClassOpPragmas Name
type RenamedClassPragmas = ClassPragmas Name
type RenamedDataPragmas = DataPragmas Name
type RenamedGenPragmas = GenPragmas Name
type RenamedImpStrictness = ImpStrictness Name
type RenamedInstancePragmas = InstancePragmas Name
data TypePragmas = NoTypePragmas | AbstractTySynonym
instance Outputable a => Outputable (ClassOpPragmas a)
instance Outputable a => Outputable (ClassPragmas a)
instance Outputable a => Outputable (GenPragmas a)
instance Outputable a => Outputable (InstancePragmas a)
{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
interface HsTypes where
import Name(Name)
import Outputable(Outputable)
import Pretty(PprStyle, PrettyRep)
import ProtoName(ProtoName)
type ClassAssertion a = (a, a)
type Context a = [(a, a)]
data MonoType a = MonoTyVar a | MonoTyCon a [MonoType a] | FunMonoTy (MonoType a) (MonoType a) | ListMonoTy (MonoType a) | TupleMonoTy [PolyType a] | MonoTyVarTemplate a | MonoDict a (MonoType a)
data PolyType a = UnoverloadedTy (MonoType a) | OverloadedTy [(a, a)] (MonoType a) | ForAllTy [a] (MonoType a)
type ProtoNameContext = [(ProtoName, ProtoName)]
type ProtoNameMonoType = MonoType ProtoName
type ProtoNamePolyType = PolyType ProtoName
type RenamedContext = [(Name, Name)]
type RenamedMonoType = MonoType Name
type RenamedPolyType = PolyType Name
cmpList :: (a -> a -> Int#) -> [a] -> [a] -> Int#
cmpMonoType :: (a -> a -> Int#) -> MonoType a -> MonoType a -> Int#
cmpPolyType :: (a -> a -> Int#) -> PolyType a -> PolyType a -> Int#
eqMonoType :: MonoType ProtoName -> MonoType ProtoName -> Bool
pprContext :: Outputable a => PprStyle -> [(a, a)] -> Int -> Bool -> PrettyRep
pprParendMonoType :: Outputable a => PprStyle -> MonoType a -> Int -> Bool -> PrettyRep
instance Outputable a => Outputable (MonoType a)
instance Outputable a => Outputable (PolyType a)
{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
interface Name where
import Id(Id)
import NameTypes(FullName, ShortName)
import Outputable(NamedThing, Outputable)
import PreludePS(_PackedString)
import TyCon(TyCon)
import Unique(Unique)
data Id
data FullName
data Name = Short Unique ShortName | WiredInTyCon TyCon | WiredInVal Id | PreludeVal Unique FullName | PreludeTyCon Unique FullName Int Bool | PreludeClass Unique FullName | OtherTyCon Unique FullName Int Bool [Name] | OtherClass Unique FullName [Name] | OtherTopId Unique FullName | ClassOpName Unique Name _PackedString Int | Unbound _PackedString
data ShortName
data TyCon
data Unique
cmpName :: Name -> Name -> Int#
eqName :: Name -> Name -> Bool
getTagFromClassOpName :: Name -> Int
invisibleName :: Name -> Bool
isClassName :: Name -> Bool
isClassOpName :: Name -> Name -> Bool
isTyConName :: Name -> Bool
isUnboundName :: Name -> Bool
instance Eq Name
instance Ord Name
instance NamedThing Name
instance Outputable Name
{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
interface AbsUniType where
import Bag(Bag)
import Class(Class, ClassOp, cmpClass, derivableClassKeys, getClassBigSig, getClassInstEnv, getClassKey, getClassOpId, getClassOpLocalType, getClassOpString, getClassOpTag, getClassOps, getClassSig, getConstMethodId, getDefaultMethodId, getSuperDictSelId, isNumericClass, isStandardClass, isSuperClassOf, mkClass, mkClassOp)
import CmdLineOpts(GlobalSwitch)
import Id(DataCon(..), Id)
import IdEnv(IdEnv(..))
import InstEnv(ClassInstEnv(..), InstTemplate, MatchEnv(..))
import Maybes(Labda)
import Name(Name)
import NameTypes(FullName, ShortName)
import Outputable(ExportFlag, NamedThing, Outputable)
import PreludePS(_PackedString)
import Pretty(PprStyle, Pretty(..), PrettyRep)
import PrimKind(PrimKind)
import SimplEnv(UnfoldingDetails)
import TyCon(Arity(..), TyCon, cmpTyCon, derivedFor, eqTyCon, getTyConArity, getTyConDataCons, getTyConDerivings, getTyConFamilySize, getTyConKind, getTyConTyVarTemplates, isBigTupleTyCon, isBoxedTyCon, isDataTyCon, isEnumerationTyCon, isLocalGenTyCon, isLocalSpecTyCon, isPrimTyCon, isSynTyCon, isTupleTyCon, isVisibleSynTyCon, maybeCharLikeTyCon, maybeDoubleLikeTyCon, maybeFloatLikeTyCon, maybeIntLikeTyCon, maybeSingleConstructorTyCon, mkDataTyCon, mkPrimTyCon, mkSpecTyCon, mkSynonymTyCon, mkTupleTyCon)
import TyVar(TyVar, TyVarTemplate, alphaTyVars, alpha_tv, alpha_tyvar, beta_tv, beta_tyvar, cloneTyVar, cloneTyVarFromTemplate, cmpTyVar, delta_tv, delta_tyvar, epsilon_tv, epsilon_tyvar, eqTyVar, gamma_tv, gamma_tyvar, instantiateTyVarTemplates, ltTyVar, mkOpenSysTyVar, mkPolySysTyVar, mkSysTyVarTemplate, mkTemplateTyVars, mkUserTyVar, mkUserTyVarTemplate)
import TyVarEnv(TyVarEnv(..), TypeEnv(..))
import UniTyFuns(applyNonSynTyCon, applySynTyCon, applyTy, applyTyCon, applyTypeEnvToThetaTy, applyTypeEnvToTy, cmpUniTypeMaybeList, expandVisibleTySyn, extractTyVarTemplatesFromTy, extractTyVarsFromTy, extractTyVarsFromTys, funResultTy, getMentionedTyCons, getMentionedTyConsAndClassesFromClass, getMentionedTyConsAndClassesFromTyCon, getMentionedTyConsAndClassesFromUniType, getTauType, getTyVar, getTyVarMaybe, getTyVarTemplateMaybe, getTypeString, getUniDataSpecTyCon, getUniDataSpecTyCon_maybe, getUniDataTyCon, getUniDataTyCon_maybe, getUniTyDescription, glueTyArgs, instanceIsExported, isDictTy, isForAllTy, isFunType, isGroundOrTyVarTy, isGroundTy, isLeakFreeType, isPrimType, isTauTy, isTyVarTemplateTy, isTyVarTy, isUnboxedDataType, kindFromType, mapOverTyVars, matchTy, maybeBoxedPrimType, maybePurelyLocalClass, maybePurelyLocalTyCon, maybePurelyLocalType, maybeUnpackFunTy, mkSuperDictSelType, pprClassOp, pprIfaceClass, pprMaybeTy, pprParendUniType, pprTyCon, pprUniType, returnsRealWorld, showTyCon, showTypeCategory, specMaybeTysSuffix, specialiseTy, splitDictType, splitForalls, splitTyArgs, splitType, splitTypeWithDictsAsArgs, typeMaybeString, unDictifyTy)
import UniType(InstTyEnv(..), RhoType(..), SigmaType(..), TauType(..), ThetaType(..), UniType, alpha, alpha_ty, beta, beta_ty, cmpUniType, delta, delta_ty, epsilon, epsilon_ty, gamma, gamma_ty, instantiateTauTy, instantiateThetaTy, instantiateTy, mkDictTy, mkForallTy, mkRhoTy, mkSigmaTy, mkTyVarTemplateTy, mkTyVarTy, quantifyTy)
import UniqFM(UniqFM)
import Unique(Unique)
data Bag a
data Class
data ClassOp
data GlobalSwitch
type DataCon = Id
data Id
type IdEnv a = UniqFM a
type ClassInstEnv = [(UniType, InstTemplate)]
data InstTemplate
type MatchEnv a b = [(a, b)]
data Labda a
data Name
data FullName
data ShortName
data ExportFlag
data PprStyle
type Pretty = Int -> Bool -> PrettyRep
data PrettyRep
data PrimKind
data UnfoldingDetails
type Arity = Int
data TyCon
data TyVar
data TyVarTemplate
type TyVarEnv a = UniqFM a
type TypeEnv = UniqFM UniType
type InstTyEnv = [(TyVarTemplate, UniType)]
type RhoType = UniType
type SigmaType = UniType
type TauType = UniType
type ThetaType = [(Class, UniType)]
data UniType
data UniqFM a
data Unique
cmpClass :: Class -> Class -> Int#
derivableClassKeys :: [Unique]
getClassBigSig :: Class -> (TyVarTemplate, [Class], [Id], [ClassOp], [Id], [Id])
getClassInstEnv :: Class -> [(UniType, InstTemplate)]
getClassKey :: Class -> Unique
getClassOpId :: Class -> ClassOp -> Id
getClassOpLocalType :: ClassOp -> UniType
getClassOpString :: ClassOp -> _PackedString
getClassOpTag :: ClassOp -> Int
getClassOps :: Class -> [ClassOp]
getClassSig :: Class -> (TyVarTemplate, [Class], [ClassOp])
getConstMethodId :: Class -> ClassOp -> UniType -> Id
getDefaultMethodId :: Class -> ClassOp -> Id
getSuperDictSelId :: Class -> Class -> Id
isNumericClass :: Class -> Bool
isStandardClass :: Class -> Bool
isSuperClassOf :: Class -> Class -> Labda [Class]
mkClass :: Name -> TyVarTemplate -> [Class] -> [Id] -> [ClassOp] -> [Id] -> [Id] -> [(UniType, InstTemplate)] -> Class
mkClassOp :: _PackedString -> Int -> UniType -> ClassOp
cmpTyCon :: TyCon -> TyCon -> Int#
derivedFor :: Class -> TyCon -> Bool
eqTyCon :: TyCon -> TyCon -> Bool
getTyConArity :: TyCon -> Int
getTyConDataCons :: TyCon -> [Id]
getTyConDerivings :: TyCon -> [Class]
getTyConFamilySize :: TyCon -> Labda Int
getTyConKind :: TyCon -> [PrimKind] -> PrimKind
getTyConTyVarTemplates :: TyCon -> [TyVarTemplate]
isBigTupleTyCon :: TyCon -> Bool
isBoxedTyCon :: TyCon -> Bool
isDataTyCon :: TyCon -> Bool
isEnumerationTyCon :: TyCon -> Bool
isLocalGenTyCon :: TyCon -> Bool
isLocalSpecTyCon :: Bool -> TyCon -> Bool
isPrimTyCon :: TyCon -> Bool
isSynTyCon :: TyCon -> Bool
isTupleTyCon :: TyCon -> Bool
isVisibleSynTyCon :: TyCon -> Bool
maybeCharLikeTyCon :: TyCon -> Labda Id
maybeDoubleLikeTyCon :: TyCon -> Labda Id
maybeFloatLikeTyCon :: TyCon -> Labda Id
maybeIntLikeTyCon :: TyCon -> Labda Id
maybeSingleConstructorTyCon :: TyCon -> Labda Id
mkDataTyCon :: Unique -> FullName -> Int -> [TyVarTemplate] -> [Id] -> [Class] -> Bool -> TyCon
mkPrimTyCon :: Unique -> FullName -> Int -> ([PrimKind] -> PrimKind) -> TyCon
mkSpecTyCon :: TyCon -> [Labda UniType] -> TyCon
mkSynonymTyCon :: Unique -> FullName -> Int -> [TyVarTemplate] -> UniType -> Bool -> TyCon
mkTupleTyCon :: Int -> TyCon
alphaTyVars :: [TyVarTemplate]
alpha_tv :: TyVarTemplate
alpha_tyvar :: TyVar
beta_tv :: TyVarTemplate
beta_tyvar :: TyVar
cloneTyVar :: TyVar -> Unique -> TyVar
cloneTyVarFromTemplate :: TyVarTemplate -> Unique -> TyVar
cmpTyVar :: TyVar -> TyVar -> Int#
delta_tv :: TyVarTemplate
delta_tyvar :: TyVar
epsilon_tv :: TyVarTemplate
epsilon_tyvar :: TyVar
eqTyVar :: TyVar -> TyVar -> Bool
gamma_tv :: TyVarTemplate
gamma_tyvar :: TyVar
instantiateTyVarTemplates :: [TyVarTemplate] -> [Unique] -> ([(TyVarTemplate, UniType)], [TyVar], [UniType])
ltTyVar :: TyVar -> TyVar -> Bool
mkOpenSysTyVar :: Unique -> TyVar
mkPolySysTyVar :: Unique -> TyVar
mkSysTyVarTemplate :: Unique -> _PackedString -> TyVarTemplate
mkTemplateTyVars :: [TyVar] -> [TyVarTemplate]
mkUserTyVar :: Unique -> ShortName -> TyVar
mkUserTyVarTemplate :: Unique -> ShortName -> TyVarTemplate
applyNonSynTyCon :: TyCon -> [UniType] -> UniType
applySynTyCon :: TyCon -> [UniType] -> UniType
applyTy :: UniType -> UniType -> UniType
applyTyCon :: TyCon -> [UniType] -> UniType
applyTypeEnvToThetaTy :: UniqFM UniType -> [(a, UniType)] -> [(a, UniType)]
applyTypeEnvToTy :: UniqFM UniType -> UniType -> UniType
cmpUniTypeMaybeList :: [Labda UniType] -> [Labda UniType] -> Int#
expandVisibleTySyn :: UniType -> UniType
extractTyVarTemplatesFromTy :: UniType -> [TyVarTemplate]
extractTyVarsFromTy :: UniType -> [TyVar]
extractTyVarsFromTys :: [UniType] -> [TyVar]
funResultTy :: UniType -> Int -> UniType
getMentionedTyCons :: TyCon -> [TyCon]
getMentionedTyConsAndClassesFromClass :: Class -> (Bag TyCon, Bag Class)
getMentionedTyConsAndClassesFromTyCon :: TyCon -> (Bag TyCon, Bag Class)
getMentionedTyConsAndClassesFromUniType :: UniType -> (Bag TyCon, Bag Class)
getTauType :: UniType -> UniType
getTyVar :: [Char] -> UniType -> TyVar
getTyVarMaybe :: UniType -> Labda TyVar
getTyVarTemplateMaybe :: UniType -> Labda TyVarTemplate
getTypeString :: UniType -> [_PackedString]
getUniDataSpecTyCon :: UniType -> (TyCon, [UniType], [Id])
getUniDataSpecTyCon_maybe :: UniType -> Labda (TyCon, [UniType], [Id])
getUniDataTyCon :: UniType -> (TyCon, [UniType], [Id])
getUniDataTyCon_maybe :: UniType -> Labda (TyCon, [UniType], [Id])
getUniTyDescription :: UniType -> [Char]
glueTyArgs :: [UniType] -> UniType -> UniType
instanceIsExported :: Class -> UniType -> Bool -> Bool
isDictTy :: UniType -> Bool
isForAllTy :: UniType -> Bool
isFunType :: UniType -> Bool
isGroundOrTyVarTy :: UniType -> Bool
isGroundTy :: UniType -> Bool
isLeakFreeType :: [TyCon] -> UniType -> Bool
isPrimType :: UniType -> Bool
isTauTy :: UniType -> Bool
isTyVarTemplateTy :: UniType -> Bool
isTyVarTy :: UniType -> Bool
isUnboxedDataType :: UniType -> Bool
kindFromType :: UniType -> PrimKind
mapOverTyVars :: (TyVar -> UniType) -> UniType -> UniType
matchTy :: UniType -> UniType -> Labda [(TyVarTemplate, UniType)]
maybeBoxedPrimType :: UniType -> Labda (Id, UniType)
maybePurelyLocalClass :: Class -> Labda [Int -> Bool -> PrettyRep]
maybePurelyLocalTyCon :: TyCon -> Labda [Int -> Bool -> PrettyRep]
maybePurelyLocalType :: UniType -> Labda [Int -> Bool -> PrettyRep]
maybeUnpackFunTy :: UniType -> Labda (UniType, UniType)
mkSuperDictSelType :: Class -> Class -> UniType
pprClassOp :: PprStyle -> ClassOp -> Int -> Bool -> PrettyRep
pprIfaceClass :: (GlobalSwitch -> Bool) -> (Id -> Id) -> UniqFM UnfoldingDetails -> Class -> Int -> Bool -> PrettyRep
pprMaybeTy :: PprStyle -> Labda UniType -> Int -> Bool -> PrettyRep
pprParendUniType :: PprStyle -> UniType -> Int -> Bool -> PrettyRep
pprTyCon :: PprStyle -> TyCon -> [[Labda UniType]] -> Int -> Bool -> PrettyRep
pprUniType :: PprStyle -> UniType -> Int -> Bool -> PrettyRep
returnsRealWorld :: UniType -> Bool
showTyCon :: PprStyle -> TyCon -> [Char]
showTypeCategory :: UniType -> Char
specMaybeTysSuffix :: [Labda UniType] -> _PackedString
specialiseTy :: UniType -> [Labda UniType] -> Int -> UniType
splitDictType :: UniType -> (Class, UniType)
splitForalls :: UniType -> ([TyVarTemplate], UniType)
splitTyArgs :: UniType -> ([UniType], UniType)
splitType :: UniType -> ([TyVarTemplate], [(Class, UniType)], UniType)
splitTypeWithDictsAsArgs :: UniType -> ([TyVarTemplate], [UniType], UniType)
typeMaybeString :: Labda UniType -> [_PackedString]
unDictifyTy :: UniType -> UniType
alpha :: UniType
alpha_ty :: UniType
beta :: UniType
beta_ty :: UniType
cmpUniType :: Bool -> UniType -> UniType -> Int#
delta :: UniType
delta_ty :: UniType
epsilon :: UniType
epsilon_ty :: UniType
gamma :: UniType
gamma_ty :: UniType
instantiateTauTy :: [(TyVarTemplate, UniType)] -> UniType -> UniType
instantiateThetaTy :: [(TyVarTemplate, UniType)] -> [(Class, UniType)] -> [(Class, UniType)]
instantiateTy :: [(TyVarTemplate, UniType)] -> UniType -> UniType
mkDictTy :: Class -> UniType -> UniType
mkForallTy :: [TyVarTemplate] -> UniType -> UniType
mkRhoTy :: [(Class, UniType)] -> UniType -> UniType
mkSigmaTy :: [TyVarTemplate] -> [(Class, UniType)] -> UniType -> UniType
mkTyVarTemplateTy :: TyVarTemplate -> UniType
mkTyVarTy :: TyVar -> UniType
quantifyTy :: [TyVar] -> UniType -> ([TyVarTemplate], UniType)
instance Eq Class
instance Eq ClassOp
instance Eq TyCon
instance Eq TyVar
instance Eq TyVarTemplate
instance Eq UniType
instance Eq Unique
instance Ord Class
instance Ord ClassOp
instance Ord TyCon
instance Ord TyVar
instance Ord TyVarTemplate
instance Ord Unique
instance NamedThing Class
instance NamedThing FullName
instance NamedThing ShortName
instance NamedThing TyCon
instance NamedThing TyVar
instance NamedThing TyVarTemplate
instance Outputable Class
instance Outputable ClassOp