[pro] Declarations in compilers (feedback welcome)

[Gail Zacharias]

Using declarations vs using THE is often a stylistic consideration, and
while you may be able to get ECL-only users to accept your additional
semantics, you might have trouble getting maintainers of portable libraries
to observe this arbitrary distinction.

Why not let SPEED into the mix?  E.g. if SPEED > SAFETY then don't compile
typechecks.

On Thu, Dec 29, 2011 at 5:24 AM, Juan Jose Garcia-Ripoll <
juanjose.garciaripoll at googlemail.com> wrote:

> After struggling mentally with this for a few weeks, I would like to have
> some consultation before I introduce some changes in ECL -- not that I
> expect many users here, but at least some implementor-fellows and power
> users of other implementations.
>
> My concerns right now relate to how declarations should be used by a
> compiler, and in particular how declarations interact with SAFETY levels.
> Please correct me if I am wrong, but I have seen more or less the following
> approaches
>
> [a]- Most implementations blindly believe declarations below a certain
> safety level. Above it, they seem more or less useless.
>
> [b]- SBCL takes declarations (and THE) as type assertions. For instance,
> in (LET ((Y (FOO X))) (DECLARE (FIXNUM Y))) ...) the assignment to Y would
> be checked to be a FIXNUM. This means the type declaration is actually
> enforced and believed and only at SAFETY 0 the checks are dropped (*)
>
> In both cases one ends up with a model in which in order to truly believe
> a declaration and have no extra burden (assertions), one has to drop to
> SAFETY 0 in all code that is involved with it, which is a mess, because it
> might inadvertently affect other parts of the code. It is for this reason
> that I am considering an alternative model for ECL which would grade safety
> as follows
>
> - Type declarations are always believed
> - SAFETY >= 1 adds type checks to enforce them.
> - SAFETY = 0, no checks.
> - SAFETY = 1, the special form THE or additional proclamations on the
> functions can be used to deactivate the check. As in (LET ((Y (THE FIXNUM
> (FOO X))) ...)
>
> This would allow one to keep most code safe, while deactivating some
> checks when they are really known to be true (**). Do you think this is
> useful/useless? The problem I see with this approach is that all code
> around is written for model [a] or [b], but I could not come up with
> something more sensible so far.
>
> Juanjo
>
> (*) Actually the checks are also deactivated when SBCL can infer the type
> of the value that is assigned to Y. This is somewhat contradictory, because
> (SETF Y (THE FIXNUM (FOO X))) would still generate a check, but proclaiming
> FOO to return a FIXNUM would completely bypass the check.
>
> (**) Yes, indeed I know that LOCALLY exists for a reason, but it does more
> than THE. For instance, if I (LOCALLY (DECLARE (SAFETY 0)) (THE FIXNUM (FOO
> (SLOT-ACCESSOR X)))... this influences the safety of the code that accesses
> a structure, which is not good.
>
> P.S.: Thanks to Paul Khuong for pointing out that SBCL behaves differently
> w.r.t. declarations.
>
> --
> Instituto de Física Fundamental, CSIC
> c/ Serrano, 113b, Madrid 28006 (Spain)
> http://juanjose.garciaripoll.googlepages.com
>
> _______________________________________________
> pro mailing list
> pro at common-lisp.net
> http://lists.common-lisp.net/cgi-bin/mailman/listinfo/pro
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://mailman.common-lisp.net/pipermail/pro/attachments/20111229/6777cc3c/attachment.html>