D言語コーディング規約メモ

int a; // OK
int a; int b; // NG. Having two statements.
if (a) {
    int a; // OK
  int b; // NG. The indent should be 4 columns.
}

int myFunc();
string myLocalVar

import std.algorithm

class Foo;
struct FooAndBar

template GetSomeType(T) { alias GetSomeType = T; }
template isSomeType(T) { enum isSomeType = is(T == SomeType); }
template MyType(T) { struct MyType { ... } }
template map(fun...) { auto map(Range r) { ... } }

int done();
int doneProcessing();

enum secondsPerMinute = 60;
immutable hexDigits = "0123456789ABCDEF";

enum Direction { bwd, fwd, both }
enum OpenRight { no, yes }

enum Attribute { nothrow_, pure_, safe }

class UTFException;
ubyte asciiChar

struct Foo {} // This struct follows the regular naming conventions.

// This is only for UDA
struct name { string value; }
@name("bar") Foo foo;

alias size_t uint; // OK
alias uint size_t; // NG

alias VOID = void;
alias INT = int;
alias pint = int*;

int[] x, y; // makes it clear that x and y are the same type
int** p, q; // ditto

int []x, y; // confusing since y is also an int[]
int **p, q; // ditto

import std.range, std.stdio;
void main()
{
    // good
    writeln();
    writeln("hello");
    iota(0, 10).dropOne.array.front.writeln;

    // bad
    writeln;
    "hello".writeln;
    writeln = "hello"; // This is a syntax sugar of writeln("hello")
}

void func(int param)
{
    if (param < 0)
    {
        ...
    }
    else
    {
        ...
    }
}

(a == b) ? "foo" : "bar"; // NO
a == b ? "foo" : "bar"; // OK

for (…) { … }
foreach (…) { … }
static foreach (…) { … }
if (x) { … }
static if (x) { … }
while (…) { … }
do { … } while (…);
version (…) { … }

if (...)
{
    ...
}
else if (...)
{
    ...
}

a + b
a / b
a == b
a && b
arr[1 .. 2]
int a = 100;
b += 1;
short c = cast(short) a;
filter!(a => a == 42);

a = !a && !(2 == -1);
bool b = ~a;
auto d = &c;
e++;
assert(*d == 42);
callMyFancyFunction("hello world");

void foo(R)(R r)
if (R == 1)

// Prefer:
T transmogrify(T)(T value)
if (isIntegral!T)
in (value % 7 == 0)
out (result; result % 11 == 0)
{
    // ...
}

// over this:
T transmogrify(T)(T value)
if (isIntegral!T)
in { assert(value % 7 == 0); }
out (result) { assert(result % 11 == 0); }
do
{
    // ...
}

struct S
{
    int x;
    invariant (x > 0);
}

class MyClass
{
    // bad
    int    a;
    double b;

    // good
    int x;
    double y;
}

/**
Checks whether a number is positive.
`0` isn't considered as positive number.

Params:
    number = number to be checked

Returns: `true` if the number is positive, `0` otherwise.

See_Also: $(LREF isNegative)
*/
bool isPositive(int number)
{
    return number > 0;
}

import std.stdio;

void main()
{
    int a = 0;
    switch (a)
    {
    case 0:
        writeln("hello");
        break;
    case 1: .. case 4:
        writeln("world");
        break;
    default:
        assert(0);
    }
}

import std.stdio;

void main()
{
    int a = 0;
    switch (a)
    {
        case 0:
            writeln("hello");
            break;
        case 1: .. case 4:
            writeln("world");
            break;
        default:
            assert(0);
    }
}

import std.stdio;

void main()
{
    int a = 0;
    if (a == 0)
    {
        writeln("Hello");
    }
    else if (a == 1)
    {
        writeln("world");
    }
}

import std.stdio;

void main() {
    int a = 0;
    if (a == 0) {
        writeln("Hello");
    } else if (a == 1) {
        writeln("world");
    }
}

import std.stdio;

void main() {
    int a = 0;
    if (a == 0) {
        writeln("Hello");
    }
    else if (a == 1) {
        writeln("world");
    }
}

import std.stdio;

void main()
{
    foo: foreach (i; 0 .. 10)
    {
        writeln("hello");
    }
}

import std.stdio;

void main()
{
foo:
    foreach (i; 0 .. 10)
    {
        writeln("hello");
    }
}

import std.stdio;

void main()
{
    writeln(
        "hello");
}

import std.stdio;

void main()
{
    writeln("hello"); // ← formatted
}

import std.stdio : writeln;

import std.stdio: writeln;

// true
auto a = cast(int) 0.0;
// false
auto a = cast(int)0.0;

// true
auto a = ["a" : 0, "b" : 1];
// false
auto a = ["a": 0, "b": 1];

// true
void main (string[] args)
// false
void main(string[] args)

// conditional_newline_indent
template A(T) if (is(T == int))
{
    alias Foo = T;
}
// conditional_newline
template A(T) if (is(T == int))
{
    alias Foo = T;
}
// always_newline
template A(T)
if (is(T == int))
{
    alias Foo = T;
}
// always_newline_indent
template A(T)
        if (is(T == int))
{
    alias Foo = T;
}

# Phobos style
indent_style = space
indent_size = 4
dfmt_brace_style = allman
max_line_length = 120
dfmt_soft_max_line_length = 80
dfmt_align_switch_statements = unset
dfmt_outdent_attributes = unset
dfmt_split_operator_at_line_end = unset
dfmt_space_after_cast = true
dfmt_space_after_keywords = unset
dfmt_space_before_function_parameters = unset
dfmt_selective_import_space = true # according to the example
dfmt_compact_labeled_statements = unset
dfmt_template_constraint_style = always_newline
dfmt_single_template_constraint_indent = unset
dfmt_space_before_aa_colon = unset
dfmt_keep_line_breaks = unset
dfmt_single_indent = unset

{
  "dfmt.braceStyle": "allman",
  "dfmt.selectiveImportSpace": true,
  "dfmt.spaceAfterCast": true,
  "dfmt.templateConstraintStyle": "always_newline"
}