Commit a100763c authored by Gabor Greif's avatar Gabor Greif 💬

Get rid of some stuttering in comments and docs

parent 244d1441
......@@ -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 _
--
......
......@@ -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,
......
......@@ -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
......
......@@ -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
......
......@@ -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
......
......@@ -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.
......
......@@ -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)
......
......@@ -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.
......
......@@ -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
......
......@@ -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
......
......@@ -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,
......
......@@ -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
......
......@@ -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
......
......@@ -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
......
......@@ -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'.
......
......@@ -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
......
......@@ -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
......
......@@ -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
......
......@@ -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.
......
......@@ -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
......
......@@ -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
......
......@@ -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
......
......@@ -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.
......
......@@ -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)
......
......@@ -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.
......
......@@ -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
......
......@@ -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
......
......@@ -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
......
......@@ -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)
......
......@@ -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
......
......@@ -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.
-}
----------------------
......
......@@ -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].
......
......@@ -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
......
......@@ -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
......
......@@ -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.
......
......@@ -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)
......
......@@ -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. -}
......
......@@ -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.
......
......@@ -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:
......
......@@ -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}
......
......@@ -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
......
......@@ -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
......
......@@ -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 new thread in
-- an unmasked state use 'Control.Concurrent.forkIOWithUnmask'.
--
mask :: ((forall a. IO a -> IO a) -> IO b) -> IO b
......
......@@ -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
......
......@@ -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.
......
......@@ -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.
......
......@@ -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 #)
......
......@@ -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,
......
......@@ -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)) {
......
......@@ -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.
*/
......
......@@ -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
......
......@@ -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.
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment