Lisps that return nil for (car nil) are implementing "optional chaining".

yes, it chains:

   (cadar nil) -> nil ;; the nil object doesn't have a "car"

   (cadar '((b c))) -> c

   ;; i.e.
   (car (cdr (car '((b c))))) -> c

This is exactly like, in Swift-like syntax, doing '((b c)).car?.cdr?.car? where the ? indicates "don't blow up if it's nil", except the "don't blow up" is built into car and cdr.

This freedom was introduced in InterLisp, quite a few years before Jobs and Wozniak got together in a garage to make the Apple I.

If you want prior art, there it is.

Another prior art, related to this, is the Null Object Design Pattern, which is very similar.

In Common Lisp, this pattern (like many others) disappears because `nil` is the element of a `null` class, to which we can specialize methods. So in other words, we can make

If we have a method called position that normally returns the position of an object, if we specialize the method to the null class we can make (position nil) do something.

In Java-like OOP languages we would have a specific NullWhatever class that implements the same Whatever abstract interface/base as an ActualWhatever. Thus we then have an optional Whatever because code that takes a Whatever can take a NullWhatever or an ActualWhatever.

Yet another prior art is the use of sentinel objects instead of null pointers: for instance doubly-linked lists that have a special node, not considered part of the list, that is the predecessor of the first, and successor of the last. Then the code operating on lists neither blows up with a null access, nor does it have to check for nulls. Statements like node->prev->next = node always work.

"The single event that had the most influence on the creation of the League [for Programming Freedom] was Apple's lawsuits against Microsoft about supposed copyrights violations of the look and feel of the Macintosh in the development of Windows."

https://en.wikipedia.org/wiki/League_for_Programming_Freedom