fix typos

S02-bits.pod

@@ -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:
 

S03-operators.pod

@@ -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

S04-control.pod

@@ -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;

S05-regex.pod

@@ -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

S06-routines.pod

@@ -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

S07-iterators.pod

@@ -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) {

S11-modules.pod

@@ -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.
 

S12-objects.pod

@@ -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)