#!/usr/bin/env dub
/+ dub.sdl:
    name "uom_quantity_unit_in_type"
    targetPath "build"
+/
/**
 * Units of measure — unit-in-type storage with *lazy* boundary conversion.
 *
 * This prototype keeps the **unit**, not merely the dimension, in the type: a
 * `Unit` bundles a `ℤ³` dimension exponent vector with a rational **scale to
 * the base unit** (`num/den`, reduced by a CTFE `gcd`). So `Metre` and
 * `Nanometre` are *different types* of the same length dimension —
 * `Unit(length, 1, 1)` versus `Unit(length, 1, 1_000_000_000)`. Nothing is
 * normalized at construction; a `500`-nanometre value is stored as the bare
 * `double 500.0`. Conversion is deferred to the arithmetic boundary: `+`/`-`
 * between two units of the *same* dimension bakes a compile-time rational
 * factor (`convFactor`) and converts the right operand into the left operand's
 * unit right there, at the `+` site. Cross-dimension addition has no matching
 * operator and is rejected — the `static assert(!__traits(compiles, …))` demos
 * turn those intended failures into checked, passing parts of the program.
 *
 * The framing is a physically-based raytracer whose scene distances live in
 * metres but whose spectral wavelengths live in nanometres. `distance +
 * wavelength` must *mean* something and must not silently mix magnitudes:
 * unit-in-type keeps each quantity in its natural, human-scaled unit and lets
 * the `+` boundary insert the `1e-9` factor lazily — contrast
 * `quantity-zn-graded.d`, which stores everything in base units eagerly and
 * has no per-unit scale to carry. See `cpp-mp-units.md`, `cpp-au.md`
 * (`CommonUnit`/`Quantity<Unit>` machinery) and `rust-uom.md` for the
 * production incarnations of exactly this storage choice, and
 * `comparison.md` § "Architectural trade-offs" (the *Unit storage* row,
 * Option B: "keep the unit in the type; convert lazily at boundaries").
 *
 * Companion to docs/research/units-of-measure/examples/cpp-mp-units.md,
 * ./cpp-au.md, ./rust-uom.md and docs/research/units-of-measure/comparison.md.
 *
 * Composition: unit-in-type composes with `sparkles:math`'s `Vector` as
 * ordering A — `Quantity!(unit, Vec3)`, the unit (dimension + scale) wrapping
 * the payload, `Payload` defaulting to `double` exactly as in
 * `quantity-affine-torsor.d`. A positions-in-`cm` `Vec3` and a bounds-in-`m`
 * `Vec3` are then *different types* that convert lazily at the `+` boundary,
 * reusing the very same rational-scale `convFactor` shown here for scalars.
 *
 * Run with: `dub run --single quantity-unit-in-type.d`
 */
module 
(module) uom_quantity_unit_in_type
Units of measure — unit-in-type storage with lazy boundary conversion.
This prototype keeps the unit, not merely the dimension, in the type: a
Unit bundles a ℤ³ dimension exponent vector with a rational scale to
the base unit (num/den, reduced by a CTFE gcd). So Metre and
Nanometre are different types of the same length dimension —
Unit(length, 1, 1) versus Unit(length, 1, 1_000_000_000). Nothing is
normalized at construction; a 500-nanometre value is stored as the bare
double 500.0. Conversion is deferred to the arithmetic boundary: +/-
between two units of the same dimension bakes a compile-time rational
factor (convFactor) and converts the right operand into the left operand's
unit right there, at the + site. Cross-dimension addition has no matching
operator and is rejected — the static assert(!__traits(compiles, …)) demos
turn those intended failures into checked, passing parts of the program.
The framing is a physically-based raytracer whose scene distances live in
metres but whose spectral wavelengths live in nanometres. distance +
wavelength must mean something and must not silently mix magnitudes:
unit-in-type keeps each quantity in its natural, human-scaled unit and lets
the + boundary insert the 1e-9 factor lazily — contrast
quantity-zn-graded.d, which stores everything in base units eagerly and
has no per-unit scale to carry. See cpp-mp-units.md, cpp-au.md
(CommonUnit/Quantity<Unit> machinery) and rust-uom.md for the
production incarnations of exactly this storage choice, and
comparison.md § "Architectural trade-offs" (the Unit storage row,
Option B: "keep the unit in the type; convert lazily at boundaries").
Companion to docs/research/units-of-measure/examples/cpp-mp-units.md,
./cpp-au.md, ./rust-uom.md and docs/research/units-of-measure/comparison.md.
Composition
unit-in-type composes with sparkles:math's Vector as
ordering A — Quantity!(unit, Vec3), the unit (dimension + scale) wrapping
the payload, Payload defaulting to double exactly as in
quantity-affine-torsor.d. A positions-in-cm Vec3 and a bounds-in-m
Vec3 are then different types that convert lazily at the + boundary,
reusing the very same rational-scale convFactor shown here for scalars.
Run with: dub run --single quantity-unit-in-type.duom_quantity_unit_in_type;

/// Euclid on non-negative operands; CTFE-friendly, no Phobos needed. Used to
/// reduce every rational scale to a unique normal form so equal scales are
/// bit-identical `Unit` template arguments (hence the same `Quantity` type).
long 
long uom_quantity_unit_in_type.gcd(long a, long b) pure nothrow @nogc @safe
Euclid on non-negative operands; CTFE-friendly, no Phobos needed. Used to
reduce every rational scale to a unique normal form so equal scales are
bit-identical Unit template arguments (hence the same Quantity type).gcd(long 
(parameter) long aa, long 
(parameter) long bb) @safe pure nothrow @nogc
in (
(parameter) long aa >= 0 && 
(parameter) long bb >= 0)
{
    while (
(parameter) long bb != 0)
    {
        const 
(local variable) const(long) tt = 
(parameter) long aa % 
(parameter) long bb;
        
(parameter) long aa = 
(parameter) long bb;
        
(parameter) long bb = 
(local variable) const(long) tt;
    }
    return 
(parameter) long aa;
}

/// A dimension: an exponent vector in the free abelian group `ℤ³` over the base
/// dimensions (mass, length, time), stored directly as its normal form.
struct 
(struct) uom_quantity_unit_in_type.Dim
A dimension: an exponent vector in the free abelian group ℤ³ over the base
dimensions (mass, length, time), stored directly as its normal form.Dim
{
    int 
(field) int uom_quantity_unit_in_type.Dim.massmass;
    int 
(field) int uom_quantity_unit_in_type.Dim.lengthlength;
    int 
(field) int uom_quantity_unit_in_type.Dim.timetime;
}

/// The dimension group operation, component-wise: `sign = +1` for
/// multiplication (join of dimensions), `sign = -1` for division (the inverse).
(struct) uom_quantity_unit_in_type.Dim
A dimension: an exponent vector in the free abelian group ℤ³ over the base
dimensions (mass, length, time), stored directly as its normal form.Dim 
uom_quantity_unit_in_type.Dim uom_quantity_unit_in_type.combine(in uom_quantity_unit_in_type.Dim a, in uom_quantity_unit_in_type.Dim b, in int sign) pure nothrow @nogc @safe
The dimension group operation, component-wise: sign` = +1` for
multiplication (join of dimensions), sign = -1 for division (the inverse).combine(in 
(struct) uom_quantity_unit_in_type.Dim
A dimension: an exponent vector in the free abelian group ℤ³ over the base
dimensions (mass, length, time), stored directly as its normal form.Dim 
(parameter) const(uom_quantity_unit_in_type.Dim) aa, in 
(struct) uom_quantity_unit_in_type.Dim
A dimension: an exponent vector in the free abelian group ℤ³ over the base
dimensions (mass, length, time), stored directly as its normal form.Dim 
(parameter) const(uom_quantity_unit_in_type.Dim) bb, in int 
(parameter) const(int) signsign) @safe pure nothrow @nogc
in (
(parameter) const(int) signsign == 1 || 
(parameter) const(int) signsign == -1)
{
    return 
(struct) uom_quantity_unit_in_type.Dim
A dimension: an exponent vector in the free abelian group ℤ³ over the base
dimensions (mass, length, time), stored directly as its normal form.Dim(
        mass: 
(parameter) const(uom_quantity_unit_in_type.Dim) aa.
(field) int uom_quantity_unit_in_type.Dim.massmass + 
(parameter) const(int) signsign * 
(parameter) const(uom_quantity_unit_in_type.Dim) bb.
(field) int uom_quantity_unit_in_type.Dim.massmass,
        length: 
(parameter) const(uom_quantity_unit_in_type.Dim) aa.
(field) int uom_quantity_unit_in_type.Dim.lengthlength + 
(parameter) const(int) signsign * 
(parameter) const(uom_quantity_unit_in_type.Dim) bb.
(field) int uom_quantity_unit_in_type.Dim.lengthlength,
        time: 
(parameter) const(uom_quantity_unit_in_type.Dim) aa.
(field) int uom_quantity_unit_in_type.Dim.timetime + 
(parameter) const(int) signsign * 
(parameter) const(uom_quantity_unit_in_type.Dim) bb.
(field) int uom_quantity_unit_in_type.Dim.timetime,
    );
}

/// A **unit**: a dimension *plus* a rational scale `num/den` to the base unit of
/// that dimension. This is the whole point of the prototype — the type carries
/// the unit, not just the dimension. `Nanometre` has the same `dim` as `Metre`
/// but `den = 1e9`, so they are distinct types. Kept normalized (`den > 0`,
/// `gcd(num, den) == 1`) by `unit` below, so scale equality is value equality.
struct 
(struct) uom_quantity_unit_in_type.Unit
A unit: a dimension plus a rational scale num/den to the base unit of
that dimension. This is the whole point of the prototype — the type carries
the unit, not just the dimension. Nanometre has the same dim as Metre
but den = 1e9, so they are distinct types. Kept normalized (den > 0,
gcd(num, den) == 1) by unit below, so scale equality is value equality.Unit
{
    
(struct) uom_quantity_unit_in_type.Dim
A dimension: an exponent vector in the free abelian group ℤ³ over the base
dimensions (mass, length, time), stored directly as its normal form.Dim 
(field) uom_quantity_unit_in_type.Dim uom_quantity_unit_in_type.Unit.dimdim;
    long 
(field) long uom_quantity_unit_in_type.Unit.numnum = 1;
    long 
(field) long uom_quantity_unit_in_type.Unit.denden = 1;
}

/// Builds a `Unit` in unique normal form: reduces the scale by its gcd and
/// keeps `den > 0`. Normalization is what makes `Metre` and `Metre` the *same*
/// type while `Metre` and `Centimetre` differ.
(struct) uom_quantity_unit_in_type.Unit
A unit: a dimension plus a rational scale num/den to the base unit of
that dimension. This is the whole point of the prototype — the type carries
the unit, not just the dimension. Nanometre has the same dim as Metre
but den = 1e9, so they are distinct types. Kept normalized (den > 0,
gcd(num, den) == 1) by unit below, so scale equality is value equality.Unit 
uom_quantity_unit_in_type.Unit uom_quantity_unit_in_type.unit(in uom_quantity_unit_in_type.Dim d, long num, long den) pure nothrow @nogc @safe
Builds a Unit in unique normal form: reduces the scale by its gcd and
keeps ``den > 0. Normalization is what makes Metre and Metre the same
type while Metre and Centimetre differ.unit(in 
(struct) uom_quantity_unit_in_type.Dim
A dimension: an exponent vector in the free abelian group ℤ³ over the base
dimensions (mass, length, time), stored directly as its normal form.Dim 
(parameter) const(uom_quantity_unit_in_type.Dim) dd, long 
(parameter) long numnum, long 
(parameter) long denden) @safe pure nothrow @nogc
in (
(parameter) long denden != 0, "unit scale denominator must be non-zero")
out (u; 
(local variable) const(uom_quantity_unit_in_type.Unit) uu.
(field) long uom_quantity_unit_in_type.Unit.denden > 0)
{
    if (
(parameter) long denden < 0)
    {
        
(parameter) long numnum = -
(parameter) long numnum;
        
(parameter) long denden = -
(parameter) long denden;
    }
    const 
(local variable) const(long) gg = 
long uom_quantity_unit_in_type.gcd(long a, long b) pure nothrow @nogc @safe
Euclid on non-negative operands; CTFE-friendly, no Phobos needed. Used to
reduce every rational scale to a unique normal form so equal scales are
bit-identical Unit template arguments (hence the same Quantity type).gcd(
(parameter) long numnum < 0 ? -
(parameter) long numnum : 
(parameter) long numnum, 
(parameter) long denden);
    const 
(local variable) const(long) gggg = 
(local variable) const(long) gg == 0 ? 1 : 
(local variable) const(long) gg;
    return 
(struct) uom_quantity_unit_in_type.Unit
A unit: a dimension plus a rational scale num/den to the base unit of
that dimension. This is the whole point of the prototype — the type carries
the unit, not just the dimension. Nanometre has the same dim as Metre
but den = 1e9, so they are distinct types. Kept normalized (den > 0,
gcd(num, den) == 1) by unit below, so scale equality is value equality.Unit(
(parameter) const(uom_quantity_unit_in_type.Dim) dd, 
(parameter) long numnum / 
(local variable) const(long) gggg, 
(parameter) long denden / 
(local variable) const(long) gggg);
}

/// The unit group operation for `*`/`/`: dimensions combine (add/subtract
/// exponents) and scales multiply/divide as rationals, renormalized. So
/// `cm * cm` is an area whose scale is `1/10000` of `m²`, tracked exactly.
(struct) uom_quantity_unit_in_type.Unit
A unit: a dimension plus a rational scale num/den to the base unit of
that dimension. This is the whole point of the prototype — the type carries
the unit, not just the dimension. Nanometre has the same dim as Metre
but den = 1e9, so they are distinct types. Kept normalized (den > 0,
gcd(num, den) == 1) by unit below, so scale equality is value equality.Unit 
uom_quantity_unit_in_type.Unit uom_quantity_unit_in_type.scaleCombine(in uom_quantity_unit_in_type.Unit a, in uom_quantity_unit_in_type.Unit b, in int sign) pure nothrow @nogc @safe
The unit group operation for *//: dimensions combine (add/subtract
exponents) and scales multiply/divide as rationals, renormalized. So
cm * cm is an area whose scale is 1/10000 of m², tracked exactly.scaleCombine(in 
(struct) uom_quantity_unit_in_type.Unit
A unit: a dimension plus a rational scale num/den to the base unit of
that dimension. This is the whole point of the prototype — the type carries
the unit, not just the dimension. Nanometre has the same dim as Metre
but den = 1e9, so they are distinct types. Kept normalized (den > 0,
gcd(num, den) == 1) by unit below, so scale equality is value equality.Unit 
(parameter) const(uom_quantity_unit_in_type.Unit) aa, in 
(struct) uom_quantity_unit_in_type.Unit
A unit: a dimension plus a rational scale num/den to the base unit of
that dimension. This is the whole point of the prototype — the type carries
the unit, not just the dimension. Nanometre has the same dim as Metre
but den = 1e9, so they are distinct types. Kept normalized (den > 0,
gcd(num, den) == 1) by unit below, so scale equality is value equality.Unit 
(parameter) const(uom_quantity_unit_in_type.Unit) bb, in int 
(parameter) const(int) signsign) @safe pure nothrow @nogc
in (
(parameter) const(int) signsign == 1 || 
(parameter) const(int) signsign == -1)
{
    const 
(local variable) const(uom_quantity_unit_in_type.Dim) dd = 
uom_quantity_unit_in_type.Dim uom_quantity_unit_in_type.combine(in uom_quantity_unit_in_type.Dim a, in uom_quantity_unit_in_type.Dim b, in int sign) pure nothrow @nogc @safe
The dimension group operation, component-wise: sign` = +1` for
multiplication (join of dimensions), sign = -1 for division (the inverse).combine(
(parameter) const(uom_quantity_unit_in_type.Unit) aa.
(field) uom_quantity_unit_in_type.Dim uom_quantity_unit_in_type.Unit.dimdim, 
(parameter) const(uom_quantity_unit_in_type.Unit) bb.
(field) uom_quantity_unit_in_type.Dim uom_quantity_unit_in_type.Unit.dimdim, 
(parameter) const(int) signsign);
    // scale(a) * scale(b)^sign : (na/da) * (nb/db) or (na/da) / (nb/db).
    const 
(local variable) const(long) numnum = 
(parameter) const(int) signsign == 1 ? 
(parameter) const(uom_quantity_unit_in_type.Unit) aa.
(field) long uom_quantity_unit_in_type.Unit.numnum * 
(parameter) const(uom_quantity_unit_in_type.Unit) bb.
(field) long uom_quantity_unit_in_type.Unit.numnum : 
(parameter) const(uom_quantity_unit_in_type.Unit) aa.
(field) long uom_quantity_unit_in_type.Unit.numnum * 
(parameter) const(uom_quantity_unit_in_type.Unit) bb.
(field) long uom_quantity_unit_in_type.Unit.denden;
    const 
(local variable) const(long) denden = 
(parameter) const(int) signsign == 1 ? 
(parameter) const(uom_quantity_unit_in_type.Unit) aa.
(field) long uom_quantity_unit_in_type.Unit.denden * 
(parameter) const(uom_quantity_unit_in_type.Unit) bb.
(field) long uom_quantity_unit_in_type.Unit.denden : 
(parameter) const(uom_quantity_unit_in_type.Unit) aa.
(field) long uom_quantity_unit_in_type.Unit.denden * 
(parameter) const(uom_quantity_unit_in_type.Unit) bb.
(field) long uom_quantity_unit_in_type.Unit.numnum;
    return 
uom_quantity_unit_in_type.Unit uom_quantity_unit_in_type.unit(in uom_quantity_unit_in_type.Dim d, long num, long den) pure nothrow @nogc @safe
Builds a Unit in unique normal form: reduces the scale by its gcd and
keeps ``den > 0. Normalization is what makes Metre and Metre the same
type while Metre and Centimetre differ.unit(
(local variable) const(uom_quantity_unit_in_type.Dim) dd, 
(local variable) const(long) numnum, 
(local variable) const(long) denden);
}

/// The **lazy boundary conversion** factor: multiply a value expressed in
/// `from` by this to re-express it in `to` (same dimension assumed). It is the
/// ratio of the two rational scales, `(from.num/from.den) / (to.num/to.den)`,
/// evaluated to a `double` at the `+` site — the deferred conversion made
/// concrete. For `nm → m` it is `1e-9`; for `m → nm` it is `1e9`.
double 
double uom_quantity_unit_in_type.convFactor(in uom_quantity_unit_in_type.Unit from, in uom_quantity_unit_in_type.Unit to) pure nothrow @nogc @safe
The lazy boundary conversion factor: multiply a value expressed in
from by this to re-express it in to (same dimension assumed). It is the
ratio of the two rational scales, (from.num/from.den) / (to.num/to.den),
evaluated to a double at the + site — the deferred conversion made
concrete. For nm → m it is 1e-9; for m → nm it is 1e9.convFactor(in 
(struct) uom_quantity_unit_in_type.Unit
A unit: a dimension plus a rational scale num/den to the base unit of
that dimension. This is the whole point of the prototype — the type carries
the unit, not just the dimension. Nanometre has the same dim as Metre
but den = 1e9, so they are distinct types. Kept normalized (den > 0,
gcd(num, den) == 1) by unit below, so scale equality is value equality.Unit 
(parameter) const(uom_quantity_unit_in_type.Unit) fromfrom, in 
(struct) uom_quantity_unit_in_type.Unit
A unit: a dimension plus a rational scale num/den to the base unit of
that dimension. This is the whole point of the prototype — the type carries
the unit, not just the dimension. Nanometre has the same dim as Metre
but den = 1e9, so they are distinct types. Kept normalized (den > 0,
gcd(num, den) == 1) by unit below, so scale equality is value equality.Unit 
(parameter) const(uom_quantity_unit_in_type.Unit) toto) @safe pure nothrow @nogc
    => (cast(double) 
(parameter) const(uom_quantity_unit_in_type.Unit) fromfrom.
(field) long uom_quantity_unit_in_type.Unit.numnum * 
(parameter) const(uom_quantity_unit_in_type.Unit) toto.
(field) long uom_quantity_unit_in_type.Unit.denden) / (cast(double) 
(parameter) const(uom_quantity_unit_in_type.Unit) fromfrom.
(field) long uom_quantity_unit_in_type.Unit.denden * 
(parameter) const(uom_quantity_unit_in_type.Unit) toto.
(field) long uom_quantity_unit_in_type.Unit.numnum);

/// CTFE base-dimension label for an exponent vector (only ever run at compile
/// time). `Dim(length: 2)` renders `"m^2"`; the identity is `"(dimensionless)"`.
(alias) object.string = stringstring 
string uom_quantity_unit_in_type.dimString(in uom_quantity_unit_in_type.Dim d) pure @safe
CTFE base-dimension label for an exponent vector (only ever run at compile
time). Dim(length: 2) renders "m^2"; the identity is "(dimensionless)".dimString(in 
(struct) uom_quantity_unit_in_type.Dim
A dimension: an exponent vector in the free abelian group ℤ³ over the base
dimensions (mass, length, time), stored directly as its normal form.Dim 
(parameter) const(uom_quantity_unit_in_type.Dim) dd) @safe pure
{
    import 
(package) stdstd.
(module) std.conv
A one-stop shop for converting values from one type to another.
Category 
Functions 
Generic 
asOriginalType castFrom parse to toChars bitCast 
Strings 
text wtext dtext writeText writeWText writeDText hexString 
Numeric 
octal roundTo signed unsigned 
Exceptions 
ConvException ConvOverflowException 
Source
std/conv.d
@copyrightCopyright The D Language Foundation 2007-.@licenseBoost License 1.0.@authorsWalter Bright,
Andrei Alexandrescu,
Shin Fujishiro,
Adam D. Ruppe,
Kenji Haraconv : 
(alias template) to = std.conv.to(T)
The to template converts a value from one type _to another.
The source type is deduced and the target type must be specified, for example the
expression to!int(42.0) converts the number 42 from
double _to int. The conversion is "safe", i.e.,
it checks for overflow; to!int(4.2e10) would throw the
ConvOverflowException exception. Overflow checks are only
inserted when necessary, e.g., to!double(42) does not do
any checking because any int fits in a double.
Conversions from string _to numeric types differ from the C equivalents
atoi() and atol() by checking for overflow and not allowing whitespace.
For conversion of strings _to signed types, the grammar recognized is:
$(PRE $(I Integer):
    $(I Sign UnsignedInteger)
    $(I UnsignedInteger)
$(I Sign):
    $(B +)
    $(B -))
For conversion _to unsigned types, the grammar recognized is:
$(PRE $(I UnsignedInteger):
    $(I DecimalDigit)
    $(I DecimalDigit) $(I UnsignedInteger))to;

    
(alias) object.string = stringstring 
(local variable) string resultresult;

    void 
void uom_quantity_unit_in_type.dimString.put(in string symbol, in int exp) pure nothrow @safeput(in 
(alias) object.string = stringstring 
(parameter) const(string) symbolsymbol, in int 
(parameter) const(int) expexp)
    {
        if (
(parameter) const(int) expexp == 0)
            return;
        if (
(local variable) string resultresult.
(field) ulong string.lengthlength > 0)
            
(local variable) string resultresult ~= ' ';
        
(local variable) string resultresult ~= 
(parameter) const(string) symbolsymbol;
        if (
(parameter) const(int) expexp != 1)
            
(local variable) string resultresult ~= "^" ~ 
(parameter) const(int) expexp.
string std.conv.to!string.to!(const(int))(const(int) __param_0) pure nothrow @safe
The to template converts a value from one type to another.
The source type is deduced and the target type must be specified, for example the
expression to`!int(42.0)` converts the number 42 from
`double` to `int`. The conversion is "safe", i.e.,
it checks for overflow; to!int(4.2e10) would throw the
ConvOverflowException exception. Overflow checks are only
inserted when necessary, e.g., ``to!double(42) does not do
any checking because any int fits in a double.
Conversions from string to numeric types differ from the C equivalents
atoi() and atol() by checking for overflow and not allowing whitespace.
For conversion of strings to signed types, the grammar recognized is:
Integer:
Sign UnsignedInteger
UnsignedInteger
Sign:
+
-
For conversion to unsigned types, the grammar recognized is:
UnsignedInteger:
DecimalDigit
DecimalDigit UnsignedInteger
Examples
Converting a value to its own type (useful mostly for generic code)
simply returns its argument.
int a = 42;
int b = to!int(a);
double c = to!double(3.14); // c is double with value 3.14
Converting among numeric types is a safe way to cast them around.
Conversions from floating-point types to integral types allow loss of
precision (the fractional part of a floating-point number). The
conversion is truncating towards zero, the same way a cast would
truncate. (To round a floating point value when casting to an
integral, use roundTo.)
import std.exception : assertThrown;

int a = 420;
assert(to!long(a) == a);
assertThrown!ConvOverflowException(to!byte(a));

assert(to!int(4.2e6) == 4200000);
assertThrown!ConvOverflowException(to!uint(-3.14));
assert(to!uint(3.14) == 3);
assert(to!uint(3.99) == 3);
assert(to!int(-3.99) == -3);
When converting strings to numeric types, note that D hexadecimal and binary
literals are not handled. Neither the prefixes that indicate the base, nor the
horizontal bar used to separate groups of digits are recognized. This also
applies to the suffixes that indicate the type.
To work around this, you can specify a radix for conversions involving numbers.
auto str = to!string(42, 16);
assert(str == "2A");
auto i = to!int(str, 16);
assert(i == 42);
Conversions from integral types to floating-point types always
succeed, but might lose accuracy. The largest integers with a
predecessor representable in floating-point format are 2^24-1 for
float, 2^53-1 for double, and 2^64-1 for real (when
real is 80-bit, e.g. on Intel machines).
// 2^24 - 1, largest proper integer representable as float
int a = 16_777_215;
assert(to!int(to!float(a)) == a);
assert(to!int(to!float(-a)) == -a);
Conversion from string types to char types enforces the input
to consist of a single code point, and said code point must
fit in the target type. Otherwise, ConvException is thrown.
import std.exception : assertThrown;

assert(to!char("a") == 'a');
assertThrown(to!char("ñ")); // 'ñ' does not fit into a char
assert(to!wchar("ñ") == 'ñ');
assertThrown(to!wchar("😃")); // '😃' does not fit into a wchar
assert(to!dchar("😃") == '😃');

// Using wstring or dstring as source type does not affect the result
assert(to!char("a"w) == 'a');
assert(to!char("a"d) == 'a');

// Two code points cannot be converted to a single one
assertThrown(to!char("ab"));
Converting an array to another array type works by converting each
element in turn. Associative arrays can be converted to associative
arrays as long as keys and values can in turn be converted.
import std.string : split;

int[] a = [1, 2, 3];
auto b = to!(float[])(a);
assert(b == [1.0f, 2, 3]);
string str = "1 2 3 4 5 6";
auto numbers = to!(double[])(split(str));
assert(numbers == [1.0, 2, 3, 4, 5, 6]);
int[string] c;
c["a"] = 1;
c["b"] = 2;
auto d = to!(double[wstring])(c);
assert(d["a"w] == 1 && d["b"w] == 2);
Conversions operate transitively, meaning that they work on arrays and
associative arrays of any complexity.
This conversion works because to`!short` applies to an `int`, to!wstring
applies to a string, to`!string` applies to a `double`, and
to!(double[]) applies to an int[]. The conversion might throw an
exception because ``to!short might fail the range check.
int[string][double[int[]]] a;
auto b = to!(short[wstring][string[double[]]])(a);
Object-to-object conversions by dynamic casting throw exception when
the source is non-null and the target is null.
import std.exception : assertThrown;
// Testing object conversions
class A {}
class B : A {}
class C : A {}
A a1 = new A, a2 = new B, a3 = new C;
assert(to!B(a2) is a2);
assert(to!C(a3) is a3);
assertThrown!ConvException(to!B(a3));
Stringize conversion from all types is supported.
String to string conversion works for any two string types having
    (char, wchar, dchar) character widths and any
    combination of qualifiers (mutable, const, or immutable).
Converts array (other than strings) to string.
    Each element is converted by calling ``to!T.
Associative array to string conversion.
    Each element is converted by calling ``to!T.
Object to string conversion calls toString against the object or
    returns "null" if the object is null.
Struct to string conversion calls toString against the struct if
    it is defined.
For structs that do not define toString, the conversion to string
    produces the list of fields.
Enumerated types are converted to strings as their symbolic names.
Boolean values are converted to "true" or "false".
char, wchar, dchar to a string type.
Unsigned or signed integers to strings.
  special case
  : Convert integral value to string in radix radix.
    radix must be a value from 2 to 36.
    value is treated as a signed value only if radix is 10.
    The characters A through Z are used to represent values 10 through 36
    and their case is determined by the letterCase parameter.
All floating point types to all string types.
Pointer to string conversions convert the pointer to a size_t value.
    If pointer is char*, treat it as C-style strings.
    In that case, this function is @system.
See formatValue on how toString should be defined.
// Conversion representing dynamic/static array with string
long[] a = [ 1, 3, 5 ];
assert(to!string(a) == "[1, 3, 5]");

// Conversion representing associative array with string
int[string] associativeArray = ["0":1, "1":2];
assert(to!string(associativeArray) == `["0":1, "1":2]` ||
       to!string(associativeArray) == `["1":2, "0":1]`);

// char* to string conversion
assert(to!string(cast(char*) null) == "");
assert(to!string("foo\0".ptr) == "foo");

// Conversion reinterpreting void array to string
auto w = "abcx"w;
const(void)[] b = w;
assert(b.length == 8);

auto c = to!(wchar[])(b);
assert(c == "abcx");
Strings can be converted to enum types. The enum member with the same name as the
input string is returned. The comparison is case-sensitive.
A ConvException is thrown if the enum does not have the specified member.
import std.exception : assertThrown;

enum E { a, b, c }
assert(to!E("a") == E.a);
assert(to!E("b") == E.b);
assertThrown!ConvException(to!E("A"));
to!
(alias) object.string = stringstring;
    }

    
void uom_quantity_unit_in_type.dimString.put(in string symbol, in int exp) pure nothrow @safeput("kg", 
(parameter) const(uom_quantity_unit_in_type.Dim) dd.
(field) int uom_quantity_unit_in_type.Dim.massmass);
    
void uom_quantity_unit_in_type.dimString.put(in string symbol, in int exp) pure nothrow @safeput("m", 
(parameter) const(uom_quantity_unit_in_type.Dim) dd.
(field) int uom_quantity_unit_in_type.Dim.lengthlength);
    
void uom_quantity_unit_in_type.dimString.put(in string symbol, in int exp) pure nothrow @safeput("s", 
(parameter) const(uom_quantity_unit_in_type.Dim) dd.
(field) int uom_quantity_unit_in_type.Dim.timetime);
    return 
(local variable) string resultresult.
(field) ulong string.lengthlength > 0 ? 
(local variable) string resultresult : "(dimensionless)";
}

/// CTFE label for a whole unit: SI shorthand for the length units the raytracer
/// uses (`m`/`cm`/`mm`/`um`/`nm`), otherwise the base label with an explicit
/// rational scale annotation. GC-allocating, but only evaluated at compile time.
(alias) object.string = stringstring 
string uom_quantity_unit_in_type.unitString(in uom_quantity_unit_in_type.Unit u) pure @safe
CTFE label for a whole unit: SI shorthand for the length units the raytracer
uses (m/cm/mm/um/nm), otherwise the base label with an explicit
rational scale annotation. GC-allocating, but only evaluated at compile time.unitString(in 
(struct) uom_quantity_unit_in_type.Unit
A unit: a dimension plus a rational scale num/den to the base unit of
that dimension. This is the whole point of the prototype — the type carries
the unit, not just the dimension. Nanometre has the same dim as Metre
but den = 1e9, so they are distinct types. Kept normalized (den > 0,
gcd(num, den) == 1) by unit below, so scale equality is value equality.Unit 
(parameter) const(uom_quantity_unit_in_type.Unit) uu) @safe pure
{
    import 
(package) stdstd.
(module) std.conv
A one-stop shop for converting values from one type to another.
Category 
Functions 
Generic 
asOriginalType castFrom parse to toChars bitCast 
Strings 
text wtext dtext writeText writeWText writeDText hexString 
Numeric 
octal roundTo signed unsigned 
Exceptions 
ConvException ConvOverflowException 
Source
std/conv.d
@copyrightCopyright The D Language Foundation 2007-.@licenseBoost License 1.0.@authorsWalter Bright,
Andrei Alexandrescu,
Shin Fujishiro,
Adam D. Ruppe,
Kenji Haraconv : 
(alias template) to = std.conv.to(T)
The to template converts a value from one type _to another.
The source type is deduced and the target type must be specified, for example the
expression to!int(42.0) converts the number 42 from
double _to int. The conversion is "safe", i.e.,
it checks for overflow; to!int(4.2e10) would throw the
ConvOverflowException exception. Overflow checks are only
inserted when necessary, e.g., to!double(42) does not do
any checking because any int fits in a double.
Conversions from string _to numeric types differ from the C equivalents
atoi() and atol() by checking for overflow and not allowing whitespace.
For conversion of strings _to signed types, the grammar recognized is:
$(PRE $(I Integer):
    $(I Sign UnsignedInteger)
    $(I UnsignedInteger)
$(I Sign):
    $(B +)
    $(B -))
For conversion _to unsigned types, the grammar recognized is:
$(PRE $(I UnsignedInteger):
    $(I DecimalDigit)
    $(I DecimalDigit) $(I UnsignedInteger))to;

    if (
(parameter) const(uom_quantity_unit_in_type.Unit) uu.
(field) uom_quantity_unit_in_type.Dim uom_quantity_unit_in_type.Unit.dimdim == 
(struct) uom_quantity_unit_in_type.Dim
A dimension: an exponent vector in the free abelian group ℤ³ over the base
dimensions (mass, length, time), stored directly as its normal form.Dim(length: 1) && 
(parameter) const(uom_quantity_unit_in_type.Unit) uu.
(field) long uom_quantity_unit_in_type.Unit.numnum == 1)
        switch (
(parameter) const(uom_quantity_unit_in_type.Unit) uu.
(field) long uom_quantity_unit_in_type.Unit.denden)
        {
        case 1: return "m";
        case 100: return "cm";
        case 1000: return "mm";
        case 1_000_000: return "um";
        case 1_000_000_000: return "nm";
        default: break;
        }

    const 
(local variable) const(string) basebase = 
string uom_quantity_unit_in_type.dimString(in uom_quantity_unit_in_type.Dim d) pure @safe
CTFE base-dimension label for an exponent vector (only ever run at compile
time). Dim(length: 2) renders "m^2"; the identity is "(dimensionless)".dimString(
(parameter) const(uom_quantity_unit_in_type.Unit) uu.
(field) uom_quantity_unit_in_type.Dim uom_quantity_unit_in_type.Unit.dimdim);
    if (
(parameter) const(uom_quantity_unit_in_type.Unit) uu.
(field) long uom_quantity_unit_in_type.Unit.numnum == 1 && 
(parameter) const(uom_quantity_unit_in_type.Unit) uu.
(field) long uom_quantity_unit_in_type.Unit.denden == 1)
        return 
(local variable) const(string) basebase;
    return "[" ~ 
(parameter) const(uom_quantity_unit_in_type.Unit) uu.
(field) long uom_quantity_unit_in_type.Unit.numnum.
string std.conv.to!string.to!(const(long))(const(long) __param_0) pure nothrow @safe
The to template converts a value from one type to another.
The source type is deduced and the target type must be specified, for example the
expression to`!int(42.0)` converts the number 42 from
`double` to `int`. The conversion is "safe", i.e.,
it checks for overflow; to!int(4.2e10) would throw the
ConvOverflowException exception. Overflow checks are only
inserted when necessary, e.g., ``to!double(42) does not do
any checking because any int fits in a double.
Conversions from string to numeric types differ from the C equivalents
atoi() and atol() by checking for overflow and not allowing whitespace.
For conversion of strings to signed types, the grammar recognized is:
Integer:
Sign UnsignedInteger
UnsignedInteger
Sign:
+
-
For conversion to unsigned types, the grammar recognized is:
UnsignedInteger:
DecimalDigit
DecimalDigit UnsignedInteger
Examples
Converting a value to its own type (useful mostly for generic code)
simply returns its argument.
int a = 42;
int b = to!int(a);
double c = to!double(3.14); // c is double with value 3.14
Converting among numeric types is a safe way to cast them around.
Conversions from floating-point types to integral types allow loss of
precision (the fractional part of a floating-point number). The
conversion is truncating towards zero, the same way a cast would
truncate. (To round a floating point value when casting to an
integral, use roundTo.)
import std.exception : assertThrown;

int a = 420;
assert(to!long(a) == a);
assertThrown!ConvOverflowException(to!byte(a));

assert(to!int(4.2e6) == 4200000);
assertThrown!ConvOverflowException(to!uint(-3.14));
assert(to!uint(3.14) == 3);
assert(to!uint(3.99) == 3);
assert(to!int(-3.99) == -3);
When converting strings to numeric types, note that D hexadecimal and binary
literals are not handled. Neither the prefixes that indicate the base, nor the
horizontal bar used to separate groups of digits are recognized. This also
applies to the suffixes that indicate the type.
To work around this, you can specify a radix for conversions involving numbers.
auto str = to!string(42, 16);
assert(str == "2A");
auto i = to!int(str, 16);
assert(i == 42);
Conversions from integral types to floating-point types always
succeed, but might lose accuracy. The largest integers with a
predecessor representable in floating-point format are 2^24-1 for
float, 2^53-1 for double, and 2^64-1 for real (when
real is 80-bit, e.g. on Intel machines).
// 2^24 - 1, largest proper integer representable as float
int a = 16_777_215;
assert(to!int(to!float(a)) == a);
assert(to!int(to!float(-a)) == -a);
Conversion from string types to char types enforces the input
to consist of a single code point, and said code point must
fit in the target type. Otherwise, ConvException is thrown.
import std.exception : assertThrown;

assert(to!char("a") == 'a');
assertThrown(to!char("ñ")); // 'ñ' does not fit into a char
assert(to!wchar("ñ") == 'ñ');
assertThrown(to!wchar("😃")); // '😃' does not fit into a wchar
assert(to!dchar("😃") == '😃');

// Using wstring or dstring as source type does not affect the result
assert(to!char("a"w) == 'a');
assert(to!char("a"d) == 'a');

// Two code points cannot be converted to a single one
assertThrown(to!char("ab"));
Converting an array to another array type works by converting each
element in turn. Associative arrays can be converted to associative
arrays as long as keys and values can in turn be converted.
import std.string : split;

int[] a = [1, 2, 3];
auto b = to!(float[])(a);
assert(b == [1.0f, 2, 3]);
string str = "1 2 3 4 5 6";
auto numbers = to!(double[])(split(str));
assert(numbers == [1.0, 2, 3, 4, 5, 6]);
int[string] c;
c["a"] = 1;
c["b"] = 2;
auto d = to!(double[wstring])(c);
assert(d["a"w] == 1 && d["b"w] == 2);
Conversions operate transitively, meaning that they work on arrays and
associative arrays of any complexity.
This conversion works because to`!short` applies to an `int`, to!wstring
applies to a string, to`!string` applies to a `double`, and
to!(double[]) applies to an int[]. The conversion might throw an
exception because ``to!short might fail the range check.
int[string][double[int[]]] a;
auto b = to!(short[wstring][string[double[]]])(a);
Object-to-object conversions by dynamic casting throw exception when
the source is non-null and the target is null.
import std.exception : assertThrown;
// Testing object conversions
class A {}
class B : A {}
class C : A {}
A a1 = new A, a2 = new B, a3 = new C;
assert(to!B(a2) is a2);
assert(to!C(a3) is a3);
assertThrown!ConvException(to!B(a3));
Stringize conversion from all types is supported.
String to string conversion works for any two string types having
    (char, wchar, dchar) character widths and any
    combination of qualifiers (mutable, const, or immutable).
Converts array (other than strings) to string.
    Each element is converted by calling ``to!T.
Associative array to string conversion.
    Each element is converted by calling ``to!T.
Object to string conversion calls toString against the object or
    returns "null" if the object is null.
Struct to string conversion calls toString against the struct if
    it is defined.
For structs that do not define toString, the conversion to string
    produces the list of fields.
Enumerated types are converted to strings as their symbolic names.
Boolean values are converted to "true" or "false".
char, wchar, dchar to a string type.
Unsigned or signed integers to strings.
  special case
  : Convert integral value to string in radix radix.
    radix must be a value from 2 to 36.
    value is treated as a signed value only if radix is 10.
    The characters A through Z are used to represent values 10 through 36
    and their case is determined by the letterCase parameter.
All floating point types to all string types.
Pointer to string conversions convert the pointer to a size_t value.
    If pointer is char*, treat it as C-style strings.
    In that case, this function is @system.
See formatValue on how toString should be defined.
// Conversion representing dynamic/static array with string
long[] a = [ 1, 3, 5 ];
assert(to!string(a) == "[1, 3, 5]");

// Conversion representing associative array with string
int[string] associativeArray = ["0":1, "1":2];
assert(to!string(associativeArray) == `["0":1, "1":2]` ||
       to!string(associativeArray) == `["1":2, "0":1]`);

// char* to string conversion
assert(to!string(cast(char*) null) == "");
assert(to!string("foo\0".ptr) == "foo");

// Conversion reinterpreting void array to string
auto w = "abcx"w;
const(void)[] b = w;
assert(b.length == 8);

auto c = to!(wchar[])(b);
assert(c == "abcx");
Strings can be converted to enum types. The enum member with the same name as the
input string is returned. The comparison is case-sensitive.
A ConvException is thrown if the enum does not have the specified member.
import std.exception : assertThrown;

enum E { a, b, c }
assert(to!E("a") == E.a);
assert(to!E("b") == E.b);
assertThrown!ConvException(to!E("A"));
to!
(alias) object.string = stringstring ~ "/" ~ 
(parameter) const(uom_quantity_unit_in_type.Unit) uu.
(field) long uom_quantity_unit_in_type.Unit.denden.
string std.conv.to!string.to!(const(long))(const(long) __param_0) pure nothrow @safe
The to template converts a value from one type to another.
The source type is deduced and the target type must be specified, for example the
expression to`!int(42.0)` converts the number 42 from
`double` to `int`. The conversion is "safe", i.e.,
it checks for overflow; to!int(4.2e10) would throw the
ConvOverflowException exception. Overflow checks are only
inserted when necessary, e.g., ``to!double(42) does not do
any checking because any int fits in a double.
Conversions from string to numeric types differ from the C equivalents
atoi() and atol() by checking for overflow and not allowing whitespace.
For conversion of strings to signed types, the grammar recognized is:
Integer:
Sign UnsignedInteger
UnsignedInteger
Sign:
+
-
For conversion to unsigned types, the grammar recognized is:
UnsignedInteger:
DecimalDigit
DecimalDigit UnsignedInteger
Examples
Converting a value to its own type (useful mostly for generic code)
simply returns its argument.
int a = 42;
int b = to!int(a);
double c = to!double(3.14); // c is double with value 3.14
Converting among numeric types is a safe way to cast them around.
Conversions from floating-point types to integral types allow loss of
precision (the fractional part of a floating-point number). The
conversion is truncating towards zero, the same way a cast would
truncate. (To round a floating point value when casting to an
integral, use roundTo.)
import std.exception : assertThrown;

int a = 420;
assert(to!long(a) == a);
assertThrown!ConvOverflowException(to!byte(a));

assert(to!int(4.2e6) == 4200000);
assertThrown!ConvOverflowException(to!uint(-3.14));
assert(to!uint(3.14) == 3);
assert(to!uint(3.99) == 3);
assert(to!int(-3.99) == -3);
When converting strings to numeric types, note that D hexadecimal and binary
literals are not handled. Neither the prefixes that indicate the base, nor the
horizontal bar used to separate groups of digits are recognized. This also
applies to the suffixes that indicate the type.
To work around this, you can specify a radix for conversions involving numbers.
auto str = to!string(42, 16);
assert(str == "2A");
auto i = to!int(str, 16);
assert(i == 42);
Conversions from integral types to floating-point types always
succeed, but might lose accuracy. The largest integers with a
predecessor representable in floating-point format are 2^24-1 for
float, 2^53-1 for double, and 2^64-1 for real (when
real is 80-bit, e.g. on Intel machines).
// 2^24 - 1, largest proper integer representable as float
int a = 16_777_215;
assert(to!int(to!float(a)) == a);
assert(to!int(to!float(-a)) == -a);
Conversion from string types to char types enforces the input
to consist of a single code point, and said code point must
fit in the target type. Otherwise, ConvException is thrown.
import std.exception : assertThrown;

assert(to!char("a") == 'a');
assertThrown(to!char("ñ")); // 'ñ' does not fit into a char
assert(to!wchar("ñ") == 'ñ');
assertThrown(to!wchar("😃")); // '😃' does not fit into a wchar
assert(to!dchar("😃") == '😃');

// Using wstring or dstring as source type does not affect the result
assert(to!char("a"w) == 'a');
assert(to!char("a"d) == 'a');

// Two code points cannot be converted to a single one
assertThrown(to!char("ab"));
Converting an array to another array type works by converting each
element in turn. Associative arrays can be converted to associative
arrays as long as keys and values can in turn be converted.
import std.string : split;

int[] a = [1, 2, 3];
auto b = to!(float[])(a);
assert(b == [1.0f, 2, 3]);
string str = "1 2 3 4 5 6";
auto numbers = to!(double[])(split(str));
assert(numbers == [1.0, 2, 3, 4, 5, 6]);
int[string] c;
c["a"] = 1;
c["b"] = 2;
auto d = to!(double[wstring])(c);
assert(d["a"w] == 1 && d["b"w] == 2);
Conversions operate transitively, meaning that they work on arrays and
associative arrays of any complexity.
This conversion works because to`!short` applies to an `int`, to!wstring
applies to a string, to`!string` applies to a `double`, and
to!(double[]) applies to an int[]. The conversion might throw an
exception because ``to!short might fail the range check.
int[string][double[int[]]] a;
auto b = to!(short[wstring][string[double[]]])(a);
Object-to-object conversions by dynamic casting throw exception when
the source is non-null and the target is null.
import std.exception : assertThrown;
// Testing object conversions
class A {}
class B : A {}
class C : A {}
A a1 = new A, a2 = new B, a3 = new C;
assert(to!B(a2) is a2);
assert(to!C(a3) is a3);
assertThrown!ConvException(to!B(a3));
Stringize conversion from all types is supported.
String to string conversion works for any two string types having
    (char, wchar, dchar) character widths and any
    combination of qualifiers (mutable, const, or immutable).
Converts array (other than strings) to string.
    Each element is converted by calling ``to!T.
Associative array to string conversion.
    Each element is converted by calling ``to!T.
Object to string conversion calls toString against the object or
    returns "null" if the object is null.
Struct to string conversion calls toString against the struct if
    it is defined.
For structs that do not define toString, the conversion to string
    produces the list of fields.
Enumerated types are converted to strings as their symbolic names.
Boolean values are converted to "true" or "false".
char, wchar, dchar to a string type.
Unsigned or signed integers to strings.
  special case
  : Convert integral value to string in radix radix.
    radix must be a value from 2 to 36.
    value is treated as a signed value only if radix is 10.
    The characters A through Z are used to represent values 10 through 36
    and their case is determined by the letterCase parameter.
All floating point types to all string types.
Pointer to string conversions convert the pointer to a size_t value.
    If pointer is char*, treat it as C-style strings.
    In that case, this function is @system.
See formatValue on how toString should be defined.
// Conversion representing dynamic/static array with string
long[] a = [ 1, 3, 5 ];
assert(to!string(a) == "[1, 3, 5]");

// Conversion representing associative array with string
int[string] associativeArray = ["0":1, "1":2];
assert(to!string(associativeArray) == `["0":1, "1":2]` ||
       to!string(associativeArray) == `["1":2, "0":1]`);

// char* to string conversion
assert(to!string(cast(char*) null) == "");
assert(to!string("foo\0".ptr) == "foo");

// Conversion reinterpreting void array to string
auto w = "abcx"w;
const(void)[] b = w;
assert(b.length == 8);

auto c = to!(wchar[])(b);
assert(c == "abcx");
Strings can be converted to enum types. The enum member with the same name as the
input string is returned. The comparison is case-sensitive.
A ConvException is thrown if the enum does not have the specified member.
import std.exception : assertThrown;

enum E { a, b, c }
assert(to!E("a") == E.a);
assert(to!E("b") == E.b);
assertThrown!ConvException(to!E("A"));
to!
(alias) object.string = stringstring ~ "] " ~ 
(local variable) const(string) basebase;
}

/// A quantity whose *unit* (dimension + rational scale) lives in the type. The
/// bare `double value` is expressed in that unit — nothing is normalized to
/// base units. Ordering-A composition would add a `Payload = double` parameter
/// (a `Vec3` for dimensioned vectors); this scalar prototype keeps it a `double`.
struct 
(struct) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 2, 0), 1L, 10000L))
A quantity whose unit (dimension + rational scale) lives in the type. The
bare double value is expressed in that unit — nothing is normalized to
base units. Ordering-A composition would add a Payload = double parameter
(a Vec3 for dimensioned vectors); this scalar prototype keeps it a double.Quantity(Unit U)
{
    double 
(field) double uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 2, 0), 1L, 10000L)).valuevalue;

    /// The unit carried by this type (dimension + scale), for introspection.
    alias 
(alias constant) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 2, 0), 1L, 10000L)).unit = uom_quantity_unit_in_type.Unit uom_quantity_unit_in_type.U = Unit(Dim(0, 2, 0), 1L, 10000L)
The unit carried by this type (dimension + scale), for introspection.unit = 
(constant) uom_quantity_unit_in_type.Unit uom_quantity_unit_in_type.U = Unit(Dim(0, 2, 0), 1L, 10000L)U;

    /// Compile-time label of this unit (used by `toString`).
    enum 
(alias) object.string = stringstring 
(constant) string uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 2, 0), 1L, 10000L)).symbol = "[1/10000] m^2"
Compile-time label of this unit (used by toString).symbol = 
string uom_quantity_unit_in_type.unitString(in uom_quantity_unit_in_type.Unit u) pure @safe
CTFE label for a whole unit: SI shorthand for the length units the raytracer
uses (m/cm/mm/um/nm), otherwise the base label with an explicit
rational scale annotation. GC-allocating, but only evaluated at compile time.unitString(
(constant) uom_quantity_unit_in_type.Unit uom_quantity_unit_in_type.U = Unit(Dim(0, 1, 0), 1L, 1L)U);

    /// Scale by a plain dimensionless scalar, keeping the unit.
    Quantity 
pure nothrow @nogc @safe Quantity opBinary(string op)(in double s) const
Scale by a plain dimensionless scalar, keeping the unit.opBinary(string op)(in double 
(parameter) double ss) const @safe pure nothrow @nogc
    if (op == "*" || op == "/")
        => Quantity(mixin("value " ~ op ~ " s"));

    /// `+`/`-` between two units of the **same dimension**: insert a *lazy*
    /// boundary conversion. The right operand is converted into *this* (the
    /// left) operand's unit by the compile-time `convFactor`, and the result is
    /// in the left unit. If the dimensions differ, this overload's constraint
    /// fails, no operator matches, and the addition does not compile.
    auto 
pure nothrow @nogc @safe auto opBinary(string op, Unit RU)(in Quantity!RU rhs) const
+/- between two units of the same dimension: insert a lazy
boundary conversion. The right operand is converted into this (the
left) operand's unit by the compile-time convFactor, and the result is
in the left unit. If the dimensions differ, this overload's constraint
fails, no operator matches, and the addition does not compile.opBinary(string op, Unit RU)(in 
(constant) uom_quantity_unit_in_type.Unit uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1000000000L)).RU = Unit(Dim(0, 1, 0), 1L, 1L)Quantity!
(unresolved type) RURU 
(parameter) Quantity!RU rhsrhs) const @safe pure nothrow @nogc
    if ((op == "+" || op == "-") && U.dim == RU.dim)
    {
        enum double 
(constant) double f = convFactor(RU, U)f = 
double uom_quantity_unit_in_type.convFactor(in uom_quantity_unit_in_type.Unit from, in uom_quantity_unit_in_type.Unit to) pure nothrow @nogc @safe
The lazy boundary conversion factor: multiply a value expressed in
from by this to re-express it in to (same dimension assumed). It is the
ratio of the two rational scales, (from.num/from.den) / (to.num/to.den),
evaluated to a double at the + site — the deferred conversion made
concrete. For nm → m it is 1e-9; for m → nm it is 1e9.convFactor(
(constant) uom_quantity_unit_in_type.Unit uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1000000000L)).RU = Unit(Dim(0, 1, 0), 1L, 1L)RU, 
(constant) uom_quantity_unit_in_type.Unit uom_quantity_unit_in_type.U = Unit(Dim(0, 1, 0), 1L, 1000000000L)U); // the deferred conversion, baked here
        return 
(template instance) Quantity!UQuantity!
(constant) uom_quantity_unit_in_type.Unit uom_quantity_unit_in_type.U = Unit(Dim(0, 1, 0), 1L, 1000000000L)U(mixin("value " ~ op ~ " rhs.value * f"));
    }

    /// `*`/`/` between quantities: dimensions and scales combine via
    /// `scaleCombine`; the numeric payloads multiply/divide directly. `cm * cm`
    /// is thus an area in `cm²` — a distinct type from `m²`, with scale tracked.
    auto 
pure nothrow @nogc @safe auto opBinary(string op, Unit RU)(in Quantity!RU rhs) const
*// between quantities: dimensions and scales combine via
scaleCombine; the numeric payloads multiply/divide directly. cm * cm
is thus an area in cm² — a distinct type from m², with scale tracked.opBinary(string op, Unit RU)(in 
(constant) uom_quantity_unit_in_type.Unit uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 100L)).RU = Unit(Dim(0, 1, 0), 1L, 100L)Quantity!
(unresolved type) RURU 
(parameter) Quantity!RU rhsrhs) const @safe pure nothrow @nogc
    if (op == "*" || op == "/")
    {
        enum 
(struct) uom_quantity_unit_in_type.Unit
A unit: a dimension plus a rational scale num/den to the base unit of
that dimension. This is the whole point of the prototype — the type carries
the unit, not just the dimension. Nanometre has the same dim as Metre
but den = 1e9, so they are distinct types. Kept normalized (den > 0,
gcd(num, den) == 1) by unit below, so scale equality is value equality.Unit 
(constant) Unit ru = scaleCombine(U, RU, op == "*" ? 1 : -1)ru = 
uom_quantity_unit_in_type.Unit uom_quantity_unit_in_type.scaleCombine(in uom_quantity_unit_in_type.Unit a, in uom_quantity_unit_in_type.Unit b, in int sign) pure nothrow @nogc @safe
The unit group operation for *//: dimensions combine (add/subtract
exponents) and scales multiply/divide as rationals, renormalized. So
cm * cm is an area whose scale is 1/10000 of m², tracked exactly.scaleCombine(
(constant) uom_quantity_unit_in_type.Unit uom_quantity_unit_in_type.U = Unit(Dim(0, 1, 0), 1L, 100L)U, 
(constant) uom_quantity_unit_in_type.Unit uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 100L)).RU = Unit(Dim(0, 1, 0), 1L, 100L)RU, 
(constant) string uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 100L)).op = "*"op == "*" ? 1 : -1);
        return 
(constant) uom_quantity_unit_in_type.Unit uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 100L)).opBinary!("*", Unit(Dim(0, 1, 0), 1L, 100L)).ru = Unit(Dim(0, 2, 0), 1L, 10000L)Quantity!
(constant) uom_quantity_unit_in_type.Unit uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 100L)).opBinary!("*", Unit(Dim(0, 1, 0), 1L, 100L)).ru = Unit(Dim(0, 2, 0), 1L, 10000L)ru(mixin("value " ~ op ~ " rhs.value"));
    }

    /// Render as `value symbol`, e.g. `2 m` or `500 nm`.
    
(alias) object.string = stringstring 
string uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 2, 0), 1L, 10000L)).toString() const pure @safe
Render as value symbol, e.g. 2 m or 500 nm.toString() const @safe
    {
        import 
(package) stdstd.
(module) std.array
Functions and types that manipulate built-in arrays and associative arrays.
This module provides all kinds of functions to create, manipulate or convert arrays:
Function Name 
Description 
| array |
Returns a copy of the input in a newly allocated dynamic array.
|
| appender |
Returns a new Appender or RefAppender initialized with a given array.
|
| assocArray |
Returns a newly allocated associative array from a range/ranges of keys and values.
|
| byPair |
Construct a range iterating over an associative array by key/value tuples.
|
| insertInPlace |
Inserts into an existing array at a given position.
|
| join |
Concatenates a range of ranges into one array.
|
| minimallyInitializedArray |
Returns a new array of type T.
|
| replace |
Returns a new array with all occurrences of a certain subrange replaced.
|
| replaceFirst |
Returns a new array with the first occurrence of a certain subrange replaced.
|
| replaceInPlace |
Replaces all occurrences of a certain subrange and puts the result into a given array.
|
| replaceInto |
Replaces all occurrences of a certain subrange and puts the result into an output range.
|
| replaceLast |
Returns a new array with the last occurrence of a certain subrange replaced.
|
| replaceSlice |
Returns a new array with a given slice replaced.
|
| replicate |
Creates a new array out of several copies of an input array or range.
|
| sameHead |
Checks if the initial segments of two arrays refer to the same
place in memory.
|
| sameTail |
Checks if the final segments of two arrays refer to the same place
in memory.
|
| split |
Eagerly split a range or string into an array.
|
| staticArray |
Creates a new static array from given data.
|
| uninitializedArray |
Returns a new array of type T without initializing its elements.
|
Source
std/array.d
@copyrightCopyright Andrei Alexandrescu 2008- and Jonathan M Davis 2011-.@licenseBoost License 1.0.@authorsAndrei Alexandrescu and
Jonathan M Davisarray : 
(alias template) appender = std.array.appender(A)() if (isDynamicArray!A)
Convenience function that returns an $(LREF Appender) instance,
    optionally initialized with array.appender;
        import 
(package) stdstd.
(module) std.format
This package provides string formatting functionality using
printf style format strings.
Submodule 
Function Name 
Description 
package 
format 
Converts its arguments according to a format string into a string. 
|     package |
sformat |
Converts its arguments according to a format string into a buffer. |
|     package |
FormatException |
Signals a problem while formatting. |
|     write |
formattedWrite |
Converts its arguments according to a format string and writes
the result to an output range. |
|     write |
formatValue |
Formats a value of any type according to a format specifier and
writes the result to an output range. |
|     read |
formattedRead |
Reads an input range according to a format string and stores the read
values into its arguments. |
|     read |
unformatValue |
Reads a value from the given input range and converts it according to
a format specifier. |
|     spec |
FormatSpec |
A general handler for format strings. |
|     spec |
singleSpec |
Helper function that returns a FormatSpec for a single format specifier. |
Limitation
This package does not support localization, but
adheres to the rounding mode of the floating point unit, if
available.
Format Strings
The functions contained in this package use format strings. A
format string describes the layout of another string for reading or
writing purposes. A format string is composed of normal text
interspersed with format specifiers. A format specifier starts
with a percentage sign '%', optionally followed by one or more
parameters and ends with a format indicator. A format
indicator may be a simple format character or a compound
indicator.
Format strings are composed according to the following grammar:
FormatString:
FormatStringItem FormatString
FormatStringItem:
Character
FormatSpecifier
FormatSpecifier:
'%' Parameters FormatIndicator
FormatIndicator:
FormatCharacter
CompoundIndicator
FormatCharacter:
see remark below
CompoundIndicator:
'(' FormatString '%)'
'(' FormatString '%|' Delimiter '%)'
Delimiter
empty
Character Delimiter
Parameters:
Position Flags Width Precision Separator
Position:
empty
Integer '$'**
*Integer* **':'** *Integer* **'$'
Integer ':' '$'**
*Flags*:
*empty*
*Flag* *Flags*
*Flag*:
**'-'**|**'+'**|**'&nbsp;'**|**'0'**|**'#'**|**'='**
*Width*:
*OptionalPositionalInteger*
*Precision*:
*empty*
**'.'** *OptionalPositionalInteger*
*Separator*:
*empty*
**','** *OptionalInteger*
**','** *OptionalInteger* **'?'**
*OptionalInteger*:
*empty*
*Integer*
**'*'**
*OptionalPositionalInteger*:
*OptionalInteger*
**'*'** *Integer* **'$'
Character
'%%'
AnyCharacterExceptPercent
Integer:
NonZeroDigit Digits
Digits:
empty
Digit Digits
NonZeroDigit:
'1'|'2'|'3'|'4'|'5'|'6'|'7'|'8'|'9'
Digit:
'0'|'1'|'2'|'3'|'4'|'5'|'6'|'7'|'8'|'9'
Note
FormatCharacter is unspecified. It can be any character
that has no other purpose in this grammar, but it is
recommended to assign (lower- and uppercase) letters.
Note
The Parameters of a CompoundIndicator are currently
limited to a '-' flag.
Format Indicator
The format indicator can either be a single character or an
expression surrounded by '%(' and '%)'. It specifies the
basic manner in which a value will be formatted and is the minimum
requirement to format a value.
The following characters can be used as format characters:
FormatCharacter 
Semantics 
's' 
To be formatted in a human readable format.
Can be used with all types. 
'c' 
To be formatted as a character. 
'd' 
To be formatted as a signed decimal integer. 
'u' 
To be formatted as a decimal image of the underlying bit representation. 
'b' 
To be formatted as a binary image of the underlying bit representation. 
'o' 
To be formatted as an octal image of the underlying bit representation. 
'x' / 'X' 
To be formatted as a hexadecimal image of the underlying bit representation. 
'e' / 'E' 
To be formatted as a real number in decimal scientific notation. 
'f' / 'F' 
To be formatted as a real number in decimal natural notation. 
'g' / 'G' 
To be formatted as a real number in decimal short notation.
Depending on the number, a scientific notation or
a natural notation is used. 
'a' / 'A' 
To be formatted as a real number in hexadecimal scientific notation. 
'r' 
To be formatted as raw bytes.
The output may not be printable and depends on endianness. 
The compound indicator can be used to describe compound types
like arrays or structs in more detail. A compound type is enclosed
within '%(' and '%)'. The enclosed sub-format string is
applied to individual elements. The trailing portion of the
sub-format string following the specifier for the element is
interpreted as the delimiter, and is therefore omitted following the
last element. The '%|' specifier may be used to explicitly
indicate the start of the delimiter, so that the preceding portion of
the string will be included following the last element.
The format string inside of the compound indicator should
contain exactly one format specifier (two in case of associative
arrays), which specifies the formatting mode of the elements of the
compound type. This format specifier can be a compound
indicator itself.
Note
Inside a compound indicator, strings and characters are
escaped automatically. To avoid this behavior, use "%-("
instead of "%(".
Flags
There are several flags that affect the outcome of the formatting.
Flag 
Semantics 
'-' 
When the formatted result is shorter than the value
given by the width parameter, the output is left
justified. Without the '-' flag, the output remains
right justified.
There are two exceptions where the '-' flag has a
different meaning: (1) with 'r' it denotes to use little
endian and (2) in case of a compound indicator it means that
no special handling of the members is applied. |
| '=' |
When the formatted result is shorter than the value
given by the width parameter, the output is centered.
If the central position is not possible it is moved slightly
to the right. In this case, if '-' flag is present in
addition to the '=' flag, it is moved slightly to the left. |
| '+'&nbsp;/&nbsp;*'&nbsp;'* |
Applies to numerical values. By default, positive numbers are not
formatted to include the + sign. With one of these two flags present,
positive numbers are preceded by a plus sign or a space.
When both flags are present, a plus sign is used.
In case of 'r', a big endian format is used. |
| '0' |
Is applied to numerical values that are printed right justified.
If the zero flag is present, the space left to the number is
filled with zeros instead of spaces. |
| '#' |
Denotes that an alternative output must be used. This depends on the type
to be formatted and the format character used. See the
sections below for more information. |
Width, Precision and Separator
The width parameter specifies the minimum width of the result.
The meaning of precision depends on the format indicator. For
integers it denotes the minimum number of digits printed, for
real numbers it denotes the number of fractional digits and for
strings and compound types it denotes the maximum number of elements
that are included in the output.
A separator is used for formatting numbers. If it is specified,
the output is divided into chunks of three digits, separated by a ','. The number of digits in a chunk can be given explicitly by
providing a number or a ''* after the ','.
In all three cases the number of digits can be replaced by a ''*. In this scenario, the next argument is used as the number of
digits. If the argument is a negative number, the precision and
separator parameters are considered unspecified. For width,
the absolute value is used and the '-' flag is set.
The separator can also be followed by a '?'. In that case,
an additional argument is used to specify the symbol that should be
used to separate the chunks.
Position
By default, the arguments are processed in the provided order. With
the position parameter it is possible to address arguments
directly. It is also possible to denote a series of arguments with
two numbers separated by ':', that are all processed in the same
way. The second number can be omitted. In that case the series ends
with the last argument.
It's also possible to use positional arguments for width, precision and separator by adding a number and a '$' after the ''*.
Types
This section describes the result of combining types with format
characters. It is organized in 2 subsections: a list of general
information regarding the formatting of types in the presence of
format characters and a table that contains details for every
available combination of type and format character.
When formatting types, the following rules apply:
If the format character is upper case, the resulting string will
    be formatted using upper case letters.
The default precision for floating point numbers is 6 digits.
Rounding of floating point numbers adheres to the rounding mode
    of the floating point unit, if available.
The floating point values NaN and Infinity are formatted as
    nan and inf, possibly preceded by '+' or '-' sign.
Formatting reals is only supported for 64 bit reals and 80 bit reals.
    All other reals are cast to double before they are formatted. This will
    cause the result to be inf for very large numbers.
Characters and strings formatted with the 's' format character
    inside of compound types are surrounded by single and double quotes
    and unprintable characters are escaped. To avoid this, a '-'
    flag can be specified for the compound specifier
    (e.g. "%-(%s%)" instead of "%(%s%)" ).
Structs, unions, classes and interfaces are formatted by calling a
    toString method if available.
    See module std.format.write for more
    details.
Only part of these combinations can be used for reading. See
    module std.format.read for more
    detailed information.
This table contains descriptions for every possible combination of
type and format character:
<th scope="col" width="20%">Type</th> <th scope="col" width="20%">Format Character</th>  Formatted as... 
<td rowspan="1">null</td> 's' 
null 
|<td rowspan="3">bool</td> 's' |
false or true |
| 'b', 'd', 'o', 'u', 'x', 'X' |
As the integrals 0 or 1 with the same format character.
Please note, that 'o' and 'x' with '#' flag
might produce unexpected results due to special handling of
the value 0. |
| 'r' |
\0 or \1 |
|<td rowspan="4">Integral</td> 's', 'd' |
A signed decimal number. The '#' flag is ignored. |
| 'b', 'o', 'u', 'x', 'X' |
An unsigned binary, decimal, octal or hexadecimal number.
In case of 'o' and 'x', the '#' flag
denotes that the number must be preceded by 0 and 0x, with
the exception of the value 0, where this does not apply. For
'b' and 'u' the '#' flag has no effect. |
| 'e', 'E', 'f', 'F', 'g', 'G', 'a', 'A' |
As a floating point value with the same specifier.
Default precision is large enough to add all digits
of the integral value.
In case of 'a' and 'A', the integral digit can be
any hexadecimal digit.
|
| 'r' |
Characters taken directly from the binary representation. |
|<td rowspan="5">Floating Point</td> 'e', 'E' |
Scientific notation: Exactly one integral digit followed by a dot
and fractional digits, followed by the exponent.
The exponent is formatted as 'e' followed by
a '+' or '-' sign, followed by at least
two digits.
When there are no fractional digits and the '#' flag
is not present, the dot is omitted. |
| 'f', 'F' |
Natural notation: Integral digits followed by a dot and
fractional digits.
When there are no fractional digits and the '#' flag
is not present, the dot is omitted.
Please note: the difference between 'f' and 'F'
is only visible for NaN and Infinity. |
| 's', 'g', 'G' |
Short notation: If the absolute value is larger than 10 ^^ precision
or smaller than 0.0001, the scientific notation is used.
If not, the natural notation is applied.
In both cases precision denotes the count of all digits, including
the integral digits. Trailing zeros (including a trailing dot) are removed.
If '#' flag is present, trailing zeros are not removed. |
| 'a', 'A' |
Hexadecimal scientific notation: 0x followed by 1
(or 0 in case of value zero or denormalized number)
followed by a dot, fractional digits in hexadecimal
notation and an exponent. The exponent is build by p,
followed by a sign and the exponent in decimal notation.
When there are no fractional digits and the '#' flag
is not present, the dot is omitted. |
| 'r' |
Characters taken directly from the binary representation. |
|<td rowspan="3">Character</td> 's', 'c' |
As the character.
Inside of a compound indicator 's' is treated differently: The
character is surrounded by single quotes and non printable
characters are escaped. This can be avoided by preceding
the compound indicator with a '-' flag
(e.g. "%-(%s%)"). |
| 'b', 'd', 'o', 'u', 'x', 'X' |
As the integral that represents the character. |
| 'r' |
Characters taken directly from the binary representation. |
|<td rowspan="3">String</td> 's' |
The sequence of characters that form the string.
Inside of a compound indicator the string is surrounded by double quotes
and non printable characters are escaped. This can be avoided
by preceding the compound indicator with a '-' flag
(e.g. "%-(%s%)"). |
| 'r' |
The sequence of characters, each formatted with 'r'. |
| compound |
As an array of characters. |
|<td rowspan="3">Array</td> 's' |
When the elements are characters, the array is formatted as
a string. In all other cases the array is surrounded by square brackets
and the elements are separated by a comma and a space. If the elements
are strings, they are surrounded by double quotes and non
printable characters are escaped. |
| 'r' |
The sequence of the elements, each formatted with 'r'. |
| compound |
The sequence of the elements, each formatted according to the specifications
given inside of the compound specifier. |
|<td rowspan="2">Associative Array</td> 's' |
As a sequence of the elements in unpredictable order. The output is
surrounded by square brackets. The elements are separated by a
comma and a space. The elements are formatted as key:value. |
| compound |
As a sequence of the elements in unpredictable order. Each element
is formatted according to the specifications given inside of the
compound specifier. The first specifier is used for formatting
the key and the second specifier is used for formatting the value.
The order can be changed with positional arguments. For example
"%(%2$s (%1$s), %)" will write the value, followed by the key in
parenthesis. |
|<td rowspan="2">Enum</td> 's' |
The name of the value. If the name is not available, the base value
is used, preceeded by a cast. |
| All, but 's' |
Enums can be formatted with all format characters that can be used
with the base value. In that case they are formatted like the base value. |
|<td rowspan="3">Input Range</td> 's' |
When the elements of the range are characters, they are written like a string.
In all other cases, the elements are enclosed by square brackets and separated
by a comma and a space. |
| 'r' |
The sequence of the elements, each formatted with 'r'. |
| compound |
The sequence of the elements, each formatted according to the specifications
given inside of the compound specifier. |
|<td rowspan="1">Struct</td> 's' |
When the struct has neither an applicable toString
nor is an input range, it is formatted as follows:
StructType(field1, field2, ...). |
|<td rowspan="1">Class</td> 's' |
When the class has neither an applicable toString
nor is an input range, it is formatted as the
fully qualified name of the class. |
|<td rowspan="1">Union</td> 's' |
When the union has neither an applicable toString
nor is an input range, it is formatted as its base name. |
|<td rowspan="2">Pointer</td> 's' |
A null pointer is formatted as 'null'. All other pointers are
formatted as hexadecimal numbers with the format character 'X'. |
| 'x', 'X' |
Formatted as a hexadecimal number. |
|<td rowspan="3">SIMD vector</td> 's' |
The array is surrounded by square brackets
and the elements are separated by a comma and a space. |
| 'r' |
The sequence of the elements, each formatted with 'r'. |
| compound |
The sequence of the elements, each formatted according to the specifications
given inside of the compound specifier. |
|<td rowspan="1">Delegate</td> 's', 'r', compound |
As the .stringof of this delegate treated as a string.
Please note: The implementation is currently buggy
and its use is discouraged. |
Source
std/format/package.d
Examples
Simple use:
// Easiest way is to use `%s` everywhere:
assert(format("I got %s %s for %s euros.", 30, "eggs", 5.27) == "I got 30 eggs for 5.27 euros.");

// Other format characters provide more control:
assert(format("I got %b %(%X%) for %f euros.", 30, "eggs", 5.27) == "I got 11110 65676773 for 5.270000 euros.");
Compound specifiers allow formatting arrays and other compound types:
/*
The trailing end of the sub-format string following the specifier for
each item is interpreted as the array delimiter, and is therefore
omitted following the last array item:
 */
    assert(format("My items are %(%s %).", [1,2,3]) == "My items are 1 2 3.");
    assert(format("My items are %(%s, %).", [1,2,3]) == "My items are 1, 2, 3.");

/*
The "%|" delimiter specifier may be used to indicate where the
delimiter begins, so that the portion of the format string prior to
it will be retained in the last array element:
 */
    assert(format("My items are %(-%s-%|, %).", [1,2,3]) == "My items are -1-, -2-, -3-.");

/*
These compound format specifiers may be nested in the case of a
nested array argument:
 */
    auto mat = [[1, 2, 3],
                [4, 5, 6],
                [7, 8, 9]];

    assert(format("%(%(%d %) - %)", mat), "1 2 3 - 4 5 6 - 7 8 9");
    assert(format("[%(%(%d %) - %)]", mat), "[1 2 3 - 4 5 6 - 7 8 9]");
    assert(format("[%([%(%d %)]%| - %)]", mat), "[1 2 3] - [4 5 6] - [7 8 9]");

/*
Strings and characters are escaped automatically inside compound
format specifiers. To avoid this behavior, use "%-(" instead of "%(":
 */
    assert(format("My friends are %s.", ["John", "Nancy"]) == `My friends are ["John", "Nancy"].`);
    assert(format("My friends are %(%s, %).", ["John", "Nancy"]) == `My friends are "John", "Nancy".`);
    assert(format("My friends are %-(%s, %).", ["John", "Nancy"]) == `My friends are John, Nancy.`);
Using parameters:
// Flags can be used to influence to outcome:
assert(format("%g != %+#g", 3.14, 3.14) == "3.14 != +3.14000");

// Width and precision help to arrange the formatted result:
assert(format(">%10.2f<", 1234.56789) == ">   1234.57<");

// Numbers can be grouped:
assert(format("%,4d", int.max) == "21,4748,3647");

// It's possible to specify the position of an argument:
assert(format("%3$s %1$s", 3, 17, 5) == "5 3");
Providing parameters as arguments:
// Width as argument
assert(format(">%*s<", 10, "abc") == ">       abc<");

// Precision as argument
assert(format(">%.*f<", 5, 123.2) == ">123.20000<");

// Grouping as argument
assert(format("%,*d", 1, int.max) == "2,1,4,7,4,8,3,6,4,7");

// Grouping separator as argument
assert(format("%,3?d", '_', int.max) == "2_147_483_647");

// All at once
assert(format("%*.*,*?d", 20, 15, 6, '/', int.max) == "   000/002147/483647");
@copyrightCopyright The D Language Foundation 2000-2021.@licenseBoost License 1.0.@authorsWalter Bright, Andrei Alexandrescu, and Kenji Haraformat : 
(alias template) formattedWrite = std.format.write.formattedWrite(Writer, Char, Args...)(auto ref Writer w, scope const Char[] fmt, Args args)
Converts its arguments according to a format string and writes
the result to an output range.
The second version of formattedWrite takes the format string as a
template argument. In this case, it is checked for consistency at
compile-time.
Params:
    w = an $(REF_ALTTEXT output range, isOutputRange, std, range, primitives),
        where the formatted result is written to
    fmt = a $(MREF_ALTTEXT format string, std,format)
    args = a variadic list of arguments to be formatted
    Writer = the type of the writer w
    Char = character type of fmt
    Args = a variadic list of types of the arguments
Returns:
    The index of the last argument that was formatted. If no positional
    arguments are used, this is the number of arguments that where formatted.
Throws:
    A $(REF_ALTTEXT FormatException, FormatException, std, format)
    if formatting did not succeed.
Note:
    In theory this function should be @nogc. But with the current
    implementation there are some cases where allocations occur.
    See $(REF_ALTTEXT $(D sformat), sformat, std, format) for more details.formattedWrite;

        auto 
(local variable) std.array.Appender!string sinksink = 
std.array.Appender!string std.array.appender!string() pure nothrow @safe
Convenience function that returns an Appender instance,
optionally initialized with array.appender!
(alias) object.string = stringstring();
        
uint std.format.write.formattedWrite!(std.array.Appender!string, char, const(double), string)(ref std.array.Appender!string w, scope const(char[]) fmt, const(double) __param_2, string __param_3) pure @safe
Converts its arguments according to a format string and writes
the result to an output range.
The second version of formattedWrite takes the format string as a
template argument. In this case, it is checked for consistency at
compile-time.
Note
In theory this function should be @nogc. But with the current
implementation there are some cases where allocations occur.
See sformat for more details.
Examples
import std.array : appender;

auto writer1 = appender!string();
formattedWrite(writer1, "%s is the ultimate %s.", 42, "answer");
assert(writer1[] == "42 is the ultimate answer.");

auto writer2 = appender!string();
formattedWrite(writer2, "Increase: %7.2f %%", 17.4285);
assert(writer2[] == "Increase:   17.43 %");
@paramw an output range, where the formatted result is written to@paramfmt a format string@paramargs a variadic list of arguments to be formatted@paramWriter the type of the writer w@paramChar character type of fmt@paramArgs a variadic list of types of the arguments@returnsThe index of the last argument that was formatted. If no positional
arguments are used, this is the number of arguments that where formatted.@throwsA FormatException
if formatting did not succeed.formattedWrite(
(local variable) std.array.Appender!string sinksink, "%.7g %s", 
(field) double uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 2, 0), 1L, 10000L)).valuevalue, 
(constant) string uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 2, 0), 1L, 10000L)).symbol = "[1/10000] m^2"
Compile-time label of this unit (used by toString).symbol);
        return 
(local variable) std.array.Appender!string sinksink[];
    }
}

enum 
(struct) uom_quantity_unit_in_type.Dim
A dimension: an exponent vector in the free abelian group ℤ³ over the base
dimensions (mass, length, time), stored directly as its normal form.Dim 
(constant) uom_quantity_unit_in_type.Dim uom_quantity_unit_in_type.lengthDim = Dim(0, 1, 0)lengthDim = 
(struct) uom_quantity_unit_in_type.Dim
A dimension: an exponent vector in the free abelian group ℤ³ over the base
dimensions (mass, length, time), stored directly as its normal form.Dim(length: 1);
enum 
(struct) uom_quantity_unit_in_type.Dim
A dimension: an exponent vector in the free abelian group ℤ³ over the base
dimensions (mass, length, time), stored directly as its normal form.Dim 
(constant) uom_quantity_unit_in_type.Dim uom_quantity_unit_in_type.timeDim = Dim(0, 0, 1)timeDim = 
(struct) uom_quantity_unit_in_type.Dim
A dimension: an exponent vector in the free abelian group ℤ³ over the base
dimensions (mass, length, time), stored directly as its normal form.Dim(time: 1);

enum 
(struct) uom_quantity_unit_in_type.Unit
A unit: a dimension plus a rational scale num/den to the base unit of
that dimension. This is the whole point of the prototype — the type carries
the unit, not just the dimension. Nanometre has the same dim as Metre
but den = 1e9, so they are distinct types. Kept normalized (den > 0,
gcd(num, den) == 1) by unit below, so scale equality is value equality.Unit 
(constant) uom_quantity_unit_in_type.Unit uom_quantity_unit_in_type.metre = Unit(Dim(0, 1, 0), 1L, 1L)metre = 
(struct) uom_quantity_unit_in_type.Unit
A unit: a dimension plus a rational scale num/den to the base unit of
that dimension. This is the whole point of the prototype — the type carries
the unit, not just the dimension. Nanometre has the same dim as Metre
but den = 1e9, so they are distinct types. Kept normalized (den > 0,
gcd(num, den) == 1) by unit below, so scale equality is value equality.Unit(
(constant) uom_quantity_unit_in_type.Dim uom_quantity_unit_in_type.lengthDim = Dim(0, 1, 0)lengthDim, 1, 1);
enum 
(struct) uom_quantity_unit_in_type.Unit
A unit: a dimension plus a rational scale num/den to the base unit of
that dimension. This is the whole point of the prototype — the type carries
the unit, not just the dimension. Nanometre has the same dim as Metre
but den = 1e9, so they are distinct types. Kept normalized (den > 0,
gcd(num, den) == 1) by unit below, so scale equality is value equality.Unit 
(constant) uom_quantity_unit_in_type.Unit uom_quantity_unit_in_type.centimetre = Unit(Dim(0, 1, 0), 1L, 100L)centimetre = 
(struct) uom_quantity_unit_in_type.Unit
A unit: a dimension plus a rational scale num/den to the base unit of
that dimension. This is the whole point of the prototype — the type carries
the unit, not just the dimension. Nanometre has the same dim as Metre
but den = 1e9, so they are distinct types. Kept normalized (den > 0,
gcd(num, den) == 1) by unit below, so scale equality is value equality.Unit(
(constant) uom_quantity_unit_in_type.Dim uom_quantity_unit_in_type.lengthDim = Dim(0, 1, 0)lengthDim, 1, 100);
enum 
(struct) uom_quantity_unit_in_type.Unit
A unit: a dimension plus a rational scale num/den to the base unit of
that dimension. This is the whole point of the prototype — the type carries
the unit, not just the dimension. Nanometre has the same dim as Metre
but den = 1e9, so they are distinct types. Kept normalized (den > 0,
gcd(num, den) == 1) by unit below, so scale equality is value equality.Unit 
(constant) uom_quantity_unit_in_type.Unit uom_quantity_unit_in_type.nanometre = Unit(Dim(0, 1, 0), 1L, 1000000000L)nanometre = 
(struct) uom_quantity_unit_in_type.Unit
A unit: a dimension plus a rational scale num/den to the base unit of
that dimension. This is the whole point of the prototype — the type carries
the unit, not just the dimension. Nanometre has the same dim as Metre
but den = 1e9, so they are distinct types. Kept normalized (den > 0,
gcd(num, den) == 1) by unit below, so scale equality is value equality.Unit(
(constant) uom_quantity_unit_in_type.Dim uom_quantity_unit_in_type.lengthDim = Dim(0, 1, 0)lengthDim, 1, 1_000_000_000);
enum 
(struct) uom_quantity_unit_in_type.Unit
A unit: a dimension plus a rational scale num/den to the base unit of
that dimension. This is the whole point of the prototype — the type carries
the unit, not just the dimension. Nanometre has the same dim as Metre
but den = 1e9, so they are distinct types. Kept normalized (den > 0,
gcd(num, den) == 1) by unit below, so scale equality is value equality.Unit 
(constant) uom_quantity_unit_in_type.Unit uom_quantity_unit_in_type.second = Unit(Dim(0, 0, 1), 1L, 1L)second = 
(struct) uom_quantity_unit_in_type.Unit
A unit: a dimension plus a rational scale num/den to the base unit of
that dimension. This is the whole point of the prototype — the type carries
the unit, not just the dimension. Nanometre has the same dim as Metre
but den = 1e9, so they are distinct types. Kept normalized (den > 0,
gcd(num, den) == 1) by unit below, so scale equality is value equality.Unit(
(constant) uom_quantity_unit_in_type.Dim uom_quantity_unit_in_type.timeDim = Dim(0, 0, 1)timeDim, 1, 1);

/// Scene distances live in metres; spectral wavelengths in nanometres.
alias 
(alias) uom_quantity_unit_in_type.Metre = uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1L))
Scene distances live in metres; spectral wavelengths in nanometres.Metre = 
(constant) uom_quantity_unit_in_type.Unit uom_quantity_unit_in_type.metre = Unit(Dim(0, 1, 0), 1L, 1L)Quantity!
(constant) uom_quantity_unit_in_type.Unit uom_quantity_unit_in_type.metre = Unit(Dim(0, 1, 0), 1L, 1L)metre;
alias 
(alias) uom_quantity_unit_in_type.Centimetre = uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 100L))Centimetre = 
(constant) uom_quantity_unit_in_type.Unit uom_quantity_unit_in_type.centimetre = Unit(Dim(0, 1, 0), 1L, 100L)Quantity!
(constant) uom_quantity_unit_in_type.Unit uom_quantity_unit_in_type.centimetre = Unit(Dim(0, 1, 0), 1L, 100L)centimetre;
alias 
(alias) uom_quantity_unit_in_type.Nanometre = uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1000000000L))Nanometre = 
(constant) uom_quantity_unit_in_type.Unit uom_quantity_unit_in_type.nanometre = Unit(Dim(0, 1, 0), 1L, 1000000000L)Quantity!
(constant) uom_quantity_unit_in_type.Unit uom_quantity_unit_in_type.nanometre = Unit(Dim(0, 1, 0), 1L, 1000000000L)nanometre;
alias 
(alias) uom_quantity_unit_in_type.Second = uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 0, 1), 1L, 1L))Second = 
(constant) uom_quantity_unit_in_type.Unit uom_quantity_unit_in_type.second = Unit(Dim(0, 0, 1), 1L, 1L)Quantity!
(constant) uom_quantity_unit_in_type.Unit uom_quantity_unit_in_type.second = Unit(Dim(0, 0, 1), 1L, 1L)second;

@("Quantity.unit-in-type.lazy-conversion-and-cross-dimension-rejection")
@safe pure nothrow @nogc
unittest
{
    // Same dimension, DIFFERENT units — distinct types.
    static assert(!is(
(alias) uom_quantity_unit_in_type.Metre = uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1L))
Scene distances live in metres; spectral wavelengths in nanometres.Metre == Nanometre));
    static assert(
(struct) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1L))Metre.
(constant) uom_quantity_unit_in_type.Unit uom_quantity_unit_in_type.U = Unit(Dim(0, 1, 0), 1L, 1L)unit.
(field) uom_quantity_unit_in_type.Dim uom_quantity_unit_in_type.Unit.dimdim == 
(struct) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1000000000L))Nanometre.
(constant) uom_quantity_unit_in_type.Unit uom_quantity_unit_in_type.U = Unit(Dim(0, 1, 0), 1L, 1000000000L)unit.
(field) uom_quantity_unit_in_type.Dim uom_quantity_unit_in_type.Unit.dimdim);

    auto 
(local variable) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1L)) distancedistance = 
(struct) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1L))Metre(2.0);          // 2 m, scene scale
    auto 
(local variable) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1000000000L)) wavelengthwavelength = 
(struct) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1000000000L))Nanometre(500.0);  // 500 nm, spectral scale

    // distance + wavelength : convert the nm operand into metres, lazily.
    auto 
(local variable) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1L)) d1d1 = 
(local variable) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1L)) distancedistance + 
uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1L)) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1L)).opBinary!("+", Unit(Dim(0, 1, 0), 1L, 1000000000L))(in uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1000000000L)) rhs) const pure nothrow @nogc @safe
+/- between two units of the same dimension: insert a lazy
boundary conversion. The right operand is converted into this (the
left) operand's unit by the compile-time convFactor, and the result is
in the left unit. If the dimensions differ, this overload's constraint
fails, no operator matches, and the addition does not compile.wavelength;
    static assert(
(local variable) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1L)) d1d1.
(constant) uom_quantity_unit_in_type.Unit uom_quantity_unit_in_type.U = Unit(Dim(0, 1, 0), 1L, 1L)unit == 
(constant) uom_quantity_unit_in_type.Unit uom_quantity_unit_in_type.metre = Unit(Dim(0, 1, 0), 1L, 1L)metre); // result is in the LEFT operand's unit
    assert(
(local variable) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1L)) d1d1.
(field) double uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1L)).valuevalue == 2.0 + 500.0 * 1e-9);

    // wavelength + distance : now the metre operand converts into nanometres.
    auto 
(local variable) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1000000000L)) d2d2 = 
(local variable) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1000000000L)) wavelengthwavelength + 
uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1000000000L)) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1000000000L)).opBinary!("+", Unit(Dim(0, 1, 0), 1L, 1L))(in uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1L)) rhs) const pure nothrow @nogc @safe
+/- between two units of the same dimension: insert a lazy
boundary conversion. The right operand is converted into this (the
left) operand's unit by the compile-time convFactor, and the result is
in the left unit. If the dimensions differ, this overload's constraint
fails, no operator matches, and the addition does not compile.distance;
    static assert(
(local variable) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1000000000L)) d2d2.
(constant) uom_quantity_unit_in_type.Unit uom_quantity_unit_in_type.U = Unit(Dim(0, 1, 0), 1L, 1000000000L)unit == 
(constant) uom_quantity_unit_in_type.Unit uom_quantity_unit_in_type.nanometre = Unit(Dim(0, 1, 0), 1L, 1000000000L)nanometre);
    assert(
(local variable) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1000000000L)) d2d2.
(field) double uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1000000000L)).valuevalue == 500.0 + 2.0 * 1e9);

    // Cross-dimension addition is REJECTED: no operator matches (constraint
    // `U.dim == RU.dim` fails). The assert holds because the `+` does not exist.
    static assert(!__traits(compiles, 
(struct) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1L))Metre(1.0) + 
(struct) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 0, 1), 1L, 1L))Second(1.0)),
        "adding a length to a time must not compile");

    // Multiplication tracks the scale: cm * cm is an area in cm², not m².
    auto 
(local variable) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 2, 0), 1L, 10000L)) areaarea = 
(struct) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 100L))Centimetre(3.0) * 
uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 2, 0), 1L, 10000L)) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 100L)).opBinary!("*", Unit(Dim(0, 1, 0), 1L, 100L))(in uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 100L)) rhs) const pure nothrow @nogc @safe
*// between quantities: dimensions and scales combine via
scaleCombine; the numeric payloads multiply/divide directly. cm * cm
is thus an area in cm² — a distinct type from m², with scale tracked.Centimetre(4.0);
    static assert(
(local variable) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 2, 0), 1L, 10000L)) areaarea.
(constant) uom_quantity_unit_in_type.Unit uom_quantity_unit_in_type.U = Unit(Dim(0, 2, 0), 1L, 10000L)unit == 
(struct) uom_quantity_unit_in_type.Unit
A unit: a dimension plus a rational scale num/den to the base unit of
that dimension. This is the whole point of the prototype — the type carries
the unit, not just the dimension. Nanometre has the same dim as Metre
but den = 1e9, so they are distinct types. Kept normalized (den > 0,
gcd(num, den) == 1) by unit below, so scale equality is value equality.Unit(
(struct) uom_quantity_unit_in_type.Dim
A dimension: an exponent vector in the free abelian group ℤ³ over the base
dimensions (mass, length, time), stored directly as its normal form.Dim(length: 2), 1, 10_000));
    assert(
(local variable) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 2, 0), 1L, 10000L)) areaarea.
(field) double uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 2, 0), 1L, 10000L)).valuevalue == 12.0);
}

void 
void D main() @safemain() @safe
{
    import 
(package) stdstd.
(module) std.stdio
Category 
Symbols 
File handles 
_popen File isFileHandle openNetwork stderr stdin stdout 
Reading 
chunks lines readf readfln readln 
Writing 
toFile write writef writefln writeln 
Misc 
KeepTerminator LockType StdioException 
Standard I/O functions that extend core.stdc.stdio.  core.stdc.stdio
is publically imported when importing std.stdio.
There are three layers of I/O:
The lowest layer is the operating system layer. The two main schemes are Windows and Posix.
C's stdio.h which unifies the two operating system schemes.
std.stdio, this module, unifies the various stdio.h implementations into
    a high level package for D programs.
Source
std/stdio.d
@copyrightCopyright The D Language Foundation 2007-.@licenseBoost License 1.0.@authorsWalter Bright,
Andrei Alexandrescu,
Alex Rønne Petersenstdio : 
(alias template) writeln = std.stdio.writeln(T...)(T args)
Equivalent to write(args, '\n').  Calling writeln without
 arguments is valid and just prints a newline to the standard
 output.
 Params:
      args = the items to write to stdout
 Throws:
      In case of an I/O error, throws an $(LREF StdioException).
 Example:
        Reads stdin and writes it to stdout with an argument
        counter.
import std.stdio;
void main()
{
    string line;
    for (size_t count = 0; (line = readln) !is null; count++)
    {
         writeln("Input ", count, ": ", line);
    }
}
---writeln;

    // A raytracer scene: distances in metres, a wavelength in nanometres.
    auto 
(local variable) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1L)) sceneDepthsceneDepth = 
(struct) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1L))Metre(2.0);
    auto 
(local variable) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1000000000L)) wavelengthwavelength = 
(struct) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1000000000L))Nanometre(500.0); // green-ish light

    // nm + m converts LAZILY at the boundary. Left operand fixes the result
    // unit, so we can read the same physical sum at either scale.
    auto 
(local variable) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1L)) inMetresinMetres = 
(local variable) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1L)) sceneDepthsceneDepth + 
uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1L)) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1L)).opBinary!("+", Unit(Dim(0, 1, 0), 1L, 1000000000L))(in uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1000000000L)) rhs) const pure nothrow @nogc @safe
+/- between two units of the same dimension: insert a lazy
boundary conversion. The right operand is converted into this (the
left) operand's unit by the compile-time convFactor, and the result is
in the left unit. If the dimensions differ, this overload's constraint
fails, no operator matches, and the addition does not compile.wavelength;      // 2 m + 500 nm, kept in m
    auto 
(local variable) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1000000000L)) inNanometresinNanometres = 
(local variable) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1000000000L)) wavelengthwavelength + 
uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1000000000L)) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1000000000L)).opBinary!("+", Unit(Dim(0, 1, 0), 1L, 1L))(in uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1L)) rhs) const pure nothrow @nogc @safe
+/- between two units of the same dimension: insert a lazy
boundary conversion. The right operand is converted into this (the
left) operand's unit by the compile-time convFactor, and the result is
in the left unit. If the dimensions differ, this overload's constraint
fails, no operator matches, and the addition does not compile.sceneDepth;  // 500 nm + 2 m, kept in nm
    static assert(
(local variable) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1L)) inMetresinMetres.
(constant) uom_quantity_unit_in_type.Unit uom_quantity_unit_in_type.U = Unit(Dim(0, 1, 0), 1L, 1L)unit == 
(constant) uom_quantity_unit_in_type.Unit uom_quantity_unit_in_type.metre = Unit(Dim(0, 1, 0), 1L, 1L)metre);
    static assert(
(local variable) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1000000000L)) inNanometresinNanometres.
(constant) uom_quantity_unit_in_type.Unit uom_quantity_unit_in_type.U = Unit(Dim(0, 1, 0), 1L, 1000000000L)unit == 
(constant) uom_quantity_unit_in_type.Unit uom_quantity_unit_in_type.nanometre = Unit(Dim(0, 1, 0), 1L, 1000000000L)nanometre);

    // A patch area from two edge lengths given in centimetres, tracked in cm².
    auto 
(local variable) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 2, 0), 1L, 10000L)) patchAreapatchArea = 
(struct) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 100L))Centimetre(3.0) * 
uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 2, 0), 1L, 10000L)) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 100L)).opBinary!("*", Unit(Dim(0, 1, 0), 1L, 100L))(in uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 100L)) rhs) const pure nothrow @nogc @safe
*// between quantities: dimensions and scales combine via
scaleCombine; the numeric payloads multiply/divide directly. cm * cm
is thus an area in cm² — a distinct type from m², with scale tracked.Centimetre(4.0);
    static assert(
(local variable) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 2, 0), 1L, 10000L)) patchAreapatchArea.
(constant) uom_quantity_unit_in_type.Unit uom_quantity_unit_in_type.U = Unit(Dim(0, 2, 0), 1L, 10000L)unit == 
(struct) uom_quantity_unit_in_type.Unit
A unit: a dimension plus a rational scale num/den to the base unit of
that dimension. This is the whole point of the prototype — the type carries
the unit, not just the dimension. Nanometre has the same dim as Metre
but den = 1e9, so they are distinct types. Kept normalized (den > 0,
gcd(num, den) == 1) by unit below, so scale equality is value equality.Unit(
(struct) uom_quantity_unit_in_type.Dim
A dimension: an exponent vector in the free abelian group ℤ³ over the base
dimensions (mass, length, time), stored directly as its normal form.Dim(length: 2), 1, 10_000));

    // Cross-dimension addition is rejected at compile time — the asserts hold
    // precisely because the operations do NOT compile.
    static assert(!__traits(compiles, 
(local variable) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1L)) sceneDepthsceneDepth + 
(struct) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 0, 1), 1L, 1L))Second(1.0)),
        "length + time must not compile");
    static assert(!__traits(compiles, 
(local variable) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1000000000L)) wavelengthwavelength + 
(struct) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 0, 1), 1L, 1L))Second(1.0)),
        "length + time must not compile even across scales");
    static assert(__traits(compiles, 
(local variable) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1L)) sceneDepthsceneDepth + 
(local variable) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1000000000L)) wavelengthwavelength)); // ...but m + nm is fine.

    
void std.stdio.writeln!(string, uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1L)))(string __param_0, uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1L)) __param_1) @safe
Equivalent to write(args, '\n').  Calling writeln without
arguments is valid and just prints a newline to the standard
output.
Example
Reads stdin and writes it to stdout with an argument
counter.
import std.stdio;

void main()
{
    string line;

    for (size_t count = 0; (line = readln) !is null; count++)
    {
         writeln("Input ", count, ": ", line);
    }
}
@paramargs the items to write to stdout@throwsIn case of an I/O error, throws an StdioException.writeln("scene depth        = ", 
(local variable) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1L)) sceneDepthsceneDepth);
    
void std.stdio.writeln!(string, uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1000000000L)))(string __param_0, uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1000000000L)) __param_1) @safe
Equivalent to write(args, '\n').  Calling writeln without
arguments is valid and just prints a newline to the standard
output.
Example
Reads stdin and writes it to stdout with an argument
counter.
import std.stdio;

void main()
{
    string line;

    for (size_t count = 0; (line = readln) !is null; count++)
    {
         writeln("Input ", count, ": ", line);
    }
}
@paramargs the items to write to stdout@throwsIn case of an I/O error, throws an StdioException.writeln("wavelength         = ", 
(local variable) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1000000000L)) wavelengthwavelength);
    
void std.stdio.writeln!(string, uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1L)), string)(string __param_0, uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1L)) __param_1, string __param_2) @safe
Equivalent to write(args, '\n').  Calling writeln without
arguments is valid and just prints a newline to the standard
output.
Example
Reads stdin and writes it to stdout with an argument
counter.
import std.stdio;

void main()
{
    string line;

    for (size_t count = 0; (line = readln) !is null; count++)
    {
         writeln("Input ", count, ": ", line);
    }
}
@paramargs the items to write to stdout@throwsIn case of an I/O error, throws an StdioException.writeln("depth + wavelength = ", 
(local variable) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1L)) inMetresinMetres, "   (lazy nm -> m at the +)");
    
void std.stdio.writeln!(string, uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1000000000L)), string)(string __param_0, uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1000000000L)) __param_1, string __param_2) @safe
Equivalent to write(args, '\n').  Calling writeln without
arguments is valid and just prints a newline to the standard
output.
Example
Reads stdin and writes it to stdout with an argument
counter.
import std.stdio;

void main()
{
    string line;

    for (size_t count = 0; (line = readln) !is null; count++)
    {
         writeln("Input ", count, ": ", line);
    }
}
@paramargs the items to write to stdout@throwsIn case of an I/O error, throws an StdioException.writeln("wavelength + depth = ", 
(local variable) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 1, 0), 1L, 1000000000L)) inNanometresinNanometres, "   (lazy m -> nm at the +)");
    
void std.stdio.writeln!(string, uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 2, 0), 1L, 10000L)), string)(string __param_0, uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 2, 0), 1L, 10000L)) __param_1, string __param_2) @safe
Equivalent to write(args, '\n').  Calling writeln without
arguments is valid and just prints a newline to the standard
output.
Example
Reads stdin and writes it to stdout with an argument
counter.
import std.stdio;

void main()
{
    string line;

    for (size_t count = 0; (line = readln) !is null; count++)
    {
         writeln("Input ", count, ": ", line);
    }
}
@paramargs the items to write to stdout@throwsIn case of an I/O error, throws an StdioException.writeln("patch area (cm*cm) = ", 
(local variable) uom_quantity_unit_in_type.Quantity!(Unit(Dim(0, 2, 0), 1L, 10000L)) patchAreapatchArea, "   (scale tracked: cm^2, not m^2)");
}