For example you want to name font sizes:
(defconstant +large+ 3)
(defconstant +medium+ 2)
(defconstant +small+ 1)
You could write a macro to make that shorter.
Above constant definitions are usually written ONLY when these numbers need to be passed to some external non-Lisp code.
Otherwise one would just use keyword symbols: :large, :medium and :small.
You can test them with EQ and everything that uses some test for equality.
(let ((size :medium))
(ecase size
(:small ...)
(:medium ...)
(:large ...)))
You can also write methods for it:
(defmethod draw-string (message x y (size (eql :large))) ...)
As mentioned you could define a set type:
(deftype size () '(member :small :medium :large))
Then you can check if something is either of those:
(let ((my-size :medium))
(check-type my-size size))
Above would signal an error if my-size is not one of :small, :medium or :large.
You can also use the type in a defclass form:
(defclass vehicle ()
((width :type size :initarg :width)))
Now you would create objects like here:
(make-instance 'vehicle :width :large)
Some Common Lisp implementations will check when you set the slot to some illegal value.
If you now create objects of class vehicle, the slots will be one of :large, :medium or :small. If you look at the object in a debugger, inspector or some other tool you will see the symbolic names and not 1, 2 or 3 (or whatever values you would normally use).
This is part of the Lisp style: use symbolic names when possible. Use symbols with number values only in interface code to foreign functions (like calling external C code that uses enums).