typeof(func!0) != typeof(func!0())

[Paul Backus]

On Monday, 22 August 2022 at 16:19:06 UTC, Andrey Zherikov wrote:
> I have an impression that template function can be called 
> without parenthesis if it doesn't have run-time parameters so 
> `func!0` is the same as `func!0()`. Am I wrong?

You're not wrong. This behavior is a special case in `typeof`. I 
was merely attempting to explain why such a special case might 
have been introduced.

> If we consider free function vs. member function, why is 
> `typeof(u.func!0)` not the same as `typeof(u.func2!0)` here?

My guess is that `u.func2!0` is rewritten to `func2!0(u)` during 
semantic analysis, so it does not trigger the special-case 
behavior.

> Is `typeof(u.func2!0)` correct in this case? If so then I'll 
> just convert my API to free-standing functions and everything 
> will work as a magic (without my own implementation of 
> `getUDA`).

It's probably not worth completely changing your API design just 
to work around this issue. Also, even if you do this, it is still 
possible for a user to run into a same problem with a member 
function of one of their own types; for example:

```d
import your.library;

struct MyStruct {
     U myFunc() { /* ... */ }
}

@(MyStruct.myFunc) whatever;
```