Conditionals in D

Analogy categoryAnalogies

Introduction to Conditionals in D

Conditional statements let a D program choose between different execution paths based on a condition. D inherits its core conditional syntax from C and C++, but tightens the rules around implicit conversions and adds powerful compile-time variants like static if. Every conditional in D ultimately evaluates an expression to a boolean value, either through direct comparison operators or through D's rules for implicit bool conversion of integers, pointers, and arrays.

🏏

Cricket analogy: A captain deciding whether to review an lbw call with DRS is a conditional: if replays show the ball missing the stumps, the decision is overturned, otherwise the on-field call stands, exactly like D evaluating a boolean expression to choose a branch.

if, else if, and else

The basic if statement in D takes a condition in parentheses followed by a statement or block. Unlike C, D restricts implicit conversions more strictly for certain types, but still allows integers, pointers, class references, and dynamic arrays to be tested directly for truthiness: zero, null, and empty arrays are false, everything else is true. Chained else if clauses let you test multiple mutually exclusive conditions in sequence, and a trailing else handles the default case when none match.

🏏

Cricket analogy: An umpire's decision tree for a run-out checks first if the bails were dislodged before the batsman's bat crossed the crease, else if the fielder's throw missed the stumps entirely, else the batsman is given not out, mirroring an if/else if/else chain.

import std.stdio;

void classifyScore(int score)
{
    if (score >= 90)
        writeln("Grade: A");
    else if (score >= 80)
        writeln("Grade: B");
    else if (score >= 70)
        writeln("Grade: C");
    else
        writeln("Grade: F");
}

void main()
{
    int[] scores = [95, 82, 61, 74];
    foreach (s; scores)
        classifyScore(s);

    // D allows pointers and arrays to be tested for truthiness directly
    int[] data;
    if (data)
        writeln("data has elements");
    else
        writeln("data is empty or null");
}

The switch Statement and final switch

D's switch statement works on integral types, characters, strings, and enums -- string switching is a notable improvement over C, which cannot switch on strings at all. Each case must end with break, return, continue, or an explicit goto case; D deliberately forbids implicit fallthrough to prevent a common class of C bugs. When you switch on an enum, D offers final switch, which forces you to cover every enum member explicitly -- omitting one is a compile error, giving you exhaustiveness checking similar to pattern matching in functional languages.

🏏

Cricket analogy: Selecting a bowling change based on the batsman's dismissal type -- caught, bowled, lbw, or run out -- with a dedicated fielding plan for each, is exactly how a switch statement branches on an enum value like DismissalType.

import std.stdio;

enum Direction { North, South, East, West }

string describe(Direction d)
{
    final switch (d)
    {
        case Direction.North: return "Heading up";
        case Direction.South: return "Heading down";
        case Direction.East:  return "Heading right";
        case Direction.West:  return "Heading left";
    }
}

void main()
{
    string command = "start";
    switch (command)
    {
        case "start":
            writeln("Starting engine");
            goto case "check"; // explicit fallthrough required
        case "check":
            writeln("Checking systems");
            break;
        case "stop":
            writeln("Stopping engine");
            break;
        default:
            writeln("Unknown command");
    }

    writeln(describe(Direction.East));
}

final switch requires every member of the enum to have a case -- even ones you consider unreachable. If a new member is later added to the enum, every final switch on it will fail to compile until the new case is handled, which is a compile-time safety net but also means adding enum members can ripple through your codebase.

Compile-Time Conditionals: static if

static if is D's compile-time conditional: its condition must be evaluable at compile time (a manifest constant, a template parameter check, a trait like is(T == class), or a version identifier), and only the taken branch is compiled -- the untaken branch isn't even semantically analyzed, which is what makes static if usable for conditionally including code that would fail to compile for certain types. This differs fundamentally from a runtime if, which always compiles both branches and chooses between them at runtime; static if is a metaprogramming tool used heavily inside templates and mixins to specialize behavior per type without runtime cost.

🏏

Cricket analogy: A stadium's pitch curator decides at match preparation time -- long before a ball is bowled -- whether to prepare a green seaming pitch or a dry turning one, a decision baked in before play starts, just like static if resolving before the program ever runs.

static if can appear inside function bodies, struct/class bodies, and at module scope, and unlike runtime if it doesn't require braces to introduce a new scope for declarations -- this makes it a natural fit for template code such as static if (is(T == int)) { ... } else static if (isFloatingPoint!T) { ... } when specializing generic algorithms per type.

D's if/else if/else chains work like C's, but D is stricter about which types implicitly convert to bool (integers, pointers, class references, and arrays).
switch in D supports integers, characters, strings, and enums, unlike C which cannot switch on strings.
D forbids implicit case fallthrough; use an explicit goto case; to fall through intentionally.
final switch on an enum forces you to handle every enum member, catching missing cases at compile time.
static if is evaluated at compile time; only the taken branch is semantically checked, making it essential for template metaprogramming.
static if commonly uses is() expressions, traits, and template parameters as its condition rather than runtime values.
Choosing between if and static if is a choice between runtime branching and compile-time code specialization.