• Francesco Mecca (20/20) Mar 24 2019 https://run.dlang.io/is/zRcj59
• ag0aep6g (4/30) Mar 24 2019 Yes.
• Benjamin Schaaf (4/24) Mar 25 2019 You can achieve the same thing by just constructing your
• Michelle Long (11/31) Mar 25 2019 You could make a Choose function:

Francesco Mecca <me francescomecca.eu> writes:

https://run.dlang.io/is/zRcj59

```
alias Alg = Algebraic!(int, string);

void main()
{
	int n = 2;
     Alg value;

     value = n == 2 ? 2 : "string";
}
```

The original code used SumType but the effect is the same.

I suppose that I could write the following:

```
     if(n == 2) value = 2;
     else value = "string";
```

Is there a workaround for this that maintains a similar syntactic 
structure?
is this behaviour accepted or should the compiler translate the 
first case in the second?

ag0aep6g <anonymous example.com> writes:

On 24.03.19 13:45, Francesco Mecca wrote:
 ```
 alias Alg = Algebraic!(int, string);
 
 void main()
 {
      int n = 2;
      Alg value;
 
      value = n == 2 ? 2 : "string";
 }
 ```
 
 The original code used SumType but the effect is the same.
 
 I suppose that I could write the following:
 
 ```
      if(n == 2) value = 2;
      else value = "string";
 ```
 
 Is there a workaround for this that maintains a similar syntactic 
 structure?

value = n == 2 ? Alg(2) : Alg("string");

 is this behaviour accepted

Yes.

 or should the compiler translate the first 
 case in the second?

No.

Benjamin Schaaf <ben.schaaf gmail.com> writes:

On Sunday, 24 March 2019 at 12:45:13 UTC, Francesco Mecca wrote:
 https://run.dlang.io/is/zRcj59

 ```
 alias Alg = Algebraic!(int, string);

 void main()
 {
 	int n = 2;
     Alg value;

     value = n == 2 ? 2 : "string";
 }
 ```

 The original code used SumType but the effect is the same.

 I suppose that I could write the following:

 ```
     if(n == 2) value = 2;
     else value = "string";
 ```

 Is there a workaround for this that maintains a similar 
 syntactic structure?
 is this behaviour accepted or should the compiler translate the 
 first case in the second?

You can achieve the same thing by just constructing your 
algebraic type earlier:

   value = n == 2 ? Alg(2) : Alg("string");

Michelle Long <HappyDance321 gmail.com> writes:

On Sunday, 24 March 2019 at 12:45:13 UTC, Francesco Mecca wrote:
 https://run.dlang.io/is/zRcj59

 ```
 alias Alg = Algebraic!(int, string);

 void main()
 {
 	int n = 2;
     Alg value;

     value = n == 2 ? 2 : "string";
 }
 ```

 The original code used SumType but the effect is the same.

 I suppose that I could write the following:

 ```
     if(n == 2) value = 2;
     else value = "string";
 ```

 Is there a workaround for this that maintains a similar 
 syntactic structure?
 is this behaviour accepted or should the compiler translate the 
 first case in the second?

You could make a Choose function:

auto Ch(A,B)(bool c, A a, B b);

Then

value = Ch(n == 2, n, "string");

Not much different than

value = (n == 2) ? Alg(2) : Alg("string");

except you don't have to write Alg all the time.

The compiler should translate the first but that requires 
implicit conversion of any of the types T... to Algebraic!T... . 
Of course, that should be possible but is it?