Skip to content
This repository
Browse code

fix typos

  • Loading branch information...
commit 45ca8c8cc45c638ec0c3a228dbc59a695e31d2ba 1 parent 4fe7d34
Nick Patch authored November 20, 2011
10  S02-bits.pod
Source Rendered
@@ -605,7 +605,7 @@ Certainly, it is difficult to give a unique name to every possible
605 605
 address space, let alone every possible address within every such
606 606
 a space.  In the absence of a universal naming scheme, it can only
607 607
 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
609 609
 address space on output of an C<ObjAt> to a different address space,
610 610
 or if serialized to YAML or XML.  (This extra identity component
611 611
 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>.)
699 699
 
700 700
 C<Rat> and C<Num> both do the C<Real> role.
701 701
 
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
703 703
 machine representation for integers and floating-point numbers,
704 704
 respectively, and do not promote to arbitrary precision, though
705 705
 larger representations are always allowed for temporary values.
@@ -1560,7 +1560,7 @@ The following roles are supported:
1560 1560
     KeyBag      KeyHash[UInt]
1561 1561
     KeyHash     Associative
1562 1562
     Pair        Associative
1563  
-    PairSeq     Associative Postional Iterable
  1563
+    PairSeq     Associative Positional Iterable
1564 1564
     Buf         Stringy
1565 1565
     IO          
1566 1566
     Routine     Callable
@@ -4773,7 +4773,7 @@ and the rules that parse them, though the latter include an extra "sym":
4773 4773
     infix:<cmp>           # the infix cmp operator
4774 4774
     infix:sym<cmp>        # the rule that parses cmp
4775 4775
 
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.
4777 4777
 The C<:sym> typically takes an argument giving the string name of the
4778 4778
 operator; some of the "circumfix" categories require two arguments
4779 4779
 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
4787 4787
     infix:ast<cmp>        # rewrite an ast node after reducing its arguments
4788 4788
 
4789 4789
 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<|>'.
4791 4791
 
4792 4792
 Here are some of the names of parse rules in STD:
4793 4793
 
8  S03-operators.pod
Source Rendered
@@ -2059,7 +2059,7 @@ Hence, to produce all octal numbers that fit in 16 bits, you can say:
2059 2059
     '000000' ... '177777'
2060 2060
 
2061 2061
 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
2063 2063
 duplicated when there is a carry:
2064 2064
 
2065 2065
     '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.
2079 2079
 As an extra special rule, that works in either direction, if the bottom
2080 2080
 character is a '0' and the top character is alphanumeric, it is assumed
2081 2081
 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
2083 2083
 hexadecimal, may be produced with:
2084 2084
 
2085 2085
     '0000' ... 'ffff'
@@ -2101,7 +2101,7 @@ For instance, you can get away with ranges of capital Greek letters:
2101 2101
     'ΑΑΑ' ... 'ΩΩΩ'
2102 2102
 
2103 2103
 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
2105 2105
 only one or two letters you don't want, you can grep out those entries,
2106 2106
 but in the general case, you need an incrementer that knows what sequence
2107 2107
 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,
3482 3482
 the max's type.  If neither min nor max have an ordering, 
3483 3483
 dispatch to .ACCEPTS fails.  It may also fail if the ordering
3484 3484
 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
3486 3486
 chosen domain of ordering.
3487 3487
 
3488 3488
 In general, the domain of comparison should be a type that can
8  S04-control.pod
Source Rendered
@@ -209,7 +209,7 @@ This is subtly different from Perl 5's behavior, which was to return
209 209
 the value of the last expression evaluated, even if that expression
210 210
 was just a conditional.  Unlike in Perl 5, if a final statement in
211 211
 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
213 213
 conditional statement is always C<Nil>.  If there are no statements
214 214
 in the block at all, the result is also C<Nil>.
215 215
 
@@ -1246,7 +1246,7 @@ As in Perl 5, many built-in functions simply return an undefined value
1246 1246
 when you ask for a value out of range, or the function fails somehow.
1247 1247
 Perl 6 has C<Failure> objects, known as "unthrown exceptions", which
1248 1248
 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
1250 1250
 most recent.
1251 1251
 
1252 1252
 [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
1774 1774
 corresponding lexical scope.  All runtime instances of a single package
1775 1775
 declaration share the same set of compile-time declared functions, however,
1776 1776
 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
1778 1778
 for the same compile-time package, an error condition exists and behavior is
1779 1779
 not specified for Perl 6.0.
1780 1780
 
@@ -1794,7 +1794,7 @@ possibly deferred.)
1794 1794
     sub foo {
1795 1795
         # conceptual cloning happens to both blocks below
1796 1796
         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
1798 1798
         my &baz := { bar(); print $x }; # block is cloned immediately, forcing cloning of bar
1799 1799
         my $code = &bar;                # this would also force bar to be cloned
1800 1800
         return &baz;
8  S05-regex.pod
Source Rendered
@@ -474,7 +474,7 @@ which is the same as:
474 474
      m/(\d+)/ && m:c/(\d+)/ && s:c/(\d+)/@data[$0]/;
475 475
 
476 476
 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
478 478
 value will be ignored.)  So:
479 479
 
480 480
 
@@ -1783,7 +1783,7 @@ is rewritten as something like:
1783 1783
 
1784 1784
 In the latter example we're assuming the DFA token matcher is going to
1785 1785
 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:
1787 1787
 
1788 1788
     <* 'ab'+>     # match a, ab, ababa, etc. (but not aab!)
1789 1789
     ==> [ 'ab'* <*ab> ]
@@ -2070,7 +2070,7 @@ newline; it is the negation of C<\n>.
2070 2070
 =item *
2071 2071
 
2072 2072
 Other new capital backslash sequences are also the negations
2073  
-of their lower-case counterparts:
  2073
+of their lowercase counterparts:
2074 2074
 
2075 2075
 =over
2076 2076
 
@@ -2695,7 +2695,7 @@ match begins with the first non-sigspace atom.  This exception applies to
2695 2695
 the rule itself as well, since any rule might participate in an alternation
2696 2696
 higher in the grammar.  And just to keep things simple, we say that the initial
2697 2697
 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
2699 2699
 thing in the regex.
2700 2700
 
2701 2701
 The initial token matcher must take into account case sensitivity
32  S06-routines.pod
Source Rendered
@@ -38,7 +38,7 @@ a thunk has no scope to declare a new variable.  Note however that
38 38
 any and all lazy constructs, whether block-based or thunk-based,
39 39
 such as gather or async or C<< ==> >> should declare their own C<$/>
40 40
 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
42 42
 be seriously misplaced...)
43 43
 
44 44
 B<Subroutines> (keyword: C<sub>) are non-inheritable routines with
@@ -82,7 +82,7 @@ name within its scope, unless they have an explicit modifier.
82 82
 (This is particularly useful when adding to rule sets or when attempting
83 83
 to compose conflicting methods from roles.)  Abstractly, the C<proto>
84 84
 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
86 86
 needs a different candidate list.
87 87
 
88 88
 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<{*}>).
1027 1027
 In the case of a C<proto> sub, this mapping can be done at the point
1028 1028
 of the call, since there can only be one possible set of positional
1029 1029
 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
1031 1031
 
1032 1032
     proto foo ($x, $y, :$bar, :$baz) {*}
1033 1033
     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
1047 1047
 because they are named in the C<proto>.  Positional parameter names
1048 1048
 are never part of the advertised API unless explicitly enabled.
1049 1049
 An explicit C<proto> may easily refrain from advertising names by
1050  
-declararing positionals with bare sigils:
  1050
+declaring positionals with bare sigils:
1051 1051
 
1052 1052
     proto foo ($, $, :$bar, :$baz) {*}
1053 1053
     multi foo ($x, $y, :$bar, :$baz) {...}
@@ -1060,7 +1060,7 @@ if finer control is desired.)
1060 1060
 
1061 1061
 It follows from all this that an intuited proto never has to worry
1062 1062
 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
1064 1064
 multis they dispatch to, since any remapping is handled before that.
1065 1065
 
1066 1066
 =head2 List parameters
@@ -1286,7 +1286,7 @@ so C<self> is not present in the C<**@slice> below:
1286 1286
 
1287 1287
 The C<**> marker is just a variant of the C<*> marker that ends up
1288 1288
 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
1290 1290
 calling C<.get>).
1291 1291
 
1292 1292
 =head2 Zero-dimensional argument list
@@ -1532,7 +1532,7 @@ have "list" semantics.  If you say
1532 1532
     (0..2; 'a'..'c') ==> my @tmp;
1533 1533
     for @tmp { .say }
1534 1534
 
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
1536 1536
 can ask for flattening semantics explicitly with C<flat>:
1537 1537
 
1538 1538
     (0..2; 'a'..'c') ==> my $tmp;
@@ -1897,7 +1897,7 @@ so C<$_> ends up being bound to the outer C<$_> anyway.)
1897 1897
 
1898 1898
 A block may also refer to either C<@_> or C<%_> or both, each of
1899 1899
 which will be added to generated signature as a normal readonly
1900  
-slurpy pararmeter:
  1900
+slurpy parameter:
1901 1901
 
1902 1902
     { say $:what; warn "bad option: $_\n" for keys %_; }
1903 1903
 
@@ -2061,7 +2061,7 @@ significant number of pathological cases that are unacceptably slow
2061 2061
 
2062 2062
 This trait is a suggestion to the compiler that caching is okay.  The
2063 2063
 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
2065 2065
 even no caching algorithm at all).  The run-time system is free to
2066 2066
 choose any kind of maximum cache size depending on the availability
2067 2067
 of memory and trends in usage patterns.  You may suggest a particular
@@ -2086,7 +2086,7 @@ around your subroutine.
2086 2086
 
2087 2087
 Specifies the precedence of an operator relative to an existing
2088 2088
 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
2090 2090
 tighter or looser than the precedence level on which they're based.
2091 2091
 Both C<tighter> and C<looser> may be specified, in which case the new
2092 2092
 precedence level is generated midway between the specified levels.
@@ -2293,7 +2293,7 @@ to a readonly parameter never triggers autovivification.
2293 2293
 Specifies that the parameter can be modified (assigned to, incremented,
2294 2294
 etc). Requires that the corresponding argument is an lvalue or can be
2295 2295
 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.
2297 2297
 (It may, however, be used with C<=> indicating a default, but only
2298 2298
 if the default expression represents something that is nameable at
2299 2299
 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.
2326 2326
 
2327 2327
 For better visual distinction, such a parameter is declared by
2328 2328
 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
2330 2330
 for introspection.
2331 2331
 
2332 2332
 =item C<is copy>
@@ -2524,13 +2524,13 @@ in order, left to right.  Note that C<Any> and C<0> are no-ops:
2524 2524
     $ctx = callframe(1);       # my frame's caller
2525 2525
     $ctx = callframe(2);       # my frame's caller's caller
2526 2526
     $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
2528 2528
     $ctx = callframe($i);      # $i'th caller
2529 2529
 
2530 2530
 Note also that negative numbers are allowed as long as you stay within
2531 2531
 the existing call stack:
2532 2532
 
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
2534 2534
 
2535 2535
 Repeating any smartmatch just matches the same frame again unless you
2536 2536
 intersperse a 1 to skip the current level:
@@ -3319,7 +3319,7 @@ or the slurpy array:
3319 3319
 
3320 3320
 Each incoming argument is automatically passed through
3321 3321
 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.
3323 3323
 If C<MAIN> is declared as a set of C<multi> subs, multi dispatch
3324 3324
 is performed, and the type information intuited by C<val()> may
3325 3325
 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
3501 3501
 for failing over every time.  This is also more conducive to inlining,
3502 3502
 since it's difficult to rewrite inlined calls.  In any case, nowadays
3503 3503
 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
3505 3505
 the C<proto> excludes junctions.
3506 3506
 
3507 3507
 =head2 Introspection
6  S07-iterators.pod
Source Rendered
@@ -65,7 +65,7 @@ any situation where the implementation is allowed to work ahead.
65 65
 Note that there are no language-defined limits on the amount of
66 66
 conjectural evaluation allowed, up to the size of available memory;
67 67
 however, an implementation may allow the arbitrary limitation of
68  
-workahead by use of pragams.
  68
+workahead by use of pragmas.
69 69
 
70 70
 I/O from a file may generally be assumed to be finite, but I/O
71 71
 from a socket may not.  However, since the definition of "finite"
@@ -384,7 +384,7 @@ to:
384 384
 =head2 Generic Lazy Slice
385 385
 
386 386
 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
388 388
 corresponds to an iteration, and the second contains the values in
389 389
 the C<Parcel> returned for that iteration, but turned into a C<Seq> object.
390 390
 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.
423 423
 
424 424
 This is not to say you cannot do coroutines in Perl6.  In fact, the
425 425
 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
427 427
 object:
428 428
 
429 429
      sub my_coro (*@slurp) {
2  S11-modules.pod
Source Rendered
@@ -696,7 +696,7 @@ most systems already come with a kind of database for modules that
696 696
 have already been installed.  So perhaps the most common case is
697 697
 that you have downloaded an older version of the same module, in
698 698
 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
700 700
 your tool can use the interface definition from that module without
701 701
 bothering to download the latest patch.
702 702
 
10  S12-objects.pod
Source Rendered
@@ -172,7 +172,7 @@ called a "prototype" or "generic" object, or just "type object".
172 172
 Perl 6 doesn't really have any classes named C<Class>.  Types of all
173 173
 kinds are instead named via these undefined type objects, which are
174 174
 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
176 176
 state of class instances.
177 177
 
178 178
 The actual object that manages instances is the metaclass object pointed
@@ -1313,7 +1313,7 @@ every parameter produces dispatch semantics much like Common Lisp.
1313 1313
 And putting a semicolon after only the first argument is much like
1314 1314
 ordinary single-dispatch methods.)  Note: This single-semicolon syntax
1315 1315
 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
1317 1317
 it has any valid use case).  Until then only the double-semicolon
1318 1318
 form will be implemented in the standard language.]
1319 1319
 
@@ -1510,7 +1510,7 @@ the right.  Our example is roughly equivalent to this closure:
1510 1510
 except that a subtype knows when to call itself.
1511 1511
 
1512 1512
 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
1514 1514
 primarily a handy way of sneaking smartmatching into multiple dispatch.
1515 1515
 Just as a role allows you to specify something more general than a
1516 1516
 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
1641 1641
 constraint on the left may, however, be a value like 0 or a named
1642 1642
 subset type.  Such a named subset type may be predeclared with an
1643 1643
 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,
1645 1645
 and the declared subset type will simply be considered nominally
1646 1646
 derived from the C<of> type mentioned in the same declaration.]
1647 1647
 
@@ -1877,7 +1877,7 @@ The enumeration typename itself may be used as a coercion operator from either
1877 1877
 the key name or a value.   First the argument is looked up as a key;
1878 1878
 if that is found, the enum object is returned.  If the key name lookup
1879 1879
 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):
1881 1881
 
1882 1882
     Day('Tue')           # Tue constant, found as key
1883 1883
     Day::('Tue')         # (same thing)
2  S14-roles-and-parametric-types.pod
Source Rendered
@@ -426,7 +426,7 @@ do any extra shenanigans.  The compiler won't call it for you at run
426 426
 time like it would at compile time.
427 427
 
428 428
 Note that the declarations above are insufficient to install new trait
429  
-auxilliaries or verbs into the user's grammar, since macro definitions
  429
+auxiliaries or verbs into the user's grammar, since macro definitions
430 430
 are lexically scoped, and in the declarations above extend only to
431 431
 the end of the role definition.  The user's lexical scope must somehow
432 432
 have processed (or imported) a proto declaration introducing the new
4  S17-concurrency.pod
Source Rendered
@@ -21,7 +21,7 @@ DRAFT: Synopsis 17: Processes and Concurrency
21 21
 
22 22
 This draft document is a paste together from various sources.  The bulk of it is simply
23 23
 the old S17-concurrency.pod, which dealt only with concurrency.  Signals were added from
24  
-S16-io, but haven't been merged with the conflicting S17 signals doco.  An event loop
  24
+S16-io, but haven't been merged with the conflicting S17 signals document.  An event loop
25 25
 section has been added here because a) Larry mentioned the idea, and b) Moritz suggested
26 26
 that L<http://www.seas.upenn.edu/~lipeng/homepage/unify.html> be our model for concurrency,
27 27
 and in that model, an event loop underlies the threads.
@@ -536,7 +536,7 @@ sleep() always respects other threads, thank you very much
536 536
 
537 537
 =item join
538 538
 
539  
-wait for invocant to finish (always item cxt)
  539
+wait for invocant to finish (always item context)
540 540
 
541 541
   my $thr = async { ... };
542 542
   $thr.join();
2  S24-testing.pod
Source Rendered
@@ -114,7 +114,7 @@ TODO: more precise explanation
114 114
     skip($reason, $count = 1)
115 115
 
116 116
 The C<todo()> function can be called before running other test functions, and
117  
-markes the next C<$count> tests as TODO.
  117
+marks the next C<$count> tests as TODO.
118 118
 
119 119
 The C<skip()> function is called I<instead> of the some tests (usually because
120 120
 they would die), and emits C<$count> SKIP markers in the TAP output.
8  S26-documentation.pod
Source Rendered
@@ -1255,7 +1255,7 @@ E<mdash;nbsp;nbsp>Writing
1255 1255
 =for para :nested(3)
1256 1256
 E<curren;nbsp;nbsp>'Rithmetic
1257 1257
 
1258  
-As with numbering styles, the bulleting strategy used for different levels
  1258
+As with numbering styles, the bulletting strategy used for different levels
1259 1259
 within a nested list is entirely up to the renderer.
1260 1260
 
1261 1261
 
@@ -1595,7 +1595,7 @@ the Associative aspect of C<$=data> object. For example:
1595 1595
 
1596 1596
 The contents of any C<=data> block that does not have a C<:key> are
1597 1597
 accessible (as a single string) via the Positional aspect of
1598  
-C<$=data>. Un-keyed C<=data> blocks are stored in the same order
  1598
+C<$=data>. Unkeyed C<=data> blocks are stored in the same order
1599 1599
 they appear in the file. For example:
1600 1600
 
1601 1601
 =begin code :allow<B>
@@ -1609,12 +1609,12 @@ they appear in the file. For example:
1609 1609
 =end code
1610 1610
 
1611 1611
 Note that, as the preceding example illustrates, because Pod is a
1612  
-compile-time phenomonenon, it is possible to specify C<=data> blocks
  1612
+compile-time phenomenon, it is possible to specify C<=data> blocks
1613 1613
 I<after> the point in the source where their contents will be used
1614 1614
 (provided they're not being used in a C<BEGIN>, of course).
1615 1615
 
1616 1616
 When C<$=data> itself is stringified, it returns the concatenation of all
1617  
-the un-keyed C<=data> blocks the parser has seen.
  1617
+the unkeyed C<=data> blocks the parser has seen.
1618 1618
 
1619 1619
 C<=data> blocks are never rendered by the standard Pod renderers.
1620 1620
 
6  S29-functions.pod
Source Rendered
@@ -541,11 +541,11 @@ C<shell> and C<run> execute an external program, and return control to
541 541
 the caller once the program has exited.
542 542
 
543 543
 C<shell> goes through the system shell (C<cmd> on windows, C</bin/sh>
544  
-on Unixish systems), thus interpreting all the usuall shell meta characters.
  544
+on Unixish systems), thus interpreting all the usual shell meta characters.
545 545
 
546 546
 C<run> treats the first argument as an executable name, and the rest of the
547 547
 positional arguments as command line arguments that are passed to the
548  
-exectuable without any processing (except that it encodes Strings to buffers
  548
+executable without any processing (except that it encodes Strings to buffers
549 549
 first, as does C<shell>).
550 550
 
551 551
 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.
813 813
 Dumped.  Restoring from core dumps is in any event not very useful on modern
814 814
 virtual-memory operating systems.  Startup acceleration should be accomplished
815 815
 using a precompiler of some kind (details will be very implementation specific),
816  
-or a pre-forking daemon such as Perl 5's App::Persistant (which will be an
  816
+or a pre-forking daemon such as Perl 5's App::Persistent (which will be an
817 817
 external module when it is ported).
818 818
 
819 819
 =item each
2  S32-setting-library/IO.pod
Source Rendered
@@ -1294,7 +1294,7 @@ operations. It implies C<IO::Readable> and C<IO::Writeable>.
1294 1294
 
1295 1295
 =back
1296 1296
 
1297  
-=head1 Unfiled
  1297
+=head1 Unfilled
1298 1298
 
1299 1299
 =over 4
1300 1300
 
6  S32-setting-library/Numeric.pod
Source Rendered
@@ -64,7 +64,7 @@ Users who provide their own scalar numeric types are encouraged to implement the
64 64
 C<Numeric> role.  It is intended that such types such support the basic arithmetic
65 65
 operators to the extent possible, as well as C<==>.  In addition, it is hoped that
66 66
 comparison operators will at least return consistent results, even if there is no
67  
-sensible mathemtical ordering of your type.  That allows functions like sort to 
  67
+sensible mathematical ordering of your type.  That allows functions like sort to
68 68
 not choke and die if they are handed a value of your type.  (See also the C<Real>
69 69
 role for scalar numeric types that represent real numbers.)
70 70
 
@@ -218,7 +218,7 @@ C<Num>, C<Int>, C<Bool> and C<Rat> implement the C<Real> role.
218 218
 Users who provide their own scalar real numeric types are encouraged to implement the
219 219
 C<Real> role.  Because real numbers are strictly-totally-ordered and
220 220
 C<Real> types try to emulate that property, it is desirable that any two
221  
-C<Real> types be mutally compatible, even if they are not aware of each other.  The
  221
+C<Real> types be mutually compatible, even if they are not aware of each other.  The
222 222
 current proposal requires you to define a C<Bridge> method in your C<Real> type, which
223 223
 converts your type into a neutral C<Real> type by restating it in terms of the fundamental
224 224
 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">.
247 247
 Returns a C<Str> representing the invocant in base C<$base>. Fails if C<$base>
248 248
 is smaller than C<2> or larger than C<36>.
249 249
 
250  
-For bases above ten, the digit repertoire is enhanced with upper-case latin
  250
+For bases above ten, the digit repertoire is enhanced with uppercase latin
251 251
 characters starting from C<A>.
252 252
 
253 253
 =item floor
6  S32-setting-library/Str.pod
Source Rendered
@@ -436,9 +436,9 @@ The directives are:
436 436
  e   a floating-point number, in scientific notation
437 437
  f   a floating-point number, in fixed decimal notation
438 438
  g   a floating-point number, in %e or %f notation
439  
- X   like x, but using upper-case letters
440  
- E   like e, but using an upper-case "E"
441  
- G   like g, but with an upper-case "E" (if applicable)
  439
+ X   like x, but using uppercase letters
  440
+ E   like e, but using an uppercase "E"
  441
+ G   like g, but with an uppercase "E" (if applicable)
442 442
  b   an unsigned integer, in binary
443 443
  C   special: invokes the arg as code, see below
444 444
 

0 notes on commit 45ca8c8

Please sign in to comment.
Something went wrong with that request. Please try again.