digitalmars.D.learn - This code completely breaks the compiler:
- Ruby The Roobster (29/29) Aug 18 2022 This snippet compiles. Even if `dsds` and `sadsad` are defined
- Ruby The Roobster (4/11) Aug 18 2022 The only way to get the code to not compile is to actually call
- JG (14/28) Aug 18 2022 I think it might help to post the entire code you think should
- Ruby The Roobster (4/33) Aug 18 2022 So that's why it compiled. Still, I believe that stuff like this
- Mike Parker (35/39) Aug 18 2022 If the template is never instantiated, it never makes it into the
- Ruby The Roobster (5/42) Aug 19 2022 This makes sense. Still, in my code, where the function has the
This snippet compiles. Even if `dsds` and `sadsad` are defined
nowhere, this code compiles.
```d
import std.typecons : Tuple;
sadsad executeFunction(Mtypes...)(dstring func, Tuple!(Mtypes)
args)
{
static foreach(type; typel.keys)
{
mixin(typel[type] ~ " ret"d ~ type ~ ";");
}
dstring returnType = "Number"d;
Switch: final switch(returnType)
{
static foreach(type; typel.keys)
{
case type:
mixin("alias ret = ret"d ~ type ~ ";");
break Switch;
}
}
dsds ret;
return ret;
}
```
The reason why this compiles is because of the varidic template
parameter, `Mtypes`.
Either there is something I'm missing, or the compiler completely
breaks when it sees varidic template arguments.
Aug 18 2022
On Friday, 19 August 2022 at 03:10:38 UTC, Ruby The Roobster wrote:This snippet compiles. Even if `dsds` and `sadsad` are defined nowhere, this code compiles. [SNIP] The reason why this compiles is because of the varidic template parameter, `Mtypes`. Either there is something I'm missing, or the compiler completely breaks when it sees varidic template arguments.The only way to get the code to not compile is to actually call the function.
Aug 18 2022
On Friday, 19 August 2022 at 03:13:03 UTC, Ruby The Roobster wrote:On Friday, 19 August 2022 at 03:10:38 UTC, Ruby The Roobster wrote:I think it might help to post the entire code you think should not compile (which does). I guess you are aware that templated code is only "fully checked" when it is instantiated. E.g. this will compile. ```d import std; auto nonsense(T)(T t) { return 5+"six"; } void main() { } ```This snippet compiles. Even if `dsds` and `sadsad` are defined nowhere, this code compiles. [SNIP] The reason why this compiles is because of the varidic template parameter, `Mtypes`. Either there is something I'm missing, or the compiler completely breaks when it sees varidic template arguments.The only way to get the code to not compile is to actually call the function.
Aug 18 2022
On Friday, 19 August 2022 at 04:16:28 UTC, JG wrote:On Friday, 19 August 2022 at 03:13:03 UTC, Ruby The Roobster wrote:So that's why it compiled. Still, I believe that stuff like this ought to be detected at compile time, as supposed to in a unittest or, if someone forgot to write the tests, in production.On Friday, 19 August 2022 at 03:10:38 UTC, Ruby The Roobster wrote:I think it might help to post the entire code you think should not compile (which does). I guess you are aware that templated code is only "fully checked" when it is instantiated. E.g. this will compile. ```d import std; auto nonsense(T)(T t) { return 5+"six"; } void main() { } ```This snippet compiles. Even if `dsds` and `sadsad` are defined nowhere, this code compiles. [SNIP] The reason why this compiles is because of the varidic template parameter, `Mtypes`. Either there is something I'm missing, or the compiler completely breaks when it sees varidic template arguments.The only way to get the code to not compile is to actually call the function.
Aug 18 2022
On Friday, 19 August 2022 at 04:25:25 UTC, Ruby The Roobster wrote:So that's why it compiled. Still, I believe that stuff like this ought to be detected at compile time, as supposed to in a unittest or, if someone forgot to write the tests, in production.If the template is never instantiated, it never makes it into the executable. It doesn't matter if it's in production or not, and has nothing to do with tests. It doesn't exist. How could the compiler catch any problems if it has no idea what `Mtypes` is? This is true for any template parameter. Consider this: ```d import std.stdio; T derp(T)(T val) { val += 10; return val; } void main() { writeln("Hello D"); } ``` `derp` obviously isn't going to work with every type. But this code compiles because `derp` is never instantiated. The compiler can't check if the code in `derp` is valid because it has no idea what `T` might be. If it's `int`, then no problem. If it's `string` then no way: ```d void main() { writeln(derp!string("No way")); } ``` Now you'll get this: ``` onlineapp.d(4): Error: slice `val` is not mutable onlineapp.d(10): Error: template instance `onlineapp.derp!string` error instantiating ```
Aug 18 2022
Ruby The Roobster <rubytheroobster yandex.com> On Friday, 19 August 2022 at 05:50:17 UTC, Mike Parker wrote:On Friday, 19 August 2022 at 04:25:25 UTC, Ruby The Roobster wrote:This makes sense. Still, in my code, where the function has the same return type regardless of instantiation, the compiler should at least check that expressions independent of the template parameter are valid.[...]If the template is never instantiated, it never makes it into the executable. It doesn't matter if it's in production or not, and has nothing to do with tests. It doesn't exist. How could the compiler catch any problems if it has no idea what `Mtypes` is? This is true for any template parameter. Consider this: ```d import std.stdio; T derp(T)(T val) { val += 10; return val; } void main() { writeln("Hello D"); } ``` `derp` obviously isn't going to work with every type. But this code compiles because `derp` is never instantiated. The compiler can't check if the code in `derp` is valid because it has no idea what `T` might be. If it's `int`, then no problem. If it's `string` then no way: ```d void main() { writeln(derp!string("No way")); } ``` Now you'll get this: ``` onlineapp.d(4): Error: slice `val` is not mutable onlineapp.d(10): Error: template instance `onlineapp.derp!string` error instantiating ```
Aug 19 2022