Idiomatic D

[Kelet]

On Friday, 10 January 2014 at 22:52:36 UTC, NoUseForAName wrote:
> I want to implement a small program in D for a personal 
> comparison of various programming languages. Given that I am 
> already quite familiar with C/C++ (from K&R C to C++11) I could 
> probably start write working D code right away by just looking 
> up a few basic syntax/standard library things.
>
> However, I would like to write idiomatic D code, not "C++ in 
> D". Is there any guide for this? If not, I would like to say 
> that I think having one would be very useful.
>
> Assuming a lack of an extensive guide could someone please just 
> give me the cliff notes on how to D properly?

I'm pretty new to D myself, but I always strive to write 
reasonably idiomatic code. So here's more or less what I've 
picked up:

- Use type inference (auto) when possible
- Use variable, function, and parameter qualifiers[1]
- Use compile time function execution[2]
- Constrain templates as much as possible
- foreach or higher-order functions are preferred over for/while 
loops[3]
- Do not overuse OOP[4]
- Use uniform function call syntax when it makes sense to chain 
calls or increase readability
- Know `alias this` and operator overloads
- Put unit tests under each function if you choose to make them
- Use Ddoc-style documentation
- Many of the examples on Rosetta Code are well-written 
http://rosettacode.org/wiki/Category:D I think bearophile did 
many of them.

[1]:
Some Qualifiers to note -
Function:
   - auto: infer return type
   - ref: returns a reference, not a value
   - inout: Deduce immutability (mutable, const, immutability) by 
parameters
   - pure: does not modify or use global state or impure functions
   - nothrow: No possibility to throw an exception
   - @safe: No operation may corrupt memory
   - @trusted – consider function safe, even if it cannot be 
verified so
   - @system – default, all @safe and @trusted functions are also 
@system
Variable:
   - const: this reference to the variable is unchangeable
     - const is nice in function parameters because it can accept 
mutable, const,
       and immutable parameters
   - immutable: all references to the variable are unchangeable
   - shared: requires that variable is sharable between threads
Parameter/Argument:
   - scope: no reference to variable can be leaked outside of 
function
   - in: equivalent to const scope
   - out: like ref, but gives default value, can be used for 
multiple returns
   - inout: see function qualifier definition
   - lazy: calculate only on usage (can duplicate calculations)

Mostly, I find myself trying to use `pure @safe nothrow` in 
functions, `immutable` in variables, and `in` in parameters as 
much as possible without modifying semantics too much.

[2]: See last example here 
http://en.wikipedia.org/wiki/Compile_time_function_execution

[3]:
for(int i = 0; i < 20; i++) =>
foreach(immutable i = 0; 0..20) OR
Use some higher-order function from std.algorithm or whatnot 
instead

[4]:
D is not Java. Modules can have their own constructors and 
private variables and such.

Regards,
Kelet