[chuck] 1.2.1.2 (dracula) unleashed

[Rich Caloggero]

Kas. wrote:
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.
...

Why not something like:
32 => Std.mtof => my_pitches_array[];

I think the bracket notation is very standard (i.e.  people are used to it from many languages), and it seems to be less confusing and fits the left-to-right reading order.

Just my one cent!
-- Rich



  ----- Original Message ----- 
  From: Kassen 
  To: ChucK Central Mailing List 
  Sent: Tuesday, July 22, 2008 11:41 PM
  Subject: Re: [chuck] 1.2.1.2 (dracula) unleashed


  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.



------------------------------------------------------------------------------


  _______________________________________________
  chuck mailing list
  chuck at lists.cs.princeton.edu
  https://lists.cs.princeton.edu/mailman/listinfo/chuck
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.cs.princeton.edu/pipermail/chuck/attachments/20080724/df4a9931/attachment.html>