"Dmitry A. Soshnikov"<
[email protected]> writes:
Example:
function foo(a,b) { return a + b; }
This function doesn't contain any closure constructions.
It doesn't access any scoped variables.
It doesn't use the arguments object.
There is nothing preventing an implementation from just reading
parameters off the stack, add them together, and return the
result (on the stack or in a register).
Yeah, logically, yes; I mentioned it the article of closures -- it can
be a general approach in any language -- if a functions do not have free
variables (with possibly analazing the whole chain), then it easily can
put arguments onto stack (or even, yes, registers), rather than use heap
for that, as generally is in languages which supports closures.
The pattern
[x,y] = [e1,e2];
should be detectable at compile time, so the introduction of the
intermediate array can be optimized away.
Moreover, it can be done syntactically without brackets, as in Python:
x, y = e1, e2;
I'd prefer that.
Or
(x,y) = (e1,e2); // except it's ambiguous with the stupid comma operator.
Damn, really, ambiguity. This could be a good question for "quiz" also
(after everybody have learned that comma returns evaluation of its last
operand):
var a = 10, b = 20;
// everybody knows, that
// comma operator returns the
// evaluation of the last operand
20, 10; // 10
a, b // 20, the same, the last
a, b = b, a;
// or even so:
a, b = 20, 10;
console.log(a, b); // 10, 10 ? Nope, still 10, 20 of course
Yes, this syntax (because of backward compats) isn't acceptable for ES;
in contrast with Python.
But then, I think any modern type system should have arbitrary tuples.
Heck, I've seen languages with a swap primitive
x :=: y;
Interesting. Yes, why not? A good syntactic sugar, increasing the
abstraction, (even if it will cause some performance penalty) is good.
Try that for strings
Yeah, I know sure. Just mentioned thinking about numbers at that time
(with numbers also can be overflow, by the way).
It's generally a bad idea to be "too smart" in a high-level language.
If you do:
int x,y;
...
x^=y;y^=x;x^=y;
to swap integers in, say, C++, then the compiler might not be able to
do as good a job as if it could recognize that you were doing a
swap. It might know low-level tricks for swapping that can't be
expressed directly in the high-level language (like knowing that
both values are in registers at the moment,
I've checked for the interest in the MS Visual Studio, in C++ -- nope,
it either do not know such optimization at all (even if I try to declare
vars as "register", although, the compiler can ignore it) and make full
operations -- as I see in disassembly window. Or make full optimization
removing my simple code with that operations
Maybe it can be caught
in more complex examples and it will use that "xchg", don't know. For
the interested it possible to disassemble std:swap to see what's going
on in assembler representation. Although, that's just the particular
implementation.
so they can be swapped
by a single xchg instruction (if on x86)).
Yeah, I remember this command, although, I don't use the assembly
language on practice.
Dmitry.
