Also I think JS still has some redundant C-syntax garbage. For
example, that "break" keyword each time in "case" of a "switch" -- for
what it is there? For what to write several times "case-case-case" if
it's possible to write it once and separate testing operands with a
colon? Moreover, this "switch" construct is non-logical in control
flow if to place "default" not in the end or to forget this "break"
garbage. Why on earth if I have x = 5 and "case 5:" should I catch
also "case 6:" if I forgot that useless "break" garbage there? So I
like better Ruby's or Coffee's way, e.g.
jashkenas.github.com/coffee-script/#switch Btw, there're many
good syntax sugars which Harmony can borrow (I know some of them are
already planned and it's very good, but maybe others too).
...
Dmitry.
Since you pointed out the redundant switch style, that too has been
bothering me. Personally I have one issue with ruby's case/with, you can
easily write out multiple with statements in case style with no warning
thinking they work case style... I was bitten by that once, didn't
realize for a while that portions of my code weren't being executed.
Personally, my ideal switch would be something like:
blockname:
switch(variable) {
case "a", "A", "Aa": { // instead of break; we use a block
print("- Alpha");
}
case "b", "B", "Beta": print("- B"); // Like if and other things lack of {} only applies to a single expression and breaks out.
case "g", "G": {
print("- Gamma");
break; // leaves the switch
}
case "o", "O": {
print("- Omega");
continue "a"; // instead of ugly fallthrough case logic continue could be used to jump to the other block
// Though, considering continue foo; ambiguity I'd expect this would probably require a slightly different syntax continue blockname, "a"; or something.
}
}
The idea came to me after a small misunderstanding about Java's
switch/case... I was looking at Rhino's source code and it had code
style with switch/case which may have lacked break only due to the use
of return, but it did give me ideas, and there have been various times
while practically coding switch statements where I really wished instead
of using ugly break-less case logic I could use continue, so those
together lead to this syntax idea.
Of course given backwards compatibility (in terms of not suddenly making
existing switch/case code break), and implementation burdens, and taking
a bit of inspiration from Ruby I think this format would be a good
revised version of that with a bit of even better shortening.
blockname:
case(variable) {
"a", "A", "Aa": {
print("- Alpha");
}
"b", "B", "Beta": print("- B"); // Like if and other things lack of {} only applies to a single expression and breaks out.
"g", "G": {
print("- Gamma");
break; // leaves the switch
}
"o", "O": {
print("- Omega");
continue blockname, "a";
}
}
case isn't valid outside of switch, so all you'd have to do is check if
it is directly followed by ( and if so switch to the new syntax. You get
an extra advantage of eliminating unnecessary case keywords, and also
end up with a syntax mildly resembling that of a object literal that
aligns nicely with case.
continue is key though, adding it preserves abilities lost by the
conversion from swtich/case and also improves what you can do with the
statement logic.
Dmitry A. Soshnikov wrote:
> ...
>
> Also I think JS still has some redundant C-syntax garbage. For
> example, that "break" keyword each time in "case" of a "switch" -- for
> what it is there? For what to write several times "case-case-case" if
> it's possible to write it once and separate testing operands with a
> colon? Moreover, this "switch" construct is non-logical in control
> flow if to place "default" not in the end or to forget this "break"
> garbage. Why on earth if I have x = 5 and "case 5:" should I catch
> also "case 6:" if I forgot that useless "break" garbage there? So I
> like better Ruby's or Coffee's way, e.g.
> http://jashkenas.github.com/coffee-script/#switch Btw, there're many
> good syntax sugars which Harmony can borrow (I know some of them are
> already planned and it's very good, but maybe others too).
>
> ...
> Dmitry.
Since you pointed out the redundant switch style, that too has been
bothering me. Personally I have one issue with ruby's case/with, you can
easily write out multiple with statements in case style with no warning
thinking they work case style... I was bitten by that once, didn't
realize for a while that portions of my code weren't being executed.
Personally, my ideal switch would be something like:
blockname:
switch(variable) {
case "a", "A", "Aa": { // instead of break; we use a block
print("- Alpha");
}
case "b", "B", "Beta": print("- B"); // Like if and other things lack of {} only applies to a single expression and breaks out.
case "g", "G": {
print("- Gamma");
break; // leaves the switch
}
case "o", "O": {
print("- Omega");
continue "a"; // instead of ugly fallthrough case logic continue could be used to jump to the other block
// Though, considering `continue foo;` ambiguity I'd expect this would probably require a slightly different syntax `continue blockname, "a";` or something.
}
}
The idea came to me after a small misunderstanding about Java's
switch/case... I was looking at Rhino's source code and it had code
style with switch/case which may have lacked break only due to the use
of return, but it did give me ideas, and there have been various times
while practically coding switch statements where I really wished instead
of using ugly break-less case logic I could use continue, so those
together lead to this syntax idea.
Of course given backwards compatibility (in terms of not suddenly making
existing switch/case code break), and implementation burdens, and taking
a bit of inspiration from Ruby I think this format would be a good
revised version of that with a bit of even better shortening.
blockname:
case(variable) {
"a", "A", "Aa": {
print("- Alpha");
}
"b", "B", "Beta": print("- B"); // Like if and other things lack of {} only applies to a single expression and breaks out.
"g", "G": {
print("- Gamma");
break; // leaves the switch
}
"o", "O": {
print("- Omega");
continue blockname, "a";
}
}
case isn't valid outside of switch, so all you'd have to do is check if
it is directly followed by ( and if so switch to the new syntax. You get
an extra advantage of eliminating unnecessary case keywords, and also
end up with a syntax mildly resembling that of a object literal that
aligns nicely with case.
continue is key though, adding it preserves abilities lost by the
conversion from swtich/case and also improves what you can do with the
statement logic.
--
~Daniel Friesen (Dantman, Nadir-Seen-Fire) [http://daniel.friesen.name]
Dmitry A. Soshnikov wrote:
Since you pointed out the redundant switch style, that too has been bothering me. Personally I have one issue with ruby's case/with, you can easily write out multiple with statements in case style with no warning thinking they work case style... I was bitten by that once, didn't realize for a while that portions of my code weren't being executed.
Personally, my ideal switch would be something like:
blockname: switch(variable) { case "a", "A", "Aa": { // instead of break; we use a block print("- Alpha"); } case "b", "B", "Beta": print("- B"); // Like if and other things lack of {} only applies to a single expression and breaks out. case "g", "G": { print("- Gamma"); break; // leaves the switch } case "o", "O": { print("- Omega"); continue "a"; // instead of ugly fallthrough case logic continue could be used to jump to the other block // Though, considering
continue foo;ambiguity I'd expect this would probably require a slightly different syntaxcontinue blockname, "a";or something. } }The idea came to me after a small misunderstanding about Java's switch/case... I was looking at Rhino's source code and it had code style with switch/case which may have lacked break only due to the use of return, but it did give me ideas, and there have been various times while practically coding switch statements where I really wished instead of using ugly break-less case logic I could use continue, so those together lead to this syntax idea.
Of course given backwards compatibility (in terms of not suddenly making existing switch/case code break), and implementation burdens, and taking a bit of inspiration from Ruby I think this format would be a good revised version of that with a bit of even better shortening.
blockname: case(variable) { "a", "A", "Aa": { print("- Alpha"); } "b", "B", "Beta": print("- B"); // Like if and other things lack of {} only applies to a single expression and breaks out. "g", "G": { print("- Gamma"); break; // leaves the switch } "o", "O": { print("- Omega"); continue blockname, "a"; } }
case isn't valid outside of switch, so all you'd have to do is check if it is directly followed by ( and if so switch to the new syntax. You get an extra advantage of eliminating unnecessary case keywords, and also end up with a syntax mildly resembling that of a object literal that aligns nicely with case.
continue is key though, adding it preserves abilities lost by the conversion from swtich/case and also improves what you can do with the statement logic.
Dmitry A. Soshnikov wrote: > ... > > Also I think JS still has some redundant C-syntax garbage. For > example, that "break" keyword each time in "case" of a "switch" -- for > what it is there? For what to write several times "case-case-case" if > it's possible to write it once and separate testing operands with a > colon? Moreover, this "switch" construct is non-logical in control > flow if to place "default" not in the end or to forget this "break" > garbage. Why on earth if I have x = 5 and "case 5:" should I catch > also "case 6:" if I forgot that useless "break" garbage there? So I > like better Ruby's or Coffee's way, e.g. > http://jashkenas.github.com/coffee-script/#switch Btw, there're many > good syntax sugars which Harmony can borrow (I know some of them are > already planned and it's very good, but maybe others too). > > ... > Dmitry. Since you pointed out the redundant switch style, that too has been bothering me. Personally I have one issue with ruby's case/with, you can easily write out multiple with statements in case style with no warning thinking they work case style... I was bitten by that once, didn't realize for a while that portions of my code weren't being executed. Personally, my ideal switch would be something like: blockname: switch(variable) { case "a", "A", "Aa": { // instead of break; we use a block print("- Alpha"); } case "b", "B", "Beta": print("- B"); // Like if and other things lack of {} only applies to a single expression and breaks out. case "g", "G": { print("- Gamma"); break; // leaves the switch } case "o", "O": { print("- Omega"); continue "a"; // instead of ugly fallthrough case logic continue could be used to jump to the other block // Though, considering `continue foo;` ambiguity I'd expect this would probably require a slightly different syntax `continue blockname, "a";` or something. } } The idea came to me after a small misunderstanding about Java's switch/case... I was looking at Rhino's source code and it had code style with switch/case which may have lacked break only due to the use of return, but it did give me ideas, and there have been various times while practically coding switch statements where I really wished instead of using ugly break-less case logic I could use continue, so those together lead to this syntax idea. Of course given backwards compatibility (in terms of not suddenly making existing switch/case code break), and implementation burdens, and taking a bit of inspiration from Ruby I think this format would be a good revised version of that with a bit of even better shortening. blockname: case(variable) { "a", "A", "Aa": { print("- Alpha"); } "b", "B", "Beta": print("- B"); // Like if and other things lack of {} only applies to a single expression and breaks out. "g", "G": { print("- Gamma"); break; // leaves the switch } "o", "O": { print("- Omega"); continue blockname, "a"; } } case isn't valid outside of switch, so all you'd have to do is check if it is directly followed by ( and if so switch to the new syntax. You get an extra advantage of eliminating unnecessary case keywords, and also end up with a syntax mildly resembling that of a object literal that aligns nicely with case. continue is key though, adding it preserves abilities lost by the conversion from swtich/case and also improves what you can do with the statement logic. -- ~Daniel Friesen (Dantman, Nadir-Seen-Fire) [http://daniel.friesen.name]