Fix typos.

ONEWS.html

@@ -133,7 +133,7 @@ <H3>The following are bug fixes since release 1.5:</H3>
    Fixed ``for (x from 0 below 10) x := x + 1 end'' to work correctly
 <P>
    Slot init-args are now processed first to last (ie, the second
-   occurence of a init-keyword is ignored when initializing
+   occurrence of a init-keyword is ignored when initializing
    instances).
 <P>
    Fixed obscure bug in the SAM cache code which caused incorrect

demos/demos.html

@@ -61,7 +61,7 @@ <H2><A HREF="cat/cat.dylan">cat</A></H2>
 <P>
 On most Unix systems you should be able to make it into an executable
 script by concatenating <SAMP>cat-exports.dbc</SAMP> and <SAMP>cat.dbc</SAMP>
-into say <SAMP>mindy-cat</SAMP>, prepending the the line
+into say <SAMP>mindy-cat</SAMP>, prepending the line
 <PRE>
   #<VAR>DYLANDIR</VAR>/bin/mindy -f
 </PRE>
@@ -100,7 +100,7 @@ <H2><A HREF="diff/diff.dylan">diff</A></H2>
 <A HREF="http://legend.gwydion.cs.cmu.edu/gwydion/dylan/docs/htdocs/tools.html">
 Makegen
 </A>
-makefile by contantenating <SAMP>diff-exports.dbc</SAMP> and <SAMP>
+makefile by concatenating <SAMP>diff-exports.dbc</SAMP> and <SAMP>
 diff.dbc</SAMP>.
 
 Limitations: Diff the stand-alone utility is meant purely as a demo.
@@ -145,12 +145,12 @@ <H2><A HREF="html2txt/html2txt.dylan">html2txt</A></H2>
 "environment" defined by the tag and for dumping the collected text from
 within that environment as formatted text.  A basic control loop in
 "process-HTML" is responsible for calling the appropriate tag actions.
-This routine may be called recusively by some of the tag actions.
+This routine may be called recursively by some of the tag actions.
 <P>
 The "interface" between adjacent environments is handled via the "blank"
 parameter which is passed around extensively.  This variable states whether
 a blank line has just been printed.  Thus environments which believe that
-they must be preceded or followed by a blank line can determine whetehr
+they must be preceded or followed by a blank line can determine whether
 they must do anything about it, and we lessen the risk that multiple
 routines will emit blank lines when we only want a maximum of one.
 <P>
@@ -192,7 +192,7 @@ <H2><A HREF="library-demo/library-demo.dylan">library-demo</A></H2>
 </PRE>
 Note however that <SAMP>library-demo-lib.dbc</SAMP> does <EM>not</EM> include
 the <CODE>Fact</CODE> library.  Instead this is demand-loaded by searching on
-<SAMP>DYLANPATH</SAMP> for <SAMP>fact-lib.dbc</SAMP> (preferrably) or
+<SAMP>DYLANPATH</SAMP> for <SAMP>fact-lib.dbc</SAMP> (preferably) or
 <SAMP>fact.dbc</SAMP>.  Sometimes you can get in trouble if the
 <SAMP>-lib.dbc</SAMP> file doesn't appear in <SAMP>DYLANPATH</SAMP> before some
 other file that happens to use the unsuffixed name.

demos/hello-world/hello-world.dylan

@@ -7,7 +7,7 @@ module: Hello-World
 // ignore them.
 //
 // Note that even something this simplistic must have its own module and a
-// seperate hello-world-exports.dylan file to set up the library and module.
+// separate hello-world-exports.dylan file to set up the library and module.
 //
 define method main (argv0 :: <byte-string>, #rest noise)
   puts("Hello, World.\n");

demos/html2txt/html2txt.dylan

@@ -46,7 +46,7 @@ synopsis:        Converts a file in WWW "HyperText Markup Language" into
 // source file.
 //
 // On most unix systems you should be able to make it into an executable
-// script by prepending the the line
+// script by prepending the line
 //   #!BINDIR/mindy -f
 // to the compiled "dbc" file.  You must, of course, remember to specify the
 // MINDYPATH environment variable so that it points to the libraries "dylan",
@@ -59,12 +59,12 @@ synopsis:        Converts a file in WWW "HyperText Markup Language" into
 // "environment" defined by the tag and for dumping the collected text from
 // within that environment as formatted text.  A basic control loop in
 // "process-HTML" is responsible for calling the appropriate tag actions.
-// This routine may be called recusively by some of the tag actions.
+// This routine may be called recursively by some of the tag actions.
 //
 // The "interface" between adjacent environments is handled via the "blank"
 // parameter which is passed around extensively.  This variable states whether
 // a blank line has just been printed.  Thus environments which believe that
-// they must be preceded or followed by a blank line can determine whetehr
+// they must be preceded or followed by a blank line can determine whether
 // they must do anything about it, and we lessen the risk that multiple
 // routines will emit blank lines when we only want a maximum of one.
 //
@@ -143,7 +143,7 @@ define method rsfind(seq :: <sequence>, pred?,
 end method rsfind;
 
 // The notation "'!' * 5" is a good way to create a string of repeated
-// characters.  This variety of overloaing is becoming popular in several
+// characters.  This variety of overloading is becoming popular in several
 // modern languages (i.e. C++, Perl, and Ada).
 define method \*(ch :: <character>,
                  times :: <integer>)  => (result :: <byte-string>);
@@ -154,7 +154,7 @@ end method \*;
 //                             Basic HTML Utilities                      //
 ////////////////////////////////////////////////////////////////////////
 
-// Simply a conventient shorthand for writing to *standard-output*.
+// Simply a convenient shorthand for writing to *standard-output*.
 define method write-string(string :: <string>)
   write(*standard-output*, string);
 end method write-string;
@@ -368,7 +368,7 @@ define method process-HTML(Tag :: <symbol>, Out-Text :: <strings>,
                                                 start: first)));
         // Call the appropriate action for the tag.  This may invoke
         // a recursive call to "process-HTML" for start tags and will exit
-        // this recusive call for closing tags.
+        // this recursive call for closing tags.
         Current-Text := copy-sequence(Current-Text, start: End-Tag + 1);
         if (Is-Close)
           return(Current-Text, tag-close(Tag, New-Tag, Out-Text, blank));
@@ -401,7 +401,7 @@ define method process-HTML(Tag :: <symbol>, Out-Text :: <strings>,
   end block
 end method process-HTML;
 
-// specialized routines to open various sourts of streams and invoke
+// specialized routines to open various sorts of streams and invoke
 // "process-HTML".
 define method html2text(fd :: <stream>) => ();
   process-HTML(#"TEXT", make(<strings>), "", fd, #t);
@@ -498,7 +498,7 @@ add-tag(#["TEXT"],               // Default environment
 
 // This tag action is used for many different tags -- it simply invokes
 // "process-HTML" recursively without doing anything special to the
-// accumulated text.  This is handy for "lightweight" enviromentents like
+// accumulated text.  This is handy for "lightweight" environments like
 // "<I>".
 define constant tag-start-recurse =
   method (New-Tag :: <symbol>, Old-Tag :: <symbol>,
@@ -509,8 +509,8 @@ define constant tag-start-recurse =
   end method;
 
 // This tag action is a logical partner for "tag-start-recurse".  It simply
-// exits so that control will return to an inclosing "process-HTML" call
-// without distrubing the accumulated text.
+// exits so that control will return to an enclosing "process-HTML" call
+// without disturbing the accumulated text.
 define constant tag-close-nothing =
   method (tag :: <symbol>, Out-Text :: <strings>, blank :: <boolean>)
     blank;

demos/tk-html2txt/html2txt.dylan

@@ -46,7 +46,7 @@ synopsis:        Converts a file in WWW "HyperText Markup Language" into
 // source file.
 //
 // On most unix systems you should be able to make it into an executable
-// script by prepending the the line
+// script by prepending the line
 //   #!BINDIR/mindy -f
 // to the compiled "dbc" file.  You must, of course, remember to specify the
 // MINDYPATH environment variable so that it points to the libraries "dylan",
@@ -59,12 +59,12 @@ synopsis:        Converts a file in WWW "HyperText Markup Language" into
 // "environment" defined by the tag and for dumping the collected text from
 // within that environment as formatted text.  A basic control loop in
 // "process-HTML" is responsible for calling the appropriate tag actions.
-// This routine may be called recusively by some of the tag actions.
+// This routine may be called recursively by some of the tag actions.
 //
 // The "interface" between adjacent environments is handled via the "blank"
 // parameter which is passed around extensively.  This variable states whether
 // a blank line has just been printed.  Thus environments which believe that
-// they must be preceded or followed by a blank line can determine whetehr
+// they must be preceded or followed by a blank line can determine whether
 // they must do anything about it, and we lessen the risk that multiple
 // routines will emit blank lines when we only want a maximum of one.
 //
@@ -390,7 +390,7 @@ define method rsfind(seq :: <sequence>, pred?,
 end method rsfind;
 
 // The notation "'!' * 5" is a good way to create a string of repeated
-// characters.  This variety of overloaing is becoming popular in several
+// characters.  This variety of overloading is becoming popular in several
 // modern languages (i.e. C++, Perl, and Ada).
 define method \*(ch :: <character>,
                  times :: <integer>)  => (result :: <byte-string>);
@@ -401,7 +401,7 @@ end method \*;
 //                             Basic HTML Utilities                      //
 ////////////////////////////////////////////////////////////////////////
 
-// Simply a conventient shorthand for writing to *window-stream*.
+// Simply a convenient shorthand for writing to *window-stream*.
 define method write-string(string :: <string>)
   if (html-status == #"aborting")
     abort();
@@ -620,7 +620,7 @@ define method process-HTML(Tag :: <symbol>, Out-Text :: <strings>,
                                                 start: first)));
         // Call the appropriate action for the tag.  This may invoke
         // a recursive call to "process-HTML" for start tags and will exit
-        // this recusive call for closing tags.
+        // this recursive call for closing tags.
         Current-Text := copy-sequence(Current-Text, start: End-Tag + 1);
         if (Is-Close)
           return(Current-Text, tag-close(Tag, New-Tag, Out-Text, blank));
@@ -653,7 +653,7 @@ define method process-HTML(Tag :: <symbol>, Out-Text :: <strings>,
   end block
 end method process-HTML;
 
-// specialized routines to open various sourts of streams and invoke
+// specialized routines to open various sorts of streams and invoke
 // "process-HTML".
 define method html2text(fd :: <stream>) => ();
   grab-lock(html-status-lock);
@@ -770,7 +770,7 @@ add-tag(#["TEXT"],               // Default environment
 
 // This tag action is used for many different tags -- it simply invokes
 // "process-HTML" recursively without doing anything special to the
-// accumulated text.  This is handy for "lightweight" enviromentents like
+// accumulated text.  This is handy for "lightweight" environments like
 // "<I>".
 define constant tag-start-recurse =
   method (New-Tag :: <symbol>, Old-Tag :: <symbol>,
@@ -781,8 +781,8 @@ define constant tag-start-recurse =
   end method;
 
 // This tag action is a logical partner for "tag-start-recurse".  It simply
-// exits so that control will return to an inclosing "process-HTML" call
-// without distrubing the accumulated text.
+// exits so that control will return to an enclosing "process-HTML" call
+// without disturbing the accumulated text.
 define constant tag-close-nothing =
   method (tag :: <symbol>, Out-Text :: <strings>, blank :: <boolean>)
     blank;

doc/dylan.7.in

@@ -5,7 +5,7 @@
 Dylan \- An object-oriented, dynamic language.
 .SH DESCRIPTION
 Dylan is an object-oriented, dynamic, infix, garbage\-collected programming
-language with support for multiple inheritence, multiple dispatch (an
+language with support for multiple inheritance, multiple dispatch (an
 advanced form of polymorphism), typed and untyped variables, closures and
 exceptions. Dylan also supports pattern-based hygenic macros. These allow
 you to define new control constructs and fully integrate them with the
@@ -51,7 +51,7 @@ omits the meta-object protocol and method combination rules.
 Dylan did include, however, many new features to help the compiler generate
 efficient code. Programmers can specify type declarations to help the
 compiler infer types, or they can omit the type declarations if they don't
-care about peformance. Special classes allow the efficient representation
+care about performance. Special classes allow the efficient representation
 of vectors and arrays of primitive types. Libraries can forbid their
 clients to subclass certain types, allowing method dispatch to be performed
 at compile time.
@@ -64,21 +64,21 @@ A good Dylan compiler can match a C or C++ compiler in most ways, providing
 the programmer is willing to use type declarations and avoid the more
 expensive features.
 .PP
-Harlequin's Dylan compiler can generate code which matches the performace
+Harlequin's Dylan compiler can generate code which matches the performance
 of C on many benchmarks, even those involving complex numeric calculations.
 Gwydion Dylan generates code about half as good as the underlying C
 compiler. Limited collection types must be used when processing large
 amounts of data, of course.
 .PP
 Memory usage for a Dylan program is about twice that of an equivalent C
-program, thanks to the garbage collector. However, the amortitized
+program, thanks to the garbage collector. However, the amortized
 allocation and collection speed of a good modern garbage collector is
 effectively the same as that of malloc and free.
 .PP
 Using recent research, generic function dispatch can be performed at the
 price of three or four instructions per polymorphic argument. Membership in
 a class can be determined in constant time. Graph-coloring algorithms can
-be used to optimize slot access in the presence of multiple inheritence.
+be used to optimize slot access in the presence of multiple inheritance.
 .PP
 In light of these facts, Dylan appears to be a good choice for application
 development and an entirely reasonable choice for certain kinds of systems

doc/melange.1.in

@@ -56,7 +56,7 @@ C compiler.
 .PP
 Eventually, we want Melange to handle any header which GCC can parse. For
 the time being, generating interfaces is more of an art, and any large set
-of headers is virtually gauranteed to find a new bug. Please report every
+of headers is virtually guaranteed to find a new bug. Please report every
 bug you encounter to
 .IR [email protected] ,
 preferably with a short example. We're trying to locate and fix all the

libraries/collection-extensions/sequence-utils.dylan

@@ -483,7 +483,7 @@ define function alist-delete (elt, alist :: <sequence>,
          alist);
 end function alist-delete;
 
-// SATISFIES -- find the first element that satifies PRED.
+// SATISFIES -- find the first element that satisfies PRED.
 //
 define method satisfies
     (pred :: <function>, seq :: <sequence>,

libraries/collection-extensions/solist.dylan

@@ -41,7 +41,7 @@ synopsis:        Provides "self-organizing lists".  These explicit key
 // time in the best case.
 //
 // Because they have a very low overhead, self-organizing lists may
-// provide better peformance than hash tables in cases where
+// provide better performance than hash tables in cases where
 // references have a high degree of temporal locality.  They may also
 // be useful in situations where it is difficult to create a proper
 // hash function.

libraries/collection-extensions/strsearch.dylan

@@ -66,7 +66,7 @@ synopsis:        Provides a small assortment of specialized operations for
 //
 //     As a further optimization, you may pre-compute a "compiled" dispatch
 //     table for the pattern with compile-substring and pass it in (along with
-//     the pattern itselef) via the compiled: keyword.  This will save both
+//     the pattern itself) via the compiled: keyword.  This will save both
 //     time and space if you are searching for the same pattern repeatedly.
 //
 // compile-substring pattern => compiled
@@ -75,7 +75,7 @@ synopsis:        Provides a small assortment of specialized operations for
 //     strings, thus avoiding one of the more expensive parts of the search.
 //
 // replace-substring big pattern goal #key count compiled => result
-//     Replaces all (or up to count) occurences of pattern in big with goal.
+//     Replaces all (or up to count) occurrences of pattern in big with goal.
 //     As in substring-position all three arguments must be <byte-string>s.
 //     Accepts the compiled: keyword as described above.  Returns a new string
 //     iff it finds at least one match to replace.
@@ -185,7 +185,7 @@ define method compile-substring(pattern :: <byte-string>) => (compiled);
   end if;
 end method;
 
-// Replaces all (or up to count:) occurences of pattern in big with goal.
+// Replaces all (or up to count:) occurrences of pattern in big with goal.
 // Accepts the "compiled:" keyword as described above.  Returns a new string
 // or the unmodified original.
 define method

libraries/dylan/cmp.dylan

@@ -28,7 +28,7 @@ author: William Lott ([email protected])
 //
 //======================================================================
 //
-// This file contains the comparisons that arn't built in.
+// This file contains the comparisons that aren't built in.
 //
 
 

libraries/dylan/coll.dylan

@@ -321,7 +321,7 @@ define method any?(proc :: <function>, collection :: <collection>,
   end block;
 end method any?;
 
-// Pick off 1-collection list case for efficency.
+// Pick off 1-collection list case for efficiency.
 define method any?(proc :: <function>, collection :: <list>,
                     #next next-method, #rest more-collections)
  => answer :: <object>;
@@ -365,7 +365,7 @@ define method every?(proc :: <function>, collection :: <collection>,
   end block;
 end method every?;
 
-// Pick off 1-collection list case for efficency.
+// Pick off 1-collection list case for efficiency.
 define method every?(proc :: <function>, collection :: <list>,
                     #next next-method, #rest more-collections)
  => answer :: <boolean>;
@@ -729,7 +729,7 @@ define method fill!(sequence :: <mutable-sequence>, value :: <object>,
                     #next next-method,
                     #key start: first = 0, end: last)
  => seq :: <mutable-sequence>;
-  // The "collection" method will likely be faster if there are no keywrds.
+  // The "collection" method will likely be faster if there are no keywords.
   if (first = 0 & ~last) next-method() end if;
 
   let (init-state, limit, next-state, done?,

libraries/dylan/deque.dylan

@@ -52,7 +52,7 @@ author: David Pierce ([email protected])
 // <deque-element> -- internal
 //
 // Each <deque-element> has a DEQUE-ELEMENT-DATA slot and slots for the
-// prvious and next deque elements.  If there is no PREV-DEQUE-ELEMENT or
+// previous and next deque elements.  If there is no PREV-DEQUE-ELEMENT or
 // NEXT-DEQUE-ELEMENT, the marker #f should be used in these slots.
 //
 define class <deque-element> (<object>)

libraries/dylan/extern.dylan

@@ -370,7 +370,7 @@ end method import-value;
 define class <c-vector> (<vector>, <statically-typed-pointer>) end class;
 
 // C does not do bounds checking on vectors, and many of the interface files
-// make use of this weakngess.  Therefore, we do no bounds checking either.
+// make use of this weakness.  Therefore, we do no bounds checking either.
 // Caveat emptor.
 //
 define method element
@@ -380,7 +380,7 @@ define method element
 end method element;
 
 // C does not do bounds checking on vectors, and many of the interface files
-// make use of this weakngess.  Therefore, we do no bounds checking either.
+// make use of this weakness.  Therefore, we do no bounds checking either.
 // Caveat emptor.
 //
 define method element-setter
@@ -389,7 +389,7 @@ define method element-setter
   pointer-value(vec, index: index) := value;
 end method element-setter;
 
-// For "normal" ponters, the size is "#f", indicating that the size is unknown
+// For "normal" pointers, the size is "#f", indicating that the size is unknown
 // and potentially infinite.  However, subtypes can redefine this to higher
 // values and the iteration protocol will still work.
 //

libraries/dylan/range.dylan

@@ -755,7 +755,7 @@ end method;
 // element of the original range, by: the negative of the original by,
 // with size: the size of the original range.
 //
-// Unbounded ranges cannot be reversed.p
+// Unbounded ranges cannot be reversed.
 //
 define method reverse (range-to-reverse :: <bounded-range>)
  => new-range :: <range>;