But definition are different between language aren't they?

Some are, and that's a pity because it only leads to confusion. I like standards and one of them is a standard jargon/lexicon. If some language decides that it's going to abandon that then it is to that language's detriment.

Like a closure can just be an anonymous function in some languages.

That's just plain nuts. If a function isn't closing over anything then it is not a closure - QED. :-)

Or do you consider that there is one true definition, and incorrect uses?

For some terms, absolutely. There are terms which are well defined within Comp Sci (pointer, array, function, etc.) which if used to mean something else would certainly be classed as an incorrect use.

I won't discuss much further, or at all, because who cares about python anyway?

Amen, brother. Our fellow monk betmatt does seem rather obsessed by it, though. Poor chap.

For some terms, absolutely. There are terms which are well defined within Comp Sci (pointer, array, function, etc.) which if used to mean something else would certainly be classed as an incorrect use.

"Well defined" within certain contexts, as all things are

Maybe in the 1970s this meant more, back when there were fewer choices

OK if you want to define "lexical" by the order of statements inside a scope, (our is a good example) than let's compromise on "private" .

Both Perl and Python have private variables.

• in Perl they are also called "lexical vars" and declared with my for the rest of the scope
• in Python they are called "local vars" and implicitly declared while assigning in a function scope or some obscure comprehensions for the full scope, even up-wards

OK?

My "OK" is on your edit where variables in python are now described as being similar to my, rather than implying that they are equivalent ;-). As a compromise, I can also change my statement into:

Python doesn't have sane lexicals.

> on your edit where variables in python are now described as being similar to my

not sure if I introduced "similar" now, but I certainly wrote "More or less" right from the begining! :-P

I think it's a bit messy that we use "lexical" for scope and variable in Perl.

That's why the documentation for our is confusing, it binds a symbol inside a lexical scope to a non-lexical variable.

> Python doesn't have sane lexicals.

Everything has a price, code looks tidier but no chance to have strict checking.

Cheers Rolf
_{(addicted to the Perl Programming Language :)
Wikisyntax for the Monastery FootballPerl is like chess, only without the dice}

Lisp popularized both concepts for decades, other languages can't bend the definitions into the opposite.

And Larry took them from Lisp after adapting it to the different syntax of Perl when designing Perl 5

A lexical variable is a variable that can be referenced only within the lexical scope of the form that establishes that variable; lexical variables have lexical scope. Each time a form creates a lexical binding of a variable, a fresh binding is established.

So there you have a form where the variables are defined at the very beginning. °

 (let ((var1 init-form-1)
       (var2 init-form-2)
       ...
       (varm init-form-m))

   form1
   form2
   ...
   formn)
[download]

Both Perl and Python avoid extra "blocks" for each declaration by coupling the declaration to the surrounding scope.

(To exactly simulate this behaviour we'd need a do block in Perl where all lexical vars are defined at the very beginning)

So yes Perl is a bit saner but with a more complex implementation than Python and JS which are pretending the declaration happened at the scopes start.

So using your arguments none of these languages are implementing lexical vars, because none is using a "let block" syntax.

My argument is that semantics matter not syntax.

AND you can easily transform Python and JS scoping to Perl's by moving the declaration at their scopes start and leaving the init parts at their respective place.

Replicating my former example

sub fun2 {
    my $a;
    print $a;  # undef warning *
    $a = 33;
}
[download]

I hope my POV is clearer now.

*) In order to have a fatal like in python just tie the declarations with a tied variable that croaks when fetched.

°) though I don't know the original notation in lambda calculus