Regarding the type analysis assertion there was an interesting post on this
topic a while ago on Slashdot (believe it or not). I think the post was by the
main implementor of CMU Common Lisp and the claim was that the CMU compiler
does type inference for the monomorphic subset of Common Lisp. This is
normally the bits where speed matters the most (e.g. numerical processing) so
it works well in practice.
The aim of this is optimizing. It tries to find code that is used
mono-morphically. I'm only interested in the safety part of static typing, not
the performance part. Performance is mainly the pb of the critical path,
whereas safety must take care of the whole program.
As for the static/dynamic typing debate as a DrScheme user I use their soft
typer (MrSpidey) every time I use DrScheme. The message you reference talks
about an old soft typer. MrSpidey is a lot better and gets around the issues
raised in the message.
I've been trying MrSpidey to see how some pbs were solved. But I must have
missed something. Even trivial examples give unreadable "error" messages:
(define (sum l)
(if (empty? l) null
(+ (car l) (sum (cdr l)))))
the analyser display a nice window the source code with supposed errors
colored red. You have to click on one red expression to get a box containing
((y1 (list (union nil num))))
((union nil y1 (cons num y1)) *-> num))
the error here must be <tt>(union nil num)</tt>, but i have not tried to
understand the full recursive type meaning.
As a comparison, ocaml would say:
let rec sum = function
|  -> 
| e::l -> e + sum l
This expression has type 'a list but is here used with type int
I've also tried using a simple "<tt>let</tt>" but with no luck... Doesn't it
handle simple scheme?