Typos in comments [skip ci]

8 files changed, 9 insertions, 9 deletions

diff --git a/compiler/coreSyn/CoreLint.hs b/compiler/coreSyn/CoreLint.hs
index b00e1ac141..5bf2d4f1d2 100644
--- a/compiler/coreSyn/CoreLint.hs
+++ b/compiler/coreSyn/CoreLint.hs
@@ -522,7 +522,7 @@ lintIdUnfolding bndr bndr_ty (CoreUnfolding { uf_tmpl = rhs, uf_src = src })
   = do { ty <- lintCoreExpr rhs
        ; checkTys bndr_ty ty (mkRhsMsg bndr (ptext (sLit "unfolding")) ty) }
 lintIdUnfolding  _ _ _
-  = return ()       -- Do not Lint unstable unfoldings, becuase that leads
+  = return ()       -- Do not Lint unstable unfoldings, because that leads
                     -- to exponential behaviour; c.f. CoreFVs.idUnfoldingVars
 
 {-
diff --git a/compiler/coreSyn/CoreUnfold.hs b/compiler/coreSyn/CoreUnfold.hs
index 3a54b2773e..91dbed9ecb 100644
--- a/compiler/coreSyn/CoreUnfold.hs
+++ b/compiler/coreSyn/CoreUnfold.hs
@@ -715,7 +715,7 @@ of extra incentive we give a discount of 10*(1 + n_val_args).
 
 Simon M tried a MUCH bigger discount: (10 * (10 + n_val_args)),
 and said it was an "unambiguous win", but its terribly dangerous
-because a fuction with many many case branches, each finishing with
+because a function with many many case branches, each finishing with
 a constructor, can have an arbitrarily large discount.  This led to
 terrible code bloat: see Trac #6099.
 
@@ -1003,7 +1003,7 @@ nonTriv _       = True
 data CallCtxt
   = BoringCtxt
   | RhsCtxt             -- Rhs of a let-binding; see Note [RHS of lets]
-  | DiscArgCtxt         -- Argument of a fuction with non-zero arg discount
+  | DiscArgCtxt         -- Argument of a function with non-zero arg discount
   | RuleArgCtxt         -- We are somewhere in the argument of a function with rules
 
   | ValAppCtxt          -- We're applied to at least one value arg
diff --git a/compiler/llvmGen/LlvmCodeGen/CodeGen.hs b/compiler/llvmGen/LlvmCodeGen/CodeGen.hs
index 517da53cab..9896c4040a 100644
--- a/compiler/llvmGen/LlvmCodeGen/CodeGen.hs
+++ b/compiler/llvmGen/LlvmCodeGen/CodeGen.hs
@@ -297,7 +297,7 @@ genCall (PrimTarget (MO_U_Mul2 w)) [dstH, dstL] [lhs, rhs] = do
 
 -- MO_U_QuotRem2 is another case we handle by widening the registers to double
 -- the width and use normal LLVM instructions (similarly to the MO_U_Mul2). The
--- main difference here is that we need to conmbine two words into one register
+-- main difference here is that we need to combine two words into one register
 -- and then use both 'udiv' and 'urem' instructions to compute the result.
 genCall (PrimTarget (MO_U_QuotRem2 w)) [dstQ, dstR] [lhsH, lhsL, rhs] = run $ do
     let width = widthToLlvmInt w
diff --git a/compiler/main/DynFlags.hs b/compiler/main/DynFlags.hs
index 35e5dc5fc5..c94c6d9567 100644
--- a/compiler/main/DynFlags.hs
+++ b/compiler/main/DynFlags.hs
@@ -1562,7 +1562,7 @@ defaultDynFlags mySettings =
         ufCreationThreshold = 750,
         ufUseThreshold      = 60,
         ufFunAppDiscount    = 60,
-        -- Be fairly keen to inline a fuction if that means
+        -- Be fairly keen to inline a function if that means
         -- we'll be able to pick the right method from a dictionary
         ufDictDiscount      = 30,
         ufKeenessFactor     = 1.5,
diff --git a/compiler/parser/Parser.y b/compiler/parser/Parser.y
index 7518951ac1..1cfe491461 100644
--- a/compiler/parser/Parser.y
+++ b/compiler/parser/Parser.y
@@ -2826,7 +2826,7 @@ oqtycon_no_varcon :: { Located RdrName }  -- Type constructor which cannot be mi
 {- Note [Type constructors in export list]
 ~~~~~~~~~~~~~~~~~~~~~
 Mixing type constructors and variable constructors in export lists introduces
-ambiguity in grammar: e.g. (*) may be both a type constuctor and a function.
+ambiguity in grammar: e.g. (*) may be both a type constructor and a function.
 
 -XExplicitNamespaces allows to disambiguate by explicitly prefixing type
 constructors with 'type' keyword.
diff --git a/compiler/specialise/Specialise.hs b/compiler/specialise/Specialise.hs
index fe9cba6291..6f22ed466c 100644
--- a/compiler/specialise/Specialise.hs
+++ b/compiler/specialise/Specialise.hs
@@ -1190,7 +1190,7 @@ specCalls mb_mod env rules_for_me calls_for_me fn rhs
       = ASSERT( call_ts `lengthIs` n_tyvars  && call_ds `lengthIs` n_dicts )
 
         -- Suppose f's defn is  f = /\ a b c -> \ d1 d2 -> rhs
-        -- Supppose the call is for f [Just t1, Nothing, Just t3] [dx1, dx2]
+        -- Suppose the call is for f [Just t1, Nothing, Just t3] [dx1, dx2]
 
         -- Construct the new binding
         --      f1 = SUBST[a->t1,c->t3, d1->d1', d2->d2'] (/\ b -> rhs)
diff --git a/compiler/typecheck/TcSplice.hs b/compiler/typecheck/TcSplice.hs
index 4a414a2d43..faebecd525 100644
--- a/compiler/typecheck/TcSplice.hs
+++ b/compiler/typecheck/TcSplice.hs
@@ -703,7 +703,7 @@ runMeta' show_code ppr_hs run_and_convert expr
 {-
 Note [Exceptions in TH]
 ~~~~~~~~~~~~~~~~~~~~~~~
-Supppose we have something like this
+Suppose we have something like this
         $( f 4 )
 where
         f :: Int -> Q [Dec]
diff --git a/compiler/utils/Outputable.hs b/compiler/utils/Outputable.hs
index 2bed1d1e4f..86ac85e31f 100644
--- a/compiler/utils/Outputable.hs
+++ b/compiler/utils/Outputable.hs
@@ -160,7 +160,7 @@ data PrintUnqualified = QueryQualify {
 -- | given an /original/ name, this function tells you which module
 -- name it should be qualified with when printing for the user, if
 -- any.  For example, given @Control.Exception.catch@, which is in scope
--- as @Exception.catch@, this fuction will return @Just "Exception"@.
+-- as @Exception.catch@, this function will return @Just "Exception"@.
 -- Note that the return value is a ModuleName, not a Module, because
 -- in source code, names are qualified by ModuleNames.
 type QueryQualifyName = Module -> OccName -> QualifyName