I have come across the identity function in the past, and never
really got it.  Like I probably used it without understanding it.

The setup is I am using mapcar to find if all elements in a list
are equal. Why is not important :)

My REPLing gives me:
```
(defun my-list-eq-1 (list)
  (let* ((first (car list))
         (mapres (mapcar #'(lambda (x) (eq x first)) list)))
    (every #'(lambda (x) x) mapres)))

(defun my-list-eq-2 (list)
  (let* ((first (car list))
         (mapres (mapcar #'(lambda (x) (eq x first)) list)))
    (every #'identity mapres)))

(my-list-eq-1 '(1 2 3 4)) 
(my-list-eq-1 '(2 2 2 2)) 
(my-list-eq-2 '(1 2 3 4)) 
(my-list-eq-2 '(2 2 2 2)) 
```

These two functions are the same.  The example calls would show
that.  Do you see the difference between the two functions?  This
was very cool for me.  After I wrote the first version some past
memory popped into my head about a function that just resolves to
itself.  I even knew to call it the identity function.  It must
have been explained to me at some point, idk.  Anyways, sure enough
common-lisp has an identity function.

To be honest I don't mind using the lambda version, because I am
deliberately being unsophisticated now in learning and playing with
common-lisp.  But I do prefer the identity function version, because
the intention is obvious.

Oh if i buried the lead... The whole point of this is that *this*
example shows to me the utility of the identity function.  I must
have known about it before not got the *why* of it.