typos

6 files changed, 13 insertions, 13 deletions

diff --git a/compiler/GHC/ByteCode/Instr.hs b/compiler/GHC/ByteCode/Instr.hs
index ebbce3ef50..17c39b7220 100644
--- a/compiler/GHC/ByteCode/Instr.hs
+++ b/compiler/GHC/ByteCode/Instr.hs
@@ -300,7 +300,7 @@ instance Outputable BCInstr where
    ppr CASEFAIL              = text "CASEFAIL"
    ppr (JMP lab)             = text "JMP"      <+> ppr lab
    ppr (CCALL off marshall_addr flags) = text "CCALL   " <+> ppr off
-                                                <+> text "marshall code at"
+                                                <+> text "marshal code at"
                                                <+> text (show marshall_addr)
                                                <+> (case flags of
                                                       0x1 -> text "(interruptible)"
diff --git a/compiler/GHC/Core/Opt/Specialise.hs b/compiler/GHC/Core/Opt/Specialise.hs
index 2dc2257525..2fd731c654 100644
--- a/compiler/GHC/Core/Opt/Specialise.hs
+++ b/compiler/GHC/Core/Opt/Specialise.hs
@@ -307,7 +307,7 @@ only it knows how to build the dictionaries d1 and d2!  For example
 Here, the specialised version of g is an application of g's rhs to the
 Ord dictionary for (Tree Int), which only the type checker can conjure
 up.  There might not even *be* one, if (Tree Int) is not an instance of
-Ord!  (All the other specialision has suitable dictionaries to hand
+Ord!  (All the other specialisation has suitable dictionaries to hand
 from actual calls.)
 
 Problem.  The type checker doesn't have to hand a convenient <f_rhs>, because
@@ -1335,7 +1335,7 @@ specBind top_lvl env (NonRec fn rhs) do_body
 
              fn3 = zapIdDemandInfo fn2
              -- We zap the demand info because the binding may float,
-             -- which would invaidate the demand info (see #17810 for example).
+             -- which would invalidate the demand info (see #17810 for example).
              -- Destroying demand info is not terrible; specialisation is
              -- always followed soon by demand analysis.
 
diff --git a/compiler/GHC/Core/Rules.hs b/compiler/GHC/Core/Rules.hs
index d1a1d982f6..c722addf28 100644
--- a/compiler/GHC/Core/Rules.hs
+++ b/compiler/GHC/Core/Rules.hs
@@ -153,7 +153,7 @@ Note [Overall plumbing for rules]
 
   In a single simplifier run new rules can be added into the EPS so it matters
   to keep an up-to-date view of which rules have been loaded. For examples of
-  where this went wrong and caused cryptic performance regressions seee
+  where this went wrong and caused cryptic performance regressions 
   see T19790 and !6735.
 
 
@@ -971,7 +971,7 @@ match renv subst e1 (Var v2) mco  -- Note [Expanding variables]
 -- Note the match on MRefl!  We fail if there is a cast in the target
 --     (e1 e2) ~ (d1 d2) |> co
 -- See Note [Cancel reflexive casts]: in the Cast equations for 'match'
--- we agressively ensure that if MCo is reflective, it really is MRefl.
+-- we aggressively ensure that if MCo is reflective, it really is MRefl.
 match renv subst (App f1 a1) (App f2 a2) MRefl
   = do  { subst' <- match renv subst f1 f2 MRefl
         ; match renv subst' a1 a2 MRefl }
@@ -1150,7 +1150,7 @@ when we eta-reduce (\a b. blah a b) to 'blah', we'll get
 and we really want to spot that the co/sym-co cancels out.
 Hence
   * We keep an invariant that the MCoercion is always MRefl
-    if the MCoercion is reflextve
+    if the MCoercion is reflexive
   * We maintain this invariant via the call to checkReflexiveMCo
     in the Cast case of 'match'.
 -}
diff --git a/compiler/GHC/CoreToStg/Prep.hs b/compiler/GHC/CoreToStg/Prep.hs
index 2405a2feda..0a0eae47f0 100644
--- a/compiler/GHC/CoreToStg/Prep.hs
+++ b/compiler/GHC/CoreToStg/Prep.hs
@@ -129,7 +129,7 @@ The goal of this pass is to prepare for code generation.
     annotate according to scoping rules when floating.
 
 11. Collect cost centres (including cost centres in unfoldings) if we're in
-    profiling mode. We have to do this here beucase we won't have unfoldings
+    profiling mode. We have to do this here because we won't have unfoldings
     after this pass (see `trimUnfolding` and Note [Drop unfoldings and rules].
 
 12. Eliminate case clutter in favour of unsafe coercions.
@@ -179,7 +179,7 @@ CorePrep does these two transformations:
    Tiresome, but not difficult.
 
 These transformations get rid of "case clutter", leaving only casts.
-We are doing no further significant tranformations, so the reasons
+We are doing no further significant transformations, so the reasons
 for the case forms have disappeared. And it is extremely helpful for
 the ANF-ery, CoreToStg, and backends, if trivial expressions really do
 look trivial. #19700 was an example.
@@ -2028,7 +2028,7 @@ enterRecGroupRHSs env grp
 {- Note [CpeTyCoEnv]
 ~~~~~~~~~~~~~~~~~~~~
 The cpe_tyco_env :: Maybe CpeTyCoEnv field carries a substitution
-for type and coercion varibles
+for type and coercion variables
 
 * We need the coercion substitution to support the elimination of
   unsafeEqualityProof (see Note [Unsafe coercions])
diff --git a/compiler/GHC/Stg/Lint.hs b/compiler/GHC/Stg/Lint.hs
index 15586cfce9..6104407913 100644
--- a/compiler/GHC/Stg/Lint.hs
+++ b/compiler/GHC/Stg/Lint.hs
@@ -68,8 +68,8 @@ is much coarser. In particular, STG programs must be /well-kinded/.
 More precisely, if f :: ty1 -> ty2, then in the application (f e)
 where e :: ty1', we must have kind(ty1) = kind(ty1').
 
-So the STG type system does not distinguish beteen Int and Bool,
-but it /does/ distinguish beteen Int and Int#, because they have
+So the STG type system does not distinguish between Int and Bool,
+but it /does/ distinguish between Int and Int#, because they have
 different kinds.  Actually, since all terms have kind (TYPE rep),
 we might say that the STG language is well-runtime-rep'd.
 
@@ -356,7 +356,7 @@ lintStgAppReps fun args = do
         | and $ zipWith (primRepCompatible platform) actual_rep expected_rep
         = match_args actual_reps_left expected_reps_left
 
-        | otherwise = addErrL $ hang (text "Function type reps and function argument reps missmatched") 2 $
+        | otherwise = addErrL $ hang (text "Function type reps and function argument reps mismatched") 2 $
             (text "In application " <> ppr fun <+> ppr args $$
               text "argument rep:" <> ppr actual_rep $$
               text "expected rep:" <> ppr expected_rep $$
diff --git a/compiler/GHC/StgToByteCode.hs b/compiler/GHC/StgToByteCode.hs
index 3c08b8941c..c94da8792d 100644
--- a/compiler/GHC/StgToByteCode.hs
+++ b/compiler/GHC/StgToByteCode.hs
@@ -1330,7 +1330,7 @@ generateCCall d0 s p (CCallSpec target cconv safety) result_ty args_r_to_l
             Addr# address_of_C_fn
             <placeholder-for-result#> (must be an unboxed type)
 
-         The interpreter then calls the marshall code mentioned
+         The interpreter then calls the marshal code mentioned
          in the CCALL insn, passing it (& <placeholder-for-result#>),
          that is, the addr of the topmost word in the stack.
          When this returns, the placeholder will have been