www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - Syntax ideas for `ref` returning delegate and FP parameters

reply Q. Schroll <qs.il.paperinik gmail.com> writes:
Currently in D, one cannot directly express that a function 
parameter's type is a delegate or function pointer that returns 
by `ref`. If you write
```D
void f(ref int delegate() dg) { .. }
```
then `dg` will be bound by reference which is probably not what 
the user likely intended. It is equivalent to:
```D
alias DG = int delegate();
void f(ref DG dg) { .. }
```
I guess it should be possible to express
```D
alias refDG = ref int delegate();
void f(refDG dg) { .. }
```
without an alias. The obvious idea is allowing
```D
void f(int delegate() ref dg)
```
but I really dislike not having `ref` next to the return type. I 
guess most users read `ref int` as a pseudo type, so having them 
separated is misleading.

Another was a breaking change making `ref` part of the delegate 
type when spelled out:
```D
void f(ref int delegate() dg) { .. }
```
would take `dg` by copy and `typeof(dg)` would be `ref int 
delegate()`. If you want to take the delegate by reference, use 
an alias.

A third one that is a little obscure is allowing `ref(int)` as a 
syntax for delegate and function pointer return types. Then it 
would be akin to `const int* method()` being different from 
`const(int*) method()`.

Do you guys have any better ideas? I don't really like mine.
Apr 10
next sibling parent reply Nick Treleaven <nick geany.org> writes:
On Saturday, 10 April 2021 at 14:27:31 UTC, Q. Schroll wrote:
 ```D
 alias refDG = ref int delegate();
 void f(refDG dg) { .. }
 ```
 without an alias. The obvious idea is allowing
 ```D
 void f(int delegate() ref dg)
 ```
 but I really dislike not having `ref` next to the return type.
I don't mind that. Also this (particularly if std.meta.Alias was in object.d) is a workaround: void f(Alias!(ref int delegate()) dg);
Apr 10
parent Nick Treleaven <nick geany.org> writes:
On Saturday, 10 April 2021 at 15:26:16 UTC, Nick Treleaven wrote:
 void f(Alias!(ref int delegate()) dg);
Actually that doesn't work :-/
Apr 10
prev sibling next sibling parent reply MoonlightSentinel <moonlightsentinel disroot.org> writes:
On Saturday, 10 April 2021 at 14:27:31 UTC, Q. Schroll wrote:
 A third one that is a little obscure is allowing `ref(int)` as 
 a syntax for delegate and function pointer return types. Then 
 it would be akin to `const int* method()` being different from 
 `const(int*) method()`.
That's the best option IMO because it adapts a well known pattern.
 Do you guys have any better ideas? I don't really like mine.
Maybe allow `ref` as a postfix? ```d void foo(int ref delegate() dg) {} ``` Allthough that looks kinda weird.
Apr 10
parent Kagamin <spam here.lot> writes:
On Saturday, 10 April 2021 at 21:25:07 UTC, MoonlightSentinel 
wrote:
 Maybe allow `ref` as a postfix?

 ```d
 void foo(int ref delegate() dg) {}
 ```

 Allthough that looks kinda weird.
An obvious solution. It's composable too: ```d void foo(int ref delegate() ref delegate() dg) {} ```
Apr 13
prev sibling next sibling parent reply user1234 <user1234 12.de> writes:
On Saturday, 10 April 2021 at 14:27:31 UTC, Q. Schroll wrote:
 Currently in D, one cannot directly express that a function 
 parameter's type is a delegate or function pointer that returns 
 by `ref`. If you write
 ```D
 void f(ref int delegate() dg) { .. }
 ```
 then `dg` will be bound by reference which is probably not what 
 the user likely intended. It is equivalent to:
 ```D
 alias DG = int delegate();
 void f(ref DG dg) { .. }
 ```
Slightly off topic but very curiously `auto ref` seems to have for effect to set the function pointer type return as `ref` rather than the parameter itself ```d void f(DG/* = int function()*/)(auto ref DG dg) { dg()++; } ref int a() { static int b; return b; } void main() { f(&a); assert(a == 1); // passes } ``` a bug certainly.
Apr 10
parent Q. Schroll <qs.il.paperinik gmail.com> writes:
On Sunday, 11 April 2021 at 05:44:58 UTC, user1234 wrote:
 On Saturday, 10 April 2021 at 14:27:31 UTC, Q. Schroll wrote:
 Currently in D, one cannot directly express that a function 
 parameter's type is a delegate or function pointer that 
 returns by `ref`. If you write
 ```D
 void f(ref int delegate() dg) { .. }
 ```
 then `dg` will be bound by reference which is probably not 
 what the user likely intended. It is equivalent to:
 ```D
 alias DG = int delegate();
 void f(ref DG dg) { .. }
 ```
Slightly off topic but very curiously `auto ref` seems to have for effect to set the function pointer type return as `ref` rather than the parameter itself ```d void f(DG/* = int function()*/)(auto ref DG dg) { dg()++; } ref int a() { static int b; return b; } void main() { f(&a); assert(a == 1); // passes } ``` a bug certainly.
No. When doing `f(&a)`, the `auto ref` boils down to by copy (i.e. no `ref`) and `DG` is inferred by IFTI to be `int function() ref` which can easily be observed using `pragma(msg, DG)` in `f`. You can remove `auto ref` no problem. If you replace the comment by `: int function()`, you get a compile error, because `ref` return and value return are incompatible.
Apr 11
prev sibling next sibling parent Boris Carvajal <boris2.9 gmail.com> writes:
On Saturday, 10 April 2021 at 14:27:31 UTC, Q. Schroll wrote:
 Do you guys have any better ideas? I don't really like mine.
https://github.com/dlang/dmd/pull/10018#issuecomment-504347888 In short, allow putting function/delegate keyword at the beginning like function literals do: ```d // declaration function int(char c) fp = function int(char c) { ... }; // also function literal syntax already accepts 'ref' returns function ref int(char c) fp = function ref int(char c) { ... }; // as parameter void fun(ref function ref int(char c) fp); ```
Apr 11
prev sibling parent Dukc <ajieskola gmail.com> writes:
On Saturday, 10 April 2021 at 14:27:31 UTC, Q. Schroll wrote:
 Currently in D, one cannot directly express that a function 
 parameter's type is a delegate or function pointer that returns 
 by `ref`. If you write
 ```D
 void f(ref int delegate() dg) { .. }
 ```
 then `dg` will be bound by reference which is probably not what 
 the user likely intended. It is equivalent to:
 ```D
 alias DG = int delegate();
 void f(ref DG dg) { .. }
 ```
Question to somebody more familiar with grammar specs: is this behaviour enforced by the spec, or is it implementation-defined behaviour?
Apr 13