Re: Any convenient way for cl-generic to dispatch on a callable Lisp Object?

[Stefan Monnier]

> cl-generic can dispatch on builtin types, so subr and complied-function can be
> dispatched. But looks that it lacks support of dispatching on funcall-able 
> Lisp
> Object(e.g. dynamic constructed lambda expression, closure, a symbol with
> function slot set). Can we add this?

The reason I haven't is that I felt that it would add too much extra
cost to the dispatch.  Currently the computation of the "tag" on which
to dispatch for built-in types is (as you can see in
`cl--generic-typeof-generalizer`):

    (if ,name (type-of ,name) 'null)

We'd have to change this to distinguish generic `cons` from "cons cell
with a `lambda` or `closure` in its `car`".

I did implement it in Elisp locally, but I felt that it makes the
computation of the tag a bit too expensive for my taste.
I guess if we do it in C (by implementing a new `type-of-for-cl-generic`
built-in function), it would be cheap enough.

But next thing we know someone will want to dispatch on `face` or
`keymap`, and then we'd need to distinguish

    symbol, symbol-and-function, symbol-and-function-and-face-and-keymap
    symbol-and-function-and-face-but-not-keymap,
    symbol-and-function-and-keymap-but-not-face, ...

which will quickly become tiresome.

Another way to make it cheaper is to rework the way generalizers work
such that the code that builds the tag-computation can know which
specializers we're interested in, so that we could use just `type-of` when
there's no dispatch on `function` and use a more costly computation for
those rare places where we do dispatch on `function`.


        Stefan