Next in the list of Lisp features I’m reviewing here is fmakunbound.  There isn’t very much to say about this if you understand the behaviour of packages and intern, covered in this earlier article.  The fmakunbound function causes the function field associated with the symbol to be discarded.  If that symbol formerly had a function field associated with it, allowing the function to be invoked by interpreting the symbol in a function context, then that method of invocation is no longer available.

As with fboundp, fmakunbound does not see lexically scoped symbols, it only acts on the set of interned symbols, so it does not affect behaviour driven by flet, labels, or macrolet.

Now, we’re going to switch a little bit, because I’m discussing flet.  Unlike many of the commands I’ve been talking about, the beginner Lisp programmer is quite likely to have encountered flet in introductory material.  Depending on the source, though, the distinction between flet and labels may not have been made particularly clear, so that’s what I’ll be talking about here.

The flet special operator, like labels, modifies the lexical environment, and like labels it does not intern a new symbol.  The difference is that the forms in the flet do not, themselves, see those modifications to the lexical environment.  For purposes of writing the forms within flet, symbols are resolved according to the enclosing environment.  This means, for instance, that flet-defined functions cannot call themselves recursively.  This is the difference between flet and labels.  Examples may help.

In the code below, I write a pair of global functions, func-A and func-B.  If func-A is called, it recursively calls func-A, then calls func-B.  Output appears on the screen to show what functions are being called.  I then shadow these functions with forms in flet, in demonstrate-flet, and labels, in demonstrate-labels.  The new definitions are exactly the same as the global ones, save for the text that is printed, to demonstrate which version of the function is being called.  As you can see, under the flet, the invocation of func-A calls the one defined in the flet, but within the flet, the recursive call to func-A calls, instead, the global symbol function.  On the other hand, under labels, the recursive call to func-A calls itself, the definition in the labels statement.
 

(defun func-A (&optional (depth 0))
  (format t "~V,0TThis is depth ~D of global symbol table func-A~%"
          (* depth 10) depth)
  (when (= 0 depth)
    (format t "Calling the functions func-A and func-B...~%")
    (func-A (1+ depth))
    (func-B (1+ depth))))

(defun func-B (&optional (depth 0))
  (format t "~V,0TThis is depth ~D of global symbol table func-B~%"
          (* depth 10) depth))

(defun demonstrate-flet ()
  (flet 
      ((func-A (&optional (depth 0))
         (format t "~V,0TThis is depth ~D of flet func-A~%"
                 (* depth 10) depth)
         (when (= 0 depth)
           (format t "Calling the functions func-A and func-B...~%")
           (func-A (1+ depth))
           (func-B (1+ depth))))

       (func-B (&optional (depth 0))
         (format t "~V,0TThis is depth ~D of flet func-B~%"
                 (* depth 10) depth)))

    (func-A)))

(defun demonstrate-labels ()
  (labels 
      ((func-A (&optional (depth 0))
         (format t "~V,0TThis is depth ~D of labels func-A~%"
                 (* depth 10) depth)
         (when (= 0 depth)
           (format t "Calling the functions func-A and func-B...~%")
           (func-A (1+ depth))
           (func-B (1+ depth))))

       (func-B (&optional (depth 0))
         (format t "~V,0TThis is depth ~D of labels func-B~%"
                 (* depth 10) depth)))

    (func-A)))

CL-USER> (demonstrate-flet)
This is depth 0 of flet func-A
Calling the functions func-A and func-B...
          This is depth 1 of global symbol table func-A
          This is depth 1 of global symbol table func-B
NIL
CL-USER> (demonstrate-labels)
This is depth 0 of labels func-A
Calling the functions func-A and func-B...
          This is depth 1 of labels func-A
          This is depth 1 of labels func-B
NIL

The next function we visit is find-symbol.  This is used to determine whether a particular package has a named symbol, and whether that symbol is internal, external, or inherited from another package.

I would recommend that you review the for thorough discussion of what a Lisp package is, under its own article.  A package in Lisp has qualities that a C++ programmer would look at as something like a cross between namespaces and classes.

The find-symbol function allows the user to query a package to discover whether a particular name is a symbol in the package, and if so, whether it is internal to the package, external to the package, or derived from an ancestor package.  This can be helpful, for example, in designing work-arounds for different versions of a library, by probing for functions not present in all versions of the package.

We now move on to find-restart.  This is not quite the same as the various find- methods we’ve been very briefly discussing recently.  There is a bit more to say about this function.

The find-restart function provides some information about the current lexical environment.  That is, it allows a form to get insight into the nature of the forms that enclose it.  Now, before talking about this, you might find it helpful to review the earlier series of posts on exception handling in Lisp.

Broadly, you can say that find-restart returns to the caller the restart object that would be invoked to handle a particular condition, or nil if there is no such restart.  In C++ terms, this is a way, at run time, for a function to ask whether there is an enclosing catch-er for a particular thrown exception.

As with find-method, I’m not going to say very  much about find-package.  It is for package objects what find-class is for class objects, and fdefinition is for functions.  If you understand those two cases, this one is no different.