Common Lisp dispatch on first element of sequence - common-lisp

Question

Is it possible to define methods that dispatch on particular elements (such as the first) in a sequence? Is it possible to do this without using "fully general" predicate dispatch machinery?
I have a program below that rewrites an expression in propositional calculus in negative normal form (i.e. all negation appears before a variable). It also removes all connectives besides and and or and replaces them with equivalent definitions.
It heavily uses methods, but I don't think I'm using the object system to full effect.
I want to be able to have a bunch of separate defmethod cases for normalize and normalize-not based on the symbol 'and, 'or, 'not, 'imp, 'iff currently heading the expression.
In particular, I'd like to be able to write something similar to the following
(defmethod normalize-all ((exprs ('and list)))
`(and ,#normalize-all (cdr exprs)))
as a standalone definition governing what happens when exprs is a list with 'and as its car.
What I have now performs "top-level" type checks only and uses cond heavily in the body of functions.
(defmethod normalize-all ((exprs list))
(loop for x in exprs collecting (normalize x)))
(defmethod prepend-not-to-all ((exprs list))
(loop for x in exprs collecting (list 'not x)))
(defmethod normalize ((expr symbol))
expr)
(defmethod normalize-not ((expr symbol))
`(not ,expr))
(defmethod normalize ((expr cons))
(let
((head (car expr))
(tail (cdr expr)))
(cond
((eq head 'and)
`(and ,#(normalize-all tail)))
((eq head 'or)
`(or ,#(normalize-all tail)))
((eq head 'imp)
`(or
,(normalize `(not ,(first tail)))
,(normalize (second tail))))
((eq head 'iff)
`(and ,(normalize `(imp ,(first tail) ,(second tail)))
,(normalize `(imp ,(second tail) ,(first tail)))))
((eq head 'not)
(normalize-not (first tail))))))
(defmethod normalize-not ((expr cons))
(let
((head (car expr))
(tail (cdr expr)))
(cond
((eq head 'and)
`(or ,#(normalize-all (prepend-not-to-all tail))))
((eq head 'or)
`(and ,#(normalize-all (prepend-not-to-all tail))))
((eq head 'imp)
`(and
,(normalize (first tail))
,(normalize-not (second tail))))
((eq head 'iff)
`(or
(normalize-not `(imp ,(first tail) ,(second tail)))
(normalize-not `(imp ,(second tail) ,(first tail)))))
((eq head 'not)
(normalize (first tail))))))
(print (normalize '(iff a b)))
More generally, I'm trying to mimic one style of writing functions in Haskell that looks like the following, because the cases are easy to inspect.
f :: Int -> String -> Int
f 0 _ = ...
f 1 (x:xs) = ...
f n _ | n `mod` 2 == 0 = ...
| otherwise = ...
The pattern appearing before the pipe is based on the structure of the types involved. Ints have no structure (n+k patterns don't count are gone anyway), so we can only match on particular integers, ignore the integer with _ or capture it with a variable.
Arbitrary boolean-valued expressions can appear after the | and control whether the definition on the rhs is in effect or not. (n `mod` 2 == 0 checks whether a number is even, otherwise is just True but reads better).
Cases that are textually earlier always have precedence over ones that are textually later. And f is closed in the sense that all components of its definition must appear at the definition site.

Answer 1

There's not built in way to do this. If you want to mimic the Haskell style, you could use a pattern matching library such as Trivia. It doesn't allow you to write the clauses in separate top-level forms though.
;; Dependencies: (ql:quickload '(:fare-quasiquote :trivia :trivia.quasiquote))
(defpackage #:normalize
(:use #:cl #:named-readtables #:trivia)
(:export #:normalize #:imp #:iff))
(in-package #:normalize)
(in-readtable :fare-quasiquote)
(defun normalize-all (exprs)
(mapcar #'normalize exprs))
(defun prepend-not-to-all (exprs)
(mapcar (lambda (x) `(not ,x)) exprs))
(defun-ematch normalize (expr)
;; The body of DEFUN-EMATCH is a list of clauses starting with the
;; pattern and followed by a body of forms to execute when the
;; pattern matches the sole argument (formatted here for the sake of
;; readability with the pattern on the left and the body on the
;; right). The EMATCH variant signals an error if no pattern matches
;; the input.
((type symbol) expr)
(`(and ,#tail) `(and ,#(normalize-all tail)))
(`(or ,#tail) `(or ,#(normalize-all tail)))
(`(imp ,a ,b) `(or ,(normalize `(not ,a))
,(normalize b)))
(`(iff ,a ,b) `(and ,(normalize `(imp ,a ,b))
,(normalize `(imp ,b ,a))))
(`(not ,expr) (normalize-not expr)))
(defun-ematch normalize-not (expr)
((type symbol) `(not ,expr))
(`(and ,#tail) `(or ,#(normalize-all (prepend-not-to-all tail))))
(`(or ,#tail) `(and ,#(normalize-all (prepend-not-to-all tail))))
(`(imp ,a ,b) `(and ,(normalize a)
,(normalize-not b)))
(`(iff ,a ,b) `(or ,(normalize-not `(imp ,a ,b))
,(normalize-not `(imp ,b ,a))))
(`(not ,expr) (normalize expr)))
(normalize '(iff foo bar))
;=> (AND (OR (NOT FOO) BAR) (OR (NOT BAR) FOO))
Alternatively, you could have another generic function to handle lists. Something like
(defmethod normalize ((expression list))
(normalize-list (first expression)
(rest expression)))
(defmethod normalize-list ((operator (eql 'and)) arguments)
`(and ,#(normalize-all arguments)))
(defmethod normalize-list ((operator (eql 'or)) arguments)
`(or ,#(normalize-all arguments)))
;; ...
But that's going to get way more verbose than pattern matching.