ghc/compiler/hsSyn/HsSyn.lhs

   1 %
   2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
   3 %
   4 \section{Haskell abstract syntax definition}
   5
   6 This module glues together the pieces of the Haskell abstract syntax,
   7 which is declared in the various \tr{Hs*} modules.  This module,
   8 therefore, is almost nothing but re-exporting.
   9
  10 \begin{code}
  11 module HsSyn (
  12
  13         -- NB: don't reexport HsCore
  14         -- this module tells about "real Haskell"
  15
  16         module HsSyn,
  17         module HsBinds,
  18         module HsDecls,
  19         module HsExpr,
  20         module HsImpExp,
  21         module HsLit,
  22         module HsMatches,
  23         module HsPat,
  24         module HsTypes,
  25         Fixity, NewOrData,
  26
  27         collectTopBinders, collectMonoBinders, collectLocatedMonoBinders
  28      ) where
  29
  30 #include "HsVersions.h"
  31
  32 -- friends:
  33 import HsDecls
  34 import HsBinds
  35 import HsExpr
  36 import HsImpExp
  37 import HsLit
  38 import HsMatches
  39 import HsPat
  40 import HsTypes
  41 import BasicTypes       ( Fixity, Version, NewOrData )
  42
  43 -- others:
  44 import Outputable
  45 import SrcLoc           ( SrcLoc )
  46 import Bag
  47 import Module           ( ModuleName )
  48 \end{code}
  49
  50 All we actually declare here is the top-level structure for a module.
  51 \begin{code}
  52 data HsModule name pat
  53   = HsModule
  54         ModuleName              -- module name
  55         (Maybe Version)         -- source interface version number
  56         (Maybe [IE name])       -- export list; Nothing => export everything
  57                                 -- Just [] => export *nothing* (???)
  58                                 -- Just [...] => as you would expect...
  59         [ImportDecl name]       -- We snaffle interesting stuff out of the
  60                                 -- imported interfaces early on, adding that
  61                                 -- info to TyDecls/etc; so this list is
  62                                 -- often empty, downstream.
  63         [HsDecl name pat]       -- Type, class, value, and interface signature decls
  64         (Maybe DeprecTxt)       -- reason/explanation for deprecation of this module
  65         SrcLoc
  66 \end{code}
  67
  68 \begin{code}
  69 instance (Outputable name, Outputable pat)
  70         => Outputable (HsModule name pat) where
  71
  72     ppr (HsModule name iface_version exports imports
  73                       decls deprec src_loc)
  74       = vcat [
  75             case exports of
  76               Nothing -> pp_header (ptext SLIT("where"))
  77               Just es -> vcat [
  78                             pp_header lparen,
  79                             nest 8 (fsep (punctuate comma (map ppr es))),
  80                             nest 4 (ptext SLIT(") where"))
  81                           ],
  82             pp_nonnull imports,
  83             pp_nonnull decls
  84         ]
  85       where
  86         pp_header rest = case deprec of
  87            Nothing -> pp_modname <+> rest
  88            Just d -> vcat [ pp_modname, ppr d, rest ]
  89
  90         pp_modname = ptext SLIT("module") <+> ppr name
  91
  92         pp_nonnull [] = empty
  93         pp_nonnull xs = vcat (map ppr xs)
  94 \end{code}
  95
  96
  97 %************************************************************************
  98 %*                                                                      *
  99 \subsection{Collecting binders from @HsBinds@}
 100 %*                                                                      *
 101 %************************************************************************
 102
 103 Get all the binders in some @MonoBinds@, IN THE ORDER OF APPEARANCE.
 104
 105 These functions are here, rather than in HsBinds, to avoid a loop between HsPat and HsBinds.
 106
 107 \begin{verbatim}
 108 ...
 109 where
 110   (x, y) = ...
 111   f i j  = ...
 112   [a, b] = ...
 113 \end{verbatim}
 114 it should return @[x, y, f, a, b]@ (remember, order important).
 115
 116 \begin{code}
 117 collectTopBinders :: HsBinds name (InPat name) -> Bag (name,SrcLoc)
 118 collectTopBinders EmptyBinds        = emptyBag
 119 collectTopBinders (MonoBind b _ _)  = listToBag (collectLocatedMonoBinders b)
 120 collectTopBinders (ThenBinds b1 b2) = collectTopBinders b1 `unionBags` collectTopBinders b2
 121
 122 collectLocatedMonoBinders :: MonoBinds name (InPat name) -> [(name,SrcLoc)]
 123 collectLocatedMonoBinders binds
 124   = go binds []
 125   where
 126     go EmptyMonoBinds          acc = acc
 127     go (PatMonoBind pat _ loc) acc = map (\v->(v,loc)) (collectPatBinders pat) ++ acc
 128     go (FunMonoBind f _ _ loc) acc = (f,loc) : acc
 129     go (AndMonoBinds bs1 bs2)  acc = go bs1 (go bs2 acc)
 130
 131 collectMonoBinders :: MonoBinds name (InPat name) -> [name]
 132 collectMonoBinders binds
 133   = go binds []
 134   where
 135     go EmptyMonoBinds          acc = acc
 136     go (PatMonoBind pat _ loc) acc = collectPatBinders pat ++ acc
 137     go (FunMonoBind f _ _ loc) acc = f : acc
 138     go (AndMonoBinds bs1 bs2)  acc = go bs1 (go bs2 acc)
 139 \end{code}