Typos in comments only [ci skip]

11 files changed, 11 insertions, 11 deletions

diff --git a/compiler/basicTypes/Demand.hs b/compiler/basicTypes/Demand.hs
index d79fa6eea9..1921da307f 100644
--- a/compiler/basicTypes/Demand.hs
+++ b/compiler/basicTypes/Demand.hs
@@ -1539,7 +1539,7 @@ Tricky point: make sure that we analyse in the 'virgin' pass. Consider
 In the virgin pass for 'f' we'll give 'f' a very strict (bottom) type.
 That might mean that we analyse the sub-expression containing the
 E = "...rec g..." stuff in a bottom demand.  Suppose we *didn't analyse*
-E, but just retuned botType.
+E, but just returned botType.
 
 Then in the *next* (non-virgin) iteration for 'f', we might analyse E
 in a weaker demand, and that will trigger doing a fixpoint iteration
diff --git a/compiler/coreSyn/CoreUtils.hs b/compiler/coreSyn/CoreUtils.hs
index bad322d62f..63733079e2 100644
--- a/compiler/coreSyn/CoreUtils.hs
+++ b/compiler/coreSyn/CoreUtils.hs
@@ -1295,7 +1295,7 @@ app_ok primop_ok fun args
               -- (which primop_ok will catch), but they ARE OK
               -- if the divisor is definitely non-zero.
               -- Often there is a literal divisor, and this
-              -- can get rid of a thunk in an inner looop
+              -- can get rid of a thunk in an inner loop
 
         | otherwise
         -> primop_ok op     -- Check the primop itself
diff --git a/compiler/coreSyn/MkCore.hs b/compiler/coreSyn/MkCore.hs
index f28e1e97b9..f670ae31f1 100644
--- a/compiler/coreSyn/MkCore.hs
+++ b/compiler/coreSyn/MkCore.hs
@@ -312,7 +312,7 @@ Note [Flattening one-tuples]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 This family of functions creates a tuple of variables/expressions/types.
   mkCoreTup [e1,e2,e3] = (e1,e2,e3)
-What if there is just one variable/expression/type in the agument?
+What if there is just one variable/expression/type in the argument?
 We could do one of two things:
 
 * Flatten it out, so that
diff --git a/compiler/deSugar/DsExpr.hs b/compiler/deSugar/DsExpr.hs
index 48aaacc224..8025c69aeb 100644
--- a/compiler/deSugar/DsExpr.hs
+++ b/compiler/deSugar/DsExpr.hs
@@ -543,7 +543,7 @@ dsExpr expr@(RecordUpd { rupd_expr = record_expr, rupd_flds = fields
         -- It's important to generate the match with matchWrapper,
         -- and the right hand sides with applications of the wrapper Id
         -- so that everything works when we are doing fancy unboxing on the
-        -- constructor aguments.
+        -- constructor arguments.
         ; alts <- mapM (mk_alt upd_fld_env) cons_to_upd
         ; ([discrim_var], matching_code)
                 <- matchWrapper RecUpd Nothing (MG { mg_alts = noLoc alts
diff --git a/compiler/prelude/primops.txt.pp b/compiler/prelude/primops.txt.pp
index a69ba97c7b..6795ca700c 100644
--- a/compiler/prelude/primops.txt.pp
+++ b/compiler/prelude/primops.txt.pp
@@ -2615,7 +2615,7 @@ binder-swap on the case, to give
 
 Now FloatOut might float that v-binding outside the \z.  But that is
 bad because that might mean x gest evaluated much too early!  (CorePrep
-adds an eval to a dataToTag# call, to ensure that the agument really is
+adds an eval to a dataToTag# call, to ensure that the argument really is
 evaluated; see CorePrep Note [dataToTag magic].)
 
 Solution: make DataToTag into a can_fail primop.  That will stop it floating
diff --git a/compiler/simplCore/OccurAnal.hs b/compiler/simplCore/OccurAnal.hs
index 4ed96f5cab..c2aa093740 100644
--- a/compiler/simplCore/OccurAnal.hs
+++ b/compiler/simplCore/OccurAnal.hs
@@ -931,7 +931,7 @@ It's particularly bad to make a DFun into a loop breaker.  See
 Note [How instance declarations are translated] in TcInstDcls
 
 We give DFuns a higher score than ordinary CONLIKE things because
-if there's a choice we want the DFun to be the non-looop breker. Eg
+if there's a choice we want the DFun to be the non-loop breaker. Eg
 
 rec { sc = /\ a \$dC. $fBWrap (T a) ($fCT @ a $dC)
 
diff --git a/compiler/specialise/SpecConstr.hs b/compiler/specialise/SpecConstr.hs
index 4aa7f04f5f..71d2d4b25d 100644
--- a/compiler/specialise/SpecConstr.hs
+++ b/compiler/specialise/SpecConstr.hs
@@ -210,7 +210,7 @@ This only makes sense if either
   b) the type variable 'a' is an argument to f (and hence fs)
 
 Actually, (a) may hold for value arguments too, in which case
-we may not want to pass them.  Supose 'x' is in scope at f's
+we may not want to pass them.  Suppose 'x' is in scope at f's
 defn, but xs is not.  Then we'd like
 
         f_spec xs = let p = (:) [a] x xs in ....as before....
diff --git a/compiler/stgSyn/CoreToStg.hs b/compiler/stgSyn/CoreToStg.hs
index 0e33918d8a..5531d31d30 100644
--- a/compiler/stgSyn/CoreToStg.hs
+++ b/compiler/stgSyn/CoreToStg.hs
@@ -835,7 +835,7 @@ mkStgRhs' con_updateable rhs_fvs bndr binder_info rhs
 --           and lots of PAP_enters.
 --
 --         - in the case where the thunk is top-level, we save building
---           a black hole and futhermore the thunk isn't considered to
+--           a black hole and furthermore the thunk isn't considered to
 --           be a CAF any more, so it doesn't appear in any SRTs.
 --
 -- We do it here, because the arity information is accurate, and we need
diff --git a/compiler/stranal/DmdAnal.hs b/compiler/stranal/DmdAnal.hs
index e2a1dc4493..e7887b94db 100644
--- a/compiler/stranal/DmdAnal.hs
+++ b/compiler/stranal/DmdAnal.hs
@@ -1234,7 +1234,7 @@ binders the CPR property.  Specifically
                    | otherwise = x
 
    For $wf2 we are going to unbox the MkT *and*, since it is strict, the
-   first agument of the MkT; see Note [Add demands for strict constructors].
+   first argument of the MkT; see Note [Add demands for strict constructors].
    But then we don't want box it up again when returning it!  We want
    'f2' to have the CPR property, so we give 'x' the CPR property.
 
diff --git a/compiler/typecheck/TcRules.hs b/compiler/typecheck/TcRules.hs
index 2983ccb612..3c9ebeaaa0 100644
--- a/compiler/typecheck/TcRules.hs
+++ b/compiler/typecheck/TcRules.hs
@@ -214,7 +214,7 @@ Consider
        f b True = ...
     #-}
 Here we *must* solve the wanted (Eq a) from the given (Eq a)
-resulting from skolemising the agument type of g.  So we
+resulting from skolemising the argument type of g.  So we
 revert to SimplCheck when going under an implication.
 
 
diff --git a/compiler/typecheck/TcSMonad.hs b/compiler/typecheck/TcSMonad.hs
index 0f98f29398..1d0ddb38d2 100644
--- a/compiler/typecheck/TcSMonad.hs
+++ b/compiler/typecheck/TcSMonad.hs
@@ -855,7 +855,7 @@ The idea is that
   - (K2c): If this holds, we can't pass through this triple infinitely
     often, because if we did then fs>=f, fw>=f, hence by (R2)
       * either fw>=fs, contradicting K2c
-      * or fs>=fw; so by the agument in K2b we can't have a loop
+      * or fs>=fw; so by the argument in K2b we can't have a loop
 
   - (K2d): if a not in s, we hae no further opportunity to apply the
     work item, similar to (K2b)