www

meval-fascicule.lisp (44314B)

---

 #|
 Exo 4.1 Vérifier ce que fait la fonction "error" dans le poly ou le manuel en ligne.
 
 24.1. General Error-Signaling Functions (beginning only)
 The functions in this section provide various mechanisms for signaling warnings, breaks, 
 continuable errors, and fatal errors.
 
 In each case, the caller specifies an error message (a string) that may be processed (and 
 perhaps displayed to the user) by the error-handling mechanism. All messages are constructed 
 by applying the function format to the quantities nil, format-string, and all the args to produce 
 a string.
 
 An error message string should not contain a newline character at either the beginning or end, 
 and should not contain any sort of herald indicating that it is an error. The system will take care
 of these according to whatever its preferred style may be.
 
 Conventionally, error messages are complete English sentences ending with a period. 
 Newlines in the middle of long messages are acceptable. There should be no indentation after
 a newline in the middle of an error message. The error message need not mention the name of the 
 function that signals the error; it is assumed that the debugger will make this information available.
 
 Implementation note: If the debugger in a particular implementation displays error messages 
 indented from the prevailing left margin (for example, indented by seven spaces because they 
 are prefixed by the seven-character herald ``Error: ''), then the debugger should take care of 
 inserting the appropriate indentation into a multi-line error message. Similarly, a debugger that 
 prefixes error messages with semicolons so that they appear to be comments should take care of 
 inserting a semicolon at the beginning of each line in a multi-line error message. These rules 
 are suggested because, even within a single implementation, there may be more than one program 
 that presents error messages to the user, and they may use different styles of presentation. 
 The caller of error cannot anticipate all such possible styles, and so it is incumbent upon the 
 presenter of the message to make any necessary adjustments.
 
 Common Lisp does not specify the manner in which error messages and other messages are displayed. 
 For the purposes of exposition, a fairly simple style of textual presentation will be used in the 
 examples in this chapter. The character > is used to represent the command prompt symbol for a debugger.
 
 
 [Function]
 error format-string &rest args
 
 This function signals a fatal error. It is impossible to continue from this kind of error; 
 thus error will never return to its caller.
 
 The debugger printout in the following example is typical of what an implementation might print when 
 error is called. Suppose that the (misspelled) symbol emergnecy-shutdown has no property named command 
 (all too likely, as it is probably a typographical error for emergency-shutdown).
 
 (defun command-dispatch (cmd) 
   (let ((fn (get cmd 'command))) 
     (if (not (null fn)) 
         (funcall fn)) 
         (error "The command ~S is unrecognized." cmd)))) 
 
 (command-dispatch 'emergnecy-shutdown) 
 Error: The command EMERGNECY-SHUTDOWN is unrecognized. 
 Error signaled by function COMMAND-DISPATCH. 
 >
 
 
 Compatibility note: Lisp Machine Lisp calls this function ferror. 
 MacLisp has a function named error that takes different arguments and can signal either a fatal 
 or a continuable error. 
 |#
 
 #|
 Exo 4.2 Vérifier ce que fait la fontion "assoc" dans le poly ou le manuel en ligne.
 
 15.6. Association Lists
 
 An association list, or a-list, is a data structure used very frequently in Lisp. 
 An a-list is a list of pairs (conses); each pair is an association. The car of a pair is called 
 the key, and the cdr is called the datum.
 
 An advantage of the a-list representation is that an a-list can be incrementally augmented 
 simply by adding new entries to the front. Moreover, because the searching function assoc 
 searches the a-list in order, new entries can ``shadow'' old entries. If an a-list is viewed 
 as a mapping from keys to data, then the mapping can be not only augmented but also altered in a 
 non-destructive manner by adding new entries to the front of the a-list.
 
 Sometimes an a-list represents a bijective mapping, and it is desirable to retrieve a key given a datum. 
 For this purpose, the ``reverse'' searching function rassoc is provided. Other variants of a-list 
 searches can be constructed using the function find or member.
 
 It is permissible to let nil be an element of an a-list in place of a pair. Such an element is not 
 considered to be a pair but is simply passed over when the a-list is searched by assoc.
 
 [Function]
 acons key datum a-list
 
 acons constructs a new association list by adding the pair (key . datum) to the old a-list.
 
 (acons x y a) == (cons (cons x y) a)
 
 This is a trivial convenience function, but I find I use it a lot.
 
 
 
 [Function]
 pairlis keys data &optional a-list
 
 pairlis takes two lists and makes an association list that associates elements of the first list 
 to corresponding elements of the second list. It is an error if the two lists keys and data are not 
 of the same length. If the optional argument a-list is provided, then the new pairs are added to the 
 front of it.
 
 The new pairs may appear in the resulting a-list in any order; in particular, either forward or 
 backward order is permitted. Therefore the result of the call
 
 (pairlis '(one two) '(1 2) '((three . 3) (four . 19)))
 
 might be
 
 ((one . 1) (two . 2) (three . 3) (four . 19))
 
 but could equally well be
 
 ((two . 2) (one . 1) (three . 3) (four . 19))
 
 
 [Function]
 assoc item a-list &key :test :test-not :key
 assoc-if predicate a-list
 assoc-if-not predicate a-list
 
 [Function]
 assoc-if predicate a-list &key :key
 assoc-if-not predicate a-list &key :key
 
 The omission of :key arguments for these functions in the first edition was probably an oversight.
 
 Each of these searches the association list a-list. The value is the first pair in the a-list such 
 that the car of the pair satisfies the test, or nil if there is no such pair in the a-list. For example:
 
 (assoc 'r '((a . b) (c . d) (r . x) (s . y) (r . z))) 
         =>  (r . x) 
 (assoc 'goo '((foo . bar) (zoo . goo))) => nil 
 (assoc '2 '((1 a b c) (2 b c d) (-7 x y z))) => (2 b c d)
 
 It is possible to rplacd the result of assoc provided that it is not nil, in order to ``update'' the 
 ``table'' that was assoc's second argument. (However, it is often better to update an a-list by 
 adding new pairs to the front, rather than altering old pairs.) For example:
 
 (setq values '((x . 100) (y . 200) (z . 50))) 
 (assoc 'y values) => (y . 200) 
 (rplacd (assoc 'y values) 201) 
 (assoc 'y values) => (y . 201) now
 
 A typical trick is to say (cdr (assoc x y)). Because the cdr of nil is guaranteed to be nil, 
 this yields nil if no pair is found or if a pair is found whose cdr is nil. This is useful 
 if nil serves its usual role as a ``default value.''
 
 The two expressions
 
 (assoc item list :test fn)
 
 and
 
 (find item list :test fn :key #'car)
 
 are equivalent in meaning with one important exception: if nil appears in the a-list in place of 
 a pair, and the item being searched for is nil, find will blithely compute the car of the nil 
 in the a-list, find that it is equal to the item, and return nil, whereas assoc will ignore the 
 nil in the a-list and continue to search for an actual pair (cons) whose car is nil. 
 See find and position.
 
 Compatibility note: In MacLisp, the assoc function uses an equal comparison rather than eql, 
 which is the default test for assoc in Common Lisp. Where in MacLisp one would write (assoc x y), 
 in Common Lisp one must write (assoc x y :test #'equal) to get the completely identical effect. 
 Similarly, one can get the precise effect, and no more, of the MacLisp (assq x y) by writing in 
 Common Lisp (assoc x y :test #'eq).
 
 In Interlisp, assoc uses an eq test, and sassoc uses an Interlisp equal test.
 
 
 [Function]
 rassoc item a-list &key :test :test-not :key
 rassoc-if predicate a-list
 rassoc-if-not predicate a-list
 
 [Function]
 rassoc-if predicate a-list &key :key
 rassoc-if-not predicate a-list &key :key
 
 The omission of :key arguments for these functions in the first edition was probably an oversight.
 change_end
 
 rassoc is the reverse form of assoc; it searches for a pair whose cdr satisfies the test, rather than 
 the car. If the a-list is considered to be a mapping, then rassoc treats the a-list as representing 
 the inverse mapping. For example:
 
 (rassoc 'a '((a . b) (b . c) (c . a) (z . a))) => (c . a)
 
 The expressions
 
 (rassoc item list :test fn)
 
 and
 
 (find item list :test fn :key #'cdr)
 
 are equivalent in meaning, except when the item is nil and nil appears in place of a pair in the a-list. 
 See the discussion of the function assoc.
 
 |#
 
 #|
 Exo 4.3 Définir la fonction "meval-body" qui prend en paramètre une liste d'expressions évaluables
 et un environnement, qui les évalue en séquence et retourne la valeur retourée par la dernière.
 |#
 #|
 (defun meval-body (liste-expr env)
 ;; on boul
  )
  |#
 
 #|
 Exo 4.4 Définir la fonction "meval-args" qui prend en paramètre une liste d'expressions évaluables
 et un environnement, qui les évalue en séquence et retourne la liste de leurs valeurs.
 |#
 #|
 (defun meval-args (liste-expr)
   )
 |#
 
 
 #|
 Exo 4.5 Définir la fonction "make-env" qui prend en paramètre une liste de symboles, une liste de
 valeurs et un environnement : construit l'environnement (une liste d'association) en appariant
 les paramètres aux valeurs correspondantes et signale une exception si paramètres et arguments 
 ne concordent pas. On ne traitera d'abord que le cas des paramètres obligatoires. Si l'environnement
 passé en paramètre n'est pas vide, le nouvel environnement doit l'inclure.
 |#
 #|
 (defun make-env (liste-symb liste-val env)
  )
  |#
  
 #|
 Exo 4.6 Définir la fonction "meval-lambda" qui applique une lambda-fonction quelconque à des valeurs
 d'arguments dans un certain environnement. Cette fonction servira aussi pour les autres cas 
 d'application de fonction, par exemple pour les macros.
 Exemple d'utilisation : 
 ((and (consp (car expr)) (eq 'lambda (caar expr))) ; lambda-fonction
 (meval-lambda (car expr) (meval-args (cdr expr) env) env))
   ;; une fonction est un symbole non constant
 ((get-defun (car expr))
 (meval-lambda (get-defun (car expr)) (meval-args (cdr expr) env) ()))
 ...)
 |#
 #|
 (defun meval-lambda (expr)
   )
 |#
 
 #|
 Exo 4.7 Vérifier ce que fait la fonction "get" dans le poly ou le manuel en ligne.
 
 10.1. The Property List
 
 Since its inception, Lisp has associated with each symbol a kind of tabular data structure called 
 a property list (plist for short). A property list contains zero or more entries; each entry 
 associates with a key (called the indicator), which is typically a symbol, an arbitrary Lisp object 
 (called the value or, sometimes, the property). There are no duplications among the indicators; a 
 property list may only have one property at a time with a given name. In this way, given a symbol 
 and an indicator (another symbol), an associated value can be retrieved.
 
 A property list is very similar in purpose to an association list. The difference is that a property 
 list is an object with a unique identity; the operations for adding and removing property-list entries 
 are destructive operations that alter the property list rather than making a new one. Association lists, 
 on the other hand, are normally augmented non-destructively (without side effects) by adding new entries 
 to the front (see acons and pairlis).
 
 A property list is implemented as a memory cell containing a list with an even number (possibly zero) 
 of elements. (Usually this memory cell is the property-list cell of a symbol, but any memory cell 
 acceptable to setf can be used if getf and remf are used.) Each pair of elements in the list 
 constitutes an entry; the first item is the indicator, and the second is the value. Because property-list 
 functions are given the symbol and not the list itself, modifications to the property list can be 
 recorded by storing back into the property-list cell of the symbol.
 
 When a symbol is created, its property list is initially empty. Properties are created by using get 
 within a setf form.
 
 Common Lisp does not use a symbol's property list as extensively as earlier Lisp implementations did. 
 Less-used data, such as compiler, debugging, and documentation information, is kept on property lists 
 in Common Lisp.
 
 In Common Lisp, the notion of ``disembodied property list'' introduced in MacLisp is eliminated. 
 It tended to be used for rather kludgy things, and in Lisp Machine Lisp is often associated with 
 the use of locatives (to make it ``off by one'' for searching alternating keyword lists). 
 In Common Lisp special setf-like property-list functions are introduced: getf and remf.
 
 
 [Function]
 get symbol indicator &optional default
 
 get searches the property list of symbol for an indicator eq to indicator. The first argument 
 must be a symbol. If one is found, then the corresponding value is returned; otherwise default 
 is returned.
 
 If default is not specified, then nil is used for default.
 
 Note that there is no way to distinguish an absent property from one whose value is default.
 
 (get x y) == (getf (symbol-plist x) y)
 
 Suppose that the property list of foo is (bar t baz 3 hunoz "Huh?"). Then, for example:
 
 (get 'foo 'baz) => 3 
 (get 'foo 'hunoz) => "Huh?" 
 (get 'foo 'zoo) => nil
 
 Compatibility note: In MacLisp, the first argument to get could be a list, in which case the cdr 
 of the list was treated as a so-called ``disembodied property list.'' The first argument to get 
 could also be any other object, in which case get would always return nil. In Common Lisp, it is 
 an error to give anything but a symbol as the first argument to get.
 
 setf may be used with get to create a new property-value pair, possibly replacing an old pair 
 with the same property name. For example:
 
 (get 'clyde 'species) => nil 
 (setf (get 'clyde 'species) 'elephant) => elephant 
 and now (get 'clyde 'species) => elephant
 
 The default argument may be specified to get in this context; it is ignored by setf but may be 
 useful in such macros as push that are related to setf:
 
 (push item (get sym 'token-stack '(initial-item)))
 
 means approximately the same as
 
 (setf (get sym 'token-stack '(initial-item)) 
       (cons item (get sym 'token-stack '(initial-item))))
 
 which in turn would be treated as simply
 
 (setf (get sym 'token-stack) 
       (cons item (get sym 'token-stack '(initial-item))))
 
 [Function]
 remprop symbol indicator
 
 This removes from symbol the property with an indicator eq to indicator. The property indicator 
 and the corresponding value are removed by destructively splicing the property list. 
 It returns nil if no such property was found, or non-nil if a property was found.
 
 (remprop x y) == (remf (symbol-plist x) y)
 
 For example, if the property list of foo is initially
 
 (color blue height 6.3 near-to bar)
 
 then the call
 
 (remprop 'foo 'height)
 
 returns a non-nil value after altering foo's property list to be
 
 (color blue near-to bar)
 
 [Function]
 symbol-plist symbol
 
 This returns the list that contains the property pairs of symbol; the contents of the property-list 
 cell are extracted and returned.
 
 Note that using get on the result of symbol-plist does not work. One must give the symbol itself 
 to get or else use the function getf.
 
 setf may be used with symbol-plist to destructively replace the entire property list of a symbol. 
 This is a relatively dangerous operation, as it may destroy important information that the 
 implementation may happen to store in property lists. Also, care must be taken that the new property 
 list is in fact a list of even length.
 
 Compatibility note: In MacLisp, this function is called plist; in Interlisp, it is called getproplist.
 
 [Function]
 getf place indicator &optional default
 
 getf searches the property list stored in place for an indicator eq to indicator. 
 If one is found, then the corresponding value is returned; otherwise default is returned. 
 If default is not specified, then nil is used for default. Note that there is no way to 
 distinguish an absent property from one whose value is default. Often place is computed 
 from a generalized variable acceptable to setf.
 
 setf may be used with getf, in which case the place must indeed be acceptable as a place to setf. 
 The effect is to add a new property-value pair, or update an existing pair, in the property 
 list kept in the place. The default argument may be specified to getf in this context; 
 it is ignored by setf but may be useful in such macros as push that are related to setf. 
 See the description of get for an example of this.
 
 Compatibility note: The Interlisp function listget is similar to getf. The Interlisp function 
 listput is similar to using getf with setf.
 
 [Macro]
 remf place indicator
 
 This removes from the property list stored in place the property with an indicator eq to indicator. 
 The property indicator and the corresponding value are removed by destructively splicing the property list. 
 remf returns nil if no such property was found, or some non-nil value if a property was found. 
 The form place may be any generalized variable acceptable to setf. See remprop.
 
 [Function]
 get-properties place indicator-list
 
 get-properties is like getf, except that the second argument is a list of indicators. 
 get-properties searches the property list stored in place for any of the indicators in 
 indicator-list until it finds the first property in the property list whose indicator 
 is one of the elements of indicator-list. Normally place is computed from a generalized 
 variable acceptable to setf.
 
 get-properties returns three values. If any property was found, then the first two values are 
 the indicator and value for the first property whose indicator was in indicator-list, and 
 the third is that tail of the property list whose car was the indicator (and whose cadr 
 is therefore the value). If no property was found, all three values are nil. Thus the 
 third value serves as a flag indicating success or failure and also allows the search to be 
 restarted, if desired, after the property was found.
 |#
 
 #|
 "Exo 4.8a" Il reste enfin à définir "get-defun". On pourrait construire un environnement spécial - 
 il s'agit bien d'ailleurs d'un environnement spécial, réservé aux fonctions et global - en réutilisant 
 des listes d'association, mais cela poserait divers problèmes techniques et le plus simple est 
 d'utiliser les propriétés des symboles et la fonction "get". On définira alors "get-defun" ainsi : ..
 |#
 (defun get-defun (symb)
   (get symb :defun))
 #|
 ... où "symb" est le symbole, c-à-d le nom de fonction concerné et ":defun" est un 'keyword',
 c-à-d un symbole constant arbitraire. Cependant, si "get" est bien "setf-able", ce n'est plus 
 le cas de "get-defun".
 |#
 #|
 Exo 4.8 Ecrire "get-defun" sous forme de maro et vérifier que cette nouvelle version est bien 
 setf-able.
 |#
 #|
 (defun get-defun (symb)
  )
 |#
 
 #|
 Exo 4.9 Vérifier ce que fait la fonction "symbol-function" dans le poly ou le manuel en ligne.
 
 [Function]
 symbol-function symbol
 
 symbol-function returns the current global function definition named by symbol. 
 An error is signalled if the symbol has no function definition; see fboundp. 
 Note that the definition may be a function or may be an object representing a special 
 form or macro. In the latter case, however, it is an error to attempt to invoke the object 
 as a function. If it is desired to process macros, special forms, and functions equally 
 well, as when writing an interpreter, it is best first to test the symbol with macro-function 
 and special-form-p and then to invoke the functional value only if these two tests both yield false.
 
 This function is particularly useful for implementing interpreters for languages embedded in Lisp.
 
 symbol-function cannot access the value of a lexical function name produced by flet or labels; 
 it can access only the global function value.
 
 The global function definition of a symbol may be altered by using setf with symbol-function. 
 Performing this operation causes the symbol to have only the specified definition as its 
 global function definition; any previous definition, whether as a macro or as a function, 
 is lost. It is an error to attempt to redefine the name of a special form (see table 5-1).
 
 change_begin
 X3J13 voted in June 1988 (FUNCTION-TYPE)   to clarify the behavior of symbol-function in the 
 light of the redefinition of the type function.
 
     * It is permissible to call symbol-function on any symbol for which fboundp returns true. 
     Note that fboundp must return true for a symbol naming a macro or a special form.
 
     * If fboundp returns true for a symbol but the symbol denotes a macro or special form, 
     then the value returned by symbol-function is not well-defined but symbol-function will 
     not signal an error.
 
     * When symbol-function is used with setf the new value must be of type function. 
     It is an error to set the symbol-function of a symbol to a symbol, a list, or the 
     value returned by symbol-function on the name of a macro or a special form. 
 |#
 
 #|
 Exo 4.10 Vérifier ce que fait la fonction "special-form-p" dans le poly ou le manuel en ligne.
 
 [Function]
 special-form-p symbol
 
 The function special-form-p takes a symbol. If the symbol globally names a special form, then 
 a non-nil value is returned; otherwise nil is returned. A returned non-nil value is typically 
 a function of implementation-dependent nature that can be used to interpret (evaluate) the special form.
 
 It is possible for both special-form-p and macro-function to be true of a symbol. This is 
 possible because an implementation is permitted to implement any macro also as a special form 
 for speed. On the other hand, the macro definition must be available for use by programs 
 that understand only the standard special forms listed in table 5-1.
 |#
 
 #|
 Exo 4.11 Vérifier ce que fait la fonction "fboundp" dans le poly ou le manuel en ligne.
 
 [Function]
 fboundp symbol
 
 fboundp is true if the symbol has a global function definition. Note that fboundp is true 
 when the symbol names a special form or macro. macro-function and special-form-p may be used 
 to test for these cases.
 
 change_begin
 X3J13 voted in June 1988 (FUNCTION-TYPE)   to emphasize that, despite the tightening of the 
 definition of the type function, fboundp must return true when the argument names a special 
 form or macro.
 
 See also symbol-function and fmakunbound.
 
 X3J13 voted in March 1989 (FUNCTION-NAME)   to extend fboundp to accept any function-name (a 
 symbol or a list whose car is setf-see section 7.1). Thus one may write (fboundp '(setf cadr)) 
 to determine whether a setf expansion function has been globally defined for cadr.
 change_end 
 |#
 
 #|
 Exo 4.12 Tester "symbol-function", "special-form-p" et "fboundp" sur des arguments de différents types : 
 autre que symbol, sur des symboles avec ou sans définition fonctionnelle, et enfin avec des définitions
 fonctionnelles de différents types (formes syntaxiques, macros, fonctions globales ou locales).
 |#
 
 #|
 Exo 4.13 Méta-définir les fonctions "fact" et "fibo". Les tester.
 |#
 #|
 (defun fact-meta ()
   )
 |#
 #|
 (defun fibo-meta ()
   )
 |#
 
 #|
 Exo 4.14 Considérer l'expression (meval '(meval '(fibo 10))) et en déduire quelle va
 être la première erreur produite par son évaluation. Vérifier par un test. Si ça marche du 
 premier coup, c'est mauvais signe : vérifier que meval a bien été méta-définie (par 
 (meval '(defun meval ...))) ! 
 |#
 
 #|
 Exo 4.15 Etendre la définition de "make-env" aux mots-clés &optional et &rest.
 On se basera sur le fait que la spécification des ces mots-clés repose sur un automate
 implicite. Expliciter l'automate et l'implémentation par des fonctions adéquates
 (voir aussi Chapitre 3, en particulier la section 3.3)
 |#
 
 (defun meval (expr &optional env)
   (cond
     ((and (atom expr) (constantp expr)) ; constante atomique
     (print "constante atomique")
       expr)
     ((atom expr) ; atom non constant, donc variable
       (print "atom non constant, donc variable")
       (let ((cell (assoc expr env)))
         (if cell
           (cdr cell)
           (error "~s n'est pas une variable" expr))))
     ;; plus d'atome à partir d'ici
     ((and (consp (car expr)) (eq 'lambda (caar expr))) ;; lambda-fonction
       (print "lambda-fonction")
       ;; ((meval-lambda (car expr) (meval-args (cdr expr) env) env))	
       (meval-body (cddar expr)
         (make-env (cadar expr)
           (meval-args (cdr expr) env)
           env)))
     ((or (not (symbolp (car expr))) (constantp (car expr))) ;; ?? en cas de "nil"
       ;; une fonction est un symbole non constant
       (error "~s ne peut être une fonction" (car expr)))
 ;    ((get-defun (car expr))
 ;      (let ((fun (get-defun (car expr))))
 ;        ;; (meval-lambda (get-defun (car expr)) (meval-args (cdr expr) env) ()))
 ;        (meval-body (cddr fun)
 ;          (make-env (cadr fun)
 ;            (meval-args (cdr expr) env)
 ;            ()))))
 ;      ((eq 'defun (car expr))
 ;        (setf (get-defun (cadr expr))
 ;          '(lambd ,@(cddr expr))))
     ((eq 'quote (car expr)) ;; quote
       (print "quote")
       (cadr expr))
     ((not (fboundp (car expr))) ;; faux gd // à étudier
       (error "~s symbole sans définition fonctionnelle" (car expr)))
     ((special-form-p (car expr))
       (print "forme spéciale non implémentée")
       (if (null env)
         (eval expr)
         (error "~s forme spéciale NYI" (car expr))))
 ;    (t (apply (symbol-function (car expr)) (meval-args (cdr expr) env)))
     ; TODO : la fin est fausse
     ((null env)
       (eval expr))
     (t (error "impossible d'évaluer ~s dans l'environnement ~s" expr env))
     ;(t (eval expr)) ; triche
     
   ))
 
 #|
 Exo 4.16 Définir cette fonction mload : (voir fascicule, page 23) on regardera dans le manuel le 
 chapitre sur les entrées-sorties, en particulier les fonctions open, read et close, ainsi que le traitement
 de la fin de fichier
 |#
 
 #|
 23.2. Opening and Closing Files
 When a file is opened, a stream object is constructed to serve as the file system's ambassador 
 to the Lisp environment; operations on the stream are reflected by operations on the file in the
 file system. The act of closing the file (actually, the stream) ends the association; the 
 transaction with the file system is terminated, and input/output may no longer be performed 
 on the stream. The stream function close may be used to close a file; the functions described 
 below may be used to open them. The basic operation is open, but with-open-file is usually 
 more convenient for most applications.
 
 [Function]
 open filename &key :direction :element-type :if-exists :if-does-not-exist :external-format
 
 This returns a stream that is connected to the file specified by filename. The filename is the 
 name of the file to be opened; it may be a string, a pathname, or a stream. (If the filename 
 is a stream, then it is not closed first or otherwise affected; it is used merely to provide 
 a file name for the opening of a new stream.)
 
 The keyword arguments specify what kind of stream to produce and how to handle errors:
 
 :direction
     This argument specifies whether the stream should handle input, output, or both.
         :input
             The result will be an input stream. This is the default.
         :output
             The result will be an output stream.
         :io
             The result will be a bidirectional stream.
         :probe
             The result will be a no-directional stream (in effect, the stream is created and then closed). This is useful for determining whether a file exists without actually setting up a complete stream.
 :element-type
     This argument specifies the type of the unit of transaction for the stream. Anything that can 
     be recognized as being a finite subtype of character or integer is acceptable. In particular, 
     the following types are recognized:
         string-char
             The unit of transaction is a string-character. The functions read-char and/or write-char 
             may be used on the stream. This is the default.
         character
             The unit of transaction is any character, not just a string-character. The functions read-char and/or write-char may be used on the stream.
 
   to eliminate the type string-char, add the type base-character, and redefine open to use the type character as the default :element-type.
 
     The preceding two possibilities should therefore be replaced by the following.
         character
             The unit of transaction is any character, not just a string-character. The functions 
             read-char and write-char (depending on the value of the :direction argument) may be 
             used on the stream. This is the default.
         base-character
             The unit of transaction is a base character. The functions read-char and write-char 
             (depending on the value of the :direction argument) may be used on the stream.
         (unsigned-byte n)
             The unit of transaction is an unsigned byte (a non-negative integer) of size n. 
             The functions read-byte and/or write-byte may be used on the stream.
         unsigned-byte
             The unit of transaction is an unsigned byte (a non-negative integer); the size of the byte 
             is determined by the file system. The functions read-byte and/or write-byte may be used 
             on the stream.
         (signed-byte n)
             The unit of transaction is a signed byte of size n. 
             The functions read-byte and/or write-byte may be used on the stream.
         signed-byte
             The unit of transaction is a signed byte; the size of the byte is determined by the 
             file system. The functions read-byte and/or write-byte may be used on the stream.
         bit
             The unit of transaction is a bit (values 0 and 1). The functions read-byte and/or 
             write-byte may be used on the stream.
         (mod n)
             The unit of transaction is a non-negative integer less than n. The functions read-byte 
             and/or write-byte may be used on the stream.
         :default
             The unit of transaction is to be determined by the file system, based on the file it finds. The type can be determined by using the function stream-element-type.
 :if-exists
     This argument specifies the action to be taken if the :direction is :output or :io and a file of 
     the specified name already exists. If the direction is :input or :probe, this argument is ignored.
         :error
             Signals an error. This is the default when the version component of the 
             filename is not :newest.
         :new-version
             Creates a new file with the same file name but with a larger version number. This is the 
             default when the version component of the filename is :newest.
         :rename
             Renames the existing file to some other name and then creates a new file with the 
             specified name.
         :rename-and-delete
             Renames the existing file to some other name and then deletes it (but does not expunge it, 
             on those systems that distinguish deletion from expunging). Then create a new file with the specified name.
         :overwrite
             Uses the existing file. Output operations on the stream will destructively modify the 
             file. If the :direction is :io, the file is opened in a bidirectional mode that allows 
             both reading and writing. The file pointer is initially positioned at the beginning of 
             the file; however, the file is not truncated back to length zero when it is opened. 
             This mode is most useful when the file-position function can be used on the stream.
         :append
             Uses the existing file. Output operations on the stream will destructively modify the 
             file. The file pointer is initially positioned at the end of the file. If the :direction 
             is :io, the file is opened in a bidirectional mode that allows both reading and writing.
         :supersede
             Supersedes the existing file. If possible, the implementation should arrange not to 
             destroy the old file until the new stream is closed, against the possibility that the 
             stream will be closed in ``abort'' mode (see close). This differs from :new-version in 
             that :supersede creates a new file with the same name as the old one, rather than a 
             file name with a higher version number.
         nil
             Does not create a file or even a stream, but instead simply returns nil to indicate failure.
     If the :direction is :output or :io and the value of :if-exists is :new-version, then the version 
     of the (newly created) file that is opened will be a version greater than that of any other file 
     in the file system whose other pathname components are the same as those of filename.
     If the :direction is :input or :probe or the value of :if-exists is not :new-version, and 
     the version component of the filename is :newest, then the file opened is that file already 
     existing in the file system that has a version greater than that of any other file in the file 
     system whose other pathname components are the same as those of filename.
 :if-does-not-exist
     This argument specifies the action to be taken if a file of the specified name does not already exist.
         :error
             Signals an error. This is the default if the :direction is :input, or if the :if-exists 
             argument is :overwrite or :append.
         :create
             Creates an empty file with the specified name and then proceeds as if it had 
             already existed (but do not perform any processing directed by the :if-exists argument). 
             This is the default if the :direction is :output or :io, and the :if-exists argument is 
             anything but :overwrite or :append.
         nil
             Does not create a file or even a stream, but instead simply returns nil to indicate failure. 
             This is the default if the :direction is :probe.
 :external-format
     This argument specifies an implementation-recognized scheme for representing characters in files. 
     The default value is :default and is implementation-defined but must support the base characters. 
     An error is signaled if the implementation does recognize the specified format.
 
     This argument may be specified if the :direction argument is :input, :output, or :io. 
     It is an error to write a character to the resulting stream that cannot be represented 
     by the specified file format. (However, the #\Newline character cannot produce such an 
     error; implementations must provide appropriate line division behavior for all character streams.)
 
 When the caller is finished with the stream, it should close the file by using the close function. The with-open-file form does this automatically, and so is preferred for most purposes. open should be used only when the control structure of the program necessitates opening and closing of a file in some way more complex than provided by with-open-file. It is suggested that any program that uses open directly should use the special form unwind-protect to close the file if an abnormal exit occurs.
 
 [Macro]
 with-open-file (stream filename {options}*)
        {declaration}* {form}*
 with-open-file evaluates the forms of the body (an implicit progn) with the variable stream bound 
 to a stream that reads or writes the file named by the value of filename. The options are evaluated 
 and are used as keyword arguments to the function open.
 
 When control leaves the body, either normally or abnormally (such as by use of throw), the file 
 is automatically closed. If a new output file is being written, and control leaves abnormally, 
 the file is aborted and the file system is left, so far as possible, as if the file had never 
 been opened. Because with-open-file always closes the file, even when an error exit is taken, 
 it is preferred over open for most applications.
 
 filename is the name of the file to be opened; it may be a string, a pathname, or a stream.
 
 For example:
 (with-open-file (ifile name 
                  :direction :input) 
   (with-open-file (ofile (merge-pathname-defaults ifile 
                                                   nil 
                                                   "out") 
                          :direction :output 
                          :if-exists :supersede) 
     (transduce-file ifile ofile)))
 ...
 (with-open-file (ifile name 
                  :direction :input 
                  :if-does-not-exist nil) 
   ;; Process the file only if it actually exists. 
   (when (streamp name)
     (compile-cobol-program ifile)))
 
 Implementation note: While with-open-file tries to automatically close the stream on exit from 
 the construct, for robustness it is helpful if the garbage collector can detect discarded 
 streams and automatically close them. 
 
 ...
 
 READ
 
 [Function]
 read &optional input-stream eof-error-p eof-value recursive-p
 
 read reads in the printed representation of a Lisp object from input-stream, builds a corresponding 
 Lisp object, and returns the object.
 
 Note that when the variable *read-suppress* is not nil, then read reads in a printed representation 
 as best it can, but most of the work of interpreting the representation is avoided (the intent 
 being that the result is to be discarded anyway). For example, all extended tokens produce 
 the result nil regardless of their syntax. 
 
 |#
 (defun mload ()
   )
 
 #|
 Exo 4.17 - Définir 'get-defmacro' comme une macro.
 |#
 
 #|
 Exo 4.18 - Définir la fonction 'displace' qui prend en argument 2 cellules, met dans la première
 le contenu de la seconde et retourne la première. Rajouter le cas où le résultat de la macro-expansion
 est un atome.
 |#
 
 #|
 Exo 4.19 - Définir la fonction 'm-macroexmand-1' qui expanse une fois une macro méta-définie
 par analogie avec 'macroexpand-1'
 |# 
 
 #|
 Exo 4.20 - Définir la fonction m-macroexpand qui expanse complètement une macro métadéfinie,
 par analogie avec 'macroexpand'. Le principe de 'macroexpand' est d'appliquer 'macroexpand-1'
 tant que le résultat de l'expansion est toujours une macro. On traitera dans cette fonction
 aussi bien les macros méta-définies que les prédéfinies.
 |#
 
 #|
 Exo 4.21 - Définir la fonction 'meval-let' qui méta-évalue une expression 'let'.
 |#
 
 #|
 Exo 4.22 - Définir la fonction 'meval-cond' qui méta-évalue une expression 'cond', 
 comme si c'était une forme syntaxique.
 |#
 
 #|
 Exo 4.23 - Etendre 'msetf' à l'affectation d'arité quelconque.
 |#
 
 #|
 Exo 4.24 - Intégrer la macro-expansion de 'place' dans 'msetf' : traiter les deux cas de macros 
 méta-définies et prédéfinies.
 |#
 
 #|
 Exo 4.25 - Au lieu d'énumérer dans 'msetf' toutes les fonctions setf-able, le mieux est 
 d'évaluer tous les arguments de 'place', de reconstruire l'expression 'place' en remplaçant les arguments
 par leur quotée, d'évaluer 'val', puis de reconstruire l'expression 'expr' avec 'place' transformée et
 la valeur de 'val' quotée. On peut alors évaluer 'expr' pour effectuer l'affectation : tous les
 arguments étant quotés, cette évaluation peut se faire dans un environnement vide.
 |#
 
 #|
 Exo 4.26 - Définir 3 fonctions de l'exemple du compteur dans le polycopié LISP
 |#
 
 #|
 Exo 4.27 - Définir cette fonction 'meval-args*' qui est à 'meval-args' ce que 
 'list*' est à 'list'.
 |#
 
 #|
 Exo 4.28 - Tester les fermetures sur le schéma de terminalisation des récursions enveloppées
 par passage de continuation. Voir polycopié de LISP.
 |#
 
 #|
 Exo 4.29 - Redéfinir les fonctions 'make-closure' et 'meval-closure' pour tenir compte de 
 l'environnement fonctionnel.
 |#
 
 #|
 Exo 4.30 - Etendre le traitement de 'function' aux fonctions locales.
 |#
 
 #|
 Exo 4.31 - Définir la fonction 'make-flet-fenv' qui construit cet environnement fonctionnel.
 |#
 
 #|
 Exo 4.32 - Définir la fonction 'make-labels-fenv' qui construit cet environnement fonctionnel
 circulaire. On appellera 'make-flet-fenv' en lui passant un environnement fonctionnel "vide"
 qu'il s'agira ensuite de remplacer par son résultat même, par exemple par appel de 'displace'.
 |#
 
 #|
 Exo 4.33 - Définir la fonction 'destruct' qui construit un environnement de façon similaire à 
 'make-env' mais avec la destructuration.
 |#
 
 #|
 Exo 4.34 - Traiter la forme syntaxique destructuring-bind' dans 'meval'.
 |#
 
 #|
 Exo 4.35 - Etendre la fonction 'make-env' pour qu'elle inclue la destructuration sur les
 paramètres obligatoires, tout en conservant la possibilité des mots-clés &optional, &key,
 &rest avec leur syntaxe habituelle.
 |#
 
 #|
 Exo 4.36 - Etendre la fonction 'destruct' pour qu'elle interdise la double occurrence d'un
 paramètre dans l'arbre.
 |#
 
 #|
 Exo 4.37 - Définir la fonction 'match' qui apparie un motif et une valeur dans un 
 environnement qu'elle étend et retourne. En cas d'échec, retourne le mot-clé :fail.
 La fonction est similaire à 'destruct' mais elle intègre ces nouvelles contraintes.
 |#
 
 #|
 Exo 4.38 - Définir la fonction 'meval-case-match' qui implémente la forme syntaxique
 'case-match' dans le méta-évaluateur.
 |#
 
 #|
 Exo 4.39 - Définir la macro 'defil' qui construit progressivement la 'case-match' qui 
 fait office de corps de la fonction.
 Le filtrage s'applique particulièrement bien aux macros, les différents motifs correspondant
 à l'analyse par cas à faire sur la syntaxe de l'expression.
 |#
 
 #|
 Exo 4.40 - Définir la macro 'defil-macro' qui construit progressivement le 'case-match'
 qui fait office de corps d'une macro.
 |#
 
 #|
 Exo 4.41 - Définir la macro 'or' par filtrage. Faire de même pour les différents exemples de
 macros du polycopié de LISP.
 |#
 
 #|
 Exo 4.42 - Définir la fonction 'rewrite-1' qui prend en entrée une donnée et une liste 
 de règles de réécriture et réécrit la donnée suivant la règle de réécriture donnée par le 
 motif et la production. Retourne :fail si l'appariement ne réussit pas.
 |#
 
 #|
 Exo 4.43 - Définir la fonction 'rewrite' qui prend en entrée une donnée et une liste de règles
 de réécriture et réécrit la donnée tant qu'une règle s'applique.
 |#
 
 #|
 Exo 4.44 - Définir la macro 'defrewrite-macro' qui définit une macro par des règles de
 réécriture, comme les 'let-syntax' et 'syntax-rules' de SCHEME. Cela revient à remplacer
 la construction explicite de l'expansion, avec 'backquote' par une construction implicite où
 l'action associée à chaque motif est implicitement 'backquotée' et où chaque variable
 figurant dans le motif y est implicitement virgulée.
 |#
 
 #|
 Exo 4.45 - Définir la macro 'or' par règles de réécriture et faire de même pour les différents
 exemples de macros du polycopié de LISP. Comment pourrait-ont éviter avec 'or' les problèmes
 de capture de variable ? (cf. Section sur les macros dans le chapitre 3 du polycopié LISP).
 |#
 
 #|
 Exo 4.46 - Etendre la fonction 'match' aux variables segments. On définira deux fonctions 
 auxiliaires pour tester si une variable est segment et pour en extraire la variable simple
 correspondante. Pour simplifier ce traitement, on peut utiliser une forme parenthésée pour
 les segments, par exemple (*x), avec le risque de limiter les squelettes possibles : il faut
 en tout cas bien placer la clause sur les segments.
 |#
 
 #|
 Exo 4.47 - Définir dans 'meval' les deux formes syntaxiques 'delay' et 'force'.
 |#
 
 #|
 Exo 4.48 - Il n'est en fait pas nécessaire de passer par des formes syntaxiques pour définir
 les retardements. Définir 'delay' comme une macro et 'force' comme une fonction.
 |#
 
 #|
 Exo 4.49 - Définir le flot 'enum-fibo' qui énumère la suite de Fibonacci. Voir aussi la 
 fonction 'next-fibo' dans le polycopié de LISP.
 |#
 
 #|
 Exo 4.50 - Définir le flot enum-prime qui énumère les nombres premiers. Voir aussi la 
 fonction 'next-prime' dans le polycopié de LISP.
 |#
 
 #|
 Exo 4.51 - Définir la fonction 'scheme-symbol-function'.
 |# 
 
 #|
 (deftest jc-meval 
   (meval "bonjour") 
   "bonjour")
 |#