Typos in comments [ci skip]

13 files changed, 21 insertions, 21 deletions

diff --git a/compiler/codeGen/StgCmmMonad.hs b/compiler/codeGen/StgCmmMonad.hs
index bb093a5e51..cf78269cc5 100644
--- a/compiler/codeGen/StgCmmMonad.hs
+++ b/compiler/codeGen/StgCmmMonad.hs
@@ -288,8 +288,8 @@ data ReturnKind
 --
 -- Since this case is so common I decided to make it more explicit and
 -- robust by programming the sharing directly, rather than relying on
--- the common-block elimiantor to catch it.  This makes
--- common-block-elimianteion an optional optimisation, and furthermore
+-- the common-block eliminator to catch it.  This makes
+-- common-block-elimination an optional optimisation, and furthermore
 -- generates less code in the first place that we have to subsequently
 -- clean up.
 --
diff --git a/compiler/deSugar/Check.hs b/compiler/deSugar/Check.hs
index 792932df5a..c08353a15b 100644
--- a/compiler/deSugar/Check.hs
+++ b/compiler/deSugar/Check.hs
@@ -91,7 +91,7 @@ liftD m = ListT $ \sk fk -> m >>= \a -> sk a fk
 
 -- Pick the first match complete covered match or otherwise the "best" match.
 -- The best match is the one with the least uncovered clauses, ties broken
--- by the number of inaccessible clauses followed by number of redudant
+-- by the number of inaccessible clauses followed by number of redundant
 -- clauses
 getResult :: PmM PmResult -> DsM PmResult
 getResult ls = do
diff --git a/compiler/deSugar/Match.hs b/compiler/deSugar/Match.hs
index 33dd7990c7..abe4dc77b2 100644
--- a/compiler/deSugar/Match.hs
+++ b/compiler/deSugar/Match.hs
@@ -159,7 +159,7 @@ corresponds roughly to @matchVarCon@.
 
 Note [Match Ids]
 ~~~~~~~~~~~~~~~~
-Most of the matching fuctions take an Id or [Id] as argument.  This Id
+Most of the matching functions take an Id or [Id] as argument.  This Id
 is the scrutinee(s) of the match. The desugared expression may
 sometimes use that Id in a local binding or as a case binder.  So it
 should not have an External name; Lint rejects non-top-level binders
diff --git a/compiler/main/HscMain.hs b/compiler/main/HscMain.hs
index fd8c2c0ca9..d6630c3282 100644
--- a/compiler/main/HscMain.hs
+++ b/compiler/main/HscMain.hs
@@ -344,7 +344,7 @@ hscParse' mod_summary
             -- that the parser gave us,
             --   - eliminate files beginning with '<'.  gcc likes to use
             --     pseudo-filenames like "<built-in>" and "<command-line>"
-            --   - normalise them (elimiante differences between ./f and f)
+            --   - normalise them (eliminate differences between ./f and f)
             --   - filter out the preprocessed source file
             --   - filter out anything beginning with tmpdir
             --   - remove duplicates
diff --git a/compiler/simplCore/CallArity.hs b/compiler/simplCore/CallArity.hs
index 2e1de85ad7..e23314b569 100644
--- a/compiler/simplCore/CallArity.hs
+++ b/compiler/simplCore/CallArity.hs
@@ -409,7 +409,7 @@ Call Arity considers everything that is not cheap (`exprIsCheap`) as a thunk.
 Note [Call Arity and Join Points]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-The Call Arity analysis does not care about joint points, and treats them just
+The Call Arity analysis does not care about join points, and treats them just
 like normal functions. This is ok.
 
 The analysis *could* make use of the fact that join points are always evaluated
@@ -420,7 +420,7 @@ This *might* be more efficient (for example, join points would not have to be
 considered interesting variables), but it would also add redundant code. So for
 now we do not do that.
 
-The simplifier never eta-expands join points (it insteads pushes extra arguments from
+The simplifier never eta-expands join points (it instead pushes extra arguments from
 an eta-expanded context into the join point’s RHS), so the call arity
 annotation on join points is not actually used. As it would be equally valid
 (though less efficient) to eta-expand join points, this is the simplifier's
diff --git a/compiler/simplCore/Simplify.hs b/compiler/simplCore/Simplify.hs
index fe8c578106..78ef3927f2 100644
--- a/compiler/simplCore/Simplify.hs
+++ b/compiler/simplCore/Simplify.hs
@@ -2408,7 +2408,7 @@ then we'd like to transform
 Nota Bene: we used to have a built-in rule for 'seq' that dropped
 casts, so that
     case (x |> co) of { _ -> blah }
-dropped the cast; in order to imporove the chances of trySeqRules
+dropped the cast; in order to improve the chances of trySeqRules
 firing.  But that works in the /opposite/ direction to Note [Improving
 seq] so there's a danger of flip/flopping.  Better to make trySeqRules
 insensitive to the cast, which is now is.
diff --git a/compiler/simplStg/StgCse.hs b/compiler/simplStg/StgCse.hs
index c0063814d7..1ee6a9a150 100644
--- a/compiler/simplStg/StgCse.hs
+++ b/compiler/simplStg/StgCse.hs
@@ -392,7 +392,7 @@ mkStgLet stgLet (Just binds) body = stgLet binds body
 {-
 Note [Trivial case scrutinee]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-We wnat to be able to handle nested reconstruction of constructors as in
+We want to be able to handle nested reconstruction of constructors as in
 
     nested :: Either Int (Either Int a) -> Either Bool (Either Bool a)
     nested (Right (Right v)) = Right (Right v)
diff --git a/compiler/typecheck/TcExpr.hs b/compiler/typecheck/TcExpr.hs
index cbe94eaecb..48252dffc6 100644
--- a/compiler/typecheck/TcExpr.hs
+++ b/compiler/typecheck/TcExpr.hs
@@ -1538,7 +1538,7 @@ tcExprSig expr sig@(PartialSig { psig_name = name, sig_loc = loc })
              my_sigma       = mkForAllTys binders (mkPhiTy  my_theta tau)
        ; wrap <- if inferred_sigma `eqType` my_sigma -- NB: eqType ignores vis.
                  then return idHsWrapper  -- Fast path; also avoids complaint when we infer
-                                          -- an ambiguouse type and have AllowAmbiguousType
+                                          -- an ambiguous type and have AllowAmbiguousType
                                           -- e..g infer  x :: forall a. F a -> Int
                  else tcSubType_NC ExprSigCtxt inferred_sigma my_sigma
 
diff --git a/compiler/typecheck/TcInteract.hs b/compiler/typecheck/TcInteract.hs
index 13485d5119..5792dfbb67 100644
--- a/compiler/typecheck/TcInteract.hs
+++ b/compiler/typecheck/TcInteract.hs
@@ -1077,7 +1077,7 @@ f2 :: (?x :: Int, ?x :: Char) => Int
 f2 = ?x
 
 Both of these are actually wrong:  when we try to use either one,
-we'll get two incompatible wnated constraints (?x :: Int, ?x :: Char),
+we'll get two incompatible wanted constraints (?x :: Int, ?x :: Char),
 which would lead to an error.
 
 I can think of two ways to fix this:
diff --git a/compiler/typecheck/TcRnTypes.hs b/compiler/typecheck/TcRnTypes.hs
index c004052483..e4a034b5f9 100644
--- a/compiler/typecheck/TcRnTypes.hs
+++ b/compiler/typecheck/TcRnTypes.hs
@@ -1816,15 +1816,15 @@ dropDerivedInsols insols = filterBag keep insols
       | otherwise      = True
 
 isDroppableDerivedLoc :: CtLoc -> Bool
--- Note [Dropping derived constraints]
+-- See Note [Dropping derived constraints]
 isDroppableDerivedLoc loc
   = case ctLocOrigin loc of
       HoleOrigin {}    -> False
       KindEqOrigin {}  -> False
       GivenOrigin {}   -> False
 
-      -- See Note [Dropping derived constraints
-      -- For fundeps, drop wanted/warnted interactions
+      -- See Note [Dropping derived constraints]
+      -- For fundeps, drop wanted/wanted interactions
       FunDepOrigin2 {} -> False
       FunDepOrigin1 _ loc1 _ loc2
         | isGivenLoc loc1 || isGivenLoc loc2 -> False
@@ -1861,8 +1861,8 @@ see dropDerivedWC.  For example
 
 But (tiresomely) we do keep *some* Derived insolubles:
 
- * Type holes are derived constraints because they have no evidence
-   and we want to keep them so we get the error report
+ * Type holes are derived constraints, because they have no evidence
+   and we want to keep them, so we get the error report
 
  * Insoluble derived equalities (e.g. [D] Int ~ Bool) may arise from
    functional dependency interactions:
@@ -2182,7 +2182,7 @@ trulyInsoluble :: Ct -> Bool
 --   a) type holes, arising from PartialTypeSignatures,
 --   b) "true" expression holes arising from TypedHoles
 --
--- A "expression hole" or "type hole" constraint isn't really an error
+-- An "expression hole" or "type hole" constraint isn't really an error
 -- at all; it's a report saying "_ :: Int" here.  But an out-of-scope
 -- variable masquerading as expression holes IS treated as truly
 -- insoluble, so that it trumps other errors during error reporting.
diff --git a/compiler/typecheck/TcSigs.hs b/compiler/typecheck/TcSigs.hs
index 989fe94e8c..0a8fb5e35c 100644
--- a/compiler/typecheck/TcSigs.hs
+++ b/compiler/typecheck/TcSigs.hs
@@ -754,7 +754,7 @@ tcImpPrags prags
     -- Ignore SPECIALISE pragmas for imported things
     -- when we aren't specialising, or when we aren't generating
     -- code.  The latter happens when Haddocking the base library;
-    -- we don't wnat complaints about lack of INLINABLE pragmas
+    -- we don't want complaints about lack of INLINABLE pragmas
     not_specialising dflags
       | not (gopt Opt_Specialise dflags) = True
       | otherwise = case hscTarget dflags of
diff --git a/compiler/typecheck/TcSimplify.hs b/compiler/typecheck/TcSimplify.hs
index 58830ec645..4d5772d059 100644
--- a/compiler/typecheck/TcSimplify.hs
+++ b/compiler/typecheck/TcSimplify.hs
@@ -787,7 +787,7 @@ If the monomorphism restriction does not apply, then we quantify as follows:
   Motivation for re-simplification (Trac #7857): imagine we have a
   constraint (C (a->b)), where 'a :: TYPE l1' and 'b :: TYPE l2' are
   not free in the envt, and instance forall (a::*) (b::*). (C a) => C
-  (a -> b) The instance doesnt' match while l1,l2 are polymorphic, but
+  (a -> b) The instance doesn't match while l1,l2 are polymorphic, but
   it will match when we default them to LiftedRep.
 
   This is all very tiresome.
@@ -901,7 +901,7 @@ defaultTyVarsAndSimplify :: TcLevel
                          -> [PredType]          -- Assumed zonked
                          -> TcM [PredType]      -- Guaranteed Zonked
 -- Default any tyvar free in the constraints,
--- and re-simplify in case the defaulting allows futher simplification
+-- and re-simplify in case the defaulting allows further simplification
 defaultTyVarsAndSimplify rhs_tclvl mono_tvs candidates
   | null candidates  -- Common shortcut
   = return []
diff --git a/compiler/typecheck/TcValidity.hs b/compiler/typecheck/TcValidity.hs
index c28c21da97..0a7a0adf7f 100644
--- a/compiler/typecheck/TcValidity.hs
+++ b/compiler/typecheck/TcValidity.hs
@@ -1997,7 +1997,7 @@ sizeTypes = sum . map sizeType
 --
 -- We are considering whether class constraints terminate.
 -- Equality constraints and constraints for the implicit
--- parameter class always termiante so it is safe to say "size 0".
+-- parameter class always terminate so it is safe to say "size 0".
 -- (Implicit parameter constraints always terminate because
 -- there are no instances for them---they are only solved by
 -- "local instances" in expressions).