Defining a type on a list that begins with a particular symbol

I am trying to use generic functions' ability to specify behaviour based on the first argument of a list.

In other words, I want the list (atypelist 1 2 3) and the list (btypelist 1 2 3) to have their individual behaviour when passed to foo. So far, this is what I came up with:

(deftype atypelist (lst)
  `(eq (car ,lst) 'atypelist))

(deftype btypelist (lst)
  `(eq (car ,lst) 'btypelist))

(defmethod foo ((lst atypelist))
  (format nil "success atypelist: ~S" lst))

(defmethod foo ((lst btypelist))
  (format nil "success btypelist: ~S" lst))

However, when I call (typep (list 'atypelist 1 2 3) 'atypelist) I get the following error:

error while parsing arguments to DEFTYPE ATYPELIST:
  too few elements in
    ()
  to satisfy lambda list
    (LST):
  exactly 1 expected, but got 0

I am guessing the error is in my definition of atypelist.

Questions:

Is there a better way to get the functionality I am looking for?
If yes - what is the way?
If not - how to properly define a type on a list/cons that has a particular symbol in the car?

Solution

Before I start: what you want to do can't work, and is confused in two ways.

Firstly deftype defines a type in terms of other type specifiers: the body of a deftype form must expand into a type specifier, not an expression, as yours does. And deftype's arguments are not the thing you want to check the type for, they are parts of the type specification.

In this case you want to specify that the thing is a cons, and that its car is eql to something. Fortunately there are specializing type specifiers for both of these things, and you end up with something like this:

(deftype cons-with-specified-car (x)
  `(cons (eql ,x) t))

And now

> (typep '(1) '(cons-with-specified-car 1))
t

> (typep '(a) '(cons-with-specified-car a))
t

> (typep '() '(cons-with-specified-car a))
nil

And if you want:

(deftype cons-with-a ()
  '(cons-with-specified-car a))

and now

> (typep '(a) 'cons-with-a)
t

Secondly none of this will work because this it not how CLOS works. CLOS dispatches on classes not types, and you have merely defined a type, not a class: your method definitions simply cannot work, since classes cannot be parametrized in this way like types can.

Some ways you might achieve what you want.

If what you want to do is to dispatch on the first element of a list, then the obvious approach, if you want to use CLOS, is to use a two-level approach where you first dispatch on the class of the thing (cons is a class), and then use eql specializers to pick out the things you want.

(defgeneric select (it)
  (:method ((it cons))
   (select* (car it) it))
  (:method (it)
   nil))

(defgeneric select* (key it)
  (:method (key it)
   (format t "~&unknown key ~S in ~S~%" key it)))

(defmethod select* ((key (eql 'a)) it)
  (format t "~&~S begins with a~%" it))

However in a case like this, unless you very much want the extensibility that CLOS gets you (which is a good reason to use CLOS here), I'd just use typecase. You could do this using the type defined above:

(defun select (it)
  (typecase it
    ((cons-with-specified-car a)
     '(cons a))
    (cons
     'cons)
    (t
     nil)))

or, probably simpler, just use what the deftype expands into:

(defun select (it)
  (typecase it
    ((cons (eql a) t)
     '(cons a))
    (cons
     'cons)
    (t
     nil)))

Finally probably what anyone doing this would actually write (again, assuming you do not want the extensibility CLOS gets you) is:

(defun select (it)
  (typecase it
    (cons
     (case (car it)
       ...))
    (t
     ...)))