Re: Should records be able to mimic primitive types?

[Stefan Monnier]

>> It's not trying hard, just a simple check for a known, small, and
>> rarely-changing list of primitive symbols.
> To me, that's working very hard:
> - extra code.
> - extra maintenance
> - extra run-time checks.
> - no benefit since this doesn't catch a common situation.

More concretely: what would be a scenario where such a check would
be useful?

AFAICT, you need all 3 of:
1- First, you'd need someone to be foolish enough to set his record's
   type to be one of the primitive types.  This is the actual bug that
   your extra check would aim to catch.
2- Then you'd need to pass that object to a chunk of code which uses
   `type-of` and then checks the result for that primitive type.
   Otherwise, the type you set would behave just like any other
   non-primitive type so the "bug" would be harmless anyway.
3- Furthermore, you'd need this object to be manipulated exclusively in
   a way which also works with your record object without signaling an
   error (e.g. if the primitive type used is `integer`, it means your
   object should never be passed to the likes of `+` since otherwise the
   bug would already be discovered by `+` without any need for your extra
   check).

I haven't seen any evidence that step 1 will ever occur, even by accident.

No idea how likely is step 2.  `type-of` is very rarely used (except via
cl-defmethod) so it's fairly unlikely, but possible.

Step 3 seems again very unlikely in itself, and even more so if step
2 occurred: if you checked with type-of that your object is of type
`integer` there's a very high likelihood that you're going to then use
operations which only work on integers.

Will all 3 steps ever occur at the same time?

Do we really want to make every call to `make-record` pay the extra test
in order to hope to catch this hypothetical case?  Obviously I think
not, and I'd be curious to understand why you think otherwise.


        Stefan