Compiler optimization of structure or class definitions

Question

What is the potential impact on compiler optimization to defining a Common Lisp structure (or class) like (defstruct person (age nil :type (or null integer))) vs (defstruct person (age -1 :type integer))? I often find it convenient, using the first form, to have a null value signifying a special condition; for example, if a person's age is not known. But in the second form, you could also use an ad-hoc designated integer like -1 to indicate this condition. Is there an advantage/disadvantage to one representation over the other? (ps: In this case the difference is likely negligible, but seems like it might not be for nested structures involving complex objects like hash-tables, etc.)

Answer 1

I think you are asking the wrong question.

"... a computer language is not just a way of getting a computer to perform operations, but rather ... it is a novel formal medium for expressing ideas about methodology"

Abelson/Sussman "Structure and Interpretation of Computer Programs".

You are writing code for people to read, not just for computer to execute. The primary driver for your design should be code readability rather than performance (especially when, as is in your case, the performance impact is most likely to be negligible):

1. Is premature optimization really the root of all evil?
2. When is optimisation premature?

Specifically in your case, if you have only one special value, and that special value means "missing", you might want to use defclass where you can have unbound slots instead of nil slot values in defstruct.

PS. Don't get me wrong - performance DOES matter. However, it matters in scalability, not micro-optimizations. IOW, the priorities should be

• Scalability (i.e., choosing a linearithmic instead of a quadratic algorithm)
• Readability/maintainability (code structure, symbol names, comments, and such)
• Micro-optimizations (e.g., type declarations in Lisp code)