On Friday, 15 October 2021 at 20:33:33 UTC, JN wrote:
Is there some nice way of achieving something like this C99
code in D?
option 1: use an intermediate lambda:
```d
import std.stdio;
struct inputs_t {
int x, y;
} // no ; needed here
void foo(inputs_t* optional_inputs) {
if (!optional_inputs) {
writeln("0 0");
} else {
writeln(optional_inputs.x, " ", optional_inputs.y);
}
}
void main() {
import std.functional : pipe;
foo(null); // prints 0 0
inputs_t(5, 6).pipe!(s => foo(&s)); // prints 5 6
}
```
option 2: use a class
```d
class inputs_t {
int x, y;
this(int x, int y) {
this.x = x;
this.y = y;
}
}
void foo(inputs_t optional_inputs) {
import std.stdio : writeln;
if (!optional_inputs) {
writeln("0 0");
} else {
writeln(optional_inputs.x, " ", optional_inputs.y);
}
}
void main() {
foo(null);
foo(new inputs_t(5, 6));
}
```
option 3: use std.sumtype
```d
import std.sumtype;
struct Point {
int x, y;
}
alias Input = SumType!(Point, typeof(null));
void foo(Input inputs) {
import std.stdio : writeln;
inputs.match!(
(typeof(null) _) => writeln("0 0"),
(Point p) => writeln(p.x, " ", p.y),
);
}
void main() {
foo(null.Input);
foo(Point(5, 6).Input);
}
```
option 4: use overloading
```d
import std.stdio : writeln;
struct Point {
int x, y;
}
void foo() {
writeln("0 0");
}
void foo(Point p) {
writeln(p.x, " ", p.y);
}
void main() {
foo();
foo(Point(5, 6));
}
```
option 5: use S.init, when your exceptional value is handled the
same
```d
struct Point {
int x, y;
}
void foo(Point p = Point.init) {
import std.stdio : writeln;
writeln(p.x, " ", p.y);
}
void main() {
foo(); // 0 0
foo(Point.init); // 0 0
foo(Point(5, 6)); // 5 6
}
```
