Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Browse files

fix typos

  • Loading branch information...
commit 45ca8c8cc45c638ec0c3a228dbc59a695e31d2ba 1 parent 4fe7d34
nick patch patch authored
10 S02-bits.pod
View
@@ -605,7 +605,7 @@ Certainly, it is difficult to give a unique name to every possible
address space, let alone every possible address within every such
a space. In the absence of a universal naming scheme, it can only
be made improbable that two addresses from two different spaces will
-collide. A sufficently large random number may represent the current
+collide. A sufficiently large random number may represent the current
address space on output of an C<ObjAt> to a different address space,
or if serialized to YAML or XML. (This extra identity component
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>.)
C<Rat> and C<Num> both do the C<Real> role.
-Lower-case types like C<int> and C<num> imply the native
+Lowercase types like C<int> and C<num> imply the native
machine representation for integers and floating-point numbers,
respectively, and do not promote to arbitrary precision, though
larger representations are always allowed for temporary values.
@@ -1560,7 +1560,7 @@ The following roles are supported:
KeyBag KeyHash[UInt]
KeyHash Associative
Pair Associative
- PairSeq Associative Postional Iterable
+ PairSeq Associative Positional Iterable
Buf Stringy
IO
Routine Callable
@@ -4773,7 +4773,7 @@ and the rules that parse them, though the latter include an extra "sym":
infix:<cmp> # the infix cmp operator
infix:sym<cmp> # the rule that parses cmp
-As you can see, the extention of the name uses colon pair notation.
+As you can see, the extension of the name uses colon pair notation.
The C<:sym> typically takes an argument giving the string name of the
operator; some of the "circumfix" categories require two arguments
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
infix:ast<cmp> # rewrite an ast node after reducing its arguments
Within a grammar, matching the proto subrule <infix> will match all visible rules
-in the infix category as parallel alteratives, as if they were separated by 'C<|>'.
+in the infix category as parallel alternatives, as if they were separated by 'C<|>'.
Here are some of the names of parse rules in STD:
8 S03-operators.pod
View
@@ -2059,7 +2059,7 @@ Hence, to produce all octal numbers that fit in 16 bits, you can say:
'000000' ... '177777'
If the start string is shorter than the stop string, the strings are
-assumed to be right justitifed, and the leftmost start character is
+assumed to be right justified, and the leftmost start character is
duplicated when there is a carry:
'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.
As an extra special rule, that works in either direction, if the bottom
character is a '0' and the top character is alphanumeric, it is assumed
to be representing a number in some base up to base 36, where digits above ten
-are represented by letters. Hence the seme sequences of 16-bit numbers, only in
+are represented by letters. Hence the same sequences of 16-bit numbers, only in
hexadecimal, may be produced with:
'0000' ... 'ffff'
@@ -2101,7 +2101,7 @@ For instance, you can get away with ranges of capital Greek letters:
'ΑΑΑ' ... 'ΩΩΩ'
However, if you try it with the lowercase letters, you'll get both
-forms of lower-case sigma, which you proably don't want. If there's
+forms of lowercase sigma, which you probably don't want. If there's
only one or two letters you don't want, you can grep out those entries,
but in the general case, you need an incrementer that knows what sequence
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,
the max's type. If neither min nor max have an ordering,
dispatch to .ACCEPTS fails. It may also fail if the ordering
in question does not have any way to coerce the object
-being smartmatched into an appropropriate type implied by the
+being smartmatched into an appropriate type implied by the
chosen domain of ordering.
In general, the domain of comparison should be a type that can
8 S04-control.pod
View
@@ -209,7 +209,7 @@ This is subtly different from Perl 5's behavior, which was to return
the value of the last expression evaluated, even if that expression
was just a conditional. Unlike in Perl 5, if a final statement in
Perl 6 is a conditional that does not execute any of its branches, it
-doesn't matter what the value of the condional is, the value of that
+doesn't matter what the value of the conditional is, the value of that
conditional statement is always C<Nil>. If there are no statements
in the block at all, the result is also C<Nil>.
@@ -1246,7 +1246,7 @@ As in Perl 5, many built-in functions simply return an undefined value
when you ask for a value out of range, or the function fails somehow.
Perl 6 has C<Failure> objects, known as "unthrown exceptions", which
know whether they have been handled or not. C<$!> is a convenient
-link to the lastest failure, and only ever contains one exception, the
+link to the last failure, and only ever contains one exception, the
most recent.
[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
corresponding lexical scope. All runtime instances of a single package
declaration share the same set of compile-time declared functions, however,
the runtime instances can have different lexical environments as described in
-the preceding paragraph. If multiple conflicting definitons of a sub exist
+the preceding paragraph. If multiple conflicting definitions of a sub exist
for the same compile-time package, an error condition exists and behavior is
not specified for Perl 6.0.
@@ -1794,7 +1794,7 @@ possibly deferred.)
sub foo {
# conceptual cloning happens to both blocks below
my $x = 1;
- my sub bar { print $x } # already conceptualy cloned, but can be lazily deferred
+ my sub bar { print $x } # already conceptually cloned, but can be lazily deferred
my &baz := { bar(); print $x }; # block is cloned immediately, forcing cloning of bar
my $code = &bar; # this would also force bar to be cloned
return &baz;
8 S05-regex.pod
View
@@ -474,7 +474,7 @@ which is the same as:
m/(\d+)/ && m:c/(\d+)/ && s:c/(\d+)/@data[$0]/;
The argument to C<:nth> is allowed to be a list of integers, but such a list
-should be monotically increasing. (Values which are less than or equal to the previous
+should be monotonically increasing. (Values which are less than or equal to the previous
value will be ignored.) So:
@@ -1783,7 +1783,7 @@ is rewritten as something like:
In the latter example we're assuming the DFA token matcher is going to
give us the longest match regardless. It's also possible that quantified
-multichar sequences can be recursively remapped:
+multi-character sequences can be recursively remapped:
<* 'ab'+> # match a, ab, ababa, etc. (but not aab!)
==> [ 'ab'* <*ab> ]
@@ -2070,7 +2070,7 @@ newline; it is the negation of C<\n>.
=item *
Other new capital backslash sequences are also the negations
-of their lower-case counterparts:
+of their lowercase counterparts:
=over
@@ -2695,7 +2695,7 @@ match begins with the first non-sigspace atom. This exception applies to
the rule itself as well, since any rule might participate in an alternation
higher in the grammar. And just to keep things simple, we say that the initial
whitespace in any regex before the first actual match is not subject to significance.
-This includes any whitespace after a C<:sigspace>, if that declararation is the first
+This includes any whitespace after a C<:sigspace>, if that declaration is the first
thing in the regex.
The initial token matcher must take into account case sensitivity
32 S06-routines.pod
View
@@ -38,7 +38,7 @@ a thunk has no scope to declare a new variable. Note however that
any and all lazy constructs, whether block-based or thunk-based,
such as gather or async or C<< ==> >> should declare their own C<$/>
and C<$!> so that the user's values for those variables cannot be
-clobbered asyncronously. And this parentheticl remark is starting to
+clobbered asynchronously. And this parenthetical remark is starting to
be seriously misplaced...)
B<Subroutines> (keyword: C<sub>) are non-inheritable routines with
@@ -82,7 +82,7 @@ name within its scope, unless they have an explicit modifier.
(This is particularly useful when adding to rule sets or when attempting
to compose conflicting methods from roles.) Abstractly, the C<proto>
is a generic wrapper around the dispatch to the C<multi>s. Each C<proto>
-is instantianted into an actual dispatcher for each scope that
+is instantiated into an actual dispatcher for each scope that
needs a different candidate list.
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<{*}>).
In the case of a C<proto> sub, this mapping can be done at the point
of the call, since there can only be one possible set of positional
names, and the proto to be called can be known at compile time (in
-the absense of CANDO declarations in the outer scopes). So after
+the absence of CANDO declarations in the outer scopes). So after
proto foo ($x, $y, :$bar, :$baz) {*}
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
because they are named in the C<proto>. Positional parameter names
are never part of the advertised API unless explicitly enabled.
An explicit C<proto> may easily refrain from advertising names by
-declararing positionals with bare sigils:
+declaring positionals with bare sigils:
proto foo ($, $, :$bar, :$baz) {*}
multi foo ($x, $y, :$bar, :$baz) {...}
@@ -1060,7 +1060,7 @@ if finer control is desired.)
It follows from all this that an intuited proto never has to worry
about supplying the API names of positional parameters. And no proto
-ever has to worry about conficting names in the positionals of the
+ever has to worry about conflicting names in the positionals of the
multis they dispatch to, since any remapping is handled before that.
=head2 List parameters
@@ -1286,7 +1286,7 @@ so C<self> is not present in the C<**@slice> below:
The C<**> marker is just a variant of the C<*> marker that ends up
requesting parcels when binding (underlyingly calling C<.getarg>) rather
-than requesting individual elements as the flatening C<*> does (underlyingly
+than requesting individual elements as the flattening C<*> does (underlyingly
calling C<.get>).
=head2 Zero-dimensional argument list
@@ -1532,7 +1532,7 @@ have "list" semantics. If you say
(0..2; 'a'..'c') ==> my @tmp;
for @tmp { .say }
-then you get 0,1,2,'a','b','c'. If you have a multidim array, you
+then you get 0,1,2,'a','b','c'. If you have a multidimensional array, you
can ask for flattening semantics explicitly with C<flat>:
(0..2; 'a'..'c') ==> my $tmp;
@@ -1897,7 +1897,7 @@ so C<$_> ends up being bound to the outer C<$_> anyway.)
A block may also refer to either C<@_> or C<%_> or both, each of
which will be added to generated signature as a normal readonly
-slurpy pararmeter:
+slurpy parameter:
{ say $:what; warn "bad option: $_\n" for keys %_; }
@@ -2061,7 +2061,7 @@ significant number of pathological cases that are unacceptably slow
This trait is a suggestion to the compiler that caching is okay. The
compiler is free to choose any kind of caching algorithm (including
-non-expiring, random, lru, pseudo-lru, or adaptive algoritms, or
+non-expiring, random, lru, pseudo-lru, or adaptive algorithms, or
even no caching algorithm at all). The run-time system is free to
choose any kind of maximum cache size depending on the availability
of memory and trends in usage patterns. You may suggest a particular
@@ -2086,7 +2086,7 @@ around your subroutine.
Specifies the precedence of an operator relative to an existing
operator. C<tighter> and C<looser> precedence levels default to
-being left associative. They define a new precedence level slighty
+being left associative. They define a new precedence level slightly
tighter or looser than the precedence level on which they're based.
Both C<tighter> and C<looser> may be specified, in which case the new
precedence level is generated midway between the specified levels.
@@ -2293,7 +2293,7 @@ to a readonly parameter never triggers autovivification.
Specifies that the parameter can be modified (assigned to, incremented,
etc). Requires that the corresponding argument is an lvalue or can be
converted to one. Since this option forces an argument to be required,
-it cannot co-exist with the C<?> mark to make an argument optional.
+it cannot coexist with the C<?> mark to make an argument optional.
(It may, however, be used with C<=> indicating a default, but only
if the default expression represents something that is nameable at
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.
For better visual distinction, such a parameter is declared by
prefixing with a backslash rather than by using C<is parcel> directly.
-The backslash is also more succint; the trait is there primarily
+The backslash is also more succinct; the trait is there primarily
for introspection.
=item C<is copy>
@@ -2524,13 +2524,13 @@ in order, left to right. Note that C<Any> and C<0> are no-ops:
$ctx = callframe(1); # my frame's caller
$ctx = callframe(2); # my frame's caller's caller
$ctx = callframe(3); # my frame's caller's caller's caller
- $ctx = callframe(1,0,1,1); # my frames's caller's caller's caller
+ $ctx = callframe(1,0,1,1); # my frame's caller's caller's caller
$ctx = callframe($i); # $i'th caller
Note also that negative numbers are allowed as long as you stay within
the existing call stack:
- $ctx = callframe(4,-1); # my frames's caller's caller's caller
+ $ctx = callframe(4,-1); # my frame's caller's caller's caller
Repeating any smartmatch just matches the same frame again unless you
intersperse a 1 to skip the current level:
@@ -3319,7 +3319,7 @@ or the slurpy array:
Each incoming argument is automatically passed through
the C<val()> function, which will attempt to intuit the types of the
-texual arguments such that they may be used in multimethod dispatch.
+textual arguments such that they may be used in multimethod dispatch.
If C<MAIN> is declared as a set of C<multi> subs, multi dispatch
is performed, and the type information intuited by C<val()> may
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
for failing over every time. This is also more conducive to inlining,
since it's difficult to rewrite inlined calls. In any case, nowadays
a C<proto> declaration is considered to be a kind of C<only> sub,
-and needs to handle autothreading similaraly if the signature of
+and needs to handle autothreading similarly if the signature of
the C<proto> excludes junctions.
=head2 Introspection
6 S07-iterators.pod
View
@@ -65,7 +65,7 @@ any situation where the implementation is allowed to work ahead.
Note that there are no language-defined limits on the amount of
conjectural evaluation allowed, up to the size of available memory;
however, an implementation may allow the arbitrary limitation of
-workahead by use of pragams.
+workahead by use of pragmas.
I/O from a file may generally be assumed to be finite, but I/O
from a socket may not. However, since the definition of "finite"
@@ -384,7 +384,7 @@ to:
=head2 Generic Lazy Slice
The generic lazy slice consumes the C<Parcel>s from an iterator but
-stores the results as a bi-dimensional list, where the first dimension
+stores the results as a bidimensional list, where the first dimension
corresponds to an iteration, and the second contains the values in
the C<Parcel> returned for that iteration, but turned into a C<Seq> object.
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.
This is not to say you cannot do coroutines in Perl6. In fact, the
gather/take construct is a simple coroutine. But if you want to pass
-values back and forth Lua-style, you have to use a suplimentary
+values back and forth Lua-style, you have to use a supplementary
object:
sub my_coro (*@slurp) {
2  S11-modules.pod
View
@@ -696,7 +696,7 @@ most systems already come with a kind of database for modules that
have already been installed. So perhaps the most common case is
that you have downloaded an older version of the same module, in
which case the tool can know from the interface version whether that
-older module represesents the language tweak sufficiently well that
+older module represents the language tweak sufficiently well that
your tool can use the interface definition from that module without
bothering to download the latest patch.
10 S12-objects.pod
View
@@ -172,7 +172,7 @@ called a "prototype" or "generic" object, or just "type object".
Perl 6 doesn't really have any classes named C<Class>. Types of all
kinds are instead named via these undefined type objects, which are
considered to have exactly the same type as an instantiated version of
-themsleves. But such type objects are inert, and do not manage the
+themselves. But such type objects are inert, and do not manage the
state of class instances.
The actual object that manages instances is the metaclass object pointed
@@ -1313,7 +1313,7 @@ every parameter produces dispatch semantics much like Common Lisp.
And putting a semicolon after only the first argument is much like
ordinary single-dispatch methods.) Note: This single-semicolon syntax
is merely to be considered reserved until we understand the semantics
-of it, and more importantly, the pragamatics of it (that is, whether
+of it, and more importantly, the pragmatics of it (that is, whether
it has any valid use case). Until then only the double-semicolon
form will be implemented in the standard language.]
@@ -1510,7 +1510,7 @@ the right. Our example is roughly equivalent to this closure:
except that a subtype knows when to call itself.
A subtype is not a subclass. Subclasses add capabilities, whereas
-a subtype adds constraints (takes away capabilites). A subtype is
+a subtype adds constraints (takes away capabilities). A subtype is
primarily a handy way of sneaking smartmatching into multiple dispatch.
Just as a role allows you to specify something more general than a
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
constraint on the left may, however, be a value like 0 or a named
subset type. Such a named subset type may be predeclared with an
arbitrarily complex C<where> clause; for 6.0.0 any structure type
-information inferrable from the C<where> clause will be ignored,
+information inferable from the C<where> clause will be ignored,
and the declared subset type will simply be considered nominally
derived from the C<of> type mentioned in the same declaration.]
@@ -1877,7 +1877,7 @@ The enumeration typename itself may be used as a coercion operator from either
the key name or a value. First the argument is looked up as a key;
if that is found, the enum object is returned. If the key name lookup
fails, the value is looked up using an inverted mapping table (which
-might have dups if the mapping is not one-to-one):
+might have duplicates if the mapping is not one-to-one):
Day('Tue') # Tue constant, found as key
Day::('Tue') # (same thing)
2  S14-roles-and-parametric-types.pod
View
@@ -426,7 +426,7 @@ do any extra shenanigans. The compiler won't call it for you at run
time like it would at compile time.
Note that the declarations above are insufficient to install new trait
-auxilliaries or verbs into the user's grammar, since macro definitions
+auxiliaries or verbs into the user's grammar, since macro definitions
are lexically scoped, and in the declarations above extend only to
the end of the role definition. The user's lexical scope must somehow
have processed (or imported) a proto declaration introducing the new
4 S17-concurrency.pod
View
@@ -21,7 +21,7 @@ DRAFT: Synopsis 17: Processes and Concurrency
This draft document is a paste together from various sources. The bulk of it is simply
the old S17-concurrency.pod, which dealt only with concurrency. Signals were added from
-S16-io, but haven't been merged with the conflicting S17 signals doco. An event loop
+S16-io, but haven't been merged with the conflicting S17 signals document. An event loop
section has been added here because a) Larry mentioned the idea, and b) Moritz suggested
that L<http://www.seas.upenn.edu/~lipeng/homepage/unify.html> be our model for concurrency,
and in that model, an event loop underlies the threads.
@@ -536,7 +536,7 @@ sleep() always respects other threads, thank you very much
=item join
-wait for invocant to finish (always item cxt)
+wait for invocant to finish (always item context)
my $thr = async { ... };
$thr.join();
2  S24-testing.pod
View
@@ -114,7 +114,7 @@ TODO: more precise explanation
skip($reason, $count = 1)
The C<todo()> function can be called before running other test functions, and
-markes the next C<$count> tests as TODO.
+marks the next C<$count> tests as TODO.
The C<skip()> function is called I<instead> of the some tests (usually because
they would die), and emits C<$count> SKIP markers in the TAP output.
8 S26-documentation.pod
View
@@ -1255,7 +1255,7 @@ E<mdash;nbsp;nbsp>Writing
=for para :nested(3)
E<curren;nbsp;nbsp>'Rithmetic
-As with numbering styles, the bulleting strategy used for different levels
+As with numbering styles, the bulletting strategy used for different levels
within a nested list is entirely up to the renderer.
@@ -1595,7 +1595,7 @@ the Associative aspect of C<$=data> object. For example:
The contents of any C<=data> block that does not have a C<:key> are
accessible (as a single string) via the Positional aspect of
-C<$=data>. Un-keyed C<=data> blocks are stored in the same order
+C<$=data>. Unkeyed C<=data> blocks are stored in the same order
they appear in the file. For example:
=begin code :allow<B>
@@ -1609,12 +1609,12 @@ they appear in the file. For example:
=end code
Note that, as the preceding example illustrates, because Pod is a
-compile-time phenomonenon, it is possible to specify C<=data> blocks
+compile-time phenomenon, it is possible to specify C<=data> blocks
I<after> the point in the source where their contents will be used
(provided they're not being used in a C<BEGIN>, of course).
When C<$=data> itself is stringified, it returns the concatenation of all
-the un-keyed C<=data> blocks the parser has seen.
+the unkeyed C<=data> blocks the parser has seen.
C<=data> blocks are never rendered by the standard Pod renderers.
6 S29-functions.pod
View
@@ -541,11 +541,11 @@ C<shell> and C<run> execute an external program, and return control to
the caller once the program has exited.
C<shell> goes through the system shell (C<cmd> on windows, C</bin/sh>
-on Unixish systems), thus interpreting all the usuall shell meta characters.
+on Unixish systems), thus interpreting all the usual shell meta characters.
C<run> treats the first argument as an executable name, and the rest of the
positional arguments as command line arguments that are passed to the
-exectuable without any processing (except that it encodes Strings to buffers
+executable without any processing (except that it encodes Strings to buffers
first, as does C<shell>).
The return value of either function is the exit status
@@ -813,7 +813,7 @@ Does a floating point modulo operation, i.e. 5.5 % 1 == 0.5 and 5 % 2.5 == 0.
Dumped. Restoring from core dumps is in any event not very useful on modern
virtual-memory operating systems. Startup acceleration should be accomplished
using a precompiler of some kind (details will be very implementation specific),
-or a pre-forking daemon such as Perl 5's App::Persistant (which will be an
+or a pre-forking daemon such as Perl 5's App::Persistent (which will be an
external module when it is ported).
=item each
2  S32-setting-library/IO.pod
View
@@ -1294,7 +1294,7 @@ operations. It implies C<IO::Readable> and C<IO::Writeable>.
=back
-=head1 Unfiled
+=head1 Unfilled
=over 4
6 S32-setting-library/Numeric.pod
View
@@ -64,7 +64,7 @@ Users who provide their own scalar numeric types are encouraged to implement the
C<Numeric> role. It is intended that such types such support the basic arithmetic
operators to the extent possible, as well as C<==>. In addition, it is hoped that
comparison operators will at least return consistent results, even if there is no
-sensible mathemtical ordering of your type. That allows functions like sort to
+sensible mathematical ordering of your type. That allows functions like sort to
not choke and die if they are handed a value of your type. (See also the C<Real>
role for scalar numeric types that represent real numbers.)
@@ -218,7 +218,7 @@ C<Num>, C<Int>, C<Bool> and C<Rat> implement the C<Real> role.
Users who provide their own scalar real numeric types are encouraged to implement the
C<Real> role. Because real numbers are strictly-totally-ordered and
C<Real> types try to emulate that property, it is desirable that any two
-C<Real> types be mutally compatible, even if they are not aware of each other. The
+C<Real> types be mutually compatible, even if they are not aware of each other. The
current proposal requires you to define a C<Bridge> method in your C<Real> type, which
converts your type into a neutral C<Real> type by restating it in terms of the fundamental
Perl 6 types and calling C<Bridge> on them. This then makes the default C<Real> methods
@@ -247,7 +247,7 @@ number, so for example, the C<Rat> C<5/4> is returned as C<"1.2">.
Returns a C<Str> representing the invocant in base C<$base>. Fails if C<$base>
is smaller than C<2> or larger than C<36>.
-For bases above ten, the digit repertoire is enhanced with upper-case latin
+For bases above ten, the digit repertoire is enhanced with uppercase latin
characters starting from C<A>.
=item floor
6 S32-setting-library/Str.pod
View
@@ -436,9 +436,9 @@ The directives are:
e a floating-point number, in scientific notation
f a floating-point number, in fixed decimal notation
g a floating-point number, in %e or %f notation
- X like x, but using upper-case letters
- E like e, but using an upper-case "E"
- G like g, but with an upper-case "E" (if applicable)
+ X like x, but using uppercase letters
+ E like e, but using an uppercase "E"
+ G like g, but with an uppercase "E" (if applicable)
b an unsigned integer, in binary
C special: invokes the arg as code, see below
Please sign in to comment.
Something went wrong with that request. Please try again.