From f61026119df4700f69eb73e95620bc5928ca0fcb Mon Sep 17 00:00:00 2001 From: User Date: Tue, 13 Oct 2009 02:52:09 +0000 Subject: Grand rename for gitit transfer --- books/Seasoned Schemer | 139 ------------------------------------------------- 1 file changed, 139 deletions(-) delete mode 100644 books/Seasoned Schemer (limited to 'books/Seasoned Schemer') diff --git a/books/Seasoned Schemer b/books/Seasoned Schemer deleted file mode 100644 index 0bc6346..0000000 --- a/books/Seasoned Schemer +++ /dev/null @@ -1,139 +0,0 @@ -============================ -The Seasoned Schemer -============================ - -:by: Daniel Friedman and Matthias Felleisen -:Edition: First (1st) - -See also `Scheme `__. This book is a sequel -to `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/ - -Issues/Omissions --------------------------- -The Y combinator function is never defined in this book, I had to copy it out of -`The Little Schemer`_; - - (define Y - (lambda (thing) - ((lambda (le) - ((lambda (f) (f f)) - (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``: - - (call-with-current-continuation (lambda (hook) ...) - ; is the same as - (letcc hook (...)) - - ; as noted in the book (p. 89) - (try x a b) - ; is the same as - (letcc success - (letcc x - (success a)) - b) - ; is the same as - (call-with-current-continuation - (lambda (success) - (begin - (call-with-current-continuation - (lambda (x) - (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 --------------------------- - -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!** - - - - -- cgit v1.2.3