Francois <[EMAIL PROTECTED]> wrote: > Since I did a lot of work in Scheme, rigor and consistency are most > important to me, and Python certainly meets this requirement.
It does pretty well, with some tempering of pragmatism -- but, to play devil's advocate, Ruby isn't far in this respect. In either case, you will find more rigor and consistency in good languages of a more academic bent, such as Haskell, but will surely find a lot in either Ruby or Python. The trick about distinguishing a name's exact nature based on whether the compiler sees an assignment to that name in some part of code is found in both languages, albeit in different ways. In Ruby, as you've pointed out, it's the heuristic used to disambiguate local variable access from zero-argument method calls, and the "part of code" is the function up to the point of access. In Python, it's used to disambiguate local from global or free variables, and the "part of code" is the body of the whole function (Ruby does not need to make this latter distinction because it strops global names with a leading sigil -- $a is always the global variable a, just like @a is always the instance attribute a, which we'd write self.a in Python). Another subtle case in Ruby is whether an assignment such as a=23 _within a block_ is meant to be local to the block or meant to rebind local name 'a' within the enclosing function; again, the heuristic is similar, depending only on whether the compiler had seen another assignment to a before it saw the block (Python forbids the rebinding of variables coming from an enclosing but non-global scope, to avoid facing this issue). All in all, Python is more likely with these heuristics to respect the principles (from the "zen of python", import this at an interactive prompt): in face of ambiguity, refuse the temptation to guess; errors should not pass silently, unless explicitly silenced. I.e., any Python code which accidentally runs afoul of these heuristics is likely to raise an exception, alerting you to the situation. Ruby strives rather for a "do what I mean" ethos, and obviously some people prefer that. I also share your preference for a single namespace for callable and non-callable values, as in Python (and Scheme, Lisp, C++, ...), rather than disjoint namespaces as in Ruby (and Smalltalk), but I do not see it as a question of rigor and consistency at all -- e.g., I do not perceive Smalltalk as less rigorous or consistent than C++, on the contrary. So, I agree with your choice, and I think I understand your motivations, but I do not entirely share your motivations, personally speaking. Alex -- http://mail.python.org/mailman/listinfo/python-list
