Typos in comments [ci skip]

13 files changed, 19 insertions, 19 deletions

diff --git a/compiler/basicTypes/ConLike.hs b/compiler/basicTypes/ConLike.hs
index 53e22fd4bb..b8bab31297 100644
--- a/compiler/basicTypes/ConLike.hs
+++ b/compiler/basicTypes/ConLike.hs
@@ -147,7 +147,7 @@ conLikeResTy (PatSynCon ps)    tys = patSynInstResTy ps tys
 
 -- | The \"full signature\" of the 'ConLike' returns, in order:
 --
--- 1) The universally quanitifed type variables
+-- 1) The universally quantified type variables
 --
 -- 2) The existentially quantified type variables
 --
diff --git a/compiler/basicTypes/RdrName.hs b/compiler/basicTypes/RdrName.hs
index 490ab47b4d..1bba34d27d 100644
--- a/compiler/basicTypes/RdrName.hs
+++ b/compiler/basicTypes/RdrName.hs
@@ -836,7 +836,7 @@ greLabel (GRE{gre_name = n, gre_par = FldParent{}})     = Just (occNameFS (nameO
 greLabel _                                              = Nothing
 
 unQualOK :: GlobalRdrElt -> Bool
--- ^ Test if an unqualifed version of this thing would be in scope
+-- ^ Test if an unqualified version of this thing would be in scope
 unQualOK (GRE {gre_lcl = lcl, gre_imp = iss })
   | lcl = True
   | otherwise = any unQualSpecOK iss
@@ -851,7 +851,7 @@ as 'rdr', say "x".  It does two things:
     * Unqualified, as 'x'    if want_unqual  is Unqual _
 
 (b) for that subset, filter the provenance field (gre_lcl and gre_imp)
-    to ones that brought it into scope qualifed or unqualified resp.
+    to ones that brought it into scope qualified or unqualified resp.
 
 Example:
       module A ( f ) where
@@ -881,7 +881,7 @@ pickGREs :: RdrName -> [GlobalRdrElt] -> [GlobalRdrElt]
 --    * Unqualified, as 'x'    if want_unqual  is Unqual _
 --
 -- Return each such GRE, with its ImportSpecs filtered, to reflect
--- how it is in scope qualifed or unqualified respectively.
+-- how it is in scope qualified or unqualified respectively.
 -- See Note [GRE filtering]
 pickGREs (Unqual {})  gres = mapMaybe pickUnqualGRE     gres
 pickGREs (Qual mod _) gres = mapMaybe (pickQualGRE mod) gres
diff --git a/compiler/cmm/CmmSink.hs b/compiler/cmm/CmmSink.hs
index acac1c1ede..afa77d5bc4 100644
--- a/compiler/cmm/CmmSink.hs
+++ b/compiler/cmm/CmmSink.hs
@@ -138,7 +138,7 @@ type Assignment = (LocalReg, CmmExpr, AbsMem)
   -- the RHS of the assignment.
 
 type Assignments = [Assignment]
-  -- A sequence of assignements; kept in *reverse* order
+  -- A sequence of assignments; kept in *reverse* order
   -- So the list [ x=e1, y=e2 ] means the sequence of assignments
   --     y = e2
   --     x = e1
diff --git a/compiler/coreSyn/CoreSyn.hs b/compiler/coreSyn/CoreSyn.hs
index 4ea913bfa1..6f692e0ea5 100644
--- a/compiler/coreSyn/CoreSyn.hs
+++ b/compiler/coreSyn/CoreSyn.hs
@@ -518,7 +518,7 @@ this exhaustive list can be empty!
 ********************************************************************* -}
 
 {- Many passes apply a substitution, and it's very handy to have type
-   synonyms to remind us whether or not the subsitution has been applied -}
+   synonyms to remind us whether or not the substitution has been applied -}
 
 -- Pre-cloning or substitution
 type InBndr     = CoreBndr
@@ -1380,13 +1380,13 @@ canUnfold _                                   = False
 {- Note [Fragile unfoldings]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 An unfolding is "fragile" if it mentions free variables (and hence would
-need substitution) or might be affeceted by optimisation.  The non-fragile
+need substitution) or might be affected by optimisation.  The non-fragile
 ones are
 
    NoUnfolding, BootUnfolding
 
    OtherCon {}    If we know this binder (say a lambda binder) will be
-                  bound to an evaluated thing, we weant to retain that
+                  bound to an evaluated thing, we want to retain that
                   info in simpleOptExpr; see Trac #13077.
 
 We consider even a StableUnfolding as fragile, because it needs substitution.
diff --git a/compiler/deSugar/DsMeta.hs b/compiler/deSugar/DsMeta.hs
index b43f72801e..27106a2c8b 100644
--- a/compiler/deSugar/DsMeta.hs
+++ b/compiler/deSugar/DsMeta.hs
@@ -250,7 +250,7 @@ and have Template Haskell turn it into this:
   idProxy :: forall k proxy (b :: k). proxy b -> proxy b
   idProxy x = x
 
-Notice that we explicitly quantifed the variable `k`! This is quite bad, as the
+Notice that we explicitly quantified the variable `k`! This is quite bad, as the
 latter declaration requires -XTypeInType, while the former does not. Not to
 mention that the latter declaration isn't even what the user wrote in the
 first place.
diff --git a/compiler/iface/IfaceSyn.hs b/compiler/iface/IfaceSyn.hs
index 3d62e46bd4..72a5b57f43 100644
--- a/compiler/iface/IfaceSyn.hs
+++ b/compiler/iface/IfaceSyn.hs
@@ -191,7 +191,7 @@ data IfaceClassOp
                  IfaceType                         -- Class op type
                  (Maybe (DefMethSpec IfaceType))   -- Default method
                  -- The types of both the class op itself,
-                 -- and the default method, are *not* quantifed
+                 -- and the default method, are *not* quantified
                  -- over the class variables
 
 data IfaceAT = IfaceAT  -- See Class.ClassATItem
diff --git a/compiler/main/DynFlags.hs b/compiler/main/DynFlags.hs
index 6dbd723f9e..c504deebbd 100644
--- a/compiler/main/DynFlags.hs
+++ b/compiler/main/DynFlags.hs
@@ -4612,7 +4612,7 @@ interpretPackageEnv dflags = do
     envError env = liftMaybeT . throwGhcExceptionIO . CmdLineError $
          "Package environment "
       ++ show env
-      ++ " (specified in GHC_ENVIRIONMENT) not found"
+      ++ " (specified in GHC_ENVIRONMENT) not found"
 
 
 -- If we're linking a binary, then only targets that produce object
diff --git a/compiler/rename/RnEnv.hs b/compiler/rename/RnEnv.hs
index 97718f88d2..7c05994c0a 100644
--- a/compiler/rename/RnEnv.hs
+++ b/compiler/rename/RnEnv.hs
@@ -648,7 +648,7 @@ But when adding to the UsedRdrNames we must make that qualification
 explicit (saying "used  M.f"), otherwise we get "Redundant import of M.f".
 
 So we make up a suitable (fake) RdrName.  But be careful
-   import qualifed M
+   import qualified M
    import M( C(f) )
    instance C T where
      f x = x
@@ -1155,7 +1155,7 @@ lookupQualifiedNameGHCi rdr_name
                         ; return [] } }
 
       | otherwise
-      = do { traceRn "lookupQualifedNameGHCi: off" (ppr rdr_name)
+      = do { traceRn "lookupQualifiedNameGHCi: off" (ppr rdr_name)
            ; return [] }
 
     doc = text "Need to find" <+> ppr rdr_name
diff --git a/compiler/simplCore/CoreMonad.hs b/compiler/simplCore/CoreMonad.hs
index ea94d9b20e..12e69b97e2 100644
--- a/compiler/simplCore/CoreMonad.hs
+++ b/compiler/simplCore/CoreMonad.hs
@@ -809,7 +809,7 @@ instance MonadThings CoreM where
 -- | Attempt to convert a Template Haskell name to one that GHC can
 -- understand. Original TH names such as those you get when you use
 -- the @'foo@ syntax will be translated to their equivalent GHC name
--- exactly. Qualified or unqualifed TH names will be dynamically bound
+-- exactly. Qualified or unqualified TH names will be dynamically bound
 -- to names in the module being compiled, if possible. Exact TH names
 -- will be bound to the name they represent, exactly.
 thNameToGhcName :: TH.Name -> CoreM (Maybe Name)
diff --git a/compiler/stgSyn/StgSyn.hs b/compiler/stgSyn/StgSyn.hs
index 56978f868c..93b6e76264 100644
--- a/compiler/stgSyn/StgSyn.hs
+++ b/compiler/stgSyn/StgSyn.hs
@@ -568,7 +568,7 @@ type StgRhs      = GenStgRhs      Id Id
 type StgAlt      = GenStgAlt      Id Id
 
 {- Many passes apply a substitution, and it's very handy to have type
-   synonyms to remind us whether or not the subsitution has been applied.
+   synonyms to remind us whether or not the substitution has been applied.
    See CoreSyn for precedence in Core land
 -}
 
diff --git a/compiler/typecheck/TcErrors.hs b/compiler/typecheck/TcErrors.hs
index bb591c8e01..9294b78ca2 100644
--- a/compiler/typecheck/TcErrors.hs
+++ b/compiler/typecheck/TcErrors.hs
@@ -2749,7 +2749,7 @@ relevantBindings want_filtering ctxt ct
 
                  else if run_out n_left && id_tvs `subVarSet` tvs_seen
                           -- We've run out of n_left fuel and this binding only
-                          -- mentions aleady-seen type variables, so discard it
+                          -- mentions already-seen type variables, so discard it
                  then go tidy_env ct_tvs n_left tvs_seen docs
                          True      -- Record that we have now discarded something
                          tc_bndrs
diff --git a/compiler/typecheck/TcSMonad.hs b/compiler/typecheck/TcSMonad.hs
index 5f6a4f16d3..d80fea1fda 100644
--- a/compiler/typecheck/TcSMonad.hs
+++ b/compiler/typecheck/TcSMonad.hs
@@ -840,7 +840,7 @@ The idea is that
 
 * (K2) is about inertness.  Intuitively, any infinite chain T^0(f,t),
   T^1(f,t), T^2(f,T).... must pass through the new work item infnitely
-  often, since the substution without the work item is inert; and must
+  often, since the substitution without the work item is inert; and must
   pass through at least one of the triples in S infnitely often.
 
   - (K2a): if not(fs>=fs) then there is no f that fs can rewrite (fs>=f),
@@ -1279,7 +1279,7 @@ lookupFlattenTyVar ieqs ftv
 
 {- Note [lookupFlattenTyVar]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Supppose we have an injective function F and
+Suppose we have an injective function F and
   inert_funeqs:   F t1 ~ fsk1
                   F t2 ~ fsk2
   inert_eqs:      fsk1 ~ fsk2
diff --git a/compiler/types/Unify.hs b/compiler/types/Unify.hs
index 42febcb30c..c2f2141e9e 100644
--- a/compiler/types/Unify.hs
+++ b/compiler/types/Unify.hs
@@ -128,7 +128,7 @@ tcMatchTysX subst tys1 tys2
 tcMatchTyKisX :: TCvSubst        -- ^ Substitution to extend
               -> [Type]          -- ^ Template
               -> [Type]          -- ^ Target
-              -> Maybe TCvSubst  -- ^ One-shot subtitution
+              -> Maybe TCvSubst  -- ^ One-shot substitution
 tcMatchTyKisX subst tys1 tys2
   = tc_match_tys_x True subst tys1 tys2