- lint
# We allow the submodule checker to fail when run on merge requests (to
-# accomodate, e.g., haddock changes not yet upstream) but not on `master` or
+# accommodate, e.g., haddock changes not yet upstream) but not on `master` or
# Marge jobs.
.lint-submods:
<<: *only-default
| otherwise = doc
startsWithUnderscore :: OccName -> Bool
--- ^ Haskell 98 encourages compilers to suppress warnings about unsed
+-- ^ Haskell 98 encourages compilers to suppress warnings about unused
-- names in a pattern if they start with @_@: this implements that test
startsWithUnderscore occ = headFS (occNameFS occ) == '_'
We have a CFG with edge weights based on which we try to place blocks next to
each other.
- Edge weights not only represent likelyhood of control transfer between blocks
+ Edge weights not only represent likelihood of control transfer between blocks
but also how much a block would benefit from being placed sequentially after
it's predecessor.
For example blocks which are preceded by an info table are more likely to end
_ -> case x of
CmmLit (CmmInt imm _)
| Just _ <- makeImmediate rep True imm
- -- subfi ('substract from' with immediate) doesn't exist
+ -- subfi ('subtract from' with immediate) doesn't exist
-> trivialCode rep True SUBFC y x
_ -> trivialCodeNoImm' (intFormat rep) SUBF y x
-- a! b -- a suffix occurrence
--
-- The rules are a bit more elaborate than simply checking for whitespace, in
--- order to accomodate the following use cases:
+-- order to accommodate the following use cases:
--
-- f (!a) = ... -- prefix occurrence
-- g (a !) -- loose infix occurrence
{- Note [PatBuilder]
~~~~~~~~~~~~~~~~~~~~
-Unlike HsExpr or HsCmd, the Pat type cannot accomodate all intermediate forms,
+Unlike HsExpr or HsCmd, the Pat type cannot accommodate all intermediate forms,
so we introduce the notion of a PatBuilder.
Consider a pattern like this:
from the 'integer' library. These are handled by rule_shift_op,
and match_Integer_shift_op.
- Here we could in principle shift by any amount, but we arbitary
+ Here we could in principle shift by any amount, but we arbitrary
limit the shift to 4 bits; in particular we do not want shift by a
huge amount, which can happen in code like that above.
the type synonym S. While we know that S depends upon 'Q depends upon Closed,
we have no idea that Closed depends upon Open!
- To accomodate for these situations, we ensure that an instance is checked
+ To accommodate for these situations, we ensure that an instance is checked
before every @TyClDecl@ on which it does not depend. That's to say, instances
are checked as early as possible in @tcTyAndClassDecls@.
interesting :: InterestingVarFun
interesting v = isLocalVar v || (isId v && isDFunId v)
-- Very important: include DFunIds /even/ if it is imported
- -- Reason: See Note [Avoiding loops], the second exmaple
+ -- Reason: See Note [Avoiding loops], the second example
-- involving an imported dfun. We must know whether
-- a dictionary binding depends on an imported dfun,
-- in case we try to specialise that imported dfun
{-
Note [Auxiliary binders]
~~~~~~~~~~~~~~~~~~~~~~~~
-We often want to make a top-level auxiliary binding. E.g. for comparison we haev
+We often want to make a top-level auxiliary binding. E.g. for comparison we have
instance Ord T where
compare a b = $con2tag a `compare` $con2tag b
Note [reduceNodesIntoVertices implementations]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
reduceNodesIntoVertices is parameterized by the container type.
-This is to accomodate key types that don't have an Ord instance
+This is to accommodate key types that don't have an Ord instance
and hence preclude the use of Data.Map. An example of such type
would be Unique, there's no way to implement Ord Unique
deterministically.
laid out in \verb|Note [Invariants on join points]| in
\ghcfile{coreSyn/CoreSyn.hs}:
\begin{enumerate}
- \item All occurences must be tail calls. This is enforced in our typing
+ \item All occurrences must be tail calls. This is enforced in our typing
rules using the label environment $[[D]]$.
\item Each join point has a \emph{join arity}. In this document, we write
each label as $[[p/I_t]]$ for the name $[[p]]$, the type $[[t]]$, and the
source-language features of
\emph{GADTs}~\cite{cheney-hinze:phantom-types,sheard:omega,spj+:gadt}
and \emph{type families}~\cite{Kiselyov09funwith,chak+:synonyms}.
-The key feature that allows System FC to accomodate GADTs and type
+The key feature that allows System FC to accommodate GADTs and type
families is its use of explicit \emph{coercions} that witness the
equality of two syntactically-different types. Coercions are erased
before runtime but, like types, serve as a static consistency
\gram{\ottheap}
-Execution procedes until a return value (a literal or a variable, i.e.
+Execution proceeds until a return value (a literal or a variable, i.e.
pointer to the heap) is produced. To accommodate for let-no-escape
bindings, we also allow execution to terminate with a jump to a function
application of a let-no-escape variable.
For this reason we should be cautious when interpreting the source locations
provided by GDB. While these locations will usually be in some sense
- "correct", they aren't always useful. This is why profiling tools targetting
+ "correct", they aren't always useful. This is why profiling tools targeting
Haskell should supplement the standard source location information with
GHC-specific annotations (emitted with ``-g2``) when assigning costs.
type: git
location: https://gitlab.haskell.org/ghc/ghc
--- To accomodate #16873
+-- To accommodate #16873
flag threaded
manual: True
default: True
-- | Get the directory name for binary distribution files
-- @<arch>-<os>-ghc-<version>@.
--
--- We preform some renaming to accomodate Cabal's slightly different naming
+-- We preform some renaming to accommodate Cabal's slightly different naming
-- conventions (see 'cabalOsString' and 'cabalArchString').
distDir :: Stage -> Action FilePath
distDir st = do
needed. We use a higher-order accumulation trick to mediate between
left-associative constructor application vs. right-associative binary
operation (e.g., @(:)@). When the query is meant to compute a value
-of type @r@, then the result type withing generic folding is @r -> r@.
+of type @r@, then the result type within generic folding is @r -> r@.
So the result of folding is a function to which we finally pass the
right unit.
allocation)
Allocation (in the case of a small request) consists of walking the nursery to
-find a page that will accomodate the request. If none exists then we allocate a
+find a page that will accommodate the request. If none exists then we allocate a
new nursery page (flushing an existing one to the filled list if the nursery is
full).
#if defined(darwin_HOST_OS)
// Without MAP_FIXED, Apple's mmap ignores addr.
- // With MAP_FIXED, it overwrites already mapped regions, whic
+ // With MAP_FIXED, it overwrites already mapped regions, which
// mmap(0, ... MAP_FIXED ...) is worst of all: It unmaps the program text
// and replaces it with zeroes, causing instant death.
// This behaviour seems to be conformant with IEEE Std 1003.1-2001.
// oldest_gen->scavenged_large_objects back to oldest_gen->large_objects.
ASSERT(oldest_gen->scavenged_large_objects == NULL);
if (RtsFlags.GcFlags.useNonmoving && major_gc) {
- // All threads in non-moving heap should be found to be alive, becuase
+ // All threads in non-moving heap should be found to be alive, because
// threads in the non-moving generation's list should live in the
// non-moving heap, and we consider non-moving objects alive during
// preparation.
* generation.
*
* - Note [Aging under the non-moving collector] (NonMoving.c) describes how
- * we accomodate aging
+ * we accommodate aging
*
* - Note [Large objects in the non-moving collector] (NonMovingMark.c)
* describes how we track large objects.
but can assume only two bits are available in STATIC_LINK (due to 32-bit
systems).
- To accomodate this we move handling of static objects entirely to the
+ To accommodate this we move handling of static objects entirely to the
oldest generation when the nonmoving collector is in use. To do this safely
and efficiently we allocate the blackhole created by lockCAF() directly in
the non-moving heap. This means that the moving collector can completely
# compiles but doesn't run
NOT_THESE += dmgob_native1 dmgob_native2
-# Native library doens't exist
+# Native library doesn't exist
ifneq "$(HWL_NOFIB_HACK)" ""
NOT_THESE += callback zhang_ccall
| head tag == '(' && take 2 (reverse tag) == ":)" && length rest > 1 =
getCurrColour `thenP` \ col ->
let
- invert Black r = r -- because the move has *already* happend
+ invert Black r = r -- because the move has *already* happened
invert _ "0.00" = "0.00" -- don't negate 0
invert _ ('-':r) = r
invert _ r = '-':r
{-# OPTIONS_GHC -fwarn-unsafe #-}
-- | Basic test to see if Safe warning flags compile
--- Warn if module is infered unsafe
+-- Warn if module is inferred unsafe
-- In this test the warning _should_ fire
module SafeFlags22 where
{-# OPTIONS_GHC -fwarn-unsafe -Werror #-}
-- | Basic test to see if Safe warning flags compile
--- Warn if module is infered unsafe
+-- Warn if module is inferred unsafe
-- In this test the warning _should_ fire and cause a compile fail
module SafeFlags22 where
{-# OPTIONS_GHC -fwarn-safe #-}
-- | Basic test to see if Safe warning flags compile
--- Warn if module is infered safe
+-- Warn if module is inferred safe
-- In this test the warning _shouldn't_ fire
module SafeFlags23 where
{-# OPTIONS_GHC -fwarn-safe #-}
-- | Basic test to see if Safe warning flags compile
--- Warn if module is infered safe
+-- Warn if module is inferred safe
-- In this test the warning _should_ fire
module SafeFlags25 where
{-# OPTIONS_GHC -fwarn-safe -Werror #-}
-- | Basic test to see if Safe warning flags compile
--- Warn if module is infered safe
+-- Warn if module is inferred safe
-- In this test the warning _should_ fire and cause a compile fail
module SafeFlags26 where
setTestOpts(f)
-# Tests that should compile fine as they should be infered safe
+# Tests that should compile fine as they should be inferred safe
test('SafeInfered01', [], multimod_compile, ['SafeInfered01', ''])
test('SafeInfered02', [], multimod_compile, ['SafeInfered02', ''])
test('SafeInfered03', [], multimod_compile, ['SafeInfered03', ''])
test('SafeInfered04', [], multimod_compile, ['SafeInfered04', ''])
test('SafeInfered05', [], multimod_compile, ['SafeInfered05', ''])
-# Tests that should fail to compile as they should be infered unsafe
+# Tests that should fail to compile as they should be inferred unsafe
test('UnsafeInfered01', [], multimod_compile_fail, ['UnsafeInfered01', ''])
test('UnsafeInfered02', [], multimod_compile_fail, ['UnsafeInfered02', ''])
test('UnsafeInfered03', [], multimod_compile_fail, ['UnsafeInfered03', ''])
{ datatype = dt
, conrep = cr
, constring = str
- , confields = error $ concat ["constrFields : ", (tycon dt), " is primative"]
+ , confields = error $ concat ["constrFields : ", (tycon dt), " is primitive"]
, confixity = error "constrFixity"
}
-- dll is 2^16-1, however Microsoft's lib.exe for some reason refuses to link
-- up to this amount. The reason is likely that it adds some extra symbols in
-- the generated dll, such as dllmain etc. So we reserve some space in the
--- symbol table to accomodate this. This number is just purely randomly chosen.
+-- symbol table to accommodate this. This number is just purely randomly chosen.
#define SYMBOL_PADDING 10
usage :: IO ()
mappend = (<>)
------------------------------------------------------------------------------
--- global color pallete
+-- global color palette
red,green,yellow :: String
red = "#f20913"
git.haskell.org / ghc.git / commitdiff
