GRHSs, pprPatBind )
-- friends:
-import HsImpExp ( ppr_var )
+import HsImpExp ( pprHsVar )
+import HsPat ( Pat )
import HsTypes ( HsType )
-import CoreSyn ( CoreExpr )
import PprCore ( {- instance Outputable (Expr a) -} )
--others:
import Name ( Name )
import PrelNames ( isUnboundName )
import NameSet ( NameSet, elemNameSet, nameSetToList )
-import BasicTypes ( RecFlag(..), Fixity, Activation(..) )
+import BasicTypes ( RecFlag(..), FixitySig(..), Activation(..), IPName )
import Outputable
import SrcLoc ( SrcLoc )
import Var ( TyVar )
Collections of bindings, created by dependency analysis and translation:
\begin{code}
-data HsBinds id pat -- binders and bindees
+data HsBinds id -- binders and bindees
= EmptyBinds
-
- | ThenBinds (HsBinds id pat)
- (HsBinds id pat)
-
- | MonoBind (MonoBinds id pat)
- [Sig id] -- Empty on typechecker output
- RecFlag
+ | ThenBinds (HsBinds id) (HsBinds id)
+
+ | MonoBind -- A mutually recursive group
+ (MonoBinds id)
+ [Sig id] -- Empty on typechecker output, Type Signatures
+ RecFlag
+
+ | IPBinds -- Implcit parameters
+ -- Not allowed at top level
+ [(IPName id, HsExpr id)]
+ Bool -- True <=> this was a 'with' binding
+ -- (tmp, until 'with' is removed)
\end{code}
\begin{code}
-nullBinds :: HsBinds id pat -> Bool
+nullBinds :: HsBinds id -> Bool
nullBinds EmptyBinds = True
nullBinds (ThenBinds b1 b2) = nullBinds b1 && nullBinds b2
nullBinds (MonoBind b _ _) = nullMonoBinds b
+nullBinds (IPBinds b _) = null b
-mkMonoBind :: MonoBinds id pat -> [Sig id] -> RecFlag -> HsBinds id pat
-mkMonoBind EmptyMonoBinds _ _ = EmptyBinds
-mkMonoBind mbinds sigs is_rec = MonoBind mbinds sigs is_rec
+mkMonoBind :: RecFlag -> MonoBinds id -> HsBinds id
+mkMonoBind _ EmptyMonoBinds = EmptyBinds
+mkMonoBind is_rec mbinds = MonoBind mbinds [] is_rec
\end{code}
\begin{code}
-instance (Outputable pat, Outputable id) =>
- Outputable (HsBinds id pat) where
+instance (OutputableBndr id) => Outputable (HsBinds id) where
ppr binds = ppr_binds binds
ppr_binds EmptyBinds = empty
ppr_binds (ThenBinds binds1 binds2)
= ppr_binds binds1 $$ ppr_binds binds2
+
+ppr_binds (IPBinds binds is_with)
+ = sep (punctuate semi (map pp_item binds))
+ where
+ pp_item (id,rhs) = pprBndr LetBind id <+> equals <+> pprExpr rhs
+
ppr_binds (MonoBind bind sigs is_rec)
= vcat [ppr_isrec,
vcat (map ppr sigs),
Global bindings (where clauses)
\begin{code}
-data MonoBinds id pat
+data MonoBinds id
= EmptyMonoBinds
- | AndMonoBinds (MonoBinds id pat)
- (MonoBinds id pat)
+ | AndMonoBinds (MonoBinds id)
+ (MonoBinds id)
| FunMonoBind id -- Used for both functions f x = e
-- and variables f = \x -> e
-- FunMonoBinds, so if you change this, you'll need to
-- change e.g. rnMethodBinds
Bool -- True => infix declaration
- [Match id pat]
+ [Match id]
SrcLoc
- | PatMonoBind pat -- The pattern is never a simple variable;
+ | PatMonoBind (Pat id) -- The pattern is never a simple variable;
-- That case is done by FunMonoBind
- (GRHSs id pat)
+ (GRHSs id)
SrcLoc
| VarMonoBind id -- TRANSLATION
- (HsExpr id pat)
-
- | CoreMonoBind id -- TRANSLATION
- CoreExpr -- No zonking; this is a final CoreExpr with Ids and Types!
+ (HsExpr id)
| AbsBinds -- Binds abstraction; TRANSLATION
[TyVar] -- Type variables
[id] -- Dicts
[([TyVar], id, id)] -- (type variables, polymorphic, momonmorphic) triples
NameSet -- Set of *polymorphic* variables that have an INLINE pragma
- (MonoBinds id pat) -- The "business end"
+ (MonoBinds id) -- The "business end"
-- Creates bindings for *new* (polymorphic, overloaded) locals
-- in terms of *old* (monomorphic, non-overloaded) ones.
(fm,gm) -> fm
..ditto for gp..
- p = /\ [a,b] -> \ [d1,d2] -> letrec DBINDS and BIND
- in (fm,gm)
+ tp = /\ [a,b] -> \ [d1,d2] -> letrec DBINDS and BIND
+ in (fm,gm)
\begin{code}
-- We keep the invariant that a MonoBinds is only empty
-- if it is exactly EmptyMonoBinds
-nullMonoBinds :: MonoBinds id pat -> Bool
+nullMonoBinds :: MonoBinds id -> Bool
nullMonoBinds EmptyMonoBinds = True
nullMonoBinds other_monobind = False
-andMonoBinds :: MonoBinds id pat -> MonoBinds id pat -> MonoBinds id pat
+andMonoBinds :: MonoBinds id -> MonoBinds id -> MonoBinds id
andMonoBinds EmptyMonoBinds mb = mb
andMonoBinds mb EmptyMonoBinds = mb
andMonoBinds mb1 mb2 = AndMonoBinds mb1 mb2
-andMonoBindList :: [MonoBinds id pat] -> MonoBinds id pat
+andMonoBindList :: [MonoBinds id] -> MonoBinds id
andMonoBindList binds
= loop1 binds
where
\begin{code}
-instance (Outputable id, Outputable pat) =>
- Outputable (MonoBinds id pat) where
+instance OutputableBndr id => Outputable (MonoBinds id) where
ppr mbind = ppr_monobind mbind
-ppr_monobind :: (Outputable id, Outputable pat) => MonoBinds id pat -> SDoc
+ppr_monobind :: OutputableBndr id => MonoBinds id -> SDoc
ppr_monobind EmptyMonoBinds = empty
ppr_monobind (AndMonoBinds binds1 binds2)
= ppr_monobind binds1 $$ ppr_monobind binds2
-- ToDo: print infix if appropriate
ppr_monobind (VarMonoBind name expr)
- = sep [ppr name <+> equals, nest 4 (pprExpr expr)]
-
-ppr_monobind (CoreMonoBind name expr)
- = sep [ppr name <+> equals, nest 4 (ppr expr)]
+ = sep [pprBndr LetBind name <+> equals, nest 4 (pprExpr expr)]
ppr_monobind (AbsBinds tyvars dictvars exports inlines val_binds)
= sep [ptext SLIT("AbsBinds"),
brackets (sep (punctuate comma (map ppr exports))),
brackets (interpp'SP (nameSetToList inlines))]
$$
- nest 4 (ppr val_binds)
+ nest 4 ( vcat [pprBndr LetBind x | (_,x,_) <- exports]
+ -- Print type signatures
+ $$
+ ppr val_binds )
\end{code}
%************************************************************************
SrcLoc
| FixSig (FixitySig name) -- Fixity declaration
-
-
-data FixitySig name = FixitySig name Fixity SrcLoc
-
-instance Eq name => Eq (FixitySig name) where
- (FixitySig n1 f1 _) == (FixitySig n2 f2 _) = n1==n2 && f1==f2
\end{code}
\begin{code}
okBindSig :: NameSet -> Sig Name -> Bool
-okBindSig ns (ClassOpSig _ _ _ _) = False
-okBindSig ns sig = sigForThisGroup ns sig
+okBindSig ns (ClassOpSig _ _ _ _) = False
+okBindSig ns sig = sigForThisGroup ns sig
okClsDclSig :: NameSet -> Sig Name -> Bool
-okClsDclSig ns (Sig _ _ _) = False
-okClsDclSig ns sig = sigForThisGroup ns sig
+okClsDclSig ns (Sig _ _ _) = False
+okClsDclSig ns sig = sigForThisGroup ns sig
okInstDclSig :: NameSet -> Sig Name -> Bool
-okInstDclSig ns (Sig _ _ _) = False
-okInstDclSig ns (FixSig _) = False
-okInstDclSig ns (SpecInstSig _ _) = True
-okInstDclSig ns sig = sigForThisGroup ns sig
+okInstDclSig ns (Sig _ _ _) = False
+okInstDclSig ns (FixSig _) = False
+okInstDclSig ns (SpecInstSig _ _) = True
+okInstDclSig ns sig = sigForThisGroup ns sig
sigForThisGroup ns sig
= case sigName sig of
\end{code}
\begin{code}
-hsSigDoc (Sig _ _ loc) = (SLIT("type signature"),loc)
-hsSigDoc (ClassOpSig _ _ _ loc) = (SLIT("class-method type signature"), loc)
-hsSigDoc (SpecSig _ _ loc) = (SLIT("SPECIALISE pragma"),loc)
-hsSigDoc (InlineSig True _ _ loc) = (SLIT("INLINE pragma"),loc)
-hsSigDoc (InlineSig False _ _ loc) = (SLIT("NOINLINE pragma"),loc)
-hsSigDoc (SpecInstSig _ loc) = (SLIT("SPECIALISE instance pragma"),loc)
-hsSigDoc (FixSig (FixitySig _ _ loc)) = (SLIT("fixity declaration"), loc)
+hsSigDoc (Sig _ _ loc) = (ptext SLIT("type signature"),loc)
+hsSigDoc (ClassOpSig _ _ _ loc) = (ptext SLIT("class-method type signature"), loc)
+hsSigDoc (SpecSig _ _ loc) = (ptext SLIT("SPECIALISE pragma"),loc)
+hsSigDoc (InlineSig True _ _ loc) = (ptext SLIT("INLINE pragma"),loc)
+hsSigDoc (InlineSig False _ _ loc) = (ptext SLIT("NOINLINE pragma"),loc)
+hsSigDoc (SpecInstSig _ loc) = (ptext SLIT("SPECIALISE instance pragma"),loc)
+hsSigDoc (FixSig (FixitySig _ _ loc)) = (ptext SLIT("fixity declaration"), loc)
\end{code}
\begin{code}
= sep [ppr var <+> dcolon, nest 4 (ppr ty)]
ppr_sig (ClassOpSig var dm ty _)
- = sep [ ppr_var var <+> dcolon,
+ = sep [ pprHsVar var <+> dcolon,
nest 4 (ppr ty),
nest 4 (pp_dm_comment) ]
where
= hsep [text "{-# SPECIALIZE instance", ppr ty, text "#-}"]
ppr_sig (FixSig fix_sig) = ppr fix_sig
-
-
-instance Outputable name => Outputable (FixitySig name) where
- ppr (FixitySig name fixity loc) = sep [ppr fixity, ppr name]
\end{code}
Checking for distinct signatures; oh, so boring