• BoQsc (14/14) Nov 17 2023 Let's say we have a chain of functions.
• Imperatorn (4/18) Nov 18 2023 It would be easy if you have some kind of aspect oriented
• Steven Schveighoffer (4/18) Nov 18 2023 Consider adding @mustuse on the return type.
• Julian Fondren (31/34) Nov 18 2023 Serious answer: have a function handle this, instead of the

BoQsc <vaidas.boqsc gmail.com> writes:

Let's say we have a chain of functions.
```
  a().b().c();
```


I would like to have a behaviour in `a()` that would check if 
there is `b()` or `c()` chained to it.

If `a();`is not chained: do a `writeln("You forgot to chain this 
function!");`



For me syntactically it is important. One real world application 
would be:

`program("someProgramName").pipe("someOtherProgramName");`
Executes and pipes output to another program.

`program();` - Only executes the program.

Imperatorn <johan_forsberg_86 hotmail.com> writes:

On Saturday, 18 November 2023 at 07:47:19 UTC, BoQsc wrote:
 Let's say we have a chain of functions.
 ```
  a().b().c();
 ```


 I would like to have a behaviour in `a()` that would check if 
 there is `b()` or `c()` chained to it.

 If `a();`is not chained: do a `writeln("You forgot to chain 
 this function!");`



 For me syntactically it is important. One real world 
 application would be:

 `program("someProgramName").pipe("someOtherProgramName");`
 Executes and pipes output to another program.

 `program();` - Only executes the program.

It would be easy if you have some kind of aspect oriented 
framework. Other than that I guess you need to check the trace 
info (or possibly trait).

Steven Schveighoffer <schveiguy gmail.com> writes:

On Saturday, 18 November 2023 at 07:47:19 UTC, BoQsc wrote:
 Let's say we have a chain of functions.
 ```
  a().b().c();
 ```


 I would like to have a behaviour in `a()` that would check if 
 there is `b()` or `c()` chained to it.

 If `a();`is not chained: do a `writeln("You forgot to chain 
 this function!");`



 For me syntactically it is important. One real world 
 application would be:

 `program("someProgramName").pipe("someOtherProgramName");`
 Executes and pipes output to another program.

 `program();` - Only executes the program.

Consider adding  mustuse on the return type.

https://dlang.org/spec/attribute.html#mustuse-attribute

-Steve

Julian Fondren <julian.fondren gmail.com> writes:

On Saturday, 18 November 2023 at 07:47:19 UTC, BoQsc wrote:
 `program("someProgramName").pipe("someOtherProgramName");`
 Executes and pipes output to another program.

 `program();` - Only executes the program.

Serious answer: have a function handle this, instead of the 
semicolon.

`program("p1").pipe("p2").run;` - does that
`program("p1").run;` - does the other

Supposedly this is the "builder pattern" but the wikipedia entry 
seems to be deliberately bad.

Unserious answer, especially unsuitable for your concrete example 
where you probably want subprocesses to run reliably and in 
order: do something with object lifetime functions.

```d
import std.stdio : writeln;

class Program {
     string program;
     bool used;
     this(string p) { program = p; }
     ~this() { if (!used) writeln("You forgot to chain program: ", 
program); }
}

Program a(string p) {
         return new Program(p);
}

void b(Program p) {
         p.used = true;
         writeln("using program: ", p.program);
}

void main() {
         a("2");
         a("1").b();
}
```