🚀 go-pugleaf

   !! I'm very surprised.  Scheme's optimizer must be really good.  Or does scheme
   have simpler arrays (statically typed ones) than common lisp?

Common Lisp has extensive facilities for declaring array types.  With the 
appropriate declarations an optimizing Common Lisp compiler can do quite well
with simple array references.

   I suppose lisp compilers are much more global than those of other languages.
   They must detect that an object will only ever be assigned one data type and
   then make that object static instead of dynamic.

No, thats not how Lisp compilers work.  I doubt that any Lisp compiler would
try to infer the types of random global variables.  The optimizing Lisp 
compiler that I am familiar with (Lucid) does not even try to optimize local
variables in that manner.  What it will do is infer the types of some 
intermediate values.  If a,b, and c are declared float then then compiler
wll fully optimize the expression "(+ a (+ b c))" by inferring the type
of the intermediate expression "(+ b c)".  It won't even do that much if 
a, b, and c are fixnums.  "(+ b c)" could evaluate to a bignum, so you have
to promise that that won't happen by doing "(+ a (the fixnum (+ b c)))".

   Oh that reminds me, when the above optimization is done, how are bignums
   handled?  I can see how the compiler might detect that only integers
   are involved, but how does it know that the integers will be small?  Or is
   there always runtime code for checking integer sizes?

If you promise that a variable is a fixnum then the compiler (at high levels
of optimization) will produce code that does not check for overflows.  If 
you're wrong about your promise then you lose.

- Steve Olson
  MIT Lincoln Laboratory
  olson@juliet.ll.mit.edu