On 9 November 2017 at 16:42, Martin Simmons <martin@lispworks.com> wrote:
Compiler macros are expanded too early to get inferred type info. For example,
(let ((y 10)) (loop (bar y) (setq y :not-a-fixnum)))
Right. That makes sense. So it seems declarations is the way to go if you want to make type based optimizations. Chaitanya
-- Martin Simmons LispWorks Ltd http://www.lispworks.com/
On Thu, 9 Nov 2017 14:47:53 +0530, Chaitanya Gupta said:
I tried this on SBCL:
(defun bar (x) x)
(define-compiler-macro bar (&whole form x &environment env) (when (symbolp x) (print (multiple-value-list (clast:variable-information x env)))) form)
The form below, with the declaration, prints type information correctly:
(compile nil (lambda () (let ((y 10)) (declare (fixnum y)) (bar y))))
(:LEXICAL T ((TYPE . FIXNUM)))
However, the one below with no declarations, doesn't give any info:
(compile nil (lambda () (let ((y 10)) (bar y)) (let ((y '(1 2 3))) (bar y)) (let ((y 'foo)) (bar y))))
(:LEXICAL T NIL) (:LEXICAL T NIL) (:LEXICAL T NIL)
So I guess that, at least on SBCL, this is not possible.
Chaitanya
On 9 November 2017 at 14:09, Antoniotti Marco <antoniotti.marco@disco.unimib.it> wrote:
CMUCL and SBCL have the Environment API somewhat available (*)
You can see whether they store the inferred values in there.
Marco
(*) Again, you can have a look at CLAST to see how to access it; I know: it is a shameless plug.
On Nov 9, 2017, at 09:18 , Chaitanya Gupta <mail@chaitanyagupta.com> wrote:
So thanks to the replies on this I now know that most of the popular Lisps do support inspecting the environment to figure out declared types.
But what about inferred types (e.g. in CMUCL, SBCL)? Do these Lisps provide a way to know the inferred type of a variable if no declaration was made explicitly?
Chaitanya
On 7 November 2017 at 02:13, Chaitanya Gupta <mail@chaitanyagupta.com> wrote:
Let's say I have created a function called `FOO`:
(defun foo (x) ...)
To optimize this function, I write a compiler macro. Can I make use of type declarations that users of `FOO` might have made for the argument `X` that is passed in to it?
That is, let's say `FOO` is used like this:
(let ((a (something-that-returns-an-integer))) (declare (integer a)) (foo a))
The compiler macro for `FOO` cannot make any optimizations on the value of `A`, but can it take advantage of the fact that `A` is declared as in `INTEGER` here?
Chaitanya
-- Marco Antoniotti, Associate Professor tel. +39 - 02 64 48 79 01 DISCo, Università Milano Bicocca U14 2043 http://bimib.disco.unimib.it Viale Sarca 336 I-20126 Milan (MI) ITALY
Please check: http://troncopackage.org
Please note that I am not checking my Spam-box anymore. Please do not forward this email without asking me first (cum grano salis).