Fixed many misprints signalled by Marek Kubica

6 files changed, 8 insertions, 7 deletions

diff --git a/artima/scheme/scheme18.ss b/artima/scheme/scheme18.ss
index 2a747b5..9fc6236 100644
--- a/artima/scheme/scheme18.ss
+++ b/artima/scheme/scheme18.ss
@@ -109,7 +109,7 @@ the same iterator returns different values:
  2
 
 Thus, Python iterators *are not functional*.  Functional languages
-such as Scheme ML and Haskell have no imperative iterators: they have
+such as Scheme, ML and Haskell have no imperative iterators: they have
 *streams* instead.  Ikarus comes with a built-in stream
 library, so that I can give a concrete example right now (of course
 you can use streams in other implementations simply by using the
diff --git a/artima/scheme/scheme19.ss b/artima/scheme/scheme19.ss
index 5f2511f..1c5c872 100644
--- a/artima/scheme/scheme19.ss
+++ b/artima/scheme/scheme19.ss
@@ -278,7 +278,7 @@ between R6RS-conforming implementations.
 
 All the *Adventures* have my name at the top and I take full
 responsibility for the opinions and the mistakes. But for
-the parts which are correct, I deserves little credit, since
+the parts which are correct, I deserve little credit, since
 most of the time I am just reporting advice which I have received
 from the Scheme community, mostly from comp.lang.scheme and
 ikarus-users, as well from private emails. This is true for all of
diff --git a/artima/scheme/scheme27.ss b/artima/scheme/scheme27.ss
index 3e7d030..1290ce8 100644
--- a/artima/scheme/scheme27.ss
+++ b/artima/scheme/scheme27.ss
@@ -7,7 +7,7 @@ The concept is peculiar to Scheme and has no counterpart in other
 languages (including Common Lisp), therefore it is worth to spend some time
 on it.
 
-A *syntax-object* is a kind of enhanced *s*-espression: it contains
+A *syntax-object* is a kind of enhanced *s*-expression: it contains
 the source code as a list of symbols and primitive values, but also
 additional informations, such as
 the name of the file containing the source code, the position
diff --git a/artima/scheme/scheme28.ss b/artima/scheme/scheme28.ss
index 5ae4b42..40d4779 100644
--- a/artima/scheme/scheme28.ss
+++ b/artima/scheme/scheme28.ss
@@ -52,8 +52,7 @@ that ``syntax-rules`` macros do not have guarded patterns; the most direct
 consequence is that providing good error messages for incorrect syntax
 is more difficult. You may learn everything you ever wanted to know
 about ``syntax-rules`` in the `Syntax-Rules Primer for the Mildly Insane`_
-by Joe Marshall.
-
+by Al Petrofsky.
 
 ``syntax-match`` vs ``syntax-case``
 -----------------------------------------------------------------
diff --git a/artima/scheme/scheme29.ss b/artima/scheme/scheme29.ss
index 80212e7..27734b5 100644
--- a/artima/scheme/scheme29.ss
+++ b/artima/scheme/scheme29.ss
@@ -10,7 +10,9 @@ Consider for instance the following trivial macro:
 $$DEFINE-A*
 
 ``(define-a x)`` *apparently* expand to ``(define a x)``, so
-you may find the following surprising::
+you may find the following surprising:
+
+.. code-block:: scheme
 
  > (define-a 1)
  > a
diff --git a/artima/scheme/scheme3.ss b/artima/scheme/scheme3.ss
index b77cc57..84970b5 100644
--- a/artima/scheme/scheme3.ss
+++ b/artima/scheme/scheme3.ss
@@ -189,7 +189,7 @@ Moreover, concrete implementations often have a lot of useful
 But let me go back to syntax. It must be noted that the prefix syntax
 has enourmous advantages when macros enter the game. The absolute
 regularity of Scheme/Lisp programs, which are sequences of
-*s*-espressions of the form
+*s*-expressions of the form
 
   ``(arguments ...)``