Martin Ahnelöv ;

>    - (added) dynamic, resizable arrays
>                .size( int ) resizes array; .size() returns current size()
>                << operator appends new elements into array

Is this really right? are we doing right-to-left assignment now?

I think the idea is that a value is appended, which means (reading left to right) it ends up on the right end of the array so it's easiest to visualise it as "entering from the right". I could also imagine a ">>" operator that would enter values at the beginning of the array, moving the rest one step to the right. I like it for appending single numbers, so far.

This seems in tune with the general "like you read it" philosophy of ChucK;

32 => Std.motof => my_osc.freq;

is more readable to me then the equivalent
my_osc.freq( Std.mtof( 32) );

However,  now re run into the situation where if we'd like to append a float we need to do this;

my_pitches_array << Std.mtof( 32);

Instead of sending the number into mtof like;

//warning; non-valid!!!
my_pitches_array << 32 => Std.mtof;

...which ChucK interprets as a attempt so send a array of floats into mtof, which predictably fails (and I'm not sure I like it for functions that do take arrays as their argument because the poor number looks like it's being quartered but that's no great issue as such a operation would be better with two lines anyway).

In practice this means that if we have some chain of functions that calculates a number which we'd like to append to a array (seems like a likely scenario to me) we need to do this;

my_pitches_array << ( 32 => Std.mtof);

...that one does work but I'd say it won't win any beauty awards in the "operate like it looks" department since it looks a bit confusing to me.

In that case I think I'd prefer something like;

//warning; concept, doesn't actually run
32 => Std.mtof => my_pitches_array.apnd;

I'd say that's not as intuitively "left to right"  as the current situation for appending a single number but much better then the thing we now get if that number is the result of a chain of calculations yet doesn't have a name.

As I see it so far this new feature encourages either naming variables or code that looks weird to me right now. I have no strong opinion on any of this yet, I'll have to see how it works out in practice but these are some of my thoughts on it so far. I do think "<<" is quite ChucKian as a concept but I suspect it will lead to less-then-ChucKian results in non-trivial contexts.

Yours,
Kas.