digitalmars.dip.ideas - Improvements to switch

ryuukk_ (23/23) Apr 16 It is time to make them nice to use

Basile B. (13/20) Apr 16 About this, the main point is rather

IchorDev (10/18) Apr 27 You can already do that.

Basile B. (8/28) Apr 27 Sure but the matching AST is unnecessarily complex. A function

=?UTF-8?B?Q2hsb8Op?= (31/61) Apr 28 Specifically promoting switch to an expression would be a wasted

Basile B. (28/48) Apr 30 Besides the problems exposed in the first answer (essentially:

Nick Treleaven (4/7) May 01 That's why the syntax should be designed to be easily

Meta (44/67) Apr 16 A couple more things:

Nick Treleaven (30/40) Apr 17 Presumably we could leave off the type:
Nick Treleaven (23/25) Apr 17 Some other things, based on section 3.3 of this C++ proposal:

Meta (27/52) Apr 18 This is already covered by regular switch statements. You can

Nick Treleaven (19/77) Apr 19 It would be ambiguous to write e.g. `case name if (cond) ->` - is

Meta (25/86) Apr 19 I'm not quite sure what you mean - can you illustrate in more

Nick Treleaven (25/113) Apr 23 Where you had:

ShowMeTheWay (14/23) Apr 24 the 'switch' keyword implies old-school.. D needs a new term.

Walter Bright (7/7) Apr 22 I've thought about it for a while now. Improving switch has a lot of iss...

Richard (Rikki) Andrew Cattermole (8/20) Apr 22 I was really looking forward to your recent DConf Online talk about

Walter Bright (3/12) Apr 22 Sumtypes must come before pattern matching. I had a proposal for it:

ShowMeTheWay (10/20) Apr 23 int x = 1;

ShowMeTheWay (3/26) Apr 23 aka ..a new language construct (i.e. an improvement over a switch

Quirin Schroll (3/13) Apr 25 Why not do it as C# does and put `switch` after the expression?

Dukc (18/22) Apr 24 I'm certainly open to exploring the general notion. I think

ryuukk_ <ryuukk.dev gmail.com> writes:

It is time to make them nice to use


- allow them as expression

```D
int myvalue = switch(code) {
     // ...
};

```

- more concise

```D
switch(code) {
     case 1 -> "what";
     case 2, 3 -> "ok";
     else -> "no";
}
```

- pattern match

```D
switch(tagged) {
     case A, B -> do_that();
     case C myc -> do_this(myc);
     else -> nothing();
}
```

Apr 16

Basile B. <b2.temp gmx.com> writes:

On Tuesday, 16 April 2024 at 10:34:21 UTC, ryuukk_ wrote:
 It is time to make them nice to use


 - allow them as expression

 ```D
 int myvalue = switch(code) {
     // ...
 };

 ```

About this, the main point is rather

```d
/*-->*/ const /*<--*/ int myvalue = switch(code) {
     // ...
};
```

"ah finally you can define a const var decl that relies on 
branching" (without using the conditional expression...)

Then there's something you must think about, that's the fallback, 
i.e the default
clause. If you use the default clause to error you're lucky 
because D has noreturn now.

Apr 16

IchorDev <zxinsworld gmail.com> writes:

On Tuesday, 16 April 2024 at 16:00:48 UTC, Basile B. wrote:
 About this, the main point is rather

 ```d
 /*-->*/ const /*<--*/ int myvalue = switch(code) {
     // ...
 };
 ```

 "ah finally you can define a const var decl that relies on 
 branching" (without using the conditional expression...)

You can already do that.
```d
const string myValue = (){
	switch(code){
		case 1:    return "what";
		case 2, 3: return "ok";
		default:   return "no";
	}
}();

Apr 27

Basile B. <b2.temp gmx.com> writes:

On Saturday, 27 April 2024 at 14:58:19 UTC, IchorDev wrote:
 On Tuesday, 16 April 2024 at 16:00:48 UTC, Basile B. wrote:
 About this, the main point is rather

 ```d
 /*-->*/ const /*<--*/ int myvalue = switch(code) {
     // ...
 };
 ```

 "ah finally you can define a const var decl that relies on 
 branching" (without using the conditional expression...)

 You can already do that.
 ```d
 const string myValue = (){
 	switch(code){
 		case 1:    return "what";
 		case 2, 3: return "ok";
 		default:   return "no";
 	}
 }();

Sure but the matching AST is unnecessarily complex. A function 
literal, plenty of return statements, at least 1 capture. 
Consequently the path borrowed by the compiler is much more 
complex, it has to do things that would not be done with the 
expression: return type inference, block exits, etc. Then without 
optimizations enabled that does not have the equivalent runtime 
performances.

Apr 27

=?UTF-8?B?Q2hsb8Op?= <chloekek use.startmail.com> writes:

On 4/28/24 01:58, Basile B. wrote:
 On Saturday, 27 April 2024 at 14:58:19 UTC, IchorDev wrote:
 On Tuesday, 16 April 2024 at 16:00:48 UTC, Basile B. wrote:
 About this, the main point is rather

 ```d
 /*-->*/ const /*<--*/ int myvalue = switch(code) {
     // ...
 };
 ```

 "ah finally you can define a const var decl that relies on branching" 
 (without using the conditional expression...)

 You can already do that.
 ```d
 const string myValue = (){
     switch(code){
         case 1:    return "what";
         case 2, 3: return "ok";
         default:   return "no";
     }
 }();

 
 Sure but the matching AST is unnecessarily complex. A function literal, 
 plenty of return statements, at least 1 capture. Consequently the path 
 borrowed by the compiler is much more complex, it has to do things that 
 would not be done with the expression: return type inference, block 
 exits, etc. Then without optimizations enabled that does not have the 
 equivalent runtime performances.
 

Specifically promoting switch to an expression would be a wasted 
opportunity to generalize this to other types of statements, such as try 
statements.

Here are some examples in pseudo-D of how that could be useful. In these 
examples, a hypothetical do keyword could prefix any statement and turn 
it into an expression, and a yield statement would provide the result of 
evaluating that expression:

     // no need to (default-)initialize file first
     auto file = do try {
         yield open(path);
     } catch (ErrnoException ex) {
         if (ex.errno == ENOENT)
             return;  // return from caller
         throw ex;
     };
     // use file without catching ErrnoException
     file.write("hello");

Or foreach statements:

     const value = do {
         foreach (item; someOpApplyStruct)
             if (f(item))
                 yield item;
         throw new NotFoundError;
     };

If the do-ed statement would run off the end (as with a non-void 
function lacking a return statement) that would be an error.

Besides initializing variables, another advantage of promoting 
statements to expressions directly instead of through a called lambda is 
that you can have control flow out of the expression into another 
statement, such as by break, continue, or return statements.

Apr 28