And thank dog for that.
1. No more than 17 functions handle this datum, spread among no more than three source files.
2. The structure contains no more than 8 conses.
3. In a long-running application under a typical production load, no more than 10,000 of these objects are freshly allocated in any five minute period.
4. A major software component (such as a library) can internally have at most three separate instances of such a data type, and they are not to be involved in the APIs between major software components.
Okay, that's now a target we can enforce without wishy washy judgment calls.
Sure, you can have an exact set of rules like that, and feel free to have an automated enforcement of your own set of exact rules. There are good reasons coding style guides often include things which are not exact rules, and the target for them is often not automated enforcement but supporting human judgement that balances multiple factors. Yes, that results in fuzzy boundaries, but it's because experience has both shown that there is an issue but has not provided (yet) sufficient basis for a quantifiable boundary, because the set of factors being balanced is complex and multidimensional. Reducing the dimensionality for simplicity of automated enforcement is easier, but not necessarily better.
So what happens when you have a datum that is used in exactly 17 functions, but you need to add another feature?
Or, what happens when people combine functions into larger ones to avoid having to define a real datatype, or...
These concerns exist for each thing.
"Don't use a list where you really have a struct" is much more concrete and quantifiable.
You have to add your feature in such a way that the resulting code meets the rules.
It's exactly the same like when you need to add something to a line that is already 79 characters long (maximum allowed by your coding convention). Or if you have to add lines of code into a function that is already 200 lines long (coding style max). Or if you need another argument in some API that already has the maximum of 8. You have to step back to some extent and change more of the surrounding program, than just shoving your intended change into it.
> Or, what happens when people combine functions into larger ones to avoid having to define a real datatype
If the code remains under the quantified limit for function size, then it is complying with the document.
> "Don't use a list where you really have a struct" is much more concrete and quantifiable.
There are two answers to "where do you really have a struct?" One is purely opinionated, and one is objective. The objective answer is: "you really have a struct in all situations where the list isn't a variable length container of items of the same type".
So the concrete and quantifiable (and therefore the right) interpretation of the rule amounts to never using a fundamentally characteristic Lisp technique, in Lisp!
MAXIMA (née MACSYMA) is known for lists-as-objects not only being depended upon, but also getting so out of hand it’s nearly impossible to refactor now. MAXIMA at least has the excuse of being very old software.
I feel you’re interpreting this style guide as some kind of draconian law of writing Lisp code at Google, and making awful conclusions from it (e.g., “well if you’re allergic to objects as lists might as well not use Lisp” or “most of this can be summed up as writing Lisp like Java”).
I don't disagree with that; a coding standard that is not enforceable without generous judgment calls is far less useful than a rigorous one.
Make it exact, and then get everyone to stick to it.
The basic mentality was if you couldn't responsibly follow the style guidelines after working there for a year, then you should be looking for work elsewhere.
The one exception I can think of is procedures with variadic arguments.
(There is at least a coffee machine, health benefits, and a halfway ergonomic chair to sit on, hopefully.)
The lisp I use (scheme) does not have pattern-matching built-in and nobody has made a good enough case to add it as a special form.
There's your problem. Here's a nickel (toss). Get yourself a real Lisp.
This approach is one of the things that make Lisp Lisp; if it gives you an allergic reaction, use something else.