Tips for golfing in D2

Question

What general tips do you have for golfing in D? I'm looking for ideas that can be applied to code golf problems in general that are at least somewhat specific to D (e.g. "remove comments" is not an answer). Please post one tip per answer.

Answer 1

Look, no parens!

D's functions and template functions can be called as values, methods (won't help), and properties.

I can't believe no one has said this yet. I'll list the ones that save bytes:

• fun() and fun!()() shorten to fun (assuming there is no variable fun).
• fun(par) shortens to par.fun (assuming par has no property/method fun, as well as par not being an expression like 5+2).
• fun!(T)() shortens to fun!T
• fun!(T)(par) shortens to par.fun!T (assuming par has no property/method fun)

And with objects:

• new cls() shortens to new cls (More JavaScript anyone?)
• obj.fun() and obj.fun!()() shorten to obj.fun
• obj.fun!(T)() shortens to obj.fun!T

One final thing, use old versions. It allows you to use deprecated features that shorten your code. That said, best advice: D isn't good for code-golf. It is a great language, just not for code-golf.

Answer 2

D is JavaScript.

---

Obviously not. But, when dealing with float, double and real, nan is a value which must be handled, and, as specified by IEEE 754, NaN does not compare equal with itself.

writeln(double.nan == double.nan); // false

Meaning,

writeln(value!=value); // only true for nan

is way shorter than

import std.math;
writeln(isNaN(value));

Obviously, always use math.isNaN for real code. ;)

Answer 3

D has type inference and an auto keyword. If the object is not int, then auto is probably shorter.

Answer 4

D is great at method chaining, but:

str.toLower.strip().split("").sort();

is the same as

sort(split(strip(str.toLower),""));

and usually the non-chained one is shorter, which I just realised, which lets me shorten my answer to Manage Trash So :D

Answer 5

D, as a multiparadigm (Object Functional) systems programming language, seems to embrace TIMTOWTDI, or There Is More Than One Way To Do It.

Case in point, writing the program's argv:

import std.stdio, std.array, std.algorithm;

void main(string[] args) {
    for(int i=0;i<args.length;writeln(args[i++])){};

    foreach(a;args)writeln(a);

    each!writeln(args);
}

Note the C-style for-loop requires {} as the empty block and will not accept a semicolon or nothing as a blank statement, in this case. Usually, or ; are no-ops.

Answer 6

D has a few types of C#-style lambda expressions, which can be assigned and stand alone:

(int a,int b)=>a*b;

auto a=(int a,int b)=>a*b;

However, unlike C#, the signature's types are still needed because D doesn't have Haskell-level type inferencing.

https://dlang.org/spec/expression.html#Lambda

Answer 7

If the question requires a full program, the module declaration is surprisingly unnecessary.

*cough* Java, anyone? *clears throat* Actually, D's module system is older than Java's.

Answer 8

Like C/C++, main can be int or void, but void main(){} will always be shorter than int main(){return my_func_returning_int;}.

Answer 9

Calling a function on an object with no other arguments

reverse(x);

can nearly always be shortened to

x.reverse;

to shave a byte or more.

This is because the . makes the LHS an implicit first argument, and templating lets us choose the right function for the args.