Operator overloading lets you redefine operators like ‘+’ and ‘=’. In some cases, it can really help, but on the whole, it has some potential for abuse.

Overloading is a def need. I really desired it in AS 3 but, as we know, it isn’t there. In C#, overloading makes code soooo much better. Instead of writing a method and running through the arguments array to see what was passed in you can write multiple methods with different arguments for each scenario. This works GREAT for constructors (c# code here):

public Table(string name, string schema, List columns)
{
this._name = name;
this._schema = schema;
this._columns = columns;
}

public Table(string name, string schema, bool hasView, List columns, List viewColumns) : this(name, schema, columns)
{
this._hasView = hasView;
this._viewColumns = viewColumns;
}

That kind of stuff would make AS 4 super sweet. Another thing I’d love to see is something like this (sample AS code):

public function blah(myvar:String[]){

}

This way we expect a string of arrays in myvar vs the need to create a custom type.

Anyways, I haven’t dove head-first into AS 3 but I will def’ say it is growing up right before our eyes. :-)

Thanks!

I actually misread Brendan’s slides, and I mistook one of his examples of the let block syntax to be something like lambda expressions or Ruby’s block syntax. Upon re-reading it, I wonder if it wouldn’t just be better to redefine the behavior of var and deal with backward compatibility through a flag. Yield and generics are still exciting to me.

Nullable (and non-nullable) types are interesting to me, but I haven’t fully thought through the implications. When would I want a nullable number?

Decimals are a clear win.

Array comprehensions would be more interesting to me if they were lazy evaluated (like list comprehensions).

Operator overloading is great and scary at the same time.

Thanks for the input!

Although the enhancements you mention are really exciting, I’d consider the following ones more important:
- Structural types
- Nullable types
- Decimal type and the associated math

Also, the following enhancements make for really nice syntactic sugar:
- Array comprehensions
- Operator overloading

tx, jd