While I am a big fan of reader conditionals, I often shoot myself in the
foot by loading fasls which were compiled with (or without) a certain
feature but which do not match the features in the lisp which is doing
the loading.

My solution to this problem was to hardcode checks in the code. for a
feature foo,

#+begin_src lisp
(defvar foo-present-p #+foo t #-foo nil)
(eval-when (load eval)
(assert (eq foo-present-p (load-time-value (and (find :foo *features*) t)))
nil "Feature Mismatch: FOO was ~:[absent~;present~] at compile time but is ~:*~:[present~;absent~] at runtime."
foo-present-p))
#+end_src

this is cumbersome, and there ought to be a way to mitigate the pain, a
macro like

ensure-compile-time-features (&rest features)

which would record whether a feaure is present when the file is being
compiled, and then subsequently arrange to check if the feature was
present at runtime and signal an error if the feature was absent.

Now I think this can be done, but i had to dig in the past for the
compile time value.

There was a thread in February 2008 "Re: passing values from
compile-time to load-time" initiated by SDS which you can probably find
by searching for ABAZONK. I posted a solution on that thread (note to
sds: your followup solution which tried to eliminate the global variable
does not work on any lisp except clisp. the global variable should be
totally harmless and should not be a concern)

here it is from <m3d4qw515z.fsf @robolove.meer.net> cleaned up

#+begin_src
(defvar *compile-time-value-definer* nil
"For internal only. Used by DEFCTV. At the top level this should
always be bound to NIL." )

(defmacro defctv (var expr &optional default)
"Like DEFVAR but defines a \"compile time value\". EXPR is evaluated
at only at compile time. VAR is bound to the result (from the
evaluation of EXPR when the defctv form is compiled) or to DEFAULT if
there is was no compilation."
`(progn
(defvar ,var ,default)
(setq *compile-time-value-definer* nil)
(eval-when (:compile-toplevel)
(setq *compile-time-value-definer*
`(setq ,',var ',(eval ',expr))))
(eval-when (:compile-toplevel :load-toplevel :execute)
(macrolet ((define-compile-time-value ()
*compile-time-value-definer*))
(eval-when (:load-toplevel :execute)
(define-compile-time-value))))))
#+end_src

[Has anyone invented and published defctv in the intervening 12 years?]
Now I can define

#+begin_src
(defmacro require-compile-time-features-at-run-time (&rest features)
"Ensure that the listed that were present (or absent) at compile
time are also present (or absent) at run time."
(dolist (feat features) (check-type feat keyword))
(let ((var (gensym)))
`(progn
(defctv ,var (read-from-string (format nil "(~{#+~(~a~) t ~:*#-~(~a~) nil~^ ~})" ',features)))
(eval-when (load eval)
(let ((mismatches
(loop for ctv in ,var
for feat in ',features
unless (eq ctv (and (find feat *features*) t))
append (list feat ctv))))
(assert (endp mismatches) nil
"~{~(~s~) was ~:[absent~;present~] at compile time but is ~:*~:[present~;absent~] at runtime.~^~%~}" mismatches))))))
#+end_src

Any loopholes? Or can anyone suggest a better name?

Madhu <enometh@meer.net> wrote:

>
> Any loopholes? Or can anyone suggest a better name?
>

I have a thing which I stole (borrowed may be) which lets you say

(ensuring-features
((:compile-toplevel :load-toplevel)
(and f1 f2 ...)
f3
(or f4 f5))
(<other time, t means 'all times'>
... more feature expressions ...))

It just expands into suitable eval-whens, and calls to a featurep function
which implements the rules of #+ etc. Obviously it can not do read-time
things, but it can make boolean assertions about what features must exist
at various points. It can not carry things from compile to load time
however.

--
the small snake

* Madhu <m37d9v51ik.fsf@leonis4.robolove.meer.net> :
Wrote on Wed, 16 Feb 2022 01:46:19 +0530:

> There was a thread in February 2008 "Re: passing values from
> compile-time to load-time" initiated by SDS which you can probably
> find by searching for ABAZONK. I posted a solution on that thread
> (note to sds: your followup solution which tried to eliminate the
> global variable does not work on any lisp except clisp. the global
> variable should be totally harmless and should not be a concern)

Turns out the code I exhibited here fails *only* on clisp

> here it is from <m3d4qw515z.fsf @robolove.meer.net> cleaned up
>
> #+begin_src lisp
> (defvar *compile-time-value-definer* nil
> "For internal only. Used by DEFCTV. At the top level this should
> always be bound to NIL." )
>
> (defmacro defctv (var expr &optional default)
> "Like DEFVAR but defines a \"compile time value\". EXPR is evaluated
> at only at compile time. VAR is bound to the result (from the
> evaluation of EXPR when the defctv form is compiled) or to DEFAULT if
> there is was no compilation."
> `(progn
> (defvar ,var ,default)
> (setq *compile-time-value-definer* nil)
> (eval-when (:compile-toplevel)
> (setq *compile-time-value-definer*
> `(setq ,',var ',(eval ',expr))))
> (eval-when (:compile-toplevel :load-toplevel :execute)
> (macrolet ((define-compile-time-value ()
> *compile-time-value-definer*))
> (eval-when (:load-toplevel :execute)
> (define-compile-time-value))))))
> #+end_src
>
> #+begin_src lisp
> (defmacro require-compile-time-features-at-run-time (&rest features)
> "Ensure that the listed that were present (or absent) at compile
> time are also present (or absent) at run time."
> (dolist (feat features) (check-type feat keyword))
> (let ((var (gensym)))

I'm using an uninterned gensym for the defctv which goes on to be
defined via defvar. In the code below I expect it to be the same
identical symbol both in compiled and executed phases in the expansion
for defctv (posted above)

It fails on CLISP and I need a
(let ((var (intern (symbol-name (gensym)))))
here.

> `(progn
> (defctv ,var (read-from-string (format nil "(~{#+~(~a~) t ~:*#-~(~a~) nil~^ ~})" ',features)))

VAR expands in DEFCTV to this form at compile time:

`(setq ,',var ',(eval ',expr))

Does this form prohibit VAR from being unintered? Is clisp justified in
throwing an error here?

> (eval-when (load eval)
> (let ((mismatches
> (loop for ctv in ,var
> for feat in ',features
> unless (eq ctv (and (find feat *features*) t))
> append (list feat ctv))))
> (assert (endp mismatches) nil
> "~{~(~s~) was ~:[absent~;present~] at compile time but is ~:*~:[present~;absent~] at runtime.~^~%~}" mismatches))))))
> #+end_src
>
> Any loopholes? Or can anyone suggest a better name?