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

Typos in non-code

parent cb9a1e68
......@@ -747,7 +747,7 @@ substTickish _subst other = other
{- Note [Substitute lazily]
~~~~~~~~~~~~~~~~~~~~~~~~~~~
The functions that substitute over IdInfo must be pretty lazy, becuause
The functions that substitute over IdInfo must be pretty lazy, because
they are knot-tied by substRecBndrs.
One case in point was Trac #10627 in which a rule for a function 'f'
......
......@@ -785,7 +785,7 @@ buildSize :: ExprSize
buildSize = SizeIs 0 emptyBag 40
-- We really want to inline applications of build
-- build t (\cn -> e) should cost only the cost of e (because build will be inlined later)
-- Indeed, we should add a result_discount becuause build is
-- Indeed, we should add a result_discount because build is
-- very like a constructor. We don't bother to check that the
-- build is saturated (it usually is). The "-2" discounts for the \c n,
-- The "4" is rather arbitrary.
......
......@@ -327,7 +327,7 @@ Usually we want the former, but occasionally the latter.
mkCoreVarTup :: [Id] -> CoreExpr
mkCoreVarTup ids = mkCoreTup (map Var ids)
-- | Bulid the type of a small tuple that holds the specified variables
-- | Build the type of a small tuple that holds the specified variables
-- One-tuples are flattened; see Note [Flattening of one-tuples]
mkCoreVarTupTy :: [Id] -> Type
mkCoreVarTupTy ids = mkBoxedTupleTy (map idType ids)
......
......@@ -525,7 +525,7 @@ schemeE d s p (AnnCase scrut bndr _ [(DataAlt dc, [bind1, bind2], rhs)])
-- case .... of x { (# V'd-thing, a #) -> ... }
-- to
-- case .... of a { DEFAULT -> ... }
-- becuse the return convention for both are identical.
-- because the return convention for both are identical.
--
-- Note that it does not matter losing the void-rep thing from the
-- envt (it won't be bound now) because we never look such things up.
......
......@@ -526,7 +526,7 @@ $tab { warnTab }
-- expressions and patterns use the same parser, and also because we want
-- to allow type patterns within expression patterns.
--
-- Disambiguation is accomplished by requiring *something* to appear betwen
-- Disambiguation is accomplished by requiring *something* to appear between
-- type application and the preceding token. This something must end with
-- a character that cannot be the end of the variable bound in an as-pattern.
-- Currently (June 2015), this means that the something cannot end with a
......
......@@ -353,7 +353,7 @@ We never eta-expand a thunk in a recursive group, on the grounds that if it is
part of a recursive group, then it will be called multipe times.
This is not necessarily true, e.g. it would be safe to eta-expand t2 (but not
t1) in the follwing code:
t1) in the following code:
let go x = t1
t1 = if ... then t2 else ...
......
......@@ -117,7 +117,7 @@ occurAnalyseExpr' enable_binder_swap expr
{- Note [Plugin rules]
~~~~~~~~~~~~~~~~~~~~~~
Conal Eliot (Trac #11651) built a GHC plugin that added some
Conal Elliott (Trac #11651) built a GHC plugin that added some
BuiltinRules (for imported Ids) to the mg_rules field of ModGuts, to
do some domain-specific transformations that could not be expressed
with an ordinary pattern-matching CoreRule. But then we can't extract
......
......@@ -1146,7 +1146,7 @@ zap_demand_info v
Note [Zapping the demand info]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
VERY IMPORTANT: we must zap the demand info if the thing is going to
float out, becuause it may be less demanded than at its original
float out, because it may be less demanded than at its original
binding site. Eg
f :: Int -> Int
f x = let v = 3*4 in v+x
......
......@@ -1764,7 +1764,7 @@ Note [Strictness information in worker binders]
After having calculated the strictness annotation for the worker (see Note
[Transfer strictness] above), we also want to have this information attached to
the worker’s arguments, for the benefit of later passes. The function
handOutStrictnessInformation decomposes the stricntess annotation calculated by
handOutStrictnessInformation decomposes the strictness annotation calculated by
calcSpecStrictness and attaches them to the variables.
************************************************************************
......
......@@ -1214,7 +1214,7 @@ tcArgs fun orig_fun_ty fun_orig orig_args herald
tcArg :: LHsExpr Name -- The function (for error messages)
-> LHsExpr Name -- Actual arguments
-> TcRhoType -- expected arg type
-> Int -- # of arugment
-> Int -- # of argument
-> TcM (LHsExpr TcId) -- Resulting argument
tcArg fun arg ty arg_no = addErrCtxt (funAppCtxt fun arg arg_no) $
tcPolyExprNC arg ty
......
......@@ -499,8 +499,8 @@ In type declarations:
* Invisible (k1), Specified (k)
data T a b (c :: k) = MkT (a b) (Proxy c)
Here T's kind is T :: forall {k1:*} (k:*). (k1->*) -> k1 -> k -> *
So 'k' is Specified, becuase it appears explicitly,
but 'k1' is Invisible, becuase it does not
So 'k' is Specified, because it appears explicitly,
but 'k1' is Invisible, because it does not
---- Printing -----
......
......@@ -139,7 +139,7 @@ application of a let-no-escape variable.
\gram{\ottret}
Values $v$ are functions (re-entrant closures) and constructors; thunks
are not considered vaules. Evaluation guarantees that a value will be
are not considered values. Evaluation guarantees that a value will be
produced.
Profiling also records allocation costs for creating objects on the heap:
......
......@@ -4301,7 +4301,7 @@ all currently bundled constructors. For example, we could write: ::
in which case, ``Example`` would export the type constructor ``MyNum`` with
the data constructor ``MkNum`` and also the pattern synonym ``Zero``.
Bundled patterns synoyms are type checked to ensure that they are of the same
Bundled patterns synonyms are type checked to ensure that they are of the same
type as the type constructor which they are bundled with. A pattern synonym
``P`` can not be bundled with a type constructor ``T`` if ``P``\'s type is visibly
incompatible with ``T``.
......
......@@ -53,7 +53,7 @@ main = do
-- anything xored with itself is 0
print (I# (maxI# `xorI#` maxI#) == 0)
print (I# (minI# `xorI#` minI#) == 0)
-- xoring with -1 is like bitwise negation (becuse -1 has all bits set to 1)
-- xoring with -1 is like bitwise negation (because -1 has all bits set to 1)
print (I# (minI# `xorI#` -1#) == maxI)
print (I# (maxI# `xorI#` -1#) == minI)
print (I# (-1# `xorI#` minI#) == maxI)
......
{-# LANGUAGE MultiParamTypeClasses, FunctionalDependencies,
FlexibleInstances, TypeSynonymInstances #-}
-- This one made GHC 6.4 loop becuause Unify.unify
-- This one made GHC 6.4 loop because Unify.unify
-- didn't deal correctly with unifying
-- a :=: Foo a
-- where
......
......@@ -35,7 +35,7 @@ instance M.Monad T1 where
(>>) = undefined
----------------------------------------------------------------------------
-- backward compat canonical defintion
-- backward compat canonical definition
data T2 a = T2 a deriving Functor
......
......@@ -43,7 +43,7 @@ instance MF.MonadFail T1 where
fail = M.fail
----------------------------------------------------------------------------
-- backward compat canonical defintion
-- backward compat canonical definition
data T2 a = T2 a deriving Functor
......
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