"no variable or argument declarations are necessary."

[Diez B. Roggisch]

> How about Lisp?  It seems to do some good there, without getting in
> the way.

I don't know much about lisp. But the thing is that one of the most
important data structures in python (and basically the only one in
LISP), lists, are a big problem to type-checking if they aren't
homogenous. So I guess one can write a compiler that generates
specialized code for lists of a certain homogenous kind, like lists of
int, float and maybe string - and as long as you ensure that code is
called with such a list, you're ok. But I think that is what psyco
does, too (no idea how these two compare)

Basically, all type-inferencing boils down to collecting constraints on
variable values. Like in this expression

z  = x + y

It will be internall represented by this:

z:C = x:A + y:B

which introduces type-variables A,Band C. That tells us that all
operations __plus__ and their respective types could be meant, thus A B
C are constrained by these types. Which, in an overloading-allowing
language, can get pretty much. The trick is to find a  solution for the
variables that satisfy all the constraints. And a solution are actual
types, not ad-hoc sets of types - otherwise, you can't create any
specialized code, and the compiler will puke on you.

Saying

z += 10

now creates a constraint that binds C to int, and subsequently A and B.

Now the problem is someting like this:

if x is None:
   x = 10
else:
   x = x * 10

Lets assume A as type-var for x. Then we have the two contstraints A ->
int and A -> None. Now - is there a type that satisfies both
constraints? No.  And even worse, A shall be int by x = 10 - but that
collides with A->None. So the only thing you can do is resort to A=ANY
- and interpret that code above :)

Diez