commit b3ded9511dd252130946525afcacdca7c18f008a
parent 030c938b34925733b1066d3658e9dc16a5e94596
Author: Greg Hendershott <greghendershott@gmail.com>
Date: Wed, 24 Oct 2012 17:41:28 -0400
Spell check.
Diffstat:
| M | main.rkt | | | 28 | ++++++++++++++-------------- |
1 file changed, 14 insertions(+), 14 deletions(-)
diff --git a/main.rkt b/main.rkt
@@ -44,7 +44,7 @@ I'm starting to write this at the point where the shapes are slowly
emerging from the fog.
My primary motive is selfish. Explaining something forces me to learn
-it more thorougly. Plus I expect that if I write something with
+it more thoroughly. Plus I expect that if I write something with
mistakes, other people will be eager to point them out and correct
me. Is that a social-engineering variation of meta-programming? Next
question, please. :)
@@ -91,7 +91,7 @@ about "hygiene".]
4. Finally, we'll realize that our macros could be smarter when
they're used in error. Normal Racket functions can optionally have
contracts and types. These can catch mistakes and provide clear,
-useful error messages. It would be great if there were somthing
+useful error messages. It would be great if there were something
similar for macros, and there is. One of the more-recent Racket macro
enhancements is @racket[syntax-parse].
@@ -250,8 +250,8 @@ What's going on here? First we take the input syntax, and give it to
(syntax->datum #'(reverse-me "backwards" "am" "i" values))
]
-Using @racket[cdr] slics off the first item of the list,
-@racket[reverse-me], leaving the rmainder:
+Using @racket[cdr] slices off the first item of the list,
+@racket[reverse-me], leaving the remainder:
@racket[("backwards" "am" "i" values)]. Passing that to
@racket[reverse] changes it to @racket[(values "i" "am" "backwards")]:
@@ -379,7 +379,7 @@ and @racket[cadddr] and arrange them into a @racket[cond] form:
[else ,(cadddr xs)]))
]
-So that works, but using @racket[cdddr] etc. to destructure a list is
+So that works, but using @racket[cadddr] etc. to destructure a list is
painful and error-prone. Maybe you know Racket's @racket[match]?
Using that would let us do pattern-matching.
@@ -411,7 +411,7 @@ We can write:
]
But wait, we can't. It's complaining that @racket[match] isn't
-defined. We havne't required the @racket[racket/match] module?
+defined. We haven't required the @racket[racket/match] module?
It turns out we haven't. Remember, this transformer function is
working at compile time, not run time. And at compile time, only
@@ -446,7 +446,7 @@ for writing syntax transformers. We can write these transformer
functions using familiar Racket code. The semi-bad news is that the
familiarity can make it easy to forget that we're not working at run
time. Sometimes that's important to remember. For example only
-@racket[racket/base] is required for us automtically. If we need other
+@racket[racket/base] is required for us automatically. If we need other
modules, we have to require them, and we have to require them
@italic{for compile time} using @racket[(require (for-syntax))].
@@ -456,7 +456,7 @@ modules, we have to require them, and we have to require them
Most useful syntax transformers work by taking some input syntax, and
rearranging the pieces into something else. As we saw, this is
-possible but tedious using list accessors such as @racket[cdddr]. It's
+possible but tedious using list accessors such as @racket[cadddr]. It's
more convenient and less error-prone to use pattern-matching.
@margin-note{Historically, @racket[syntax-case] and
@@ -490,9 +490,9 @@ Here's what it looks like using @racket[syntax-case]:
(our-if-using-syntax-case #t "true" "false")
]
-Prety similar, huh? The pattern part looks almost exactly the
+Pretty similar, huh? The pattern part looks almost exactly the
same. The "template" part---where we specify the new syntax---is
-simpler. We don't need to do quasiquoting and unquoting. We don't need
+simpler. We don't need to do quasi-quoting and unquoting. We don't need
to use @racket[datum->syntax]. We simply supply a template, which uses
variables from the pattern.
@@ -507,7 +507,7 @@ into @racket[syntax-case]. It's called @racket[define-syntax-rule]:
]
Here's the thing about @racket[define-syntax-rule]. Because it's so
-simple, @racket[define-syntax-rule] is ofen the first thing people are
+simple, @racket[define-syntax-rule] is often the first thing people are
taught about macros. But it's almost deceptively simple. It looks so
much like defining a normal run time function---yet it's not. It's
working at compile time, not run time. Worse, the moment you want to
@@ -531,7 +531,7 @@ Instead, let's look at some ways we're likely to get tripped up.
Let's say we want to define a function with a hyphenated name, a-b,
but we supply the a and b parts separately. The Racket @racket[struct]
-form does somethin like this---if we define a @racket[struct] named
+form does something like this---if we define a @racket[struct] named
@racket[foo], it defines a number of functions whose names are
variations on the name @racket[foo], such as @racket[foo-field1],
@racket[foo-field2], @racket[foo?], and so on.
@@ -767,7 +767,7 @@ TO-DO.
@; ----------------------------------------------------------------------------
-@section{References/Acknowledgements}
+@section{References/Acknowledgments}
Eli Barzliay wrote a blog post,
@hyperlink["http://blog.racket-lang.org/2011/04/writing-syntax-case-macros.html" "Writing
@@ -786,7 +786,7 @@ before PLT Scheme was renamed to Racket.
@; ----------------------------------------------------------------------------
-@section{Epilog}
+@section{Epilogue}
@centered{
"Before I had studied Chan (Zen) for thirty years, I saw mountains as
