diff options
52 files changed, 63 insertions, 63 deletions
diff --git a/compiler/basicTypes/RdrName.hs b/compiler/basicTypes/RdrName.hs index 84ece4e9ff..7d1c01a49a 100644 --- a/compiler/basicTypes/RdrName.hs +++ b/compiler/basicTypes/RdrName.hs @@ -888,13 +888,13 @@ pickGREs returns two GRE gre1: gre_lcl = True, gre_imp = [] gre2: gre_lcl = False, gre_imp = [ imported from Bar ] -Now the the "ambiguous occurrence" message can correctly report how the +Now the "ambiguous occurrence" message can correctly report how the ambiguity arises. -} pickGREs :: RdrName -> [GlobalRdrElt] -> [GlobalRdrElt] -- ^ Takes a list of GREs which have the right OccName 'x' --- Pick those GREs that are are in scope +-- Pick those GREs that are in scope -- * Qualified, as 'M.x' if want_qual is Qual M _ -- * Unqualified, as 'x' if want_unqual is Unqual _ -- diff --git a/compiler/cmm/Debug.hs b/compiler/cmm/Debug.hs index e5f86faaaf..c6aae691e1 100644 --- a/compiler/cmm/Debug.hs +++ b/compiler/cmm/Debug.hs @@ -330,7 +330,7 @@ code, v :: P64 = R2; if ((Sp + 8) - 32 < SpLim) (likely: False) goto c2ff; else goto c2fg; -After c2fe we we may pass to either c2ff or c2fg; let's first consider the +After c2fe we may pass to either c2ff or c2fg; let's first consider the former. In this case there is nothing in particular that we need to do other than reiterate what we already know about Sp, diff --git a/compiler/codeGen/StgCmmPrim.hs b/compiler/codeGen/StgCmmPrim.hs index da652bf1b0..0a6ac9dba3 100644 --- a/compiler/codeGen/StgCmmPrim.hs +++ b/compiler/codeGen/StgCmmPrim.hs @@ -1846,7 +1846,7 @@ doNewArrayOp res_r rep info payload n init = do arr <- CmmLocal `fmap` newTemp (bWord dflags) emit $ mkAssign arr base - -- Initialise all elements of the the array + -- Initialise all elements of the array p <- assignTemp $ cmmOffsetB dflags (CmmReg arr) (hdrSize dflags rep) for <- newBlockId emitLabel for diff --git a/compiler/coreSyn/CoreSyn.hs b/compiler/coreSyn/CoreSyn.hs index 1462aefb01..9b9d20defa 100644 --- a/compiler/coreSyn/CoreSyn.hs +++ b/compiler/coreSyn/CoreSyn.hs @@ -859,7 +859,7 @@ data TickishScoping = -- | Soft scoping: We want all code that is covered to stay -- covered. Note that this scope type does not forbid - -- transformations from happening, as as long as all results of + -- transformations from happening, as long as all results of -- the transformations are still covered by this tick or a copy of -- it. For example -- @@ -2024,7 +2024,7 @@ collectNBinders orig_n orig_expr go n bs (Lam b e) = go (n-1) (b:bs) e go _ _ _ = pprPanic "collectNBinders" $ int orig_n --- | Takes a nested application expression and returns the the function +-- | Takes a nested application expression and returns the function -- being applied and the arguments to which it is applied collectArgs :: Expr b -> (Expr b, [Arg b]) collectArgs expr @@ -2127,7 +2127,7 @@ data AnnBind bndr annot = AnnNonRec bndr (AnnExpr bndr annot) | AnnRec [(bndr, AnnExpr bndr annot)] --- | Takes a nested application expression and returns the the function +-- | Takes a nested application expression and returns the function -- being applied and the arguments to which it is applied collectAnnArgs :: AnnExpr b a -> (AnnExpr b a, [AnnExpr b a]) collectAnnArgs expr diff --git a/compiler/coreSyn/CoreUtils.hs b/compiler/coreSyn/CoreUtils.hs index 21fc65db90..d35ae235af 100644 --- a/compiler/coreSyn/CoreUtils.hs +++ b/compiler/coreSyn/CoreUtils.hs @@ -1539,7 +1539,7 @@ and do not perform evaluation. There is one primop, dataToTag#, which does /require/ a lifted argument to be evaluted. To ensure this, CorePrep adds an -eval if it can't see the the argument is definitely evaluated +eval if it can't see the argument is definitely evaluated (see [dataToTag magic] in CorePrep). We make no attempt to guarantee that dataToTag#'s argument is diff --git a/compiler/deSugar/DsListComp.hs b/compiler/deSugar/DsListComp.hs index fea637fafe..7ca85eb3f5 100644 --- a/compiler/deSugar/DsListComp.hs +++ b/compiler/deSugar/DsListComp.hs @@ -206,7 +206,7 @@ where (x1, .., xn) are the variables bound in p1, v1, p2 In the translation below, the ParStmt branch translates each parallel branch into a sub-comprehension, and desugars each independently. The resulting lists are fed to a zip function, we create a binding for all the variables bound in all -the comprehensions, and then we hand things off the the desugarer for bindings. +the comprehensions, and then we hand things off the desugarer for bindings. The zip function is generated here a) because it's small, and b) because then we don't have to deal with arbitrary limits on the number of zip functions in the prelude, nor which library the zip function came from. diff --git a/compiler/hsSyn/HsBinds.hs b/compiler/hsSyn/HsBinds.hs index 0dc5dd08ba..0d06543d10 100644 --- a/compiler/hsSyn/HsBinds.hs +++ b/compiler/hsSyn/HsBinds.hs @@ -56,7 +56,7 @@ Global bindings (where clauses) -} -- During renaming, we need bindings where the left-hand sides --- have been renamed but the the right-hand sides have not. +-- have been renamed but the right-hand sides have not. -- the ...LR datatypes are parametrized by two id types, -- one for the left and one for the right. -- Other than during renaming, these will be the same. @@ -77,7 +77,7 @@ data HsLocalBindsLR idL idR -- There should be no pattern synonyms in the HsValBindsLR -- These are *local* (not top level) bindings - -- The parser accepts them, however, leaving the the + -- The parser accepts them, however, leaving the -- renamer to report them | HsIPBinds (HsIPBinds idR) diff --git a/compiler/main/DriverPipeline.hs b/compiler/main/DriverPipeline.hs index f07f4e8ef4..90976b115b 100644 --- a/compiler/main/DriverPipeline.hs +++ b/compiler/main/DriverPipeline.hs @@ -1668,7 +1668,7 @@ Note [-Xlinker -rpath vs -Wl,-rpath] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -Wl takes a comma-separated list of options which in the case of --Wl,-rpath -Wl,some,path,with,commas parses the the path with commas +-Wl,-rpath -Wl,some,path,with,commas parses the path with commas as separate options. Buck, the build system, produces paths with commas in them. diff --git a/compiler/main/HscTypes.hs b/compiler/main/HscTypes.hs index fa0eed2344..16c8002380 100644 --- a/compiler/main/HscTypes.hs +++ b/compiler/main/HscTypes.hs @@ -1335,7 +1335,7 @@ data CgGuts -- ^ The tidied main bindings, including -- previously-implicit bindings for record and class -- selectors, and data constructor wrappers. But *not* - -- data constructor workers; reason: we we regard them + -- data constructor workers; reason: we regard them -- as part of the code-gen of tycons cg_foreign :: !ForeignStubs, -- ^ Foreign export stubs diff --git a/compiler/main/SysTools.hs b/compiler/main/SysTools.hs index dbc97a97de..4c162865ec 100644 --- a/compiler/main/SysTools.hs +++ b/compiler/main/SysTools.hs @@ -63,7 +63,7 @@ Note [How GHC finds toolchain utilities] SysTools.initSysProgs figures out exactly where all the auxiliary programs are, and initialises mutable variables to make it easy to call them. -To to this, it makes use of definitions in Config.hs, which is a Haskell +To do this, it makes use of definitions in Config.hs, which is a Haskell file containing variables whose value is figured out by the build system. Config.hs contains two sorts of things diff --git a/compiler/nativeGen/Dwarf.hs b/compiler/nativeGen/Dwarf.hs index b858b7734d..db1695864d 100644 --- a/compiler/nativeGen/Dwarf.hs +++ b/compiler/nativeGen/Dwarf.hs @@ -149,7 +149,7 @@ debugSplitProcs b = concat $ H.mapElems $ mergeMaps $ map (split Nothing) b {- Note [Splitting DebugBlocks] -DWARF requires that we break up the the nested DebugBlocks produced from +DWARF requires that we break up the nested DebugBlocks produced from the C-- AST. For instance, we begin with tick trees containing nested procs. For example, diff --git a/compiler/nativeGen/PIC.hs b/compiler/nativeGen/PIC.hs index 165c3a7a44..834aa1b86c 100644 --- a/compiler/nativeGen/PIC.hs +++ b/compiler/nativeGen/PIC.hs @@ -400,7 +400,7 @@ howToAccessLabel dflags _ _ _ _ _ -- ------------------------------------------------------------------- --- | Says what we we have to add to our 'PIC base register' in order to +-- | Says what we have to add to our 'PIC base register' in order to -- get the address of a label. picRelative :: Arch -> OS -> CLabel -> CmmLit diff --git a/compiler/nativeGen/SPARC/CodeGen/Expand.hs b/compiler/nativeGen/SPARC/CodeGen/Expand.hs index cf861df77a..0b318740db 100644 --- a/compiler/nativeGen/SPARC/CodeGen/Expand.hs +++ b/compiler/nativeGen/SPARC/CodeGen/Expand.hs @@ -142,7 +142,7 @@ expandMisalignedDoubles instr --- | The the high partner for this float reg. +-- | The high partner for this float reg. fRegHi :: Reg -> Reg fRegHi (RegReal (RealRegSingle r1)) | r1 >= 32 diff --git a/compiler/nativeGen/SPARC/Regs.hs b/compiler/nativeGen/SPARC/Regs.hs index 544e4488a9..d6aadbae94 100644 --- a/compiler/nativeGen/SPARC/Regs.hs +++ b/compiler/nativeGen/SPARC/Regs.hs @@ -193,7 +193,7 @@ fPair reg -- | All the regs that the register allocator can allocate to, --- with the the fixed use regs removed. +-- with the fixed use regs removed. -- allocatableRegs :: [RealReg] allocatableRegs diff --git a/compiler/parser/Lexer.x b/compiler/parser/Lexer.x index b2004a6cbb..76cc4ee6e6 100644 --- a/compiler/parser/Lexer.x +++ b/compiler/parser/Lexer.x @@ -1992,7 +1992,7 @@ functions alexGetByte :: AlexInput -> Maybe (Word8,AlexInput) alexInputPrevChar :: AlexInput -> Char -which Alex uses to to take apart our 'AlexInput', we must +which Alex uses to take apart our 'AlexInput', we must * return a latin1 character in the 'Word8' that 'alexGetByte' expects * return a latin1 character in 'alexInputPrevChar'. diff --git a/compiler/prelude/primops.txt.pp b/compiler/prelude/primops.txt.pp index d6c06b1b56..414a136173 100644 --- a/compiler/prelude/primops.txt.pp +++ b/compiler/prelude/primops.txt.pp @@ -105,7 +105,7 @@ section "The word size story." arithmetic operations, comparisons, and a range of conversions. The 8-bit and 16-bit sizes are always represented as {\tt Int\#} and {\tt Word\#}, and the - operations implemented in terms of the the primops on these + operations implemented in terms of the primops on these types, with suitable range restrictions on the results (using the {\tt narrow$n$Int\#} and {\tt narrow$n$Word\#} families of primops. The 32-bit sizes are represented using {\tt diff --git a/compiler/rename/RnEnv.hs b/compiler/rename/RnEnv.hs index dbc3baf887..1d9dcfa4c2 100644 --- a/compiler/rename/RnEnv.hs +++ b/compiler/rename/RnEnv.hs @@ -194,7 +194,7 @@ newTopSrcBinder (L loc rdr_name) = do { when (isQual rdr_name) (addErrAt loc (badQualBndrErr rdr_name)) -- Binders should not be qualified; if they are, and with a different - -- module name, we we get a confusing "M.T is not in scope" error later + -- module name, we get a confusing "M.T is not in scope" error later ; stage <- getStage ; if isBrackStage stage then diff --git a/compiler/rename/RnNames.hs b/compiler/rename/RnNames.hs index 60c8b1b7dd..ae3f75b1d0 100644 --- a/compiler/rename/RnNames.hs +++ b/compiler/rename/RnNames.hs @@ -134,7 +134,7 @@ So there is an interesting design question in regards to transitive trust checking. Say I have a module B compiled with -XSafe. B is dependent on a bunch of modules and packages, some packages it requires to be trusted as its using -XTrustworthy modules from them. Now if I have a module A that doesn't use safe -haskell at all and simply imports B, should A inherit all the the trust +haskell at all and simply imports B, should A inherit all the trust requirements from B? Should A now also require that a package p is trusted since B required it? @@ -1177,7 +1177,7 @@ warnMissingSignatures gbl_env pat_syns = tcg_patsyns gbl_env -- Warn about missing signatures - -- Do this only when we we have a type to offer + -- Do this only when we have a type to offer ; warn_missing_sigs <- woptM Opt_WarnMissingSignatures ; warn_only_exported <- woptM Opt_WarnMissingExportedSignatures ; warn_pat_syns <- woptM Opt_WarnMissingPatternSynonymSignatures diff --git a/compiler/rename/RnPat.hs b/compiler/rename/RnPat.hs index 2846754f11..31b23634dd 100644 --- a/compiler/rename/RnPat.hs +++ b/compiler/rename/RnPat.hs @@ -574,7 +574,7 @@ rnHsRecFields -- This surprisingly complicated pass -- a) looks up the field name (possibly using disambiguation) -- b) fills in puns and dot-dot stuff --- When we we've finished, we've renamed the LHS, but not the RHS, +-- When we've finished, we've renamed the LHS, but not the RHS, -- of each x=e binding -- -- This is used for record construction and pattern-matching, but not updates. diff --git a/compiler/rename/RnSource.hs b/compiler/rename/RnSource.hs index 897e660515..c1f0df160c 100644 --- a/compiler/rename/RnSource.hs +++ b/compiler/rename/RnSource.hs @@ -880,7 +880,7 @@ when type T (a,_) = a would be rejected. So we should not complain about an unused variable b -As usual, the warnings are not reported for for type variables with names +As usual, the warnings are not reported for type variables with names beginning with an underscore. Extra-constraints wild cards are not supported in type/data family diff --git a/compiler/rename/RnTypes.hs b/compiler/rename/RnTypes.hs index 727744d54d..cdb98fb65a 100644 --- a/compiler/rename/RnTypes.hs +++ b/compiler/rename/RnTypes.hs @@ -1010,7 +1010,7 @@ So the rule is: Note that in the denerate case data T (a :: a) = blah -we get a complaint the the second 'a' is not in scope. +we get a complaint the second 'a' is not in scope. That applies to foralls too: e.g. forall (a :: k) k . blah diff --git a/compiler/simplCore/CSE.hs b/compiler/simplCore/CSE.hs index 65b9af91f2..085ca3c3ae 100644 --- a/compiler/simplCore/CSE.hs +++ b/compiler/simplCore/CSE.hs @@ -546,7 +546,7 @@ to transform In the simplifier we use cheapEqExpr, because it is called a lot. But here in CSE we use the full eqExpr. After all, two alterantives usually differ near the root, so it probably isn't expensive to compare the full -alternative. It seems like the the same kind of thing that CSE is supposed +alternative. It seems like the same kind of thing that CSE is supposed to be doing, which is why I put it here. I acutally saw some examples in the wild, where some inlining made e1 too diff --git a/compiler/simplCore/CallArity.hs b/compiler/simplCore/CallArity.hs index 0e6cf70ba6..4935db076c 100644 --- a/compiler/simplCore/CallArity.hs +++ b/compiler/simplCore/CallArity.hs @@ -342,7 +342,7 @@ For a mutually recursive let, we begin by 3. We combine the analysis result from the body and the memoized results for the arguments (if already present). 4. For each variable, we find out the incoming arity and whether it is called - once, based on the the current analysis result. If this differs from the + once, based on the current analysis result. If this differs from the memoized results, we re-analyse the rhs and update the memoized table. 5. If nothing had to be reanalyzed, we are done. Otherwise, repeat from step 3. diff --git a/compiler/specialise/Rules.hs b/compiler/specialise/Rules.hs index edcab88f56..319404ef15 100644 --- a/compiler/specialise/Rules.hs +++ b/compiler/specialise/Rules.hs @@ -413,7 +413,7 @@ lookupRule dflags in_scope is_active fn args rules findBest :: (Id, [CoreExpr]) -> (CoreRule,CoreExpr) -> [(CoreRule,CoreExpr)] -> (CoreRule,CoreExpr) -- All these pairs matched the expression --- Return the pair the the most specific rule +-- Return the pair the most specific rule -- The (fn,args) is just for overlap reporting findBest _ (rule,ans) [] = (rule,ans) diff --git a/compiler/typecheck/FamInst.hs b/compiler/typecheck/FamInst.hs index 94bc43f862..956a412baf 100644 --- a/compiler/typecheck/FamInst.hs +++ b/compiler/typecheck/FamInst.hs @@ -394,7 +394,7 @@ checkFamInstConsistency directlyImpMods -- type family F a -- -- When typechecking A, we are NOT allowed to poke the TyThing - -- for for F until we have typechecked the family. Thus, we + -- for F until we have typechecked the family. Thus, we -- can't do consistency checking for the instance in B -- (checkFamInstConsistency is called during renaming). -- Failing to defer the consistency check lead to #11062. diff --git a/compiler/typecheck/TcBinds.hs b/compiler/typecheck/TcBinds.hs index 8e7f6dc391..6189ba51d2 100644 --- a/compiler/typecheck/TcBinds.hs +++ b/compiler/typecheck/TcBinds.hs @@ -140,7 +140,7 @@ If we don't take care, after typechecking we get in \ys:[a] -> ...f'... -Notice the the stupid construction of (f a d), which is of course +Notice the stupid construction of (f a d), which is of course identical to the function we're executing. In this case, the polymorphic recursion isn't being used (but that's a very common case). This can lead to a massive space leak, from the following top-level defn diff --git a/compiler/typecheck/TcCanonical.hs b/compiler/typecheck/TcCanonical.hs index 8a459de12f..1785b8be48 100644 --- a/compiler/typecheck/TcCanonical.hs +++ b/compiler/typecheck/TcCanonical.hs @@ -199,7 +199,7 @@ canClass ev cls tys pend_sc ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ We need to add superclass constraints for two reasons: -* For givens [G], they give us a route to to proof. E.g. +* For givens [G], they give us a route to proof. E.g. f :: Ord a => a -> Bool f x = x == x We get a Wanted (Eq a), which can only be solved from the superclass @@ -331,7 +331,7 @@ Examples of how adding superclasses can help: Follow the superclass rules to add [G] F a ~ b [D] F a ~ beta - Now we we get [D] beta ~ b, and can solve that. + Now we get [D] beta ~ b, and can solve that. -- Example (tcfail138) class L a b | a -> b diff --git a/compiler/typecheck/TcEnv.hs b/compiler/typecheck/TcEnv.hs index eac6d9fbc5..34a9dd7c21 100644 --- a/compiler/typecheck/TcEnv.hs +++ b/compiler/typecheck/TcEnv.hs @@ -469,7 +469,7 @@ tcExtendLetEnv top_lvl sig_fn (IsGroupClosed fvs fv_type_closed) tcExtendIdEnv :: [TcId] -> TcM a -> TcM a -- For lambda-bound and case-bound Ids --- Extends the the TcBinderStack as well +-- Extends the TcBinderStack as well tcExtendIdEnv ids thing_inside = tcExtendIdEnv2 [(idName id, id) | id <- ids] thing_inside diff --git a/compiler/typecheck/TcErrors.hs b/compiler/typecheck/TcErrors.hs index 0e213be585..3ba2180826 100644 --- a/compiler/typecheck/TcErrors.hs +++ b/compiler/typecheck/TcErrors.hs @@ -245,7 +245,7 @@ idea is that the main msg ('report_important') varies depending on the error in question, but context and relevant bindings are always the same, which should simplify visual parsing. -The context is added when the the Report is passed off to 'mkErrorReport'. +The context is added when the Report is passed off to 'mkErrorReport'. Unfortunately, unlike the context, the relevant bindings are added in multiple places so they have to be in the Report. -} @@ -383,7 +383,7 @@ reportImplic ctxt implic@(Implic { ic_skols = tvs, ic_given = given , cec_suppress = insoluble || cec_suppress ctxt -- Suppress inessential errors if there - -- are are insolubles anywhere in the + -- are insolubles anywhere in the -- tree rooted here, or we've come across -- a suppress-worthy constraint higher up (Trac #11541) diff --git a/compiler/typecheck/TcFlatten.hs b/compiler/typecheck/TcFlatten.hs index ff4195c289..c4fc1df6f7 100644 --- a/compiler/typecheck/TcFlatten.hs +++ b/compiler/typecheck/TcFlatten.hs @@ -1417,7 +1417,7 @@ flatten_tyvar2 tv fr@(_, eq_rel) Note [An alternative story for the inert substitution] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ (This entire note is just background, left here in case we ever want - to return the the previous state of affairs) + to return the previous state of affairs) We used (GHC 7.8) to have this story for the inert substitution inert_eqs diff --git a/compiler/typecheck/TcInstDcls.hs b/compiler/typecheck/TcInstDcls.hs index 77522c55ab..6580758788 100644 --- a/compiler/typecheck/TcInstDcls.hs +++ b/compiler/typecheck/TcInstDcls.hs @@ -990,7 +990,7 @@ Notice that into *every* method or superclass definition. (Some of it will be usused in some, but dead-code elimination will drop it.) - We achieve this by putting the the evidence variable for the overall + We achieve this by putting the evidence variable for the overall instance implication into the AbsBinds for each method/superclass. Hence the 'dfun_ev_binds' passed into tcMethods and tcSuperClasses. (And that in turn is why the abs_ev_binds field of AbBinds is a @@ -1546,7 +1546,7 @@ Wow! Three nested AbsBinds! * The middle one is only present if there is an instance signature, and does the impedance matching for that signature * The inner one is for the method binding itself against either the - signature from the class, or the the instance signature. + signature from the class, or the instance signature. -} ---------------------- diff --git a/compiler/typecheck/TcInteract.hs b/compiler/typecheck/TcInteract.hs index 8cfb65e151..324b88c090 100644 --- a/compiler/typecheck/TcInteract.hs +++ b/compiler/typecheck/TcInteract.hs @@ -470,7 +470,7 @@ But this isn't quite true. Suppose we have, c1: [W] beta ~ [alpha], c2 : [W] blah, c3 :[W] alpha ~ Int After processing the first two, we get c1: [G] beta ~ [alpha], c2 : [W] blah -Now, c3 does not interact with the the given c1, so when we spontaneously +Now, c3 does not interact with the given c1, so when we spontaneously solve c3, we must re-react it with the inert set. So we can attempt a reaction between inert c2 [W] and work-item c3 [G]. diff --git a/compiler/typecheck/TcRnDriver.hs b/compiler/typecheck/TcRnDriver.hs index 6ae299b79a..9fbe05378e 100644 --- a/compiler/typecheck/TcRnDriver.hs +++ b/compiler/typecheck/TcRnDriver.hs @@ -1850,7 +1850,7 @@ runTcInteractive hsc_env thing_inside {- Note [Initialising the type environment for GHCi] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -Most of the the Ids in ic_things, defined by the user in 'let' stmts, +Most of the Ids in ic_things, defined by the user in 'let' stmts, have closed types. E.g. ghci> let foo x y = x && not y diff --git a/compiler/typecheck/TcSMonad.hs b/compiler/typecheck/TcSMonad.hs index 0d936ff650..5755fa1f2e 100644 --- a/compiler/typecheck/TcSMonad.hs +++ b/compiler/typecheck/TcSMonad.hs @@ -1828,7 +1828,7 @@ getUnsolvedInerts -- For CFunEqCans we ignore the Derived ones, and keep -- only the Wanteds for flattening. The Derived ones -- share a unification variable with the corresponding - -- Wanted, so we definitely don't want to to participate + -- Wanted, so we definitely don't want to participate -- in unflattening -- See Note [Type family equations] add_if_wanted ct cts | isWantedCt ct = ct `consCts` cts diff --git a/compiler/typecheck/TcSigs.hs b/compiler/typecheck/TcSigs.hs index 1c0affc133..5d95503b07 100644 --- a/compiler/typecheck/TcSigs.hs +++ b/compiler/typecheck/TcSigs.hs @@ -289,7 +289,7 @@ Once we get to type checking, we decompose it into its parts, in tcPatSynSig. * Note that 'forall univ_tvs' and 'req_theta =>' and 'forall ex_tvs' and 'prov_theta =>' - are all optional. We gather the pieces at the the top of tcPatSynSig + are all optional. We gather the pieces at the top of tcPatSynSig * Initially the implicitly-bound tyvars (added by the renamer) include both universal and existential vars. diff --git a/compiler/typecheck/TcTyDecls.hs b/compiler/typecheck/TcTyDecls.hs index 6b77cc7b7b..87fab6f7fd 100644 --- a/compiler/typecheck/TcTyDecls.hs +++ b/compiler/typecheck/TcTyDecls.hs @@ -783,7 +783,7 @@ mkDefaultMethodType cls _ (GenericDM dm_ty) = mkSigmaTy tv_bndrs [pred] dm_ty -- NB: the Class doesn't have TyConBinders; we reach into its -- TyCon to get those. We /do/ need the TyConBinders because -- we need the correct visibility: these default methods are - -- used in code generated by the the fill-in for missing + -- used in code generated by the fill-in for missing -- methods in instances (TcInstDcls.mkDefMethBind), and -- then typechecked. So we need the right visibilty info -- (Trac #13998) diff --git a/compiler/typecheck/TcTypeNats.hs b/compiler/typecheck/TcTypeNats.hs index 051f9985e6..04b51a46f2 100644 --- a/compiler/typecheck/TcTypeNats.hs +++ b/compiler/typecheck/TcTypeNats.hs @@ -862,7 +862,7 @@ rootExact x y = do (z,True) <- genRoot x y -{- | Compute the the n-th root of a natural number, rounded down to +{- | Compute the n-th root of a natural number, rounded down to the closest natural number. The boolean indicates if the result is exact (i.e., True means no rounding was done, False means rounded down). The second argument specifies which root we are computing. -} diff --git a/compiler/typecheck/TcUnify.hs b/compiler/typecheck/TcUnify.hs index 0b2151b8e1..ca5396bc57 100644 --- a/compiler/typecheck/TcUnify.hs +++ b/compiler/typecheck/TcUnify.hs @@ -910,7 +910,7 @@ has the ir_inst flag. f :: forall {a}. a -> forall b. Num b => b -> b -> b This is surely confusing for users. - And worse, the the monomorphism restriction won't properly. The MR is + And worse, the monomorphism restriction won't properly. The MR is dealt with in simplifyInfer, and simplifyInfer has no way of instantiating. This could perhaps be worked around, but it may be hard to know even when instantiation should happen. diff --git a/compiler/types/FamInstEnv.hs b/compiler/types/FamInstEnv.hs index 9918a75faa..bb0da84ca7 100644 --- a/compiler/types/FamInstEnv.hs +++ b/compiler/types/FamInstEnv.hs @@ -511,7 +511,7 @@ go back to all previous equations and check that, under the substitution induced by the match, other branches are surely apart. (See Note [Apartness].) This is similar to what happens with class instance selection, when we need to guarantee that there is only a match and -no unifiers. The exact algorithm is different here because the the +no unifiers. The exact algorithm is different here because the potentially-overlapping group is closed. As another example, consider this: diff --git a/docs/ghci/ghci.tex b/docs/ghci/ghci.tex index e4fbb0b771..e102cdadd9 100644 --- a/docs/ghci/ghci.tex +++ b/docs/ghci/ghci.tex @@ -122,7 +122,7 @@ visibility. Subsequent sections elaborate who can see what. is @compile@'s private cache of information about package modules. \item {\bf Persistent Linker State (PLS)} (owner: @link@) is - @link@'s private information concerning the the current + @link@'s private information concerning the current state of the (in-memory) executable image. \end{itemize} diff --git a/docs/rts/rts.tex b/docs/rts/rts.tex index 4337bb1f8e..2260b079d1 100644 --- a/docs/rts/rts.tex +++ b/docs/rts/rts.tex @@ -2049,7 +2049,7 @@ The only label associated with a thunk is its info table: \Subsubsection{Byte-code objects}{BCO} -A Byte-Code Object (BCO) is a container for a a chunk of byte-code, +A Byte-Code Object (BCO) is a container for a chunk of byte-code, which can be executed by Hugs. The byte-code represents a supercombinator in the program: when Hugs compiles a module, it performs lambda lifting and each resulting supercombinator becomes a diff --git a/docs/users_guide/glasgow_exts.rst b/docs/users_guide/glasgow_exts.rst index 6c444cc873..603dbc5eb9 100644 --- a/docs/users_guide/glasgow_exts.rst +++ b/docs/users_guide/glasgow_exts.rst @@ -3583,7 +3583,7 @@ declaration, to generate a standard instance declaration for specified class. GHC extends this mechanism along several axes: * The derivation mechanism can be used separtely from the data type - declaration, using the the `standalone deriving mechanism + declaration, using the `standalone deriving mechanism <#stand-alone-deriving>`__. * In Haskell 98, the only derivable classes are ``Eq``, @@ -6326,7 +6326,7 @@ Overlapping instances In general, as discussed in :ref:`instance-resolution`, *GHC requires that it be unambiguous which instance declaration should be used to -resolve a type-class constraint*. GHC also provides a way to to loosen +resolve a type-class constraint*. GHC also provides a way to loosen the instance resolution, by allowing more than one instance to match, *provided there is a most specific one*. Moreover, it can be loosened further, by allowing more than one instance to match irrespective of @@ -7243,7 +7243,7 @@ defaults to ``*`` if omitted. An example is :: Parameters can also be given explicit kind signatures if needed. We call the number of parameters in a type family declaration, the family's arity, and all applications of a type family must be fully saturated -with respect to to that arity. This requirement is unlike ordinary type synonyms +with respect to that arity. This requirement is unlike ordinary type synonyms and it implies that the kind of a type family is not sufficient to determine a family's arity, and hence in general, also insufficient to determine whether a type family application is well formed. As an diff --git a/libraries/base/GHC/IO.hs b/libraries/base/GHC/IO.hs index 118ebeaeed..8d69b707e1 100644 --- a/libraries/base/GHC/IO.hs +++ b/libraries/base/GHC/IO.hs @@ -334,7 +334,7 @@ onException io what = io `catchException` \e -> do _ <- what -- 'MaskedInterruptible' state, -- use @mask_ $ forkIO ...@. This is particularly useful if you need -- to establish an exception handler in the forked thread before any --- asynchronous exceptions are received. To create a a new thread in +-- asynchronous exceptions are received. To create a new thread in -- an unmasked state use 'Control.Concurrent.forkIOWithUnmask'. -- mask :: ((forall a. IO a -> IO a) -> IO b) -> IO b diff --git a/libraries/base/GHC/MVar.hs b/libraries/base/GHC/MVar.hs index d367f2ba06..f334ddb48c 100644 --- a/libraries/base/GHC/MVar.hs +++ b/libraries/base/GHC/MVar.hs @@ -38,7 +38,7 @@ data MVar a = MVar (MVar# RealWorld a) {- ^ An 'MVar' (pronounced \"em-var\") is a synchronising variable, used for communication between concurrent threads. It can be thought of -as a a box, which may be empty or full. +as a box, which may be empty or full. -} -- pull in Eq (Mvar a) too, to avoid GHC.Conc being an orphan-instance module diff --git a/libraries/base/tests/memo001.hs b/libraries/base/tests/memo001.hs index 551bcd8cf4..bb43dd0cd4 100644 --- a/libraries/base/tests/memo001.hs +++ b/libraries/base/tests/memo001.hs @@ -12,7 +12,7 @@ testMemo = do -- mlength will memoize itself over each element of 'keys', returning -- the memoized result the second time around. Then we move onto -- keys2, and while we're doing this the first lot of memo table --- entries can be purged. Finally, we do a a large computation +-- entries can be purged. Finally, we do a large computation -- (length [1..10000]) to allow time for the memo table to be fully -- purged. diff --git a/libraries/ghc-prim/cbits/ctz.c b/libraries/ghc-prim/cbits/ctz.c index 95f327a919..fc98716968 100644 --- a/libraries/ghc-prim/cbits/ctz.c +++ b/libraries/ghc-prim/cbits/ctz.c @@ -36,7 +36,7 @@ hs_ctz64(StgWord64 x) get inlined by GCC but rather a short `__ctzdi2` runtime function is inserted when needed into compiled object files. - This workaround forces GCC on 32bit x86 to to express `hs_ctz64` in + This workaround forces GCC on 32bit x86 to express `hs_ctz64` in terms of the 32bit `__builtin_ctz()` (this is no loss, as there's no 64bit BSF instruction on i686 anyway) and thus avoid the problematic out-of-line runtime function. diff --git a/libraries/integer-simple/GHC/Integer/Type.hs b/libraries/integer-simple/GHC/Integer/Type.hs index cabdfe5a53..b46eda184a 100644 --- a/libraries/integer-simple/GHC/Integer/Type.hs +++ b/libraries/integer-simple/GHC/Integer/Type.hs @@ -781,7 +781,7 @@ quotRemPositive :: Positive -> Positive -> (# Integer, Integer #) else Cons (ys `smallShiftLPositive` n) (mkSubtractors (n -# 1#)) - -- The main function. Go the the end of xs, then walk + -- The main function. Go the end of xs, then walk -- back trying to divide the number we accumulate by ys. f :: Positive -> (# Digits, Digits #) f None = (# None, None #) diff --git a/rts/Apply.cmm b/rts/Apply.cmm index ffcd0352a1..15d8250f52 100644 --- a/rts/Apply.cmm +++ b/rts/Apply.cmm @@ -537,7 +537,7 @@ now have, │ etc. │ Now consider what happens when TSO 1 runs its duplicate-computation check. -Again, we start walking the stack from the top, where we we find the update +Again, we start walking the stack from the top, where we find the update frame updating THUNK A. We will lock this thunk, replacing it with a BLACKHOLE owned by its TSO. We now have, diff --git a/rts/PrimOps.cmm b/rts/PrimOps.cmm index 1dad14bc1b..2b3a304d06 100644 --- a/rts/PrimOps.cmm +++ b/rts/PrimOps.cmm @@ -260,7 +260,7 @@ stg_newArrayzh ( W_ n /* words */, gcptr init ) StgMutArrPtrs_ptrs(arr) = n; StgMutArrPtrs_size(arr) = size; - // Initialise all elements of the the array with the value in R2 + // Initialise all elements of the array with the value in R2 p = arr + SIZEOF_StgMutArrPtrs; for: if (p < arr + SIZEOF_StgMutArrPtrs + WDS(n)) { @@ -423,7 +423,7 @@ stg_newSmallArrayzh ( W_ n /* words */, gcptr init ) SET_HDR(arr, stg_SMALL_MUT_ARR_PTRS_DIRTY_info, CCCS); StgSmallMutArrPtrs_ptrs(arr) = n; - // Initialise all elements of the the array with the value in R2 + // Initialise all elements of the array with the value in R2 p = arr + SIZEOF_StgSmallMutArrPtrs; for: if (p < arr + SIZEOF_StgSmallMutArrPtrs + WDS(n)) { diff --git a/rts/StgCRun.c b/rts/StgCRun.c index 2166249c2a..176e64ca98 100644 --- a/rts/StgCRun.c +++ b/rts/StgCRun.c @@ -766,7 +766,7 @@ StgRun(StgFunPtr f, StgRegTable *basereg) { /* * Save callee-saves registers on behalf of the STG code. * Floating point registers only need the bottom 64 bits preserved. - * We need to use the the names x16, x17, x29 and x30 instead of ip0 + * We need to use the names x16, x17, x29 and x30 instead of ip0 * ip1, fp and lp because one of either clang or gcc doesn't understand * the later names. */ diff --git a/rts/ThreadPaused.c b/rts/ThreadPaused.c index d01be291d3..7ade0a64c5 100644 --- a/rts/ThreadPaused.c +++ b/rts/ThreadPaused.c @@ -149,7 +149,7 @@ stackSqueeze(Capability *cap, StgTSO *tso, StgPtr bottom) // | ********* | // -| ********* | // - // 'sp' points the the current top-of-stack + // 'sp' points the current top-of-stack // 'gap' points to the stack_gap structure inside the gap // ***** indicates real stack data // ..... indicates gap diff --git a/testsuite/tests/indexed-types/should_compile/PushedInAsGivens.hs b/testsuite/tests/indexed-types/should_compile/PushedInAsGivens.hs index 78f45f5f45..4537d3a21c 100644 --- a/testsuite/tests/indexed-types/should_compile/PushedInAsGivens.hs +++ b/testsuite/tests/indexed-types/should_compile/PushedInAsGivens.hs @@ -15,7 +15,7 @@ bar y = let foo :: (F Int ~ [a]) => a -> Int -- an unsolved wanted as a given and not a given/solved. -- [Wanted] F Int ~ [beta] --- forall a. F Int ~ [a] => a ~ beta --- We we push in the [Wanted] as given, it will interact and solve the implication +-- We push in the [Wanted] as given, it will interact and solve the implication -- constraint, and finally we quantify over F Int ~ [beta]. If we push it in as -- Given/Solved, it will be discarded when we meet the given (F Int ~ [a]) and -- we will not be able to solve the implication constraint. |