ddn.adam

Compact Dynamic Value Type

This module provides adam, a memory-efficient dynamic value type designed to match the semantics and API of ddn.var while minimizing memory footprint. It is suitable for applications where large numbers of dynamic values must be stored or transmitted with minimal overhead.

Features:

• Compact representation: only 16 bytes on 64-bit platforms (vs. typical 24+ for variants).
• Tagged-length encoding: type tag and collection length share a single size_t word.
• Full numeric tower: supports bool, all D integer types, float, double, and dchar.
• Composite types: arrays (adam[]) and objects (adam[string]) with JSON-like semantics.
• Type normalization: real → double, char/wchar → dchar to keep the tag space small.
• GC-safe: pointer payloads are never tagged, preserving garbage collector reachability.
• API compatibility: mirrors ddn.var operators and conversions; JSON-like

  serialization via toString().

Differences from ddn.var:

• No temporal types: adam intentionally does not support DATE, TIME, DATETIME,

  SYSTIME, or DURATION types. This is a deliberate design choice to maintain compactness and simplicity. Applications requiring temporal values should use ddn.var instead, or encode temporal values as strings or numeric timestamps.

• Type normalization: real is stored as double, and char/wchar are stored as dchar,

  reducing the number of type tags needed.

• String ownership: adam copies string data on assignment (via .idup) to ensure

  memory safety, whereas some operations may differ from var.

Example:

import ddn.adam;

// Scalar values
adam i = 42;
adam d = 3.14;
adam s = "hello";

// Arrays
adam arr = [adam(1), adam(2), adam(3)];
assert(arr.length == 3);

// Objects
adam obj;
obj["name"] = "alice";
obj["age"] = 30;
assert(obj["name"].as!string == "alice");

// JSON-like serialization (compact, strings quoted and escaped)
string json = obj.toString();

Platform Notes:

• On 64-bit systems: adam.sizeof == 16.
• On 32-bit systems: adam.sizeof is 12 bytes with typical ABIs (an

  8-byte payload union plus the 4-byte tag word; platform alignment rules may pad this), and array/string lengths are limited to 28 bits.