cleaned config.*h to prevent some confusion - suckless/dwm - Unnamed repository; edit this file 'description' to name the repository.

diff options

author	arg@10ksloc.org <unknown>	2006-08-01 15:29:37 +0200
committer	arg@10ksloc.org <unknown>	2006-08-01 15:29:37 +0200
commit	7c2e3bb67d07dd1822887bc1ae35d4cd40a6e481 (patch)
tree	337355a76a1f31be4dca86678111db23aae286cd /util.c
parent	b01a51a8449aa591a02ec22eb31850c2ae644687 (diff)
download	dwm-7c2e3bb67d07dd1822887bc1ae35d4cd40a6e481.tar.gz

cleaned config.*h to prevent some confusion

Diffstat (limited to 'util.c')

0 files changed, 0 insertions, 0 deletions

\input bkmacs \pagetag{\oz} \photo{Once you see how it works, it's not so mysterious.}{\pspicture{4in}{oz}{oz}{}} \let\ttfont=\twelvett \chapter{Example: The\/ {\ttfont Functions} Program} \chaptag{\fimp} \normaltext In Chapter \functions\ you used a program called \ttidx{functions} to explore some of Scheme's primitive functions. Now we're going to go back to that program from the other point of view: instead of using the program to learn about functions, we're going to look at how the program works as an example of programming with input and output. \backskipsubhd{The Main Loop}{7} The {\tt functions} program is an infinite loop similar to Scheme's \idx{read-eval-print loop}. It reads in a function name and some arguments, prints the result of applying that function to those arguments, and then does the whole thing over again. There are some complexities, though. The {\tt functions} program keeps asking you for arguments until it has enough. This means that the {\tt read} portion of the loop has to read a function name, figure out how many arguments that procedure takes, and then ask for the right number of arguments. On the other hand, each argument is an implicitly quoted datum rather than an expression to be evaluated; the {\tt functions} evaluator avoids the recursive complexity of arbitrary subexpressions within expressions. (That's why we wrote it:\ to focus attention on one function invocation at a time, rather than on the composition of functions.) Here's the main loop: {\prgex% (define (\ufun{functions-loop}) (let ((fn-name (get-fn))) (if (equal? fn-name 'exit) "Thanks for using FUNCTIONS!" (let ((args (get-args (arg-count fn-name)))) (if (not (in-domain? args fn-name)) (show "Argument(s) not in domain.") (show-answer (apply (scheme-procedure fn-name) args))) (functions-loop))))) } \noindent This invokes a lot of helper procedures. {\tt Arg-count} takes the name of a procedure as its argument and returns the number of arguments that the given procedure takes. {\tt In-domain?} takes a list and the name of a procedure as arguments; it returns {\tt \#t} if the elements of the list are valid arguments to the given procedure. {\tt Scheme-procedure} takes a name as its argument and returns the Scheme procedure with the given name. We'll get back to these helpers later. The other helper procedures are the ones that do the input and output. The actual versions are more complicated because of error checking; we'll show them to you later. {\prgex% (define (get-fn) ;; first version (display "Function: ") (read)) (define (\ufun{get-args} n) (if (= n 0) '() (let ((first (get-arg))) (cons first (get-args (- n 1)))))) (define (get-arg) ;; first version (display "Argument: ") (read)) (define (\ufun{show-answer} answer) (newline) (display "The result is: ") (if (not answer) (show "#F") (show answer)) (newline)) } \noindent (That weird {\tt if} expression in {\tt show-answer} is needed because in some old versions of Scheme the empty list means the same as {\tt \#f}. We wanted to avoid raising this issue in Chapter \functions, so we just made sure that false values always printed as {\tt \#F}.) \subhd{The Difference between a Procedure and Its Name} You may be wondering why we didn't just say {\prgex% (show-answer (apply fn-name args)) } \noindent in the definition of {\tt functions-loop}. Remember that the value of the variable {\tt fn-name} comes from {\tt get-fn}, which invokes {\tt read}. Suppose you said {\medskipamount=3pt\prgexskipamount=10pt {\prgex% (define x (read)) } \noindent and then typed {\prgex% (+ 2 3) } \noindent The value of {\tt x} would be the three element list {\tt (+~2~3)}, not the number five. Similarly, if you type ``butfirst,'' then read will return the {\it word\/} {\tt butfirst}, not the procedure of that name. So we need a way to turn the name of a function into the procedure itself. \backskipsubhd{The Association List of Functions}{4} We accomplish this by creating a huge association list that contains all of the functions the program knows about. Given a word, such as {\tt butfirst}, we need to know three things: \medskip {\parindent=1em\parskip=8pt \bb The Scheme procedure with that name (in this case, the {\tt butfirst} procedure). \bb The number of arguments required by the given procedure (one).\footnt{Some Scheme procedures can accept any number of arguments, but for the purposes of the {\tt functions} program we restrict these procedures to their most usual case, such as two arguments for~{\tt +}.} \bb The types of arguments required by the given procedure (one word or sentence, which must not be empty). }\medskip We need to know the number of arguments the procedure requires because the program prompts the user individually for each argument; it has to know how many to ask for. Also, it needs to know the domain of each function so it can complain if the arguments you give it are not in the domain.\footnt{Scheme would complain all by itself, of course, but would then stop running the {\tt functions} program. We want to catch the error before Scheme does, so that after seeing the error message you're still in {\tt functions}. As we mentioned in Chapter \implhof, a program meant for beginners, such as the readers of Chapter \functions, should be especially robust.} This means that each entry in the association list is a list of four elements: % . It looks like this: {\prgex% (define *the-functions* ;; partial listing (list (list '* * 2 (lambda (x y) (and (number? x) (number? y)))) (list '+ + 2 (lambda (x y) (and (number? x) (number? y)))) (list 'and (lambda (x y) (and x y)) 2 (lambda (x y) (and (boolean? x) (boolean? y)))) (list 'equal? equal? 2 (lambda (x y) #t)) (list 'even? even? 1 integer?) (list 'word word 2 (lambda (x y) (and (word? x) (word? y)))))) } \noindent The real list is much longer, of course, but you get the idea.\footnt{Since {\tt and} is a special form, we can't just say {\prgex% (list 'and and 2 (lambda (x y) (and (boolean? x) (boolean? y)))) } That's because special forms can't be elements of lists. Instead, we have to create a normal procedure that can be put in a list but computes the same function as {\tt and}: {\prgex% (lambda (x y) (and x y)) } \noindent We can get away with this because in the {\tt functions} program we don't care about argument evaluation, so it doesn't matter that {\tt and} is a special form. We do the same thing for {\tt if} and {\tt or}.} It's a convention in Scheme programming that names of global variables used throughout a program are surrounded by {\tt *}asterisks{\tt *} to distinguish them from parameters of procedures. Here are the selector procedures for looking up information in this a-list: {\prgex% (define (\ufun{scheme-procedure} fn-name) (cadr (assoc fn-name *the-functions*))) (define (\ufun{arg-count} fn-name) (caddr (assoc fn-name *the-functions*))) (define (\ufun{type-predicate} fn-name) (cadddr (assoc fn-name *the-functions*))) } \subhd{Domain Checking} } % skip kludge Note that we represent the domain of a procedure by another procedure.\footnt{The domain of a procedure is a set, and sets are generally represented in programs as lists. You might think that we'd have to store, for example, a list of all the legal arguments to {\tt butfirst}. But that would be impossible, since that list would have to be infinitely large. Instead, we can take advantage of the fact that the only use we make of this set is membership testing, that is, finding out whether a particular argument is in a function's domain.} Each domain-checking procedure, or {\it type predicate,\/} takes the same arguments as the procedure whose domain it checks. For example, the type predicate for {\tt +} is {\prgex% (lambda (x y) (and (number? x) (number? y))) } \noindent The type predicate returns {\tt \#t} if its arguments are valid and {\tt \#f} otherwise. So in the case of {\tt +}, any two numbers are valid inputs, but any other types of arguments aren't. Here's the {\tt in-domain?} predicate: {\prgex% (define (\ufun{in-domain?} args fn-name) (apply (type-predicate fn-name) args)) } Of course, certain type predicates are applicable to more than one procedure. It would be silly to type {\prgex% (lambda (x y) (and (number? x) (number? y))) } \noindent for {\tt +}, {\tt -}, {\tt =}, and so on. Instead, we give this function a name: {\prgex% (define (\ufun{two-numbers?} x y) (and (number? x) (number? y))) } \noindent We then refer to the type predicate by name in the a-list: {\prgex% (define *the-functions* ;; partial listing, revised (list (list '* * 2 two-numbers?) (list '+ + 2 two-numbers?) (list 'and (lambda (x y) (and x y)) 2 (lambda (x y) (and (boolean? x) (boolean? y)))) (list 'equal? equal? 2 (lambda (x y) #t)) (list 'even? even? 1 integer?) (list 'word word 2 (lambda (x y) (and (word? x) (word? y)))))) } Some of the type predicates are more complicated. For example, here's the one for the {\tt member?} and {\tt appearances} functions: {\prgex% (define (\ufun{member-types-ok?} small big) (and (word? small) (or (sentence? big) (and (word? big) (= (count small) 1))))) } \noindent {\tt Item} also has a complicated domain: {\prgex% (lambda (n stuff) (and (integer? n) (> n 0) (word-or-sent? stuff) (<= n (count stuff)))) } \noindent This invokes {\tt word-or-sent?}, which is itself the type predicate for the {\tt count} procedure: {\prgex% (define (word-or-sent? x) (or (word? x) (sentence? x))) } On the other hand, some are less complicated. {\tt Equal?} will accept any two arguments, so its type predicate is just {\prgex% (lambda (x y) #t) } The complete listing at the end of the chapter shows the details of all these procedures. Note that the {\tt functions} program has a more restricted idea of domain than Scheme does. For example, in Scheme {\prgex% (and 6 #t) } \noindent returns {\tt \#t} and does not generate an error. But in the {\tt functions} program the argument {\tt 6} is considered out of the domain.\footnt{Why did we choose to restrict the domain? We were trying to make the point that invoking a procedure makes sense only with appropriate arguments; that point is obscured by the complicating fact that Scheme interprets any non-{\tt \#f} value as true. In the {\tt functions} program, where composition of functions is not allowed, there's no benefit to Scheme's more permissive rule.} If you don't like math, just ignore the domain predicates for the mathematical primitives; they involve facts about the domains of math functions that we don't expect you to know.\footnt{A reason that we restricted the domains of some mathematical functions is to protect ourselves from the fact that some version of Scheme support complex numbers while others do not. We wanted to write one version of {\tt functions} that would work in either case; sometimes the easiest way to avoid possible problems was to restrict some function's domain.} \subhd{Intentionally Confusing a Function with Its Name} {\medskipamount=5pt\prgexskipamount=10pt Earlier we made a big deal about the difference between a procedure and its name, to make sure you wouldn't think you can apply the {\it word\/} {\tt butfirst} to arguments. But the {\tt functions} program completely hides this distinction from the user: {\prgex% Function: count Argument: butlast The result is: 7 Function: every Argument: butlast Argument: (helter skelter) The result is: (HELTE SKELTE) } When we give {\tt butlast} as an argument to {\tt count}, it's as if we'd said {\prgex% (count 'butlast) } \noindent In other words, it's taken as a word. But when we give {\tt butlast} as an argument to {\tt every}, it's as if we'd said {\prgex% (every butlast '(helter skelter)) } How can we treat some arguments as quoted and others not? The way this works is that {\it everything\/} is considered a word or a sentence by the {\tt functions} program. The higher-order functions {\tt every} and {\tt keep} are actually represented in the {\tt functions} implementation by Scheme procedures that take the {\it name\/} of a function as an argument, instead of a procedure itself as the ordinary versions do: {\prgex% (define (\ufun{named-every} fn-name list) (every (scheme-procedure fn-name) list)) (define (\ufun{named-keep} fn-name list) (keep (scheme-procedure fn-name) list)) > (every first '(another girl)) (A G) > (named-every 'first '(another girl)) (A G) > (every 'first '(another girl)) ERROR: ATTEMPT TO APPLY NON-PROCEDURE FIRST } } % end skip kludge \noindent This illustration hides a subtle point. When we invoked {\tt named-every} at a Scheme prompt, we had to quote the word {\tt first} that we used as its argument. But when you run the {\tt functions} program, you don't quote anything. The point is that {\tt functions} provides an evaluator that uses a different notation from Scheme's notation. It may be clearer if we show an interaction with an imaginary version of {\tt functions} that {\it does\/} use Scheme notation: {\prgex% Function: first Non-Automatically-Quoted-Argument: 'datum The result is: D Function: first Non-Automatically-Quoted-Argument: datum ERROR: THE VARIABLE DATUM IS UNBOUND. } \noindent We didn't want to raise the issue of quoting at that early point in the book, so we wrote {\tt functions} so that {\it every\/} argument is automatically quoted. Well, if that's the case, it's true even when we're invoking {\tt every}. If you say {\prgex% Function: every Argument: first \ellipsis } \noindent then by the rules of the {\tt functions} program, that argument is the quoted word {\tt first}. So {\tt named-every}, the procedure that pretends to be {\tt every} in the {\tt functions} world, has to ``un-quote'' that argument by looking up the corresponding procedure. \subhd{More on Higher-Order Functions} One of the higher-order functions that you can use in the {\tt functions} program is called {\tt number-of-arguments}. It takes a procedure (actually the name of a procedure, as we've just been saying) as argument and returns the number of arguments that that procedure accepts. This example is unusual because there's no such function in Scheme. (It would be complicated to define, for one thing, because some Scheme procedures can accept a variable number of arguments. What should {\tt number-of-arguments} return for such a procedure?) The implementation of {\tt number-of-arguments} makes use of the same a-list of functions that the {\tt functions} evaluator itself uses. Since the {\tt functions} program needs to know the number of arguments for every procedure anyway, it's hardly any extra effort to make that information available to the user. We just add an entry to the a-list: {\prgex% (list '\ufun{number-of-arguments} arg-count 1 valid-fn-name?) } \noindent The type predicate merely has to check that the argument is found in the a-list of functions: {\prgex% (define (\ufun{valid-fn-name?} name) (assoc name *the-functions*)) } The type checking for the arguments to {\tt every} and {\tt keep} is unusually complicated because what's allowed as the second argument (the collection of data) depends on which function is used as the first argument. For example, it's illegal to compute {\prgex% (every square '(think for yourself)) } \noindent even though either of those two arguments would be allowable if we changed the other one: {\prgex% > (every square '(3 4 5)) (9 16 25) > (every first '(think for yourself)) (T F Y) } The type-checking procedures for {\tt every} and {\tt keep} use a common subprocedure. The one for {\tt every} is {\prgex% (lambda (fn stuff) (hof-types-ok? fn stuff word-or-sent?)) } \noindent and the one for {\tt keep} is {\prgex% (lambda (fn stuff) (hof-types-ok? fn stuff boolean?)) } \noindent The third argument specifies what types of results {\tt fn} must return when applied to the elements of {\tt stuff}. {\prgex% (define (hof-types-ok? fn-name stuff range-predicate) (and (valid-fn-name? fn-name) (= 1 (arg-count fn-name)) (word-or-sent? stuff) (empty? (keep (lambda (element) (not ((type-predicate fn-name) element))) stuff)) (null? (filter (lambda (element) (not (range-predicate element))) (map (scheme-procedure fn-name) (every (lambda (x) x) stuff)))))) } \noindent This says that the function being used as the first argument must be a one-argument function (so you can't say, for example, {\tt every} of {\tt word} and something); also, {\it each element\/} of the second argument must be an acceptable argument to that function. (If you {\tt keep} the unacceptable arguments, you get nothing.) Finally, each invocation of the given function on an element of {\tt stuff} must return an object of the appropriate type:\ words or sentences for {\tt every}, true or false for {\tt keep}.\footnt{That last argument to {\tt and} is complicated. The reason we use {\tt map} instead of {\tt every} is that the results of the invocations of {\tt fn} might not be words or sentences, so {\tt every} wouldn't accept them. But {\tt map} has its own limitation: It won't accept a word as the {\tt stuff} argument. So we use {\tt every} to turn {\tt stuff} into a sentence---which, as you know, is really a list---and that's guaranteed to be acceptable to {\tt map}. (This is an example of a situation in which respecting a data abstraction would be too horrible to contemplate.)} \subhd{More Robustness} The program we've shown you so far works fine, as long as the user never makes a mistake. Because this program was written for absolute novices, we wanted to bend over backward to catch any kind of strange input they might give us. Using {\tt read} to accept user input has a number of disadvantages: \medskip {\parindent=1em \bb If the user enters an empty line, {\tt read} continues waiting silently for input. \bb If the user types an unmatched open parenthesis, {\tt read} continues reading forever. \bb If the user types two expressions on a line, the second one will be taken as a response to the question the {\tt functions} program hasn't asked yet. }\medskip \noindent We solve all these problems by using {\tt read-line} to read exactly one line, even if it's empty or ill-formed, and then checking explicitly for possible errors. {\tt Read-line} treats parentheses no differently from any other character. That's an advantage if the user enters mismatched or inappropriately nested parentheses. However, if the user correctly enters a sentence as an argument to some function, {\tt read-line} will include the initial open parenthesis as the first character of the first word, and the final close parenthesis as the last character of the last word. {\tt Get-arg} must correct for these extra characters. Similarly, {\tt read-line} treats number signs ({\tt #}) like any other character, so it doesn't recognize {\tt #t} and {\tt #f} as special values. Instead it reads them as the strings {\tt "#t"} and {\tt "#f"}. {\tt Get-arg} calls {\tt booleanize} to convert those strings into Boolean values. {\prgex% (define (\ufun{get-arg}) (display "Argument: ") (let ((line (read-line))) (cond ((empty? line) (show "Please type an argument!") (get-arg)) ((and (equal? "(" (first (first line))) (equal? ")" (last (last line)))) (let ((sent (remove-first-paren (remove-last-paren line)))) (if (any-parens? sent) (begin (show "Sentences can't have parentheses inside.") (get-arg)) (map booleanize sent)))) ((any-parens? line) (show "Bad parentheses") (get-arg)) ((empty? (bf line)) (booleanize (first line))) (else (show "You typed more than one argument! Try again.") (get-arg))))) } \hyphenchar\tentt=\count123 \noindent {\tt Get-arg} invokes {\tt any-parens?}, {\tt remove-first-paren}, {\tt remove-last-paren}, and {\tt booleanize}, whose meanings should be obvious from their names. You can look up their definitions in the complete listing at the end of this chapter. \hyphenchar\tentt=-1 {\tt Get-fn} is simpler than {\tt get-arg}, because there's no issue about parentheses, but it's still much more complicated than the original version, because of error checking. {\medskipamount=5pt {\prgex% (define (\ufun{get-fn}) (display "Function: ") (let ((line (read-line))) (cond ((empty? line) (show "Please type a function!") (get-fn)) ((not (= (count line) 1)) (show "You typed more than one thing! Try again.") (get-fn)) ((not (valid-fn-name? (first line))) (show "Sorry, that's not a function.") (get-fn)) (else (first line))))) } \noindent This version of {\tt get-fn} uses {\tt valid-fn-name?} (which you've already seen) to ensure that what the user types is the name of a function we know about. There's a problem with using {\tt read-line}. As we mentioned in a pitfall in Chapter \io, reading some input with {\tt read} and then reading the next input with {\tt read-line} results in {\tt read-line} returning an empty line left over by {\tt read}. Although the {\tt functions} program doesn't use {\tt read}, Scheme itself used {\tt read} to read the {\tt (functions)} expression that started the program. Therefore, {\tt get-fn}'s first attempt to read a function name will see an empty line. To fix this problem, the {\tt functions} procedure has an extra invocation of {\tt read-line}: {\prgex% (define (functions) (read-line) (show "Welcome to the FUNCTIONS program.") (functions-loop)) } } % skip kludge \subhd{Complete Program Listing} \bigskip \listing{functions.scm} \esubhd{Exercises} {\medskipamount=4pt {\exercise The {\tt get-args} procedure has a {\tt let} that creates the variable {\tt first}, and then that variable is used only once inside the body of the {\tt let}. Why doesn't it just say the following? {\prgex% (define (get-args n) (if (= n 0) '() (cons (get-arg) (get-args (- n 1))))) } } \solution The {\tt let} is needed to ensure that the arguments in the returned list are in the correct order: Suppose that the user has chosen a two-argument function, so {\tt functions-loop} calls {\tt get-args} with the argument 2. {\tt Get-args} will ask the user for two arguments; suppose that the user types ``the'' as the first response and ``beatles'' as the second response. So {\tt get-args} {\it should\/} return the list {\tt (the~beatles)}. Let's trace what happens, using the little people model. Glenda the {\tt get-args} specialist is hired, with {\tt n} being 2. Since her {\tt n} isn't 0, she evaluates the {\tt cons} expression. Assume that in this version of Scheme the arguments to a procedure are evaluated from right to left. The first thing that happens is that Glenda hires Gerry, another {\tt get-args} specialist, giving him an argument of 1. (Later, Glenda will hire a {\tt get-arg} specialist, and then a {\tt cons} specialist.) Gerry's job is to get one argument. We'll take a leap of faith and assume that he correctly reads the first expression the user typed, namely, the word {\tt the}. So Gerry returns the list {\tt (the)}. Now Glenda hires a {\tt get-arg} specialist, who reads {\tt beatles} from the user. Glenda then hires a {\tt cons} specialist to insert {\tt beatles} onto the front of {\tt (the)}, giving {\tt (beatles~the)} as her final answer. But this is wrong! Glenda's list is backwards; instead of returning {\tt (the~beatles)} she returned {\tt (beatles~the)}. The {\tt let} in the correct version of {\tt get-args} is to ensure that the call to {\tt read} happens {\it before\/} the recursive call, thus putting the elements into the list in the right order. @ {\exercise The domain-checking function for {\tt equal?} is {\prgex% (lambda (x y) #t) } \noindent This seems silly; it's a function of two arguments that ignores both arguments and always returns {\tt \#t}. Since we know ahead of time that the answer is {\tt \#t}, why won't it work to have {\tt equal?}'s entry in the a-list be {\prgex% (list 'equal? equal? 2 #t) } } \solution The {\tt functions} program uses the type-checking predicate by invoking it with the given arguments. If the entry were {\tt #t} instead of a function, then invoking it would be an error. The relevant part of the program is {\tt in-domain?}: {\prgex% (define (in-domain? args fn-name) (apply (type-predicate fn-name) args)) } \noindent If an entry had {\tt #t} as the type ``predicate,'' then this would be equivalent to {\prgex% (apply #t args) } @ } %%% kludge {\exercise Every time we want to know something about a function that the user typed in, such as its number of arguments or its domain-checking predicate, we have to do an {\tt assoc} in {\tt *the-functions*}. That's inefficient. Instead, rewrite the program so that {\tt get-fn} returns a function's entry from the a-list, instead of just its name. Then rename the variable {\tt fn-name} to {\tt fn-entry} in the {\tt functions-loop} procedure, and rewrite the selectors {\tt scheme-procedure}, {\tt arg-count}, and so on, so that they don't invoke {\tt assoc}. } \solution The changed parts of the program are shown here in boldface. {\prgex% (define (get-fn) (display "Function: ") (let ((line (read-line))) (cond ((empty? line) (show "Please type a function!") (get-fn)) ((not (= (count line) 1)) (show "You typed more than one thing! Try again.") (get-fn)) ((not (valid-fn-name? (first line))) (show "Sorry, that's not a function.") (get-fn)) (else \pmb{(assoc} (first line) \pmb{*the-functions)})))) (define (functions-loop) (let ((\pmb{fn-entry} (get-fn))) (if (equal? \pmb{(function-name fn-entry)} 'exit) "Thanks for using FUNCTIONS!" (let ((args (get-args (arg-count \pmb{fn-entry})))) (if (not (in-domain? args \pmb{fn-entry})) (show "Argument(s) not in domain.") (show-answer (apply (scheme-function \pmb{fn-entry}) args))) (functions-loop))))) (define (function-name \pmb{fn-entry}) (car \pmb{fn-entry})) (define (scheme-function \pmb{fn-entry}) (cadr \pmb{fn-entry})) (define (arg-count \pmb{fn-entry}) (caddr \pmb{fn-entry})) (define (type-predicate \pmb{fn-entry}) (cadddr \pmb{fn-entry})) } A new selector {\tt function-name} was needed to look for the use of the word {\tt exit} in place of a function name. @ {\exercise Currently, the program always gives the message ``argument(s) not in domain'' when you try to apply a function to bad arguments. Modify the program so that each record in {\tt *the-functions*} also contains a specific out-of-domain message like ``both arguments must be numbers,'' then modify {\tt functions} to look up and print this error message along with ``argument(s) not in domain.'' } \solution First we invent a new selector for the error message: {\prgex% (define (domain-error-message fn-name) (car (cddddr (assoc fn-name *the-functions*)))) } \noindent We can't just say {\tt caddddr} because those functions are only defined for up to four steps. For elements this far into the list, it might be clearer to use {\tt list-ref}: {\prgex% (define (domain-error-message fn-name) (list-ref (assoc fn-name *the-functions*) 4)) } Now we use the more specific error message. The changed parts of the procedure are shown here in boldface. {\prgex% (define (functions-loop) (let ((fn-name (get-fn))) (if (equal? fn-name 'exit) "Thanks for using FUNCTIONS!" (let ((args (get-args (arg-count fn-name)))) (if (not (in-domain? args fn-name)) \pmb{(begin} (show "Argument(s) not in domain:") \pmb{(show (domain-error-message fn-name)))} (show-answer (apply (scheme-function fn-name) args))) (functions-loop))))) } Of course we also must update the function list itself: {\prgex% (define *the-functions* (list (list '* * 2 two-numbers? "Both arguments must be numbers.") \ellipsis (list 'butfirst butfirst 1 not-empty? "The argument must be a non-empty word or sentence.") \ellipsis)) } @ \vfill\eject {\exercise Modify the program so that it prompts for the arguments this way: {\prgex% Function: if First Argument: #t Second Argument: paperback Third Argument: writer The result is: PAPERBACK } \noindent but if there's only one argument, the program shouldn't say {\tt First}: {\prgex% Function: sqrt Argument: 36 The result is 6 }} \solution The easiest way is not to modify {\tt get-arg} at all: {\prgex% (define (get-args n) (if (= n 1) (list (get-arg)) (get-args-helper 1 n))) (define (get-args-helper this total) (if (> this total) '() (begin (display (ordinal this)) (display " ") (let ((first (get-arg))) (cons first (get-args-helper (+ this 1) total)))))) (define (ordinal n) (item n '("First" "Second" "Third" "Fourth" "Fifth"))) } But it's a little bit of a kludge that {\tt get-args} prints half the prompt and {\tt get-arg} prints the other half. Instead, we can have {\tt get-args} figure out what the argument prompt should be, and tell {\tt get-arg} what to print: {\prgex% (define (get-args n) (if (= n 1) (list (get-arg "Argument: ")) (get-args-helper 1 n))) (define (get-args-helper this total) (if (> this total) '() (let ((first (get-arg (word (ordinal this) " Argument: ")))) (cons first (get-args-helper (+ this 1) total))))) (define (get-arg prompt) (display prompt) ;;{\rm everything else get-arg used to do$\ldots$} ) } @ {\exercise The {\tt assoc} procedure might return {\tt \#f} instead of an a-list record. How come it's okay for {\tt arg-count} to take the {\tt caddr} of {\tt assoc}'s return value if {\tt (caddr~\#f)} is an error? } \solution {\tt Get-fn} invokes {\tt valid-fn-name?} to check whether or not the requested function is in the a-list. If not, {\tt get-fn} asks for another function name, so the selectors like {\tt arg-count} will never be invoked with this nonexistent name. @ {\exercise Why is the domain-checking predicate for the {\tt word?} function {\prgex% (lambda (x) #t) } \noindent instead of the following procedure? {\prgex% (lambda (x) (word? x)) } } \solution The domain of the {\tt word?} function is {\it anything,} not just words. Invoking the {\tt word?} predicate is like asking the question ``is this a word?'' You can ask that question about anything you like: ``Is {\tt (1~2~3)} a word?'' --- ``No.'' ``Is {\tt \#t} a word?'' --- ``No.'' ``Is {\tt banana} a word?'' --- ``Yes.'' So {\it everything\/} is in the domain of {\tt word?}, and its domain-checking predicate always returns {\tt #t}. Not every predicate has a domain that includes every possible value. For example, the domain of the predicate {\tt even?} is just numbers; you can't ask Scheme the question ``is {\tt banana} even?'' Therefore, not every predicate will have {\prgex% (lambda (x) #t) } \noindent as its domain-checking function. But even for {\tt even?}, it would be silly to use {\tt even?} itself as the domain-checking function. If the domain of a predicate included only those things for which the predicate is true, then that predicate could never return {\tt #f}! That would make it a rather useless predicate. There's a difference between asking Scheme a question to which it replies ``no'' and asking it a meaningless question. % Many people have trouble with the difference between getting back the answer % ``no'' to a question and asking a meaningless question. If I say ``Is 5 % even?'' the answer is no. But if I ask ``Is {\tt elephant} even?'' it's a % meaningless question. The domain of the {\tt even?} primitive is just % numbers. On the other hand, the question ``Is such-and-such a word?'' is % never meaningless, no matter what object I'm asking the question about. @ {\exercise What is the value of the following Scheme expression? {\prgex% (functions) } } \solution Invoking the expression {\tt (functions)} causes a lot of activity to occur, but the value of that expression is always the string {\tt "Thanks for using FUNCTIONS!"} The {\tt functions} procedure has two (or three) expressions in its body, so Scheme evaluates them all and returns the value of the last one. In this case, the last one is a call to {\tt functions-loop}, so whatever {\tt functions-loop} returns, {\tt functions} will return that, too. {\tt Functions-loop} is recursive. In the recursive case, there's a {\tt let} with two expressions, so Scheme evaluates them both and returns the value of the second one. The second expression is a recursive call to {\tt functions-loop}, so whatever the recursive call returns is what the outer call will also return. Thus, the string {\tt "Thanks for using FUNCTIONS!"}, returned by the base case, will be the return value from every single call to {\tt functions-loop}, including the first one, so it will also be the return value from {\tt functions}. @ {\exercise We said in the recursion chapters that every recursive procedure has to have a base case and a recursive case, and that the recursive case has to somehow reduce the size of the problem, getting closer to the base case. How does the recursive call in {\tt get-fn} reduce the size of the problem? } \solution Since {\tt get-fn} has no arguments, the recursive call is exactly the same as the original call, so the problem doesn't get smaller. What saves us is that even the original problem {\it might\/} be solved without getting smaller at all, because it depends on the behavior of the human user of the program. At each recursive invocation, the problem is this: ``If the user enters a correct function, we're done. If not, try again.'' If the user makes a mistake, then the procedure calls itself recursively, with exactly the same problem. And, indeed, this {\it can\/} be an infinite loop, if the user keeps typing incorrect functions. But as soon as the user enters a correct function, the process will terminate. % A call to {\tt get-fn} looks like {\tt (get-fn)}, because the procedure % takes zero arguments. So the recursive call, {\tt (get-fn)} is exactly the % same as the original call. There are two ways to think about this. % % The first is ``The size of the problem {\it doesn't\/} get smaller.'' Since % each call to {\tt get-fn} has the same arguments, the problem never changes, % and there's an infinite loop. Indeed, if you invoke {\tt get-fn} and then % sit in front of the computer forever typing incorrect functions, the {\tt % get-fn} procedure will never return a value. % % The second way to think about this is ``even though the arguments never % change, the state of the world changes between recursive calls, so % eventually the program will return a value.'' In this case, the progress % made by each recursive call is sort of bizarre: after each time the user % incorrectly types the name of a function, he or she is more likely to get it % right the next time. @ \bye


context:
space:
mode: