www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - Idea: swap with multiple arguments

reply Andrei Alexandrescu <SeeWebsiteForEmail erdani.org> writes:
So swap(a, b) swaps the contents of a and b. This could be easily 
generalized to multiple arguments such that swap(a1, a2, ..., an) 
arranges things such that a1 gets an, a2 gets a1, a3 gets a2, etc. I do 
know applications for three arguments. Thoughts? -- Andrei
May 23 2016
next sibling parent reply Steven Schveighoffer <schveiguy yahoo.com> writes:
On 5/23/16 4:01 PM, Andrei Alexandrescu wrote:
 So swap(a, b) swaps the contents of a and b. This could be easily
 generalized to multiple arguments such that swap(a1, a2, ..., an)
 arranges things such that a1 gets an, a2 gets a1, a3 gets a2, etc. I do
 know applications for three arguments. Thoughts? -- Andrei
One thing that screams out to me: this should be called rotate, not swap. -Steve
May 23 2016
next sibling parent Tourist <gravatar gravatar.com> writes:
On Monday, 23 May 2016 at 20:27:43 UTC, Steven Schveighoffer 
wrote:
 On 5/23/16 4:01 PM, Andrei Alexandrescu wrote:
 So swap(a, b) swaps the contents of a and b. This could be 
 easily
 generalized to multiple arguments such that swap(a1, a2, ..., 
 an)
 arranges things such that a1 gets an, a2 gets a1, a3 gets a2, 
 etc. I do
 know applications for three arguments. Thoughts? -- Andrei
One thing that screams out to me: this should be called rotate, not swap. -Steve
Unless it swaps randomly :)
May 23 2016
prev sibling next sibling parent Q. Schroll <qs.il.paperinik gmail.com> writes:
On Monday, 23 May 2016 at 20:27:43 UTC, Steven Schveighoffer 
wrote:
 On 5/23/16 4:01 PM, Andrei Alexandrescu wrote:
 So swap(a, b) swaps the contents of a and b. This could be 
 easily generalized to multiple arguments such that swap(a1, 
 a2, ..., an) arranges things such that a1 gets an, a2 gets a1, 
 a3 gets a2, etc. I do know applications for three arguments. 
 Thoughts? -- Andrei
One thing that screams out to me: this should be called rotate, not swap. -Steve
Just name Andrei's function rotate and make swap just an alias of it with exactly two parameters. No confusion and everyone is happy.
May 23 2016
prev sibling next sibling parent reply Jonathan M Davis via Digitalmars-d <digitalmars-d puremagic.com> writes:
On Monday, May 23, 2016 16:27:43 Steven Schveighoffer via Digitalmars-d wrote:
 On 5/23/16 4:01 PM, Andrei Alexandrescu wrote:
 So swap(a, b) swaps the contents of a and b. This could be easily
 generalized to multiple arguments such that swap(a1, a2, ..., an)
 arranges things such that a1 gets an, a2 gets a1, a3 gets a2, etc. I do
 know applications for three arguments. Thoughts? -- Andrei
One thing that screams out to me: this should be called rotate, not swap.
That would probably be better. My immediate thought on reading Andrei's suggestion for swap was that it would be way too easy to forget what's actually being swapped when there are more than two arguments. Rotate at least implies and ordering to it. Though I confess that I've never heard of a swap function (or anything like a swap function) that's swapped more than two arguments, and I'm not aware of any point in time when I thought that such a thing might be useful. So, I'm not exactly clamoring for a function like this, but that obviously doesn't mean that it's not worth adding, just that I don't personally see any particular value in it. - Jonathan M Davis
May 23 2016
parent reply Observer <here nowhere.net> writes:
On Monday, 23 May 2016 at 21:38:54 UTC, Jonathan M Davis wrote:
 One thing that screams out to me: this should be called 
 rotate, not swap.
That would probably be better. My immediate thought on reading Andrei's suggestion for swap was that it would be way too easy to forget what's actually being swapped when there are more than two arguments. Rotate at least implies an ordering to it. Though I confess that I've never heard of a swap function (or anything like a swap function) that's swapped more than two arguments, and I'm not aware of any point in time when I thought that such a thing might be useful. So, I'm not exactly clamoring for a function like this, but that obviously doesn't mean that it's not worth adding, just that I don't personally see any particular value in it.
If you don't see value in it, you've neglected to learn PostScript. There, a similar capability is used to "rotate" a certain number of the top elements on the operand stack. However, because PostScript is a graphical language, the "rotate" operator instead does a 2D coordinate-system rotation. For the functionality that Andrei wants, PostScript uses the "roll" operator, which performs a circular shift of the top operands on the stack. Aside from those operands themselves, it takes an argument n (the number of operands to roll) and an argument j (the number of positions to roll, which can be either positive ("upward" motion on the stack) or negative ("downward" motion on the stack)). To be more visual about it, if j is 1, the top element of the stack is popped and inserted further into the stack. https://www.adobe.com/products/postscript/pdfs/PLRM.pdf (page 483 by printed-page numbering, page 489 within the PDF file) has all the details for this operator. The point is that alternative terms like "roll" and "circular shift" might be useful in naming this function, instead of either swap (which I agree is confusing) or rotate. And while n can be imputed from the number of arguments passed, it might be useful to pass j explicitly, allowing shifts of more than one position and in either direction. (Speaking of graphical contexts, if you were working in 3D, you might consider the meaning of "roll" to be "reserved", in the sense of roll/pitch/yaw.) As for utility, if you're a PostScript programmer, where keeping track of data is done via a stack-oriented model, this capability gets used all the time, to bring relevant arguments to the top of the stack to be operated upon, or to shove arguments deeper into the stack for later use.
May 23 2016
next sibling parent reply Jonathan M Davis via Digitalmars-d <digitalmars-d puremagic.com> writes:
On Tuesday, May 24, 2016 02:40:24 Observer via Digitalmars-d wrote:
 If you don't see value in it, you've neglected to learn
 PostScript.
I wasn't aware that postscript was a programming language. All I know about it is that it's what printers talk (sometimes), and I assumed that it was a protocol. - Jonathan M Davis
May 24 2016
parent Observer <here nowhere.net> writes:
On Tuesday, 24 May 2016 at 08:56:31 UTC, Jonathan M Davis wrote:
 On Tuesday, May 24, 2016 02:40:24 Observer via Digitalmars-d 
 wrote:
 If you don't see value in it, you've neglected to learn 
 PostScript.
I wasn't aware that postscript was a programming language. All I know about it is that it's what printers talk (sometimes), and I assumed that it was a protocol.
It is a full-fledged programming language, and quite nice for manipulating graphic output to raster devices. There was even a Display PostScript version that targeted output to screens, though Adobe eventually dropped support for it. The PLRM book (PostScript Language Reference Manual) I mentioned earlier is the definitive description of the language. There is also a separate book, "Mathematical Illustrations: A Manual of Geometry and PostScript", by Bill Casselman, that describes how to use it to draw 3D models. Anyway, with respect to the current discussion, PostScript has a rich and elegant set of operators, to handle stack operations, math operations, array operations, dictionary (hash) operations, string operations, control operations, file operations, graphics operations (of course), and more. It's definitely worth a look for inspiration both when designing language features, and for the clarity of its documentation (the PLRM).
May 24 2016
prev sibling parent Adrian Matoga <dlang.spam matoga.info> writes:
On Tuesday, 24 May 2016 at 02:40:24 UTC, Observer wrote:
 As for utility, if you're a PostScript programmer, where keeping
 track of data is done via a stack-oriented model, this 
 capability
 gets used all the time, to bring relevant arguments to the top
 of the stack to be operated upon, or to shove arguments deeper
 into the stack for later use.
Forth also has "swap" and "rot". The former moves 2nd value to the top of the stack (i.e. a, b becomes b, a). The latter moves 3rd value to the top (i.e. a, b, c becomes b, c, a).
May 24 2016
prev sibling next sibling parent reply =?UTF-8?Q?Ali_=c3=87ehreli?= <acehreli yahoo.com> writes:
On 05/23/2016 01:27 PM, Steven Schveighoffer wrote:
 On 5/23/16 4:01 PM, Andrei Alexandrescu wrote:
 So swap(a, b) swaps the contents of a and b. This could be easily
 generalized to multiple arguments such that swap(a1, a2, ..., an)
 arranges things such that a1 gets an, a2 gets a1, a3 gets a2, etc. I do
 know applications for three arguments. Thoughts? -- Andrei
One thing that screams out to me: this should be called rotate, not swap. -Steve
Yes, rotate(), but then I would never remember what direction it rotates. Ali
May 23 2016
next sibling parent reply Steven Schveighoffer <schveiguy yahoo.com> writes:
On 5/23/16 5:47 PM, Ali Çehreli wrote:
 On 05/23/2016 01:27 PM, Steven Schveighoffer wrote:
 On 5/23/16 4:01 PM, Andrei Alexandrescu wrote:
 So swap(a, b) swaps the contents of a and b. This could be easily
 generalized to multiple arguments such that swap(a1, a2, ..., an)
 arranges things such that a1 gets an, a2 gets a1, a3 gets a2, etc. I do
 know applications for three arguments. Thoughts? -- Andrei
One thing that screams out to me: this should be called rotate, not swap.
Yes, rotate(), but then I would never remember what direction it rotates.
Use the law of UFCS: x.rotate(y, z); // x-> y, y -> z, z -> x -Steve
May 23 2016
parent reply Jonathan M Davis via Digitalmars-d <digitalmars-d puremagic.com> writes:
On Monday, May 23, 2016 18:10:02 Steven Schveighoffer via Digitalmars-d wrote:
 On 5/23/16 5:47 PM, Ali ehreli wrote:
 On 05/23/2016 01:27 PM, Steven Schveighoffer wrote:
 On 5/23/16 4:01 PM, Andrei Alexandrescu wrote:
 So swap(a, b) swaps the contents of a and b. This could be easily
 generalized to multiple arguments such that swap(a1, a2, ..., an)
 arranges things such that a1 gets an, a2 gets a1, a3 gets a2, etc. I do
 know applications for three arguments. Thoughts? -- Andrei
One thing that screams out to me: this should be called rotate, not swap.
Yes, rotate(), but then I would never remember what direction it rotates.
Use the law of UFCS: x.rotate(y, z); // x-> y, y -> z, z -> x
Hmmm. And I would have assumed that it rotated in the other direction. This is really going to need a very specific name like rotateLeft or rotateRight in order for it not to be error-prone. - Jonathan M Davis
May 23 2016
parent reply ixid <adamsibson hotmail.com> writes:
On Tuesday, 24 May 2016 at 01:18:05 UTC, Jonathan M Davis wrote:
 Hmmm. And I would have assumed that it rotated in the other 
 direction. This is really going to need a very specific name 
 like rotateLeft or rotateRight in order for it not to be 
 error-prone.

 - Jonathan M Davis
Why would you assume it would rotate left? As a general rule to avoid verbosity we could have a default assumption of things moving in one direction and the inverse gets named. So we would have rotate and rotateLeft.
May 24 2016
parent reply "H. S. Teoh via Digitalmars-d" <digitalmars-d puremagic.com> writes:
On Tue, May 24, 2016 at 09:21:07AM +0000, ixid via Digitalmars-d wrote:
 On Tuesday, 24 May 2016 at 01:18:05 UTC, Jonathan M Davis wrote:
 Hmmm. And I would have assumed that it rotated in the other
 direction.  This is really going to need a very specific name like
 rotateLeft or rotateRight in order for it not to be error-prone.
 
 - Jonathan M Davis
Why would you assume it would rotate left? As a general rule to avoid verbosity we could have a default assumption of things moving in one direction and the inverse gets named. So we would have rotate and rotateLeft.
And why would you assume that it would rotate right? The default assumption, unless stated clearly and widely followed everywhere, is unclear and leads to misunderstandings. I'd rather unambiguously name them rotateRight and rotateLeft than the asymmetric rotate / rotateLeft. T -- What is Matter, what is Mind? Never Mind, it doesn't Matter.
May 24 2016
next sibling parent reply Wyatt <wyatt.epp gmail.com> writes:
On Tuesday, 24 May 2016 at 12:22:01 UTC, H. S. Teoh wrote:
 And why would you assume that it would rotate right? The 
 default assumption, unless stated clearly and widely followed 
 everywhere, is unclear and leads to misunderstandings. I'd 
 rather unambiguously name them rotateRight and rotateLeft than 
 the asymmetric rotate / rotateLeft.
In the APL family, we have dyadic ⌽ and ⊖: 3⌽⍳9 ⍝ left 4 5 6 7 8 9 1 2 3 ¯3⌽⍳9 ⍝ right 7 8 9 1 2 3 4 5 6 3 3⍴⍳9 1 2 3 4 5 6 7 8 9 1⊖3 3⍴⍳9 ⍝ up 4 5 6 7 8 9 1 2 3 ¯1⊖3 3⍴⍳9 ⍝ down 7 8 9 1 2 3 4 5 6 They rotate left and up in the positive case because that yields the natural indexing order. Right rotation gives you a reverse ordering. -Wyatt
May 24 2016
parent NynnFR <fopa1 wanadoo.fr> writes:
On Tuesday, 24 May 2016 at 14:49:20 UTC, Wyatt wrote:
 In the APL family, we have dyadic ⌽ and ⊖:
       3⌽⍳9 ⍝ left
 4 5 6 7 8 9 1 2 3
       ¯3⌽⍳9 ⍝ right
 7 8 9 1 2 3 4 5 6
[...]
 -Wyatt
Wow: I didn't see any APL code for years ! ;) That's fine but maybe not a very good example of what should be or not be in D... I agree that swap isn't a good name for a rotating operator and that rotateLeft / rotateRight are long names too. And why not swap!"1342"(a, b, c, d) giving (a, c, d, b) ?
May 24 2016
prev sibling parent Era Scarecrow <rtcvb32 yahoo.com> writes:
On Tuesday, 24 May 2016 at 12:22:01 UTC, H. S. Teoh wrote:
 And why would you assume that it would rotate right? The 
 default assumption, unless stated clearly and widely followed 
 everywhere, is unclear and leads to misunderstandings.
hmmm rotate left would be a lot easier (and cleaner) to implement than rotate right..? And could include tail optimizations? If i consider a purely functional language where you have access to the left-side of the argument list but not the right side... //Should probably heavily incorporate move as well... //best if only bitwise-copies are necessary to swap/rotate values void rotate(T...)(T[] arr) { T temp = arr[0]; void inner(T[] vars) { if (arr.length > 1) { vars[0] = vars[1]; inner(vars[1 .. $]); } else { vars[0] = temp; } } inner(arr); }
May 24 2016
prev sibling next sibling parent Era Scarecrow <rtcvb32 yahoo.com> writes:
On Monday, 23 May 2016 at 21:47:31 UTC, Ali Çehreli wrote:
 Yes, rotate(), but then I would never remember what direction 
 it rotates.
If we take a cue from assembly instructions, there's rol and ror (rotate left/right). These are other instructions are normally unreachable in languages; Although it's usefulness can be wagered from time to time. There's also it's cousins rotate with carry (rcl and rcr).
May 23 2016
prev sibling parent =?UTF-8?B?Tm9yZGzDtnc=?= <per.nordlow gmail.com> writes:
On Monday, 23 May 2016 at 21:47:31 UTC, Ali Çehreli wrote:
 Yes, rotate(), but then I would never remember what direction 
 it rotates.

 Ali
I agree. So we need rotate{Forward,Backward} or rotate{Left,Right} then. I vote for the former case.
May 25 2016
prev sibling parent reply Andrei Alexandrescu <SeeWebsiteForEmail erdani.org> writes:
On 05/23/2016 04:27 PM, Steven Schveighoffer wrote:
 On 5/23/16 4:01 PM, Andrei Alexandrescu wrote:
 So swap(a, b) swaps the contents of a and b. This could be easily
 generalized to multiple arguments such that swap(a1, a2, ..., an)
 arranges things such that a1 gets an, a2 gets a1, a3 gets a2, etc. I do
 know applications for three arguments. Thoughts? -- Andrei
One thing that screams out to me: this should be called rotate, not swap.
Problem is the usefulness peaks at 2-3 args, and for 2 and 3 arguments "rotate" is overkill. -- Andrei
May 23 2016
parent Steven Schveighoffer <schveiguy yahoo.com> writes:
On 5/23/16 6:22 PM, Andrei Alexandrescu wrote:
 On 05/23/2016 04:27 PM, Steven Schveighoffer wrote:
 On 5/23/16 4:01 PM, Andrei Alexandrescu wrote:
 So swap(a, b) swaps the contents of a and b. This could be easily
 generalized to multiple arguments such that swap(a1, a2, ..., an)
 arranges things such that a1 gets an, a2 gets a1, a3 gets a2, etc. I do
 know applications for three arguments. Thoughts? -- Andrei
One thing that screams out to me: this should be called rotate, not swap.
Problem is the usefulness peaks at 2-3 args, and for 2 and 3 arguments "rotate" is overkill. -- Andrei
OK, let me rephrase. For 3 arguments, swap is a totally unintuitive name :) I personally think rotate is fine, is describing pretty much exactly what is happening, and scales well. But I guess there is some existing meaning in Phobos for it, so that may not fly. -Steve
May 23 2016
prev sibling next sibling parent Xinok <xinok live.com> writes:
On Monday, 23 May 2016 at 20:01:08 UTC, Andrei Alexandrescu wrote:
 So swap(a, b) swaps the contents of a and b. This could be 
 easily generalized to multiple arguments such that swap(a1, a2, 
 ..., an) arranges things such that a1 gets an, a2 gets a1, a3 
 gets a2, etc. I do know applications for three arguments. 
 Thoughts? -- Andrei
It doesn't make sense for "swap" to make take than two arguments and it's unintuitive how it should rearrange the elements when you write swap(a1, a2, a3, ...). Who's to say that it should shift the elements to the left? I'm not saying this is useless but it would really need a better name. "swap" only makes intuitive sense when it takes two arguments, no more and no less. While this is technically a rotation, a "rotate" function generally takes an extra argument which is an element/index to rotate on. See: https://www.sgi.com/tech/stl/rotate.html
May 23 2016
prev sibling next sibling parent reply "H. S. Teoh via Digitalmars-d" <digitalmars-d puremagic.com> writes:
On Mon, May 23, 2016 at 04:01:08PM -0400, Andrei Alexandrescu via Digitalmars-d
wrote:
 So swap(a, b) swaps the contents of a and b. This could be easily
 generalized to multiple arguments such that swap(a1, a2, ..., an)
 arranges things such that a1 gets an, a2 gets a1, a3 gets a2, etc. I
 do know applications for three arguments. Thoughts? -- Andrei
As others have said, 'swap' is a horrible name for this. I'd go with 'rotate', but then there's the question of which direction it rotates. Conceivably, it's equally valid for an to get a1, a1 to get a2, etc.. So 'rotateRight' would be most unambiguous, though a handful to type. T -- What's an anagram of "BANACH-TARSKI"? BANACH-TARSKI BANACH-TARSKI.
May 23 2016
parent Piotr Szturmaj <bncrbme jadamspam.pl> writes:
On 2016-05-24 02:16, H. S. Teoh via Digitalmars-d wrote:
 On Mon, May 23, 2016 at 04:01:08PM -0400, Andrei Alexandrescu via
Digitalmars-d wrote:
 So swap(a, b) swaps the contents of a and b. This could be easily
 generalized to multiple arguments such that swap(a1, a2, ..., an)
 arranges things such that a1 gets an, a2 gets a1, a3 gets a2, etc. I
 do know applications for three arguments. Thoughts? -- Andrei
As others have said, 'swap' is a horrible name for this. I'd go with 'rotate', but then there's the question of which direction it rotates. Conceivably, it's equally valid for an to get a1, a1 to get a2, etc.. So 'rotateRight' would be most unambiguous, though a handful to type.
I would do it as rotate(RandomAccessRange, ptrdiff_t shift). shift >= 1 means rotate right by amount of shift shift <= -1 means rotate left shift == 0 does nothing This way it's more general, it's possible to rotate by any amount, left or right.
May 24 2016
prev sibling next sibling parent reply Xinok <xinok live.com> writes:
On Monday, 23 May 2016 at 20:01:08 UTC, Andrei Alexandrescu wrote:
 ...
I wish to make a different point which is more general regarding ideas like these. I see a lot of proposals to add this or that to the standard library and a lot of debate pursues. One point I've never seen mentioned though is that these ideas would probably have limited usage in the real world. I think a good rule of thumb to consider is that the standard library should be *general purpose* and mostly contain common functionality, with some exceptions of course. We should consider whether these things will actually see common usage or just add bloat to the standard library. Also consider that once it's incorporated into Phobos, the responsibility of maintaining that code falls on the community rather than those few individuals who actually desire that functionality. I'm sure this feature has some useful application in some specific domain but I question it's value in the community at large. I personally see no value in having a swap which can rotate three or more arguments to the left, or however we may choose to incorporate this functionality. On the other hand, I use swap() with two arguments all the time; it's very common functionality that most of us has likely used at least a few times. BTW, Phobos already has a function called bringToFront which can rotate/roll ranges but the interface is a bit different compared to other languages. https://dlang.org/phobos/std_algorithm_mutation.html#.bringToFront
May 24 2016
next sibling parent Andrei Alexandrescu <SeeWebsiteForEmail erdani.org> writes:
On 05/24/2016 02:48 PM, Xinok wrote:
 One point I've never seen mentioned though is that these ideas would
 probably have limited usage in the real world.
I agree. I'd be hard pressed to find a use for swap/rotate with more than three arguments. It's just that generalization that seems natural yet with limited applicability has worked nicely in a few instances in the past. -- Andrei
May 24 2016
prev sibling parent reply Andrei Alexandrescu <SeeWebsiteForEmail erdani.org> writes:
On 05/24/2016 02:48 PM, Xinok wrote:
 BTW, Phobos already has a function called bringToFront which can
 rotate/roll ranges but the interface is a bit different compared to
 other languages.

 https://dlang.org/phobos/std_algorithm_mutation.html#.bringToFront
This may be a misunderstanding. The original discussion was about rotating a fixed and compile-time-known number of values, not a range. -- Andrei
May 24 2016
parent Xinok <xinok live.com> writes:
On Tuesday, 24 May 2016 at 18:51:32 UTC, Andrei Alexandrescu 
wrote:
 On 05/24/2016 02:48 PM, Xinok wrote:
 BTW, Phobos already has a function called bringToFront which 
 can
 rotate/roll ranges but the interface is a bit different 
 compared to
 other languages.

 https://dlang.org/phobos/std_algorithm_mutation.html#.bringToFront
This may be a misunderstanding. The original discussion was about rotating a fixed and compile-time-known number of values, not a range. -- Andrei
No misunderstanding; I realize that what you're proposing is a variadic function which takes some arbitrary set of variables/l-values passed by reference. The message was directed at those discussing rotate/roll/etc from other languages. It seemed nobody was aware this functionality was already available in Phobos though understandable since bringToFront is an unusual name for this function.
May 24 2016
prev sibling parent reply Martin Tschierschke <mt smartdolphin.de> writes:
On Monday, 23 May 2016 at 20:01:08 UTC, Andrei Alexandrescu wrote:
 So swap(a, b) swaps the contents of a and b. This could be 
 easily generalized to multiple arguments such that swap(a1, a2, 
 ..., an) arranges things such that a1 gets an, a2 gets a1, a3 
 gets a2, etc. I do know applications for three arguments. 
 Thoughts? -- Andrei
A newbee question about language design: When I looked first time at Ruby I liked the simple a,b = b,a syntax, so swap. Would it be theoretically possible to allow this? And if not, where does it breaks the general language design? Best regards mt.
May 25 2016
next sibling parent Brian Schott <briancschott gmail.com> writes:
On Wednesday, 25 May 2016 at 17:08:02 UTC, Martin Tschierschke 
wrote:
 And if not, where does it breaks the general language design?
Here: https://en.wikipedia.org/wiki/Comma_operator
May 25 2016
prev sibling next sibling parent Andrei Alexandrescu <SeeWebsiteForEmail erdani.org> writes:
On 05/25/2016 01:08 PM, Martin Tschierschke wrote:
 On Monday, 23 May 2016 at 20:01:08 UTC, Andrei Alexandrescu wrote:
 So swap(a, b) swaps the contents of a and b. This could be easily
 generalized to multiple arguments such that swap(a1, a2, ..., an)
 arranges things such that a1 gets an, a2 gets a1, a3 gets a2, etc. I
 do know applications for three arguments. Thoughts? -- Andrei
A newbee question about language design: When I looked first time at Ruby I liked the simple a,b = b,a syntax, so swap. Would it be theoretically possible to allow this? And if not, where does it breaks the general language design? Best regards mt.
No fundamental breakage except probably for DRY violation (consider a and b may be arbitrarily complicated expressions yielding lvalues). Also, if expressions are involved everything must be carefully defined so e.g. (a[f()], b[i++]) = (b[i++], a[f()]) defines what operations are executed and in what order. The swap assignment is cute and I used to like it a lot more until I figured adds more problems than it solves. Andrei
May 25 2016
prev sibling parent reply Observer <here nowhere.com> writes:
On Wednesday, 25 May 2016 at 17:08:02 UTC, Martin Tschierschke 
wrote:
 A newbee question about language design:
 When I looked first time at Ruby I liked the simple a,b = b,a 
 syntax,
 so swap. Would it be theoretically possible to allow this?

 And if not, where does it breaks the general language design?
There's something about this notation that immediately makes me think more generally. swap is just the degenerate form of a more-general circular-shift operation in two different dimensions. This form assumes that the shifting stops after only a single shift position (or more generally, that the number of shift positions is odd); and having just two operands makes it unnecessary to specify whether the shifting is to the left or to the right. But even a circular-shift operation is itself just a degenerate form of a more-general arbitrary-permutation operation. Other permutations have common applicability in computer science, such as the bit-reversed addressing used on DSP chips to support butterfly operations in FFT (actually, DFT) algorithms. All of which makes me wonder: if we want to generalize swap, should we go farther than just one algorithmic stage? How about a very general routine that accepts a permutation mapping and a set of arguments, and scrambles the arguments according to the mapping?
May 25 2016
parent Seb <seb wilzba.ch> writes:
On Thursday, 26 May 2016 at 02:17:20 UTC, Observer wrote:
 On Wednesday, 25 May 2016 at 17:08:02 UTC, Martin Tschierschke 
 wrote:
 A newbee question about language design:
 When I looked first time at Ruby I liked the simple a,b = b,a 
 syntax,
 so swap. Would it be theoretically possible to allow this?

 And if not, where does it breaks the general language design?
There's something about this notation that immediately makes me think more generally. swap is just the degenerate form of a more-general circular-shift operation in two different dimensions. This form assumes that the shifting stops after only a single shift position (or more generally, that the number of shift positions is odd); and having just two operands makes it unnecessary to specify whether the shifting is to the left or to the right. But even a circular-shift operation is itself just a degenerate form of a more-general arbitrary-permutation operation. Other permutations have common applicability in computer science, such as the bit-reversed addressing used on DSP chips to support butterfly operations in FFT (actually, DFT) algorithms. All of which makes me wonder: if we want to generalize swap, should we go farther than just one algorithmic stage? How about a very general routine that accepts a permutation mapping and a set of arguments, and scrambles the arguments according to the mapping?
There's indexed, but it doesn't swap - it only provides access based on your permutation and only works if all data has a CommonType. http://dlang.org/phobos/std_range.html#.indexed For what it's worth, it's pretty cool to build rangified swaps of ranges - e.g. in combinatorics: http://docs.mir.dlang.io/latest/mir_combinatorics.html
May 26 2016