On Friday, 31 December 2021 at 00:57:26 UTC, kdevel wrote:
```dptr.d
class R {
}
void foo (R r)
{
}
alias fn = void function (R);
void lyr (fn F) (R r)
{
}
immutable fn foo_ptr = &foo; // line 14
pragma (msg, typeof (foo_ptr));
auto ptr = lyr!(foo_ptr); // line 17
```
dmd reports:
```
immutable(void function(R))
dptr.d(14): Error: expression `& foo` is not a valid template
value argument
```
If I comment out line 17 the code compiles. I want to put the
explicitly instantiated function template into an immutable AA.
How can that be phrased such that dmd compiles it?
Pointers are runtime entities and are not suitable template
parameters (compile time).
So assuming that you are trying to either pass a function
constant of a specific type signature as a template argument, or
a function pointer as an argument with either a template
specialisation or constraint:
```
class R {}
void foo(R r){}
alias fn = void function(R);
//function compile time constant
void lyr(fn fp_type)(R r){}
//As template constraint
void con(T)(T fun, R r)
if(is(T == fn))
{
fun(r);
}
/*
//As template specialisation
void con(T: fn)(T fun, R r)
{
fun(r);
}
*/
//Function constant
enum fn foo_ptr = (R r){};
pragma(msg, typeof(foo_ptr));
//Declared at compile time but only executable at runtime
auto ptr = &lyr!(foo_ptr);
void main()
{
//auto ptr = &lyr!(foo_ptr);//could declare this here
ptr(new R());
fn new_ptr = &foo;
con(new_ptr, new R());
}
```
