Quote:Original post by RAZORUNREAL

1. Any number of named returns
I'm thinking of something like this:

(int return1, int return2)Foo(int param1, int param2)

Rather than using eax for return values, which only works for things 32bit or less anyway, I thought I could pass them by reference. And I might as well pass the parameters by const reference while I'm about it, and throw pass by value out the window. So, that would make the above equivelant to the c++ snippet:

void Foo(int& return1, int& return2, const int& param1, const int& param2)

Quote:
2. All variables must be initialised
I can't think of a time where saying a variable = 0 when you create it isn't possible, and uninitialised variables can cause bugs. And honestly, I think leaving a variable uninitialised is a pretty pointless micro optimisation. Especially when my language is already overkill, and is only going to get more so because I can compile it to the system, using things like sse if available. But I'm getting off topic. The real point is it makes feature 3 easier.

Quote:
3. Type inference/template replacement
Basicly, a var type that can be anything. This could cause alot of pain, and for all I know it's impossible, but it would just be so handy. It goes like this:

(var result)Square(var num){   result = num * num;}

Basicly, the compiler generates a new function each time it encounters a call using a different type. Pretty much like a template function, only not inlined. Pretty much like this template function in fact:

template<class T, class U>void Square(T& result, const U& num){   result = num * num;}

Of course you could end up generating huge amounts of code without even noticing, but that's really the point in it anyway... One thing that you can't normally do is:

var someVar = templateFunc(someOtherVar);

Forcing variable initialisation means you can't give a var different types based on some run time condition, which would make my head explode. If you can think of any flaws with all this I'd be very grateful.

Quote:
4. Custom operators
The language should be flexible enough that the program it's embedded into can create new operators etc. But what I'm not sure about is if you should be able to in code... Probably not, given the purpose of the language. Anyway, it would look like this:

operator (vector result)X(vector lhs, vector rhs) : + // Same precedence as addition.{   // You all know how to perform a cross product right?}vector C = A X B;

For ease of parsing I'd require a space between operators and operands. I was thinking precedence would be set in relation to other operators, rather than a flat value. Like the above operator would have the same precedence as addition. It might also be useful to say an operator has precedence 1 lower than some existing operator. And perhaps if you don't provide any sort of comparison it has the highest precedence.

Quote:Original post by Extrarius

Quote:Original post by The Reindeer Effect
[...]I would also recommend making your language single assignment ... that is, variables cannot be rebound to values. If you say 'var x = 3', then in that lexical scope, you cannot rebind x. This sort of behavior does not preclude mutation (although the mechanism for expressing mutation in this sort of system is a bit untraditional), but it does make the language clearer to both humans (in my opinion) and machines. Things are certainly much easier for the compiler and garbage collector.[...]

I have to strongly disagree. Most people have a hard enough time coming up with 1 good name, you certainly don't want to force inexperienced programmers (generally the target of 'scripting languages' meant to make a program extensible) to come up with more than 1 name for something.

With this kind of requirement, you'll see tons of scripts that have variables suffixed with a number (DeltaAngle, DeltaAngle2, DeltaAngle3). This kind of 'coding practice' will lead to many, many errors that are difficult to debug because people will forget the suffix or use the wrong one (especially if they add an extra step in their calculation - the state of things will revert to the days of required line numbering in basic where programmers would increment the number by 10 or 100 to have room for adjustments, and remebering that the proper sequence is [DeltaAngle100, DeltaAngle113, DeltaAngle125, DeltaAngle200] after a few algorithm modifications isn't easy)

You can easily make the compiler internally rename a variable each time it is assigned to in order to get all the same benefits in the scripting system, and there is no reason to make the human do the work. Even the processor itself does a form of this optimization with register renaming.