summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorbnewbold <bnewbold@eta.mit.edu>2009-01-22 09:50:53 -0500
committerbnewbold <bnewbold@eta.mit.edu>2009-01-22 09:50:53 -0500
commitf18ba63a8b3d39bc9f2ca8dbe6d766d0dd5f77ec (patch)
tree52e96df028a979e4a5c2604441b62f1cf4c02ea6
parent0762c86c9f1f3d68411cbbc0012e3fe075560887 (diff)
downloadknowledge-f18ba63a8b3d39bc9f2ca8dbe6d766d0dd5f77ec.tar.gz
knowledge-f18ba63a8b3d39bc9f2ca8dbe6d766d0dd5f77ec.zip
added commandments, notes
-rw-r--r--books/Seasoned Schemer94
1 files changed, 90 insertions, 4 deletions
diff --git a/books/Seasoned Schemer b/books/Seasoned Schemer
index ed2a3fb..0bc6346 100644
--- a/books/Seasoned Schemer
+++ b/books/Seasoned Schemer
@@ -5,10 +5,21 @@ The Seasoned Schemer
:by: Daniel Friedman and Matthias Felleisen
:Edition: First (1st)
-See also `Scheme </k/software/scheme/>`__.
+See also `Scheme </k/software/scheme/>`__. This book is a sequel
+to `The Little Schemer`_; The Reasoned Schemer is a paralel exploration of
+logical programming.
-This book is a sequel `The Little Schemer`_;
-The Reasoned Schemer is a paralel exploration of logical programming.
+One of the things I liked about learning a programming language this way, or
+maybe just about scheme in general, is the seperation between the specification
+and implementations. Usually when I start learning a new language I try to
+break it as fast as possible and I am most interested in how certain little
+tricky bits are handled (are the file handles cross platform? does it catch
+infinite recursion? what kind of errors are thrown when? how big are the
+primitives and simple objects/user defined data types?). These are the
+imporant day to day issues and are a good basis for choosing a language to get
+work done in, but it's kind of like searching for anti-aliasing in digital
+photos or scanning the edges of a wall for painting mistakes. Sometimes the
+big picture is the whole point and it's worth putting up with small flaws.
.. _The Little Schemer: /k/books/littleschemer/
@@ -24,6 +35,18 @@ The Y combinator function is never defined in this book, I had to copy it out of
(lambda (f) (le (lambda (x) ((f f) x))))))
thing)))
+Also ``eqlist?``::
+
+ (define eqlist?
+ (lambda (a b)
+ (cond
+ ((and (null? a) (null? b)) #t)
+ ((or (null? a) (null? b)) #f)
+ ((and (atom? (car a)) (atom? (car b)))
+ (and (eqlist? (cdr a) (cdr b))))
+ ((or (atom? (car a)) (atom? (car b))) #f)
+ (else (and (eqlist? (car a) (car b)) (eqlist? (cdr a) (cdr b)))))))
+
MIT/GNU Scheme doesn't seem to have ``letcc`` or ``try``; I stuck with
``call-with-current-continuation``:
@@ -47,7 +70,70 @@ MIT/GNU Scheme doesn't seem to have ``letcc`` or ``try``; I stuck with
(success a)))
b)))
+When reimplementing scheme at the end of the book, I'm kind of miffed that the
+(letcc ...) definition basically just uses letcc, because magic North Pole
+compasses seem like the most interesting part.
+
+Notes
+-----------------
+Y-bang is the "applicative-order imperative Y combinator"::
+
+ (define Y-bang
+ (lambda (f)
+ (letrec
+ ((h (f (lambda (arg) (h arg)))))
+ h)))
+
+At one point I wondered::
+
+ Is there any language/interpreter which, when it runs into an undefined
+ value, lets you define it on the spot? Would be great for learners.
+
+MIT/GNU Scheme, of course, has this feature in the error REPL. But I never
+noticed it.
The Next 10 Commandments
--------------------------
-TODO
+
+The Eleventh Commandment
+ Use additional arguments when a function needs to know what other
+ arguments to the function have been like so far.
+
+The Twelfth Commandment
+ Use (letrec ..) to remove arguments that do not change for
+ recursive applications.
+
+The Thirteenth Commandment
+ Use (letrec ...) to hide and protect functions.
+
+The Fifteenth Commandment
+ Use (let ...) to name the values of repeated expressions in a function
+ definition if they may be evaluated twice for one and same use of the
+ function. And use (let ...) to name the values of expressions (without
+ set!) that are re-evaluated every time a function is used.
+
+The Sixteenth Commandment
+ Use (set! ...) only with names define in (let ...)s
+
+The Seventeenth Commandment
+ Use (set! x ...) for (let ((x ..)) ..)) only if there is at least one
+ (lambda .. between it and the (let ..), or if the new value for x is a
+ function that refers to x.
+
+The Eighteenth Commandment
+ Use (set! x ...) only when the value that x refers to is no longer needed.
+
+The Nineteenth Commandment
+ Use (set! ...) to remember valuable things between two distinct uses of a
+ function.
+
+The Twentieth Commandment
+ When thinking about a value created with (letcc ...), write down the
+ function that is equivalent but does not forget. Then, when you use it,
+ remember to forget.
+
+**I love that last sentence!**
+
+
+
+