Skip to content

Commit 45ca8c8

Browse files
committed
fix typos
1 parent 4fe7d34 commit 45ca8c8

16 files changed

+60
-60
lines changed

S02-bits.pod

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -605,7 +605,7 @@ Certainly, it is difficult to give a unique name to every possible
605605
address space, let alone every possible address within every such
606606
a space. In the absence of a universal naming scheme, it can only
607607
be made improbable that two addresses from two different spaces will
608-
collide. A sufficently large random number may represent the current
608+
collide. A sufficiently large random number may represent the current
609609
address space on output of an C<ObjAt> to a different address space,
610610
or if serialized to YAML or XML. (This extra identity component
611611
need not be output for debugging messages that assume the current
@@ -699,7 +699,7 @@ C<Num> already, C<< infix:</> >> gives you a C<Num> instead of a C<Rat>.)
699699

700700
C<Rat> and C<Num> both do the C<Real> role.
701701

702-
Lower-case types like C<int> and C<num> imply the native
702+
Lowercase types like C<int> and C<num> imply the native
703703
machine representation for integers and floating-point numbers,
704704
respectively, and do not promote to arbitrary precision, though
705705
larger representations are always allowed for temporary values.
@@ -1560,7 +1560,7 @@ The following roles are supported:
15601560
KeyBag KeyHash[UInt]
15611561
KeyHash Associative
15621562
Pair Associative
1563-
PairSeq Associative Postional Iterable
1563+
PairSeq Associative Positional Iterable
15641564
Buf Stringy
15651565
IO
15661566
Routine Callable
@@ -4773,7 +4773,7 @@ and the rules that parse them, though the latter include an extra "sym":
47734773
infix:<cmp> # the infix cmp operator
47744774
infix:sym<cmp> # the rule that parses cmp
47754775

4776-
As you can see, the extention of the name uses colon pair notation.
4776+
As you can see, the extension of the name uses colon pair notation.
47774777
The C<:sym> typically takes an argument giving the string name of the
47784778
operator; some of the "circumfix" categories require two arguments
47794779
for the opening and closing strings. Since there are so many match
@@ -4787,7 +4787,7 @@ Conjecturally, we might also have other kinds of rules, such as tree rewrite rul
47874787
infix:ast<cmp> # rewrite an ast node after reducing its arguments
47884788

47894789
Within a grammar, matching the proto subrule <infix> will match all visible rules
4790-
in the infix category as parallel alteratives, as if they were separated by 'C<|>'.
4790+
in the infix category as parallel alternatives, as if they were separated by 'C<|>'.
47914791

47924792
Here are some of the names of parse rules in STD:
47934793

S03-operators.pod

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -2059,7 +2059,7 @@ Hence, to produce all octal numbers that fit in 16 bits, you can say:
20592059
'000000' ... '177777'
20602060

20612061
If the start string is shorter than the stop string, the strings are
2062-
assumed to be right justitifed, and the leftmost start character is
2062+
assumed to be right justified, and the leftmost start character is
20632063
duplicated when there is a carry:
20642064

20652065
'0' ... '177777' # same octal sequence, without leading 0's
@@ -2079,7 +2079,7 @@ both do exactly what the forward sequences do above, only in reverse.
20792079
As an extra special rule, that works in either direction, if the bottom
20802080
character is a '0' and the top character is alphanumeric, it is assumed
20812081
to be representing a number in some base up to base 36, where digits above ten
2082-
are represented by letters. Hence the seme sequences of 16-bit numbers, only in
2082+
are represented by letters. Hence the same sequences of 16-bit numbers, only in
20832083
hexadecimal, may be produced with:
20842084

20852085
'0000' ... 'ffff'
@@ -2101,7 +2101,7 @@ For instance, you can get away with ranges of capital Greek letters:
21012101
'ΑΑΑ' ... 'ΩΩΩ'
21022102

21032103
However, if you try it with the lowercase letters, you'll get both
2104-
forms of lower-case sigma, which you proably don't want. If there's
2104+
forms of lowercase sigma, which you probably don't want. If there's
21052105
only one or two letters you don't want, you can grep out those entries,
21062106
but in the general case, you need an incrementer that knows what sequence
21072107
you're interested in. Perhaps there can be a generic method,
@@ -3482,7 +3482,7 @@ Otherwise the min's type is used if it defines ordering, or if not,
34823482
the max's type. If neither min nor max have an ordering,
34833483
dispatch to .ACCEPTS fails. It may also fail if the ordering
34843484
in question does not have any way to coerce the object
3485-
being smartmatched into an appropropriate type implied by the
3485+
being smartmatched into an appropriate type implied by the
34863486
chosen domain of ordering.
34873487

34883488
In general, the domain of comparison should be a type that can

S04-control.pod

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -209,7 +209,7 @@ This is subtly different from Perl 5's behavior, which was to return
209209
the value of the last expression evaluated, even if that expression
210210
was just a conditional. Unlike in Perl 5, if a final statement in
211211
Perl 6 is a conditional that does not execute any of its branches, it
212-
doesn't matter what the value of the condional is, the value of that
212+
doesn't matter what the value of the conditional is, the value of that
213213
conditional statement is always C<Nil>. If there are no statements
214214
in the block at all, the result is also C<Nil>.
215215

@@ -1246,7 +1246,7 @@ As in Perl 5, many built-in functions simply return an undefined value
12461246
when you ask for a value out of range, or the function fails somehow.
12471247
Perl 6 has C<Failure> objects, known as "unthrown exceptions", which
12481248
know whether they have been handled or not. C<$!> is a convenient
1249-
link to the lastest failure, and only ever contains one exception, the
1249+
link to the last failure, and only ever contains one exception, the
12501250
most recent.
12511251

12521252
[Conjecture: all unhandled exceptions within a routine could be stored
@@ -1774,7 +1774,7 @@ In such cases, the package must be cloned as if it were a sub on entry to the
17741774
corresponding lexical scope. All runtime instances of a single package
17751775
declaration share the same set of compile-time declared functions, however,
17761776
the runtime instances can have different lexical environments as described in
1777-
the preceding paragraph. If multiple conflicting definitons of a sub exist
1777+
the preceding paragraph. If multiple conflicting definitions of a sub exist
17781778
for the same compile-time package, an error condition exists and behavior is
17791779
not specified for Perl 6.0.
17801780

@@ -1794,7 +1794,7 @@ possibly deferred.)
17941794
sub foo {
17951795
# conceptual cloning happens to both blocks below
17961796
my $x = 1;
1797-
my sub bar { print $x } # already conceptualy cloned, but can be lazily deferred
1797+
my sub bar { print $x } # already conceptually cloned, but can be lazily deferred
17981798
my &baz := { bar(); print $x }; # block is cloned immediately, forcing cloning of bar
17991799
my $code = &bar; # this would also force bar to be cloned
18001800
return &baz;

S05-regex.pod

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -474,7 +474,7 @@ which is the same as:
474474
m/(\d+)/ && m:c/(\d+)/ && s:c/(\d+)/@data[$0]/;
475475

476476
The argument to C<:nth> is allowed to be a list of integers, but such a list
477-
should be monotically increasing. (Values which are less than or equal to the previous
477+
should be monotonically increasing. (Values which are less than or equal to the previous
478478
value will be ignored.) So:
479479

480480

@@ -1783,7 +1783,7 @@ is rewritten as something like:
17831783

17841784
In the latter example we're assuming the DFA token matcher is going to
17851785
give us the longest match regardless. It's also possible that quantified
1786-
multichar sequences can be recursively remapped:
1786+
multi-character sequences can be recursively remapped:
17871787

17881788
<* 'ab'+> # match a, ab, ababa, etc. (but not aab!)
17891789
==> [ 'ab'* <*ab> ]
@@ -2070,7 +2070,7 @@ newline; it is the negation of C<\n>.
20702070
=item *
20712071

20722072
Other new capital backslash sequences are also the negations
2073-
of their lower-case counterparts:
2073+
of their lowercase counterparts:
20742074

20752075
=over
20762076

@@ -2695,7 +2695,7 @@ match begins with the first non-sigspace atom. This exception applies to
26952695
the rule itself as well, since any rule might participate in an alternation
26962696
higher in the grammar. And just to keep things simple, we say that the initial
26972697
whitespace in any regex before the first actual match is not subject to significance.
2698-
This includes any whitespace after a C<:sigspace>, if that declararation is the first
2698+
This includes any whitespace after a C<:sigspace>, if that declaration is the first
26992699
thing in the regex.
27002700

27012701
The initial token matcher must take into account case sensitivity

S06-routines.pod

Lines changed: 16 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -38,7 +38,7 @@ a thunk has no scope to declare a new variable. Note however that
3838
any and all lazy constructs, whether block-based or thunk-based,
3939
such as gather or async or C<< ==> >> should declare their own C<$/>
4040
and C<$!> so that the user's values for those variables cannot be
41-
clobbered asyncronously. And this parentheticl remark is starting to
41+
clobbered asynchronously. And this parenthetical remark is starting to
4242
be seriously misplaced...)
4343

4444
B<Subroutines> (keyword: C<sub>) are non-inheritable routines with
@@ -82,7 +82,7 @@ name within its scope, unless they have an explicit modifier.
8282
(This is particularly useful when adding to rule sets or when attempting
8383
to compose conflicting methods from roles.) Abstractly, the C<proto>
8484
is a generic wrapper around the dispatch to the C<multi>s. Each C<proto>
85-
is instantianted into an actual dispatcher for each scope that
85+
is instantiated into an actual dispatcher for each scope that
8686
needs a different candidate list.
8787

8888
B<Only> (keyword: C<only>) routines do not share their short names
@@ -1027,7 +1027,7 @@ calling its internal multi dispatcher (the one represented by C<{*}>).
10271027
In the case of a C<proto> sub, this mapping can be done at the point
10281028
of the call, since there can only be one possible set of positional
10291029
names, and the proto to be called can be known at compile time (in
1030-
the absense of CANDO declarations in the outer scopes). So after
1030+
the absence of CANDO declarations in the outer scopes). So after
10311031

10321032
proto foo ($x, $y, :$bar, :$baz) {*}
10331033
multi foo ($a, $b, :$bar, :$baz) {...}
@@ -1047,7 +1047,7 @@ The C<$x> and C<$y> names above are part of the public API only
10471047
because they are named in the C<proto>. Positional parameter names
10481048
are never part of the advertised API unless explicitly enabled.
10491049
An explicit C<proto> may easily refrain from advertising names by
1050-
declararing positionals with bare sigils:
1050+
declaring positionals with bare sigils:
10511051

10521052
proto foo ($, $, :$bar, :$baz) {*}
10531053
multi foo ($x, $y, :$bar, :$baz) {...}
@@ -1060,7 +1060,7 @@ if finer control is desired.)
10601060

10611061
It follows from all this that an intuited proto never has to worry
10621062
about supplying the API names of positional parameters. And no proto
1063-
ever has to worry about conficting names in the positionals of the
1063+
ever has to worry about conflicting names in the positionals of the
10641064
multis they dispatch to, since any remapping is handled before that.
10651065

10661066
=head2 List parameters
@@ -1286,7 +1286,7 @@ so C<self> is not present in the C<**@slice> below:
12861286

12871287
The C<**> marker is just a variant of the C<*> marker that ends up
12881288
requesting parcels when binding (underlyingly calling C<.getarg>) rather
1289-
than requesting individual elements as the flatening C<*> does (underlyingly
1289+
than requesting individual elements as the flattening C<*> does (underlyingly
12901290
calling C<.get>).
12911291

12921292
=head2 Zero-dimensional argument list
@@ -1532,7 +1532,7 @@ have "list" semantics. If you say
15321532
(0..2; 'a'..'c') ==> my @tmp;
15331533
for @tmp { .say }
15341534

1535-
then you get 0,1,2,'a','b','c'. If you have a multidim array, you
1535+
then you get 0,1,2,'a','b','c'. If you have a multidimensional array, you
15361536
can ask for flattening semantics explicitly with C<flat>:
15371537

15381538
(0..2; 'a'..'c') ==> my $tmp;
@@ -1897,7 +1897,7 @@ so C<$_> ends up being bound to the outer C<$_> anyway.)
18971897

18981898
A block may also refer to either C<@_> or C<%_> or both, each of
18991899
which will be added to generated signature as a normal readonly
1900-
slurpy pararmeter:
1900+
slurpy parameter:
19011901

19021902
{ say $:what; warn "bad option: $_\n" for keys %_; }
19031903

@@ -2061,7 +2061,7 @@ significant number of pathological cases that are unacceptably slow
20612061

20622062
This trait is a suggestion to the compiler that caching is okay. The
20632063
compiler is free to choose any kind of caching algorithm (including
2064-
non-expiring, random, lru, pseudo-lru, or adaptive algoritms, or
2064+
non-expiring, random, lru, pseudo-lru, or adaptive algorithms, or
20652065
even no caching algorithm at all). The run-time system is free to
20662066
choose any kind of maximum cache size depending on the availability
20672067
of memory and trends in usage patterns. You may suggest a particular
@@ -2086,7 +2086,7 @@ around your subroutine.
20862086

20872087
Specifies the precedence of an operator relative to an existing
20882088
operator. C<tighter> and C<looser> precedence levels default to
2089-
being left associative. They define a new precedence level slighty
2089+
being left associative. They define a new precedence level slightly
20902090
tighter or looser than the precedence level on which they're based.
20912091
Both C<tighter> and C<looser> may be specified, in which case the new
20922092
precedence level is generated midway between the specified levels.
@@ -2293,7 +2293,7 @@ to a readonly parameter never triggers autovivification.
22932293
Specifies that the parameter can be modified (assigned to, incremented,
22942294
etc). Requires that the corresponding argument is an lvalue or can be
22952295
converted to one. Since this option forces an argument to be required,
2296-
it cannot co-exist with the C<?> mark to make an argument optional.
2296+
it cannot coexist with the C<?> mark to make an argument optional.
22972297
(It may, however, be used with C<=> indicating a default, but only
22982298
if the default expression represents something that is nameable at
22992299
compile time and that can bind as an lvalue, such as
@@ -2326,7 +2326,7 @@ happens, it happens at the point of use, not at the point of binding.
23262326

23272327
For better visual distinction, such a parameter is declared by
23282328
prefixing with a backslash rather than by using C<is parcel> directly.
2329-
The backslash is also more succint; the trait is there primarily
2329+
The backslash is also more succinct; the trait is there primarily
23302330
for introspection.
23312331

23322332
=item C<is copy>
@@ -2524,13 +2524,13 @@ in order, left to right. Note that C<Any> and C<0> are no-ops:
25242524
$ctx = callframe(1); # my frame's caller
25252525
$ctx = callframe(2); # my frame's caller's caller
25262526
$ctx = callframe(3); # my frame's caller's caller's caller
2527-
$ctx = callframe(1,0,1,1); # my frames's caller's caller's caller
2527+
$ctx = callframe(1,0,1,1); # my frame's caller's caller's caller
25282528
$ctx = callframe($i); # $i'th caller
25292529

25302530
Note also that negative numbers are allowed as long as you stay within
25312531
the existing call stack:
25322532

2533-
$ctx = callframe(4,-1); # my frames's caller's caller's caller
2533+
$ctx = callframe(4,-1); # my frame's caller's caller's caller
25342534

25352535
Repeating any smartmatch just matches the same frame again unless you
25362536
intersperse a 1 to skip the current level:
@@ -3319,7 +3319,7 @@ or the slurpy array:
33193319

33203320
Each incoming argument is automatically passed through
33213321
the C<val()> function, which will attempt to intuit the types of the
3322-
texual arguments such that they may be used in multimethod dispatch.
3322+
textual arguments such that they may be used in multimethod dispatch.
33233323
If C<MAIN> is declared as a set of C<multi> subs, multi dispatch
33243324
is performed, and the type information intuited by C<val()> may
33253325
be used to distinguish the different signatures:
@@ -3501,7 +3501,7 @@ the time compared to the cost of failing to bind, that tends to argue
35013501
for failing over every time. This is also more conducive to inlining,
35023502
since it's difficult to rewrite inlined calls. In any case, nowadays
35033503
a C<proto> declaration is considered to be a kind of C<only> sub,
3504-
and needs to handle autothreading similaraly if the signature of
3504+
and needs to handle autothreading similarly if the signature of
35053505
the C<proto> excludes junctions.
35063506

35073507
=head2 Introspection

S07-iterators.pod

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -65,7 +65,7 @@ any situation where the implementation is allowed to work ahead.
6565
Note that there are no language-defined limits on the amount of
6666
conjectural evaluation allowed, up to the size of available memory;
6767
however, an implementation may allow the arbitrary limitation of
68-
workahead by use of pragams.
68+
workahead by use of pragmas.
6969

7070
I/O from a file may generally be assumed to be finite, but I/O
7171
from a socket may not. However, since the definition of "finite"
@@ -384,7 +384,7 @@ to:
384384
=head2 Generic Lazy Slice
385385

386386
The generic lazy slice consumes the C<Parcel>s from an iterator but
387-
stores the results as a bi-dimensional list, where the first dimension
387+
stores the results as a bidimensional list, where the first dimension
388388
corresponds to an iteration, and the second contains the values in
389389
the C<Parcel> returned for that iteration, but turned into a C<Seq> object.
390390
Empty C<Parcel> objects are turned into empty C<Seq> objects.
@@ -423,7 +423,7 @@ cannot be made generally applicable across the Perl6 feature set.
423423

424424
This is not to say you cannot do coroutines in Perl6. In fact, the
425425
gather/take construct is a simple coroutine. But if you want to pass
426-
values back and forth Lua-style, you have to use a suplimentary
426+
values back and forth Lua-style, you have to use a supplementary
427427
object:
428428

429429
sub my_coro (*@slurp) {

S11-modules.pod

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -696,7 +696,7 @@ most systems already come with a kind of database for modules that
696696
have already been installed. So perhaps the most common case is
697697
that you have downloaded an older version of the same module, in
698698
which case the tool can know from the interface version whether that
699-
older module represesents the language tweak sufficiently well that
699+
older module represents the language tweak sufficiently well that
700700
your tool can use the interface definition from that module without
701701
bothering to download the latest patch.
702702

S12-objects.pod

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -172,7 +172,7 @@ called a "prototype" or "generic" object, or just "type object".
172172
Perl 6 doesn't really have any classes named C<Class>. Types of all
173173
kinds are instead named via these undefined type objects, which are
174174
considered to have exactly the same type as an instantiated version of
175-
themsleves. But such type objects are inert, and do not manage the
175+
themselves. But such type objects are inert, and do not manage the
176176
state of class instances.
177177

178178
The actual object that manages instances is the metaclass object pointed
@@ -1313,7 +1313,7 @@ every parameter produces dispatch semantics much like Common Lisp.
13131313
And putting a semicolon after only the first argument is much like
13141314
ordinary single-dispatch methods.) Note: This single-semicolon syntax
13151315
is merely to be considered reserved until we understand the semantics
1316-
of it, and more importantly, the pragamatics of it (that is, whether
1316+
of it, and more importantly, the pragmatics of it (that is, whether
13171317
it has any valid use case). Until then only the double-semicolon
13181318
form will be implemented in the standard language.]
13191319

@@ -1510,7 +1510,7 @@ the right. Our example is roughly equivalent to this closure:
15101510
except that a subtype knows when to call itself.
15111511

15121512
A subtype is not a subclass. Subclasses add capabilities, whereas
1513-
a subtype adds constraints (takes away capabilites). A subtype is
1513+
a subtype adds constraints (takes away capabilities). A subtype is
15141514
primarily a handy way of sneaking smartmatching into multiple dispatch.
15151515
Just as a role allows you to specify something more general than a
15161516
class, a subtype allows you to specify something more specific than
@@ -1641,7 +1641,7 @@ before the variable, and post constraints will all be considered
16411641
constraint on the left may, however, be a value like 0 or a named
16421642
subset type. Such a named subset type may be predeclared with an
16431643
arbitrarily complex C<where> clause; for 6.0.0 any structure type
1644-
information inferrable from the C<where> clause will be ignored,
1644+
information inferable from the C<where> clause will be ignored,
16451645
and the declared subset type will simply be considered nominally
16461646
derived from the C<of> type mentioned in the same declaration.]
16471647

@@ -1877,7 +1877,7 @@ The enumeration typename itself may be used as a coercion operator from either
18771877
the key name or a value. First the argument is looked up as a key;
18781878
if that is found, the enum object is returned. If the key name lookup
18791879
fails, the value is looked up using an inverted mapping table (which
1880-
might have dups if the mapping is not one-to-one):
1880+
might have duplicates if the mapping is not one-to-one):
18811881

18821882
Day('Tue') # Tue constant, found as key
18831883
Day::('Tue') # (same thing)

0 commit comments

Comments
 (0)