[chuck] 1.2.1.2 (dracula) unleashed

[Kassen]

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.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.cs.princeton.edu/pipermail/chuck/attachments/20080723/d71c92ab/attachment.htm>