990 lines
43 KiB
Common Lisp
990 lines
43 KiB
Common Lisp
#|
|
|
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")
|
|
|#
|