(defstruct a
      x y)

    (defstruct (b (:include a))
      z)

    (defgeneric grind (x)
      (:method ((x a))
        (+ (a-x x) (a-y x)))
      (:method ((x b))
        (+ (b-z x) (call-next-method)))
      (:method ((x number))
        x))

Secondly, I use functions when I don't intend the behaviour I'm
defining to be extensible, or when there are no obvious objects in the
game.  For instance, I have a function (which Erik would hate, with
good reason) PRETTY-DATE-STRING, which prints a pretty date string.
It takes one optional argument, which is a universal time, the default
being (get-universal-time).  Making it a GF would be kind of strange,
because it has no arguments...

Again, Lisp has been well-designed - there is no syntactic difference
between code which uses GFs and code that uses ordinary functions.
Therefore, if I design using plain functions but then decide I want to
change to GFs, for whatever reason, nothing other than the definitions
of my functions/GFs need change.  Compare with C++, say which has two
syntaxes, forcing a big up-front decision about whether to use
functions of methods, or changes to all client code when that decision
changes. Java seems to have done this somewhat better.

--tim