Understanding alias template parameters

[Paul Backus]

On Thursday, 21 April 2022 at 21:02:47 UTC, JG wrote:
> Hi,
>
> Could someone possibly help me to understand why the commented 
> line doesn't compile?
>
>
> ```d
> import std;
>
> struct MapResult(R,F)
> {
>     R r;
>     const F f;
>     auto empty() { return r.empty; }
>     auto front() { return f(r.front); }
>     void popFront() { r.popFront; }
>     auto save() { return typeof(this)(r.save,f); }
> }
>
> auto myMap(alias f, R)(R r) {
>     return MapResult!(R,typeof(f))(r,f);
> }
>
>
> void main()
> {
>    int function(int) f = x=>2*x;
>    iota(10).myMap!f.writeln;
>    //iota(10).myMap!(x=>2*x).writeln; <--- Why doesn't this 
> compile?
>
> }
> ```

When you write a lambda without type annotations, like `x => 
2*x`, the compiler interprets it as a function template. So in 
this case, it's the same as if you'd written

```d
T func(T)(T x) { return 2*x; }
iota(10).myMap!func.writeln;
```

The problem is, you can't store a template in a variable:

```d
auto f = func; // doesn't work - func does not have a value
```

So, when you try to create a `MapResult` with the template `x => 
2*x` as one of its member variables, it doesn't work.

By the way, you may have noticed that the error message you got 
says something about variables of type `void` not being allowed. 
That's because of [a long-standing bug][1] that causes `typeof` 
returns `void` when applied to a template. However, that bug is 
not the cause of the error here--even if it were fixed, your code 
still would not work.

[1]: https://issues.dlang.org/show_bug.cgi?id=7947