This "back-quoting" technique is a great feature in Lisp- it lets us write code that looks just like the data it creates. This happens frequently with code written in a functional style: By building functions that look like the data they create, we can make our code easier to understand and also build for longevity: As long as the data doesn't change, the functions will probably not need to be refactored or otherwise changed, since they mirror the data so closely. Imagine how you'd write a function like this in VisualBasic or C: You would probably chop the path into pieces, then append the text snippets and the pieces together again - a more haphazard process that "looks" totally different from the data that is created and probably less likely to have longevity.

Now we can describe a path, but a location in our game may have more than one path, so let's create a function called `describe-paths`:

      (defun describe-paths (location map)
        (apply #'append (mapcar #'describe-path (cddr (assoc location map)))))

This function uses another common Functional Programming technique: The use of Higher Order Functions - This means that the `apply` and `mapcar` functions are taking other functions as parameters so that they can call them themselves. To pass a function, you need to put `#'` in front of the function name. The `cddr` command chops the first two items from the front of the list (so only the path data remains). The `mapcar` simply applies another function to every object in the list, basically causing all paths to be changed into pretty descriptions by the `describe-path` function. The `apply #'append` just cleans out some parentheses and isn't so important. Let's try this new function:

      (describe-paths 'living-room map)

      ==> (there is a door going west from here - there is a stairway
           going upstairs from here -)

Beautiful!
<< begin < previous - next > end >>