compiler/iface/IfaceSyn.lhs

   1 %
   2 % (c) The University of Glasgow 2006
   3 % (c) The GRASP/AQUA Project, Glasgow University, 1993-1998
   4 %
   5
   6 \begin{code}
   7 module IfaceSyn (
   8         module IfaceType,               -- Re-export all this
   9
  10         IfaceDecl(..), IfaceClassOp(..), IfaceConDecl(..), IfaceConDecls(..),
  11         IfaceExpr(..), IfaceAlt, IfaceNote(..),
  12         IfaceBinding(..), IfaceConAlt(..), IfaceIdInfo(..),
  13         IfaceInfoItem(..), IfaceRule(..), IfaceInst(..), IfaceFamInst(..),
  14
  15         -- Misc
  16         ifaceDeclSubBndrs, visibleIfConDecls,
  17
  18         -- Equality
  19         GenIfaceEq(..), IfaceEq, (&&&), bool, eqListBy, eqMaybeBy,
  20         eqIfDecl, eqIfInst, eqIfFamInst, eqIfRule, checkBootDecl,
  21
  22         -- Pretty printing
  23         pprIfaceExpr, pprIfaceDeclHead
  24     ) where
  25
  26 #include "HsVersions.h"
  27
  28 import CoreSyn
  29 import IfaceType
  30
  31 import NewDemand
  32 import Class
  33 import UniqFM
  34 import Unique
  35 import NameSet
  36 import Name
  37 import CostCentre
  38 import Literal
  39 import ForeignCall
  40 import SrcLoc
  41 import BasicTypes
  42 import Outputable
  43 import FastString
  44 import Module
  45
  46 import Data.List
  47 import Data.Maybe
  48
  49 infixl 3 &&&
  50 infix  4 `eqIfExt`, `eqIfIdInfo`, `eqIfType`
  51 \end{code}
  52
  53
  54 %************************************************************************
  55 %*                                                                      *
  56                 Data type declarations
  57 %*                                                                      *
  58 %************************************************************************
  59
  60 \begin{code}
  61 data IfaceDecl
  62   = IfaceId { ifName   :: OccName,
  63               ifType   :: IfaceType,
  64               ifIdInfo :: IfaceIdInfo }
  65
  66   | IfaceData { ifName       :: OccName,        -- Type constructor
  67                 ifTyVars     :: [IfaceTvBndr],  -- Type variables
  68                 ifCtxt       :: IfaceContext,   -- The "stupid theta"
  69                 ifCons       :: IfaceConDecls,  -- Includes new/data info
  70                 ifRec        :: RecFlag,        -- Recursive or not?
  71                 ifGadtSyntax :: Bool,           -- True <=> declared using
  72                                                 -- GADT syntax
  73                 ifGeneric    :: Bool,           -- True <=> generic converter
  74                                                 --          functions available
  75                                                 -- We need this for imported
  76                                                 -- data decls, since the
  77                                                 -- imported modules may have
  78                                                 -- been compiled with
  79                                                 -- different flags to the
  80                                                 -- current compilation unit
  81                 ifFamInst    :: Maybe (IfaceTyCon, [IfaceType])
  82                                                 -- Just <=> instance of family
  83     }
  84
  85   | IfaceSyn  { ifName    :: OccName,           -- Type constructor
  86                 ifTyVars  :: [IfaceTvBndr],     -- Type variables
  87                 ifOpenSyn :: Bool,              -- Is an open family?
  88                 ifSynRhs  :: IfaceType          -- Type for an ordinary
  89                                                 -- synonym and kind for an
  90                                                 -- open family
  91     }
  92
  93   | IfaceClass { ifCtxt    :: IfaceContext,     -- Context...
  94                  ifName    :: OccName,          -- Name of the class
  95                  ifTyVars  :: [IfaceTvBndr],    -- Type variables
  96                  ifFDs     :: [FunDep FastString], -- Functional dependencies
  97                  ifATs     :: [IfaceDecl],      -- Associated type families
  98                  ifSigs    :: [IfaceClassOp],   -- Method signatures
  99                  ifRec     :: RecFlag           -- Is newtype/datatype associated with the class recursive?
 100     }
 101
 102   | IfaceForeign { ifName :: OccName,           -- Needs expanding when we move
 103                                                 -- beyond .NET
 104                    ifExtName :: Maybe FastString }
 105
 106 data IfaceClassOp = IfaceClassOp OccName DefMeth IfaceType
 107         -- Nothing    => no default method
 108         -- Just False => ordinary polymorphic default method
 109         -- Just True  => generic default method
 110
 111 data IfaceConDecls
 112   = IfAbstractTyCon             -- No info
 113   | IfOpenDataTyCon             -- Open data family
 114   | IfOpenNewTyCon              -- Open newtype family
 115   | IfDataTyCon [IfaceConDecl]  -- data type decls
 116   | IfNewTyCon  IfaceConDecl    -- newtype decls
 117
 118 visibleIfConDecls :: IfaceConDecls -> [IfaceConDecl]
 119 visibleIfConDecls IfAbstractTyCon  = []
 120 visibleIfConDecls IfOpenDataTyCon  = []
 121 visibleIfConDecls IfOpenNewTyCon   = []
 122 visibleIfConDecls (IfDataTyCon cs) = cs
 123 visibleIfConDecls (IfNewTyCon c)   = [c]
 124
 125 data IfaceConDecl
 126   = IfCon {
 127         ifConOcc     :: OccName,                -- Constructor name
 128         ifConInfix   :: Bool,                   -- True <=> declared infix
 129         ifConUnivTvs :: [IfaceTvBndr],          -- Universal tyvars
 130         ifConExTvs   :: [IfaceTvBndr],          -- Existential tyvars
 131         ifConEqSpec  :: [(OccName,IfaceType)],  -- Equality contraints
 132         ifConCtxt    :: IfaceContext,           -- Non-stupid context
 133         ifConArgTys  :: [IfaceType],            -- Arg types
 134         ifConFields  :: [OccName],              -- ...ditto... (field labels)
 135         ifConStricts :: [StrictnessMark]}       -- Empty (meaning all lazy),
 136                                                 -- or 1-1 corresp with arg tys
 137
 138 data IfaceInst
 139   = IfaceInst { ifInstCls  :: Name,                     -- See comments with
 140                 ifInstTys  :: [Maybe IfaceTyCon],       -- the defn of Instance
 141                 ifDFun     :: Name,                     -- The dfun
 142                 ifOFlag    :: OverlapFlag,              -- Overlap flag
 143                 ifInstOrph :: Maybe OccName }           -- See is_orph in defn of Instance
 144         -- There's always a separate IfaceDecl for the DFun, which gives
 145         -- its IdInfo with its full type and version number.
 146         -- The instance declarations taken together have a version number,
 147         -- and we don't want that to wobble gratuitously
 148         -- If this instance decl is *used*, we'll record a usage on the dfun;
 149         -- and if the head does not change it won't be used if it wasn't before
 150
 151 data IfaceFamInst
 152   = IfaceFamInst { ifFamInstFam   :: Name                -- Family tycon
 153                  , ifFamInstTys   :: [Maybe IfaceTyCon]  -- Rough match types
 154                  , ifFamInstTyCon :: IfaceTyCon          -- Instance decl
 155                  }
 156
 157 data IfaceRule
 158   = IfaceRule {
 159         ifRuleName   :: RuleName,
 160         ifActivation :: Activation,
 161         ifRuleBndrs  :: [IfaceBndr],    -- Tyvars and term vars
 162         ifRuleHead   :: Name,           -- Head of lhs
 163         ifRuleArgs   :: [IfaceExpr],    -- Args of LHS
 164         ifRuleRhs    :: IfaceExpr,
 165         ifRuleOrph   :: Maybe OccName   -- Just like IfaceInst
 166     }
 167
 168 data IfaceIdInfo
 169   = NoInfo                      -- When writing interface file without -O
 170   | HasInfo [IfaceInfoItem]     -- Has info, and here it is
 171
 172 -- Here's a tricky case:
 173 --   * Compile with -O module A, and B which imports A.f
 174 --   * Change function f in A, and recompile without -O
 175 --   * When we read in old A.hi we read in its IdInfo (as a thunk)
 176 --      (In earlier GHCs we used to drop IdInfo immediately on reading,
 177 --       but we do not do that now.  Instead it's discarded when the
 178 --       ModIface is read into the various decl pools.)
 179 --   * The version comparsion sees that new (=NoInfo) differs from old (=HasInfo *)
 180 --      and so gives a new version.
 181
 182 data IfaceInfoItem
 183   = HsArity      Arity
 184   | HsStrictness StrictSig
 185   | HsInline     Activation
 186   | HsUnfold     IfaceExpr
 187   | HsNoCafRefs
 188   | HsWorker     Name Arity     -- Worker, if any see IdInfo.WorkerInfo
 189                                         -- for why we want arity here.
 190         -- NB: we need IfaceExtName (not just OccName) because the worker
 191         --     can simplify to a function in another module.
 192 -- NB: Specialisations and rules come in separately and are
 193 -- only later attached to the Id.  Partial reason: some are orphans.
 194
 195 --------------------------------
 196 data IfaceExpr
 197   = IfaceLcl    FastString
 198   | IfaceExt    Name
 199   | IfaceType   IfaceType
 200   | IfaceTuple  Boxity [IfaceExpr]              -- Saturated; type arguments omitted
 201   | IfaceLam    IfaceBndr IfaceExpr
 202   | IfaceApp    IfaceExpr IfaceExpr
 203   | IfaceCase   IfaceExpr FastString IfaceType [IfaceAlt]
 204   | IfaceLet    IfaceBinding  IfaceExpr
 205   | IfaceNote   IfaceNote IfaceExpr
 206   | IfaceCast   IfaceExpr IfaceCoercion
 207   | IfaceLit    Literal
 208   | IfaceFCall  ForeignCall IfaceType
 209
 210 data IfaceNote = IfaceSCC CostCentre
 211                | IfaceInlineMe
 212                | IfaceCoreNote String
 213                | IfaceTickBox Module Int
 214                | IfaceBinaryTickBox Module Int Int
 215
 216 type IfaceAlt = (IfaceConAlt, [FastString], IfaceExpr)
 217         -- Note: FastString, not IfaceBndr (and same with the case binder)
 218         -- We reconstruct the kind/type of the thing from the context
 219         -- thus saving bulk in interface files
 220
 221 data IfaceConAlt = IfaceDefault
 222                  | IfaceDataAlt Name
 223                  | IfaceTupleAlt Boxity
 224                  | IfaceLitAlt Literal
 225
 226 data IfaceBinding
 227   = IfaceNonRec IfaceIdBndr IfaceExpr
 228   | IfaceRec    [(IfaceIdBndr, IfaceExpr)]
 229
 230 -- -----------------------------------------------------------------------------
 231 -- Utils on IfaceSyn
 232
 233 ifaceDeclSubBndrs :: IfaceDecl -> [OccName]
 234 --  *Excludes* the 'main' name, but *includes* the implicitly-bound names
 235 -- Deeply revolting, because it has to predict what gets bound,
 236 -- especially the question of whether there's a wrapper for a datacon
 237
 238 ifaceDeclSubBndrs (IfaceClass {ifCtxt = sc_ctxt, ifName = cls_occ,
 239                                ifSigs = sigs, ifATs = ats })
 240   = co_occs ++
 241     [tc_occ, dc_occ, dcww_occ] ++
 242     [op | IfaceClassOp op  _ _ <- sigs] ++
 243     [ifName at | at <- ats ] ++
 244     [mkSuperDictSelOcc n cls_occ | n <- [1..n_ctxt]]
 245   where
 246     n_ctxt = length sc_ctxt
 247     n_sigs = length sigs
 248     tc_occ  = mkClassTyConOcc cls_occ
 249     dc_occ  = mkClassDataConOcc cls_occ
 250     co_occs | is_newtype = [mkNewTyCoOcc tc_occ]
 251             | otherwise  = []
 252     dcww_occ -- | is_newtype = mkDataConWrapperOcc dc_occ       -- Newtypes have wrapper but no worker
 253              | otherwise  = mkDataConWorkerOcc dc_occ   -- Otherwise worker but no wrapper
 254     is_newtype = n_sigs + n_ctxt == 1                   -- Sigh
 255
 256 ifaceDeclSubBndrs IfaceData {ifCons = IfAbstractTyCon}
 257   = []
 258 -- Newtype
 259 ifaceDeclSubBndrs (IfaceData {ifName = tc_occ,
 260                               ifCons = IfNewTyCon (
 261                                          IfCon { ifConOcc = con_occ,
 262                                                            ifConFields = fields
 263                                                          }),
 264                               ifFamInst = famInst})
 265   = fields ++ [con_occ, mkDataConWorkerOcc con_occ, mkNewTyCoOcc tc_occ]
 266     ++ famInstCo famInst tc_occ
 267
 268 ifaceDeclSubBndrs (IfaceData {ifName = tc_occ,
 269                               ifCons = IfDataTyCon cons,
 270                               ifFamInst = famInst})
 271   = nub (concatMap ifConFields cons)    -- Eliminate duplicate fields
 272     ++ concatMap dc_occs cons
 273     ++ famInstCo famInst tc_occ
 274   where
 275     dc_occs con_decl
 276         | has_wrapper = [con_occ, work_occ, wrap_occ]
 277         | otherwise   = [con_occ, work_occ]
 278         where
 279           con_occ = ifConOcc con_decl
 280           strs    = ifConStricts con_decl
 281           wrap_occ = mkDataConWrapperOcc con_occ
 282           work_occ = mkDataConWorkerOcc con_occ
 283           has_wrapper = any isMarkedStrict strs -- See MkId.mkDataConIds (sigh)
 284                         || not (null . ifConEqSpec $ con_decl)
 285                         || isJust famInst
 286                 -- ToDo: may miss strictness in existential dicts
 287
 288 ifaceDeclSubBndrs _other = []
 289
 290 -- coercion for data/newtype family instances
 291 famInstCo Nothing  baseOcc = []
 292 famInstCo (Just _) baseOcc = [mkInstTyCoOcc baseOcc]
 293
 294 ----------------------------- Printing IfaceDecl ------------------------------
 295
 296 instance Outputable IfaceDecl where
 297   ppr = pprIfaceDecl
 298
 299 pprIfaceDecl (IfaceId {ifName = var, ifType = ty, ifIdInfo = info})
 300   = sep [ ppr var <+> dcolon <+> ppr ty,
 301           nest 2 (ppr info) ]
 302
 303 pprIfaceDecl (IfaceForeign {ifName = tycon})
 304   = hsep [ptext SLIT("foreign import type dotnet"), ppr tycon]
 305
 306 pprIfaceDecl (IfaceSyn {ifName = tycon, ifTyVars = tyvars,
 307                         ifOpenSyn = False, ifSynRhs = mono_ty})
 308   = hang (ptext SLIT("type") <+> pprIfaceDeclHead [] tycon tyvars)
 309        4 (equals <+> ppr mono_ty)
 310
 311 pprIfaceDecl (IfaceSyn {ifName = tycon, ifTyVars = tyvars,
 312                         ifOpenSyn = True, ifSynRhs = mono_ty})
 313   = hang (ptext SLIT("type family") <+> pprIfaceDeclHead [] tycon tyvars)
 314        4 (dcolon <+> ppr mono_ty)
 315
 316 pprIfaceDecl (IfaceData {ifName = tycon, ifGeneric = gen, ifCtxt = context,
 317                          ifTyVars = tyvars, ifCons = condecls,
 318                          ifRec = isrec, ifFamInst = mbFamInst})
 319   = hang (pp_nd <+> pprIfaceDeclHead context tycon tyvars)
 320        4 (vcat [pprRec isrec, pprGen gen, pp_condecls tycon condecls,
 321                 pprFamily mbFamInst])
 322   where
 323     pp_nd = case condecls of
 324                 IfAbstractTyCon -> ptext SLIT("data")
 325                 IfOpenDataTyCon -> ptext SLIT("data family")
 326                 IfDataTyCon _   -> ptext SLIT("data")
 327                 IfNewTyCon _    -> ptext SLIT("newtype")
 328                 IfOpenNewTyCon  -> ptext SLIT("newtype family")
 329
 330 pprIfaceDecl (IfaceClass {ifCtxt = context, ifName = clas, ifTyVars = tyvars,
 331                           ifFDs = fds, ifATs = ats, ifSigs = sigs,
 332                           ifRec = isrec})
 333   = hang (ptext SLIT("class") <+> pprIfaceDeclHead context clas tyvars <+> pprFundeps fds)
 334        4 (vcat [pprRec isrec,
 335                 sep (map ppr ats),
 336                 sep (map ppr sigs)])
 337
 338 pprRec isrec = ptext SLIT("RecFlag") <+> ppr isrec
 339 pprGen True  = ptext SLIT("Generics: yes")
 340 pprGen False = ptext SLIT("Generics: no")
 341
 342 pprFamily Nothing        = ptext SLIT("FamilyInstance: none")
 343 pprFamily (Just famInst) = ptext SLIT("FamilyInstance:") <+> ppr famInst
 344
 345 instance Outputable IfaceClassOp where
 346    ppr (IfaceClassOp n dm ty) = ppr n <+> ppr dm <+> dcolon <+> ppr ty
 347
 348 pprIfaceDeclHead :: IfaceContext -> OccName -> [IfaceTvBndr] -> SDoc
 349 pprIfaceDeclHead context thing tyvars
 350   = hsep [pprIfaceContext context, parenSymOcc thing (ppr thing),
 351           pprIfaceTvBndrs tyvars]
 352
 353 pp_condecls tc IfAbstractTyCon  = ptext SLIT("{- abstract -}")
 354 pp_condecls tc IfOpenNewTyCon   = empty
 355 pp_condecls tc (IfNewTyCon c)   = equals <+> pprIfaceConDecl tc c
 356 pp_condecls tc IfOpenDataTyCon  = empty
 357 pp_condecls tc (IfDataTyCon cs) = equals <+> sep (punctuate (ptext SLIT(" |"))
 358                                                              (map (pprIfaceConDecl tc) cs))
 359
 360 pprIfaceConDecl tc
 361         (IfCon { ifConOcc = name, ifConInfix = is_infix,
 362                  ifConUnivTvs = univ_tvs, ifConExTvs = ex_tvs,
 363                  ifConEqSpec = eq_spec, ifConCtxt = ctxt, ifConArgTys = arg_tys,
 364                  ifConStricts = strs, ifConFields = fields })
 365   = sep [main_payload,
 366          if is_infix then ptext SLIT("Infix") else empty,
 367          if null strs then empty
 368               else nest 4 (ptext SLIT("Stricts:") <+> hsep (map ppr strs)),
 369          if null fields then empty
 370               else nest 4 (ptext SLIT("Fields:") <+> hsep (map ppr fields))]
 371   where
 372     main_payload = ppr name <+> dcolon <+>
 373                    pprIfaceForAllPart (univ_tvs ++ ex_tvs) (eq_ctxt ++ ctxt) (ppr con_tau)
 374
 375     eq_ctxt = [(IfaceEqPred (IfaceTyVar (occNameFS tv)) ty)
 376               | (tv,ty) <- eq_spec]
 377     con_tau = foldr1 IfaceFunTy (arg_tys ++ [tc_app])
 378     tc_app  = IfaceTyConApp (IfaceTc tc_name)
 379                             [IfaceTyVar tv | (tv,_) <- univ_tvs]
 380     tc_name = mkInternalName (mkBuiltinUnique 1) tc noSrcLoc
 381         -- Really Gruesome, but just for debug print
 382
 383 instance Outputable IfaceRule where
 384   ppr (IfaceRule { ifRuleName = name, ifActivation = act, ifRuleBndrs = bndrs,
 385                    ifRuleHead = fn, ifRuleArgs = args, ifRuleRhs = rhs })
 386     = sep [hsep [doubleQuotes (ftext name), ppr act,
 387                  ptext SLIT("forall") <+> pprIfaceBndrs bndrs],
 388            nest 2 (sep [ppr fn <+> sep (map (pprIfaceExpr parens) args),
 389                         ptext SLIT("=") <+> ppr rhs])
 390       ]
 391
 392 instance Outputable IfaceInst where
 393   ppr (IfaceInst {ifDFun = dfun_id, ifOFlag = flag,
 394                   ifInstCls = cls, ifInstTys = mb_tcs})
 395     = hang (ptext SLIT("instance") <+> ppr flag
 396                 <+> ppr cls <+> brackets (pprWithCommas ppr_rough mb_tcs))
 397          2 (equals <+> ppr dfun_id)
 398
 399 instance Outputable IfaceFamInst where
 400   ppr (IfaceFamInst {ifFamInstFam = fam, ifFamInstTys = mb_tcs,
 401                      ifFamInstTyCon = tycon_id})
 402     = hang (ptext SLIT("family instance") <+>
 403             ppr fam <+> brackets (pprWithCommas ppr_rough mb_tcs))
 404          2 (equals <+> ppr tycon_id)
 405
 406 ppr_rough :: Maybe IfaceTyCon -> SDoc
 407 ppr_rough Nothing   = dot
 408 ppr_rough (Just tc) = ppr tc
 409 \end{code}
 410
 411
 412 ----------------------------- Printing IfaceExpr ------------------------------------
 413
 414 \begin{code}
 415 instance Outputable IfaceExpr where
 416     ppr e = pprIfaceExpr noParens e
 417
 418 pprIfaceExpr :: (SDoc -> SDoc) -> IfaceExpr -> SDoc
 419         -- The function adds parens in context that need
 420         -- an atomic value (e.g. function args)
 421
 422 pprIfaceExpr add_par (IfaceLcl v)       = ppr v
 423 pprIfaceExpr add_par (IfaceExt v)       = ppr v
 424 pprIfaceExpr add_par (IfaceLit l)       = ppr l
 425 pprIfaceExpr add_par (IfaceFCall cc ty) = braces (ppr cc <+> ppr ty)
 426 pprIfaceExpr add_par (IfaceType ty)     = char '@' <+> pprParendIfaceType ty
 427
 428 pprIfaceExpr add_par app@(IfaceApp _ _) = add_par (pprIfaceApp app [])
 429 pprIfaceExpr add_par (IfaceTuple c as)  = tupleParens c (interpp'SP as)
 430
 431 pprIfaceExpr add_par e@(IfaceLam _ _)
 432   = add_par (sep [char '\\' <+> sep (map ppr bndrs) <+> arrow,
 433                   pprIfaceExpr noParens body])
 434   where
 435     (bndrs,body) = collect [] e
 436     collect bs (IfaceLam b e) = collect (b:bs) e
 437     collect bs e              = (reverse bs, e)
 438
 439 pprIfaceExpr add_par (IfaceCase scrut bndr ty [(con, bs, rhs)])
 440   = add_par (sep [ptext SLIT("case") <+> char '@' <+> pprParendIfaceType ty
 441                         <+> pprIfaceExpr noParens scrut <+> ptext SLIT("of")
 442                         <+> ppr bndr <+> char '{' <+> ppr_con_bs con bs <+> arrow,
 443                   pprIfaceExpr noParens rhs <+> char '}'])
 444
 445 pprIfaceExpr add_par (IfaceCase scrut bndr ty alts)
 446   = add_par (sep [ptext SLIT("case") <+> char '@' <+> pprParendIfaceType ty
 447                         <+> pprIfaceExpr noParens scrut <+> ptext SLIT("of")
 448                         <+> ppr bndr <+> char '{',
 449                   nest 2 (sep (map ppr_alt alts)) <+> char '}'])
 450
 451 pprIfaceExpr add_par (IfaceCast expr co)
 452   = sep [pprIfaceExpr parens expr,
 453          nest 2 (ptext SLIT("`cast`")),
 454          pprParendIfaceType co]
 455
 456 pprIfaceExpr add_par (IfaceLet (IfaceNonRec b rhs) body)
 457   = add_par (sep [ptext SLIT("let {"),
 458                   nest 2 (ppr_bind (b, rhs)),
 459                   ptext SLIT("} in"),
 460                   pprIfaceExpr noParens body])
 461
 462 pprIfaceExpr add_par (IfaceLet (IfaceRec pairs) body)
 463   = add_par (sep [ptext SLIT("letrec {"),
 464                   nest 2 (sep (map ppr_bind pairs)),
 465                   ptext SLIT("} in"),
 466                   pprIfaceExpr noParens body])
 467
 468 pprIfaceExpr add_par (IfaceNote note body) = add_par (ppr note <+> pprIfaceExpr parens body)
 469
 470 ppr_alt (con, bs, rhs) = sep [ppr_con_bs con bs,
 471                               arrow <+> pprIfaceExpr noParens rhs]
 472
 473 ppr_con_bs (IfaceTupleAlt tup_con) bs = tupleParens tup_con (interpp'SP bs)
 474 ppr_con_bs con bs                     = ppr con <+> hsep (map ppr bs)
 475
 476 ppr_bind ((b,ty),rhs) = sep [ppr b <+> dcolon <+> ppr ty,
 477                              equals <+> pprIfaceExpr noParens rhs]
 478
 479 ------------------
 480 pprIfaceApp (IfaceApp fun arg) args = pprIfaceApp fun (nest 2 (pprIfaceExpr parens arg) : args)
 481 pprIfaceApp fun                args = sep (pprIfaceExpr parens fun : args)
 482
 483 ------------------
 484 instance Outputable IfaceNote where
 485     ppr (IfaceSCC cc)     = pprCostCentreCore cc
 486     ppr IfaceInlineMe     = ptext SLIT("__inline_me")
 487     ppr (IfaceCoreNote s) = ptext SLIT("__core_note") <+> pprHsString (mkFastString s)
 488     ppr (IfaceTickBox m n)  = ptext SLIT("__tick_box") <+> pprModule m <+>  text (show n)
 489     ppr (IfaceBinaryTickBox m t e)
 490                          = ptext SLIT("__binary_tick_box")
 491                                <+> pprModule m
 492                                <+> text (show t)
 493                                <+> text (show e)
 494
 495
 496 instance Outputable IfaceConAlt where
 497     ppr IfaceDefault      = text "DEFAULT"
 498     ppr (IfaceLitAlt l)   = ppr l
 499     ppr (IfaceDataAlt d)  = ppr d
 500     ppr (IfaceTupleAlt b) = panic "ppr IfaceConAlt"
 501         -- IfaceTupleAlt is handled by the case-alternative printer
 502
 503 ------------------
 504 instance Outputable IfaceIdInfo where
 505    ppr NoInfo       = empty
 506    ppr (HasInfo is) = ptext SLIT("{-") <+> fsep (map ppr_hs_info is) <+> ptext SLIT("-}")
 507
 508 ppr_hs_info (HsUnfold unf)      = ptext SLIT("Unfolding:") <+>
 509                                         parens (pprIfaceExpr noParens unf)
 510 ppr_hs_info (HsInline act)      = ptext SLIT("Inline:") <+> ppr act
 511 ppr_hs_info (HsArity arity)     = ptext SLIT("Arity:") <+> int arity
 512 ppr_hs_info (HsStrictness str)  = ptext SLIT("Strictness:") <+> pprIfaceStrictSig str
 513 ppr_hs_info HsNoCafRefs         = ptext SLIT("HasNoCafRefs")
 514 ppr_hs_info (HsWorker w a)      = ptext SLIT("Worker:") <+> ppr w <+> int a
 515 \end{code}
 516
 517
 518 %************************************************************************
 519 %*                                                                      *
 520         Equality, for interface file version generaion only
 521 %*                                                                      *
 522 %************************************************************************
 523
 524 Equality over IfaceSyn returns an IfaceEq, not a Bool.  The new
 525 constructor is EqBut, which gives the set of things whose version must
 526 be equal for the whole thing to be equal.  So the key function is
 527 eqIfExt, which compares Names.
 528
 529 Of course, equality is also done modulo alpha conversion.
 530
 531 \begin{code}
 532 data GenIfaceEq a
 533   = Equal               -- Definitely exactly the same
 534   | NotEqual            -- Definitely different
 535   | EqBut a       -- The same provided these Names have not changed
 536
 537 type IfaceEq = GenIfaceEq NameSet
 538
 539 instance Outputable IfaceEq where
 540   ppr Equal          = ptext SLIT("Equal")
 541   ppr NotEqual       = ptext SLIT("NotEqual")
 542   ppr (EqBut occset) = ptext SLIT("EqBut") <+> ppr (nameSetToList occset)
 543
 544 bool :: Bool -> IfaceEq
 545 bool True  = Equal
 546 bool False = NotEqual
 547
 548 toBool :: IfaceEq -> Bool
 549 toBool Equal     = True
 550 toBool (EqBut _) = True
 551 toBool NotEqual  = False
 552
 553 zapEq :: IfaceEq -> IfaceEq     -- Used to forget EqBut information
 554 zapEq (EqBut _) = Equal
 555 zapEq other     = other
 556
 557 (&&&) :: IfaceEq -> IfaceEq -> IfaceEq
 558 Equal       &&& x           = x
 559 NotEqual    &&& x           = NotEqual
 560 EqBut nms   &&& Equal       = EqBut nms
 561 EqBut nms   &&& NotEqual    = NotEqual
 562 EqBut nms1  &&& EqBut nms2  = EqBut (nms1 `unionNameSets` nms2)
 563
 564 -- This function is the core of the EqBut stuff
 565 -- ASSUMPTION: The left-hand argument is the NEW CODE, and hence
 566 -- any Names in the left-hand arg have the correct parent in them.
 567 eqIfExt :: Name -> Name -> IfaceEq
 568 eqIfExt name1 name2
 569   | name1 == name2 = EqBut (unitNameSet name1)
 570   | otherwise      = NotEqual
 571
 572 ---------------------
 573 checkBootDecl :: IfaceDecl      -- The boot decl
 574               -> IfaceDecl      -- The real decl
 575               -> Bool           -- True <=> compatible
 576 checkBootDecl (IfaceId s1 t1 _) (IfaceId s2 t2 _)
 577   = ASSERT( s1==s2 ) toBool (t1 `eqIfType` t2)
 578
 579 checkBootDecl d1@(IfaceForeign {}) d2@(IfaceForeign {})
 580   = ASSERT (ifName d1 == ifName d2 ) ifExtName d1 == ifExtName d2
 581
 582 checkBootDecl d1@(IfaceSyn {}) d2@(IfaceSyn {})
 583   = ASSERT( ifName d1 == ifName d2 )
 584     toBool $ eqWith (ifTyVars d1) (ifTyVars d2) $ \ env ->
 585           eq_ifType env (ifSynRhs d1) (ifSynRhs d2)
 586
 587 checkBootDecl d1@(IfaceData {}) d2@(IfaceData {})
 588 -- We don't check the recursion flags because the boot-one is
 589 -- recursive, to be conservative, but the real one may not be.
 590 -- I'm not happy with the way recursive flags are dealt with.
 591   = ASSERT( ifName d1    == ifName d2 )
 592     toBool $ eqWith (ifTyVars d1) (ifTyVars d2) $ \ env ->
 593         eq_ifContext env (ifCtxt d1) (ifCtxt d2) &&&
 594         case ifCons d1 of
 595             IfAbstractTyCon -> Equal
 596             cons1           -> eq_hsCD env cons1 (ifCons d2)
 597
 598 checkBootDecl d1@(IfaceClass {}) d2@(IfaceClass {})
 599   = ASSERT( ifName d1 == ifName d2 )
 600     toBool $ eqWith (ifTyVars d1) (ifTyVars d2) $ \ env ->
 601           eqListBy (eq_hsFD env)    (ifFDs d1)  (ifFDs d2) &&&
 602           case (ifCtxt d1, ifSigs d1) of
 603              ([], [])      -> Equal
 604              (cxt1, sigs1) -> eq_ifContext env cxt1 (ifCtxt d2)  &&&
 605                               eqListBy (eq_cls_sig env) sigs1 (ifSigs d2)
 606
 607 checkBootDecl _ _ = False       -- default case
 608
 609 ---------------------
 610 eqIfDecl :: IfaceDecl -> IfaceDecl -> IfaceEq
 611 eqIfDecl (IfaceId s1 t1 i1) (IfaceId s2 t2 i2)
 612   = bool (s1 == s2) &&& (t1 `eqIfType` t2) &&& (i1 `eqIfIdInfo` i2)
 613
 614 eqIfDecl d1@(IfaceForeign {}) d2@(IfaceForeign {})
 615   = bool (ifName d1 == ifName d2 && ifExtName d1 == ifExtName d2)
 616
 617 eqIfDecl d1@(IfaceData {}) d2@(IfaceData {})
 618   = bool (ifName d1    == ifName d2 &&
 619           ifRec d1     == ifRec   d2 &&
 620           ifGadtSyntax d1 == ifGadtSyntax   d2 &&
 621           ifGeneric d1 == ifGeneric d2) &&&
 622     ifFamInst d1 `eqIfTc_fam` ifFamInst d2 &&&
 623     eqWith (ifTyVars d1) (ifTyVars d2) (\ env ->
 624             eq_ifContext env (ifCtxt d1) (ifCtxt d2) &&&
 625             eq_hsCD env (ifCons d1) (ifCons d2)
 626         )
 627         -- The type variables of the data type do not scope
 628         -- over the constructors (any more), but they do scope
 629         -- over the stupid context in the IfaceConDecls
 630   where
 631     Nothing             `eqIfTc_fam` Nothing             = Equal
 632     (Just (fam1, tys1)) `eqIfTc_fam` (Just (fam2, tys2)) =
 633       fam1 `eqIfTc` fam2 &&& eqListBy eqIfType tys1 tys2
 634     _                   `eqIfTc_fam` _                   = NotEqual
 635
 636 eqIfDecl d1@(IfaceSyn {}) d2@(IfaceSyn {})
 637   = bool (ifName d1 == ifName d2) &&&
 638     eqWith (ifTyVars d1) (ifTyVars d2) (\ env ->
 639           eq_ifType env (ifSynRhs d1) (ifSynRhs d2)
 640         )
 641
 642 eqIfDecl d1@(IfaceClass {}) d2@(IfaceClass {})
 643   = bool (ifName d1 == ifName d2 &&
 644           ifRec d1  == ifRec  d2) &&&
 645     eqWith (ifTyVars d1) (ifTyVars d2) (\ env ->
 646           eq_ifContext env (ifCtxt d1) (ifCtxt d2)  &&&
 647           eqListBy (eq_hsFD env)    (ifFDs d1)  (ifFDs d2) &&&
 648           eqListBy eqIfDecl         (ifATs d1)  (ifATs d2) &&&
 649           eqListBy (eq_cls_sig env) (ifSigs d1) (ifSigs d2)
 650        )
 651
 652 eqIfDecl _ _ = NotEqual -- default case
 653
 654 -- Helper
 655 eqWith :: [IfaceTvBndr] -> [IfaceTvBndr] -> (EqEnv -> IfaceEq) -> IfaceEq
 656 eqWith = eq_ifTvBndrs emptyEqEnv
 657
 658 -----------------------
 659 eqIfInst d1 d2 = bool (ifDFun d1 == ifDFun d2 && ifOFlag d1 == ifOFlag d2)
 660 -- All other changes are handled via the version info on the dfun
 661
 662 eqIfFamInst d1 d2 = bool (ifFamInstTyCon d1 == ifFamInstTyCon d2)
 663 -- All other changes are handled via the version info on the tycon
 664
 665 eqIfRule (IfaceRule n1 a1 bs1 f1 es1 rhs1 o1)
 666          (IfaceRule n2 a2 bs2 f2 es2 rhs2 o2)
 667        = bool (n1==n2 && a1==a2 && o1 == o2) &&&
 668          f1 `eqIfExt` f2 &&&
 669          eq_ifBndrs emptyEqEnv bs1 bs2 (\env ->
 670          zapEq (eqListBy (eq_ifaceExpr env) es1 es2) &&&
 671                 -- zapEq: for the LHSs, ignore the EqBut part
 672          eq_ifaceExpr env rhs1 rhs2)
 673
 674 eq_hsCD env (IfDataTyCon c1) (IfDataTyCon c2)
 675   = eqListBy (eq_ConDecl env) c1 c2
 676
 677 eq_hsCD env (IfNewTyCon c1)  (IfNewTyCon c2)  = eq_ConDecl env c1 c2
 678 eq_hsCD env IfAbstractTyCon  IfAbstractTyCon  = Equal
 679 eq_hsCD env IfOpenDataTyCon  IfOpenDataTyCon  = Equal
 680 eq_hsCD env IfOpenNewTyCon   IfOpenNewTyCon   = Equal
 681 eq_hsCD env d1               d2               = NotEqual
 682
 683 eq_ConDecl env c1 c2
 684   = bool (ifConOcc c1     == ifConOcc c2 &&
 685           ifConInfix c1   == ifConInfix c2 &&
 686           ifConStricts c1 == ifConStricts c2 &&
 687           ifConFields c1  == ifConFields c2) &&&
 688     eq_ifTvBndrs env (ifConUnivTvs c1) (ifConUnivTvs c2) (\ env ->
 689     eq_ifTvBndrs env (ifConExTvs c1) (ifConExTvs c2) (\ env ->
 690         eq_ifContext env (ifConCtxt c1) (ifConCtxt c2) &&&
 691         eq_ifTypes env (ifConArgTys c1) (ifConArgTys c2)))
 692
 693 eq_hsFD env (ns1,ms1) (ns2,ms2)
 694   = eqListBy (eqIfOcc env) ns1 ns2 &&& eqListBy (eqIfOcc env) ms1 ms2
 695
 696 eq_cls_sig env (IfaceClassOp n1 dm1 ty1) (IfaceClassOp n2 dm2 ty2)
 697   = bool (n1==n2 && dm1 == dm2) &&& eq_ifType env ty1 ty2
 698 \end{code}
 699
 700
 701 \begin{code}
 702 -----------------
 703 eqIfIdInfo NoInfo        NoInfo        = Equal
 704 eqIfIdInfo (HasInfo is1) (HasInfo is2) = eqListBy eq_item is1 is2
 705 eqIfIdInfo i1            i2 = NotEqual
 706
 707 eq_item (HsInline a1)      (HsInline a2)      = bool (a1 == a2)
 708 eq_item (HsArity a1)       (HsArity a2)       = bool (a1 == a2)
 709 eq_item (HsStrictness s1)  (HsStrictness s2)  = bool (s1 == s2)
 710 eq_item (HsUnfold u1)   (HsUnfold u2)         = eq_ifaceExpr emptyEqEnv u1 u2
 711 eq_item HsNoCafRefs        HsNoCafRefs        = Equal
 712 eq_item (HsWorker wkr1 a1) (HsWorker wkr2 a2) = bool (a1==a2) &&& (wkr1 `eqIfExt` wkr2)
 713 eq_item _ _ = NotEqual
 714
 715 -----------------
 716 eq_ifaceExpr :: EqEnv -> IfaceExpr -> IfaceExpr -> IfaceEq
 717 eq_ifaceExpr env (IfaceLcl v1)        (IfaceLcl v2)        = eqIfOcc env v1 v2
 718 eq_ifaceExpr env (IfaceExt v1)        (IfaceExt v2)        = eqIfExt v1 v2
 719 eq_ifaceExpr env (IfaceLit l1)        (IfaceLit l2)        = bool (l1 == l2)
 720 eq_ifaceExpr env (IfaceFCall c1 ty1)  (IfaceFCall c2 ty2)  = bool (c1==c2) &&& eq_ifType env ty1 ty2
 721 eq_ifaceExpr env (IfaceType ty1)      (IfaceType ty2)      = eq_ifType env ty1 ty2
 722 eq_ifaceExpr env (IfaceTuple n1 as1)  (IfaceTuple n2 as2)  = bool (n1==n2) &&& eqListBy (eq_ifaceExpr env) as1 as2
 723 eq_ifaceExpr env (IfaceLam b1 body1)  (IfaceLam b2 body2)  = eq_ifBndr env b1 b2 (\env -> eq_ifaceExpr env body1 body2)
 724 eq_ifaceExpr env (IfaceApp f1 a1)     (IfaceApp f2 a2)     = eq_ifaceExpr env f1 f2 &&& eq_ifaceExpr env a1 a2
 725 eq_ifaceExpr env (IfaceCast e1 co1)   (IfaceCast e2 co2)   = eq_ifaceExpr env e1 e2 &&& eq_ifType env co1 co2
 726 eq_ifaceExpr env (IfaceNote n1 r1)    (IfaceNote n2 r2)    = eq_ifaceNote env n1 n2 &&& eq_ifaceExpr env r1 r2
 727
 728 eq_ifaceExpr env (IfaceCase s1 b1 ty1 as1) (IfaceCase s2 b2 ty2 as2)
 729   = eq_ifaceExpr env s1 s2 &&&
 730     eq_ifType env ty1 ty2 &&&
 731     eq_ifNakedBndr env b1 b2 (\env -> eqListBy (eq_ifaceAlt env) as1 as2)
 732   where
 733     eq_ifaceAlt env (c1,bs1,r1) (c2,bs2,r2)
 734         = bool (eq_ifaceConAlt c1 c2) &&&
 735           eq_ifNakedBndrs env bs1 bs2 (\env -> eq_ifaceExpr env r1 r2)
 736
 737 eq_ifaceExpr env (IfaceLet (IfaceNonRec b1 r1) x1) (IfaceLet (IfaceNonRec b2 r2) x2)
 738   = eq_ifaceExpr env r1 r2 &&& eq_ifIdBndr env b1 b2 (\env -> eq_ifaceExpr env x1 x2)
 739
 740 eq_ifaceExpr env (IfaceLet (IfaceRec as1) x1) (IfaceLet (IfaceRec as2) x2)
 741   = eq_ifIdBndrs env bs1 bs2 (\env -> eqListBy (eq_ifaceExpr env) rs1 rs2 &&& eq_ifaceExpr env x1 x2)
 742   where
 743     (bs1,rs1) = unzip as1
 744     (bs2,rs2) = unzip as2
 745
 746
 747 eq_ifaceExpr env _ _ = NotEqual
 748
 749 -----------------
 750 eq_ifaceConAlt :: IfaceConAlt -> IfaceConAlt -> Bool
 751 eq_ifaceConAlt IfaceDefault       IfaceDefault          = True
 752 eq_ifaceConAlt (IfaceDataAlt n1)  (IfaceDataAlt n2)     = n1==n2
 753 eq_ifaceConAlt (IfaceTupleAlt c1) (IfaceTupleAlt c2)    = c1==c2
 754 eq_ifaceConAlt (IfaceLitAlt l1)   (IfaceLitAlt l2)      = l1==l2
 755 eq_ifaceConAlt _ _ = False
 756
 757 -----------------
 758 eq_ifaceNote :: EqEnv -> IfaceNote -> IfaceNote -> IfaceEq
 759 eq_ifaceNote env (IfaceSCC c1)    (IfaceSCC c2)        = bool (c1==c2)
 760 eq_ifaceNote env IfaceInlineMe    IfaceInlineMe        = Equal
 761 eq_ifaceNote env (IfaceCoreNote s1) (IfaceCoreNote s2) = bool (s1==s2)
 762 eq_ifaceNote env (IfaceTickBox m1 n1) (IfaceTickBox m2 n2)   = bool (m1==m2 && n1==n2)
 763 eq_ifaceNote env (IfaceBinaryTickBox m1 t1 e1) (IfaceBinaryTickBox m2 t2 e2) = bool (m1==m2 && t1==t2 && e1 == e2)
 764 eq_ifaceNote env _ _ = NotEqual
 765 \end{code}
 766
 767 \begin{code}
 768 ---------------------
 769 eqIfType t1 t2 = eq_ifType emptyEqEnv t1 t2
 770
 771 -------------------
 772 eq_ifType env (IfaceTyVar n1)         (IfaceTyVar n2)         = eqIfOcc env n1 n2
 773 eq_ifType env (IfaceAppTy s1 t1)      (IfaceAppTy s2 t2)      = eq_ifType env s1 s2 &&& eq_ifType env t1 t2
 774 eq_ifType env (IfacePredTy st1)       (IfacePredTy st2)       = eq_ifPredType env st1 st2
 775 eq_ifType env (IfaceTyConApp tc1 ts1) (IfaceTyConApp tc2 ts2) = tc1 `eqIfTc` tc2 &&& eq_ifTypes env ts1 ts2
 776 eq_ifType env (IfaceForAllTy tv1 t1)  (IfaceForAllTy tv2 t2)  = eq_ifTvBndr env tv1 tv2 (\env -> eq_ifType env t1 t2)
 777 eq_ifType env (IfaceFunTy s1 t1)      (IfaceFunTy s2 t2)      = eq_ifType env s1 s2 &&& eq_ifType env t1 t2
 778 eq_ifType env _ _ = NotEqual
 779
 780 -------------------
 781 eq_ifTypes env = eqListBy (eq_ifType env)
 782
 783 -------------------
 784 eq_ifContext env a b = eqListBy (eq_ifPredType env) a b
 785
 786 -------------------
 787 eq_ifPredType env (IfaceClassP c1 tys1) (IfaceClassP c2 tys2) = c1 `eqIfExt` c2 &&&  eq_ifTypes env tys1 tys2
 788 eq_ifPredType env (IfaceIParam n1 ty1) (IfaceIParam n2 ty2)   = bool (n1 == n2) &&& eq_ifType env ty1 ty2
 789 eq_ifPredType env _ _ = NotEqual
 790
 791 -------------------
 792 eqIfTc (IfaceTc tc1) (IfaceTc tc2) = tc1 `eqIfExt` tc2
 793 eqIfTc IfaceIntTc    IfaceIntTc    = Equal
 794 eqIfTc IfaceCharTc   IfaceCharTc   = Equal
 795 eqIfTc IfaceBoolTc   IfaceBoolTc   = Equal
 796 eqIfTc IfaceListTc   IfaceListTc   = Equal
 797 eqIfTc IfacePArrTc   IfacePArrTc   = Equal
 798 eqIfTc (IfaceTupTc bx1 ar1) (IfaceTupTc bx2 ar2) = bool (bx1==bx2 && ar1==ar2)
 799 eqIfTc IfaceLiftedTypeKindTc   IfaceLiftedTypeKindTc   = Equal
 800 eqIfTc IfaceOpenTypeKindTc     IfaceOpenTypeKindTc     = Equal
 801 eqIfTc IfaceUnliftedTypeKindTc IfaceUnliftedTypeKindTc = Equal
 802 eqIfTc IfaceUbxTupleKindTc     IfaceUbxTupleKindTc     = Equal
 803 eqIfTc IfaceArgTypeKindTc      IfaceArgTypeKindTc      = Equal
 804 eqIfTc _                       _                       = NotEqual
 805 \end{code}
 806
 807 -----------------------------------------------------------
 808         Support code for equality checking
 809 -----------------------------------------------------------
 810
 811 \begin{code}
 812 ------------------------------------
 813 type EqEnv = UniqFM FastString  -- Tracks the mapping from L-variables to R-variables
 814
 815 eqIfOcc :: EqEnv -> FastString -> FastString -> IfaceEq
 816 eqIfOcc env n1 n2 = case lookupUFM env n1 of
 817                         Just n1 -> bool (n1 == n2)
 818                         Nothing -> bool (n1 == n2)
 819
 820 extendEqEnv :: EqEnv -> FastString -> FastString -> EqEnv
 821 extendEqEnv env n1 n2 | n1 == n2  = env
 822                       | otherwise = addToUFM env n1 n2
 823
 824 emptyEqEnv :: EqEnv
 825 emptyEqEnv = emptyUFM
 826
 827 ------------------------------------
 828 type ExtEnv bndr = EqEnv -> bndr -> bndr -> (EqEnv -> IfaceEq) -> IfaceEq
 829
 830 eq_ifNakedBndr :: ExtEnv FastString
 831 eq_ifBndr      :: ExtEnv IfaceBndr
 832 eq_ifTvBndr    :: ExtEnv IfaceTvBndr
 833 eq_ifIdBndr    :: ExtEnv IfaceIdBndr
 834
 835 eq_ifNakedBndr env n1 n2 k = k (extendEqEnv env n1 n2)
 836
 837 eq_ifBndr env (IfaceIdBndr b1) (IfaceIdBndr b2) k = eq_ifIdBndr env b1 b2 k
 838 eq_ifBndr env (IfaceTvBndr b1) (IfaceTvBndr b2) k = eq_ifTvBndr env b1 b2 k
 839 eq_ifBndr _ _ _ _ = NotEqual
 840
 841 eq_ifTvBndr env (v1, k1) (v2, k2) k = eq_ifType env k1 k2 &&& k (extendEqEnv env v1 v2)
 842 eq_ifIdBndr env (v1, t1) (v2, t2) k = eq_ifType env t1 t2 &&& k (extendEqEnv env v1 v2)
 843
 844 eq_ifBndrs      :: ExtEnv [IfaceBndr]
 845 eq_ifIdBndrs    :: ExtEnv [IfaceIdBndr]
 846 eq_ifTvBndrs    :: ExtEnv [IfaceTvBndr]
 847 eq_ifNakedBndrs :: ExtEnv [FastString]
 848 eq_ifBndrs      = eq_bndrs_with eq_ifBndr
 849 eq_ifIdBndrs    = eq_bndrs_with eq_ifIdBndr
 850 eq_ifTvBndrs    = eq_bndrs_with eq_ifTvBndr
 851 eq_ifNakedBndrs = eq_bndrs_with eq_ifNakedBndr
 852
 853 eq_bndrs_with eq env []       []       k = k env
 854 eq_bndrs_with eq env (b1:bs1) (b2:bs2) k = eq env b1 b2 (\env -> eq_bndrs_with eq env bs1 bs2 k)
 855 eq_bndrs_with eq env _        _        _ = NotEqual
 856 \end{code}
 857
 858 \begin{code}
 859 eqListBy :: (a->a->IfaceEq) -> [a] -> [a] -> IfaceEq
 860 eqListBy eq []     []     = Equal
 861 eqListBy eq (x:xs) (y:ys) = eq x y &&& eqListBy eq xs ys
 862 eqListBy eq xs     ys     = NotEqual
 863
 864 eqMaybeBy :: (a->a->IfaceEq) -> Maybe a -> Maybe a -> IfaceEq
 865 eqMaybeBy eq Nothing Nothing   = Equal
 866 eqMaybeBy eq (Just x) (Just y) = eq x y
 867 eqMaybeBy eq x        y        = NotEqual
 868 \end{code}