object

Формирует символы, доступные для всех программ D. Включает Object, который является корнем иерархии объектов класса. Этот модуль импортируется неявно.

Лицензия:

Boost License 1.0.

Авторы:

Walter Bright, Sean Kelly

class Object;

Все объекты класса D наследуют от Object.

string toString();

Преобразовать объект в удобочитаемую строку.

nothrow @trusted size_t toHash();

Вычислить хеш-функцию для объекта.

int opCmp(Object o);

Сравнить с другим объектом obj.

Возвращает:

this < obj	< 0
this == obj	0
this > obj	> 0

bool opEquals(Object o);

Проверить, равен ли this o. По умолчанию реализация сравнивает только по идентичности (используя оператор is). Обычно переопределения для opEquals должны пытаться сравнить объекты по их содержимому.

static Object factory(string classname);

Создать экземпляр класса, заданного полным квалифицированным именем classname. Класс должен быть либо без конструкторов, либо иметь конструктор по умолчанию.

Возвращает:

null в случае ошибки

Пример

module foo.bar;

class C
{
    this() { x = 10; }
    int x;
}

void main()
{
    auto c = cast(C)Object.factory("foo.bar.C");
    assert(c !is null && c.x == 10);
}

bool opEquals(const Object lhs, const Object rhs);

Возвращает true, если lhs и rhs равны.

Примеры:

Если ссылки указывают на один и тот же объект или оба null => равны

class F { int flag; this(int flag) { this.flag = flag; } }

F f;
assert(f == f); // both null
f = new F(1);
assert(f == f); // both aliased to the same object

Примеры:

Если любой из них null => не равны

class F { int flag; this(int flag) { this.flag = flag; } }
F f;
assert(!(new F(0) == f));
assert(!(f == new F(0)));

Примеры:

Если типы идентичны => один вызов метода opEquals

class F
{
    int flag;

    this(int flag)
    {
        this.flag = flag;
    }

    override bool opEquals(const Object o)
    {
        return flag == (cast(F) o).flag;
    }
}

F f;
assert(new F(0) == new F(0));
assert(!(new F(0) == new F(1)));

Примеры:

Общий случай => симметричные вызовы метода opEquals

int fEquals, gEquals;

class Base
{
    int flag;
    this(int flag)
    {
        this.flag = flag;
    }
}

class F : Base
{
    this(int flag) { super(flag); }

    override bool opEquals(const Object o)
    {
        fEquals++;
        return flag == (cast(Base) o).flag;
    }
}

class G : Base
{
    this(int flag) { super(flag); }

    override bool opEquals(const Object o)
    {
        gEquals++;
        return flag == (cast(Base) o).flag;
    }
}

assert(new F(1) == new G(1));
assert(fEquals == 1);
assert(gEquals == 1);

struct Interface;

Информация об интерфейсе. Когда к объекту обращаются через интерфейс, Interface* появляется в качестве первого элемента в его vtbl.

TypeInfo_Class classinfo;

.classinfo для этого интерфейса (не для содержащего класса)

size_t offset;

Смещение интерфейса 'this' от объекта 'this'

struct OffsetTypeInfo;

Массив пар, задающих смещение и информацию о типе для каждого члена в агрегате.

size_t offset;

Смещение члена от начала объекта

TypeInfo ti;

TypeInfo для этого члена

abstract class TypeInfo;

Информация о типе во время выполнения. Может быть получена для любого типа с помощью TypeidExpression.

const nothrow @trusted size_t getHash(scope const void* p);

Вычисляет хеш экземпляра типа.

Параметры:

void* p

указатель на начало экземпляра типа

Возвращает:

хеш

Ошибки:

исправить https://issues.dlang.org/show_bug.cgi?id=12516, например, изменив это на действительно безопасный интерфейс.

const bool equals(in void* p1, in void* p2);

Сравнивает два экземпляра на равенство.

const int compare(in void* p1, in void* p2);

Сравнивает два экземпляра по операторам <, == или >.

const pure nothrow @nogc @property @safe size_t tsize();

Возвращает размер типа.

const void swap(void* p1, void* p2);

Меняет местами два экземпляра типа.

inout pure nothrow @nogc @property inout(TypeInfo) next();

Получить TypeInfo для типа 'next', как определено типом, null, если нет.

abstract const pure nothrow @nogc @safe const(void)[] initializer();

Возвращает значение по умолчанию. Если тип должен быть инициализирован нулями, возвращается массив с нулевым указателем и длиной, равной размеру типа. Для статических массивов это возвращает значение по умолчанию для одного элемента массива. Используйте tsize для получения правильного размера.

const pure nothrow @nogc @property @safe uint flags();

Получить флаги типа: 1 означает, что GC должен сканировать указатели, 2 означает, что аргумент этого типа передаётся в регистр SIMD, если он доступен

const const(OffsetTypeInfo)[] offTi();

Получить информацию о типе содержимого типа; null, если недоступно

const void destroy(void* p);

Выполнить деструктор для объекта и всех его подобъектов

const void postblit(void* p);

Выполнить postblit для объекта и всех его подобъектов

const pure nothrow @nogc @property @safe size_t talign();

Возвращает выравнивание типа

nothrow @safe int argTypes(out TypeInfo arg1, out TypeInfo arg2);

Возвращает внутреннюю информацию об аргументах, помещающихся в 8 байт. См. X86-64 ABI 3.2.3

const pure nothrow @nogc @property @safe immutable(void)* rtInfo();

Возвращает информацию, используемую сборщиком мусора для точной сборки.

class TypeInfo_Class: object.TypeInfo;

Информация о типе класса во время выполнения. Может быть получена из экземпляра объекта с помощью свойства .classinfo.

byte[] m_init;

Статическая инициализация класса (init.length даёт размер класса в байтах)

string name;

Имя класса

void*[] vtbl;

Таблица указателей на виртуальные функции

Interface[] interfaces;

Реализуемые интерфейсы этого класса

TypeInfo_Class base;

Базовый класс

static const(TypeInfo_Class) find(scope const char[] classname);

Поиск во всех модулях TypeInfo_Class, соответствующего classname.

Возвращает:

null, если не найдено

const Object create();

Создать экземпляр объекта, представленного 'this'.

final const pure nothrow @nogc @trusted bool isBaseOf(scope const TypeInfo_Class child);

Возвращает true, если класс, описанный child, наследуется от или является классом, описанным этим TypeInfo_Class. Всегда возвращает false, если аргумент null.

Параметры:

TypeInfo_Class child

TypeInfo для какого-либо класса

Возвращает:

true, если класс, описанный child, наследуется от или является классом, описанным этим TypeInfo_Class.

struct ModuleInfo;

Экземпляр ModuleInfo генерируется в объектный файл для каждого скомпилированного модуля.

Он предоставляет доступ к различным аспектам модуля. Он не генерируется для betterC.

const pure nothrow @nogc @property void function() tlsctor();

Возвращает:

конструктор модуля для локальных данных потоков, null если его нет

const pure nothrow @nogc @property void function() tlsdtor();

Возвращает:

деструктор модуля для локальных данных потоков, null если его нет

const pure nothrow @nogc @property void* xgetMembers();

Возвращает:

адрес функции модуля const(MemberInfo)[] getMembers(string), null если её нет

const pure nothrow @nogc @property void function() ctor();

Возвращает:

конструктор модуля, null если его нет

const pure nothrow @nogc @property void function() dtor();

Возвращает:

деструктор модуля, null если его нет

const pure nothrow @nogc @property void function() ictor();

Возвращает:

независимый от порядка конструктор модуля, null если его нет

const pure nothrow @nogc @property void function() unitTest();

Возвращает:

адрес функции, выполняющей модульные тесты, null если её нет

const pure nothrow @nogc @property immutable(ModuleInfo*)[] importedModules();

Возвращает:

массив указателей на ModuleInfo импортированных модулей

const pure nothrow @nogc @property TypeInfo_Class[] localClasses();

Возвращает:

массив ссылок TypeInfo_Class для классов, определённых в этом модуле

const pure nothrow @nogc @property string name();

Возвращает:

имя модуля, null если имя отсутствует

class Throwable;

Базовый класс всех выбрасываемых объектов.

Все выбрасываемые объекты должны наследоваться от Throwable. Класс Exception, который наследуется от этого класса, представляет категорию выбрасываемых объектов, которые безопасно перехватывать и обрабатывать. В принципе, не следует перехватывать объекты Throwable, которые не наследуются от Exception, так как они представляют невосстанавливаемые ошибки во время выполнения. Некоторые гарантии во время выполнения могут не выполняться, когда выбрасываются эти ошибки, делая небезопасным продолжение выполнения после их перехвата.

string msg;

Сообщение, описывающее ошибку.

string file;

Имя файла исходного кода D, соответствующего месту, откуда была выброшена ошибка.

size_t line;

Номер строки исходного кода D, соответствующего месту, откуда была выброшена ошибка.

TraceInfo info;

Стек вызовов, где произошла ошибка. Это непрозрачный объект, который можно преобразовать в string, или итерировать с помощью foreach, чтобы извлечь элементы стека вызовов (как строки).

inout pure nothrow @nogc @property scope @safe inout(Throwable) next() return;

Возвращает:

Ссылка на следующую ошибку в списке. Это используется, когда новая Throwable выбрасывается изнутри блока catch. Исходно перехваченная Exception будет присоединена к новой Throwable через это поле.

pure nothrow @nogc @property scope @safe void next(Throwable tail);

Заменить next в цепочке на tail. Используйте chainTogether вместо этого, если это возможно.

final pure nothrow @nogc ref scope @system uint refcount() return;

Возвращает:

изменяемая ссылка на счетчик ссылок, который равен 0 - выделено сборщиком мусора, 1 - выделено d_newThrowable(), и >=2 это счетчик ссылок + 1

Примечание

Отмечено как @system для предотвращения случайного использования.

int opApply(scope int delegate(Throwable) dg);

Перебрать цепочку Throwables.

static pure nothrow @nogc @system Throwable chainTogether(return scope Throwable e1, return scope Throwable e2);

Добавить e2 к цепочке исключений, которая начинается с e1.

Параметры:

Throwable e1	начало цепочки (может быть null)
Throwable e2	вторая часть цепочки (может быть null)

Возвращает:

Throwable, который находится в начале цепочки; null, если оба e1 и e2 равны null

string toString();

Переопределяет Object.toString и возвращает сообщение об ошибке. Внутренне это перенаправляется на перегрузку toString которая принимает параметр sink делегат.

const void toString(scope void delegate(in char[]) sink);

Иерархия Throwable использует перегрузку toString, которая принимает делегат sink, чтобы избежать выделения памяти сборщиком мусора, что невозможно в определённых ситуациях с ошибками. Переопределите этот toString метод для настройки сообщения об ошибке.

const const(char)[] message();

Получить сообщение, описывающее ошибку. Базовое поведение - вернуть поле Throwable.msg. Переопределите для возвращения другого сообщения об ошибке.

Возвращает:

Сообщение об ошибке

class Exception: object.Throwable;

Базовый класс всех ошибок, которые безопасно перехватывать и обрабатывать.

В принципе, только выбрасываемые объекты, производные от этого класса, безопасно перехватывать внутри блока catch . Выбрасываемые объекты, не производные от Exception, представляют ошибки во время выполнения, которые не следует перехватывать, так как некоторые гарантии во время выполнения могут не выполняться, что делает небезопасным продолжение выполнения программы.

Примеры:

bool gotCaught;
try
{
    throw new Exception("msg");
}
catch (Exception e)
{
    gotCaught = true;
    assert(e.msg == "msg");
}
assert(gotCaught);

pure nothrow @nogc @safe this(string msg, string file = __FILE__, size_t line = __LINE__, Throwable nextInChain = null);

Создаёт новый экземпляр Exception. Параметр nextInChain используется внутренне и всегда должен быть null при передаче кодом пользователя. Этот конструктор не выбрасывает создаваемое исключение автоматически; для этой цели необходимо использовать оператор throw.

class Error: object.Throwable;

Базовый класс всех невосстановимых ошибок во время выполнения.

Это представляет категорию Throwable объектов, которые не безопасно перехватывать и обрабатывать. В принципе, не следует перехватывать объекты Error, так как они представляют невосстановимые ошибки во время выполнения. Некоторые гарантии во время выполнения могут не выполняться, когда выбрасываются эти ошибки, делая небезопасным продолжение выполнения после их перехвата.

Примеры:

bool gotCaught;
try
{
    throw new Error("msg");
}
catch (Error e)
{
    gotCaught = true;
    assert(e.msg == "msg");
}
assert(gotCaught);

pure nothrow @nogc @safe this(string msg, Throwable nextInChain = null);

Создаёт новый экземпляр Error. Параметр nextInChain используется внутренне и всегда должен быть null при передаче кодом пользователя. Этот конструктор не выбрасывает создаваемую ошибку автоматически; для этой цели необходимо использовать оператор throw.

Throwable bypassedException;

Первая Exception , которая была проигнорирована при выбрасывании этой ошибки, или null если никаких Exception не было в очереди.

void clear(Value, Key)(Value[Key] aa);

Удаляет все оставшиеся ключи и значения из ассоциативного массива.

Параметры:

Value[Key] aa

Ассоциативный массив.

T rehash(T : Value[Key], Value, Key)(T aa);

Переупорядочивает ассоциативный массив на месте, чтобы улучшить производительность поиска.

Параметры:

T aa	Ассоциативный массив.

Возвращает:

Переупорядоченный ассоциативный массив.

V[K] dup(T : V[K], K, V)(T aa);

Создаёт новый ассоциативный массив того же размера и копирует содержимое ассоциативного массива в него.

Параметры:

T aa	Ассоциативный массив.

pure nothrow @nogc @safe auto byKey(T : V[K], K, V)(T aa);

Возвращает диапазон для перебора ключей ассоциативного массива.

Параметры:

T aa	Ассоциативный массив.

Возвращает:

Диапазон.

pure nothrow @nogc @safe auto byValue(T : V[K], K, V)(T aa);

Возвращает диапазон для перебора значений ассоциативного массива.

Параметры:

T aa	Ассоциативный массив.

Возвращает:

Диапазон.

pure nothrow @nogc @safe auto byKeyValue(T : V[K], K, V)(T aa);

Возвращает диапазон вперед над парами ключ-значение ассоциативного массива.

Параметры:

T aa	Ассоциативный массив.

Возвращает:

Диапазон вперед.

@property Key[] keys(T : Value[Key], Value, Key)(T aa);

Возвращает динамический массив, элементами которого являются ключи в ассоциативном массиве.

Параметры:

T aa	Ассоциативный массив.

Возвращает:

Динамический массив.

@property Value[] values(T : Value[Key], Value, Key)(T aa);

Возвращает динамический массив, элементами которого являются значения в ассоциативном массиве.

Параметры:

T aa	Ассоциативный массив.

Возвращает:

Динамический массив.

inout(V) get(K, V)(inout(V[K]) aa, K key, lazy inout(V) defaultValue);

Ищет ключ; если он существует, возвращает соответствующее значение, иначе вычисляет и возвращает defaultValue.

Параметры:

inout(V[K]) aa	Ассоциативный массив.
K key	Ключ.
inout(V) defaultValue	Значение по умолчанию.

Возвращает:

Значение.

ref V require(K, V)(ref V[K] aa, K key, lazy V value = V.init);

Ищет ключ; если он существует, возвращает соответствующее значение, иначе вычисляет значение, добавляет его в ассоциативный массив и возвращает его.

Параметры:

V[K] aa	Ассоциативный массив.
K key	Ключ.
V value	Требуемое значение.

Возвращает:

Значение.

Примеры:

auto aa = ["k1": 1];
assert(aa.require("k1", 0) == 1);
assert(aa.require("k2", 0) == 0);
assert(aa["k2"] == 0);

void update(K, V, C, U)(ref V[K] aa, K key, scope C create, scope U update)
Constraints: if (is(typeof(create()) : V) && (is(typeof(update(aa[K.init])) : V) || is(typeof(update(aa[K.init])) == void)));

Ищет ключ; если он существует, применяет вызываемый объект обновления, иначе вычисляет вызываемый объект создания и добавляет его в ассоциативный массив

Параметры:

V[K] aa	Ассоциативный массив.
K key	Ключ.
C create	Вызываемый объект для применения при создании.
U update	Вызываемый объект для применения при обновлении.

Примеры:

auto aa = ["k1": 1];

aa.update("k1", {
    return -1; // create (won't be executed)
}, (ref int v) {
    v += 1; // update
});
assert(aa["k1"] == 2);

aa.update("k2", {
    return 0; // create
}, (ref int v) {
    v = -1; // update (won't be executed)
});
assert(aa["k2"] == 0);

size_t hashOf(T)(auto ref T arg, size_t seed);

size_t hashOf(T)(auto ref T arg);

Вычисляет значение хеша arg с необязательным seed начальным значением. Результат может не совпадать с typeid(T).getHash(&arg).

Параметры:

T arg	аргумент для вычисления значения хеша
size_t seed	необязательное seed значение (может использоваться для цепочки хеширования)

Возвращает

вычисленное значение хеша arg

Примеры:

class MyObject
{
    size_t myMegaHash() const @safe pure nothrow
    {
        return 42;
    }
}
struct Test
{
    int a;
    string b;
    MyObject c;
    size_t toHash() const pure nothrow
    {
        size_t hash = a.hashOf();
        hash = b.hashOf(hash);
        size_t h1 = c.myMegaHash();
        hash = h1.hashOf(hash); //Mix two hash values
        return hash;
    }
}

immutable size_t[pointerBitmap.length] RTInfoImpl(size_t[] pointerBitmap);

Создает RTInfo для типа T

enum immutable(void)* rtinfoNoPointers;

ярлыки для точного сборщика мусора, также генерируемые компилятором и используемые вместо фактической карты указателей

@property auto dup(T)(T[] a)
Constraints: if (!is(const(T) : T));

@property T[] dup(T)(const(T)[] a)
Constraints: if (is(const(T) : T));

Предоставляет свойство массива .dup.

Примеры:

auto arr = [1, 2];
auto arr2 = arr.dup;
arr[0] = 0;
assert(arr == [0, 2]);
assert(arr2 == [1, 2]);

@property immutable(T)[] idup(T)(T[] a);

@property immutable(T)[] idup(T : void)(const(T)[] a);

Предоставляет свойство массива .idup.

Примеры:

char[] arr = ['a', 'b', 'c'];
string s = arr.idup;
arr[0] = '.';
assert(s == "abc");

pure nothrow @property @trusted size_t capacity(T)(T[] arr);

(Свойство) Получает текущую емкость среза. Емкость — это размер, до которого может вырасти срез, прежде чем для подлежащего массива потребуется перераспределение или расширение.

Если при добавлении необходимо перераспределить срез без возможности расширения, то возвращается 0. Это происходит, когда срез ссылается на статический массив или если другой срез ссылается на элементы за пределами текущего среза.

Примечание

Емкость среза может изменяться из-за операций с другими срезами.

Примеры:

//Static array slice: no capacity
int[4] sarray = [1, 2, 3, 4];
int[]  slice  = sarray[];
assert(sarray.capacity == 0);
//Appending to slice will reallocate to a new array
slice ~= 5;
assert(slice.capacity >= 5);

//Dynamic array slices
int[] a = [1, 2, 3, 4];
int[] b = a[1 .. $];
int[] c = a[1 .. $ - 1];
debug(SENTINEL) {} else // non-zero capacity very much depends on the array and GC implementation
{
    assert(a.capacity != 0);
    assert(a.capacity == b.capacity + 1); //both a and b share the same tail
}
assert(c.capacity == 0);              //an append to c must relocate c.

pure nothrow @trusted size_t reserve(T)(ref T[] arr, size_t newcapacity);

Зарезервировать емкость для среза. Емкость — это размер, до которого может вырасти срез, прежде чем для подлежащего массива потребуется перераспределение или расширение.

Возвращает:

Новая емкость массива (которая может быть больше, чем запрошенная емкость).

Примеры:

//Static array slice: no capacity. Reserve relocates.
int[4] sarray = [1, 2, 3, 4];
int[]  slice  = sarray[];
auto u = slice.reserve(8);
assert(u >= 8);
assert(&sarray[0] !is &slice[0]);
assert(slice.capacity == u);

//Dynamic array slices
int[] a = [1, 2, 3, 4];
a.reserve(8); //prepare a for appending 4 more items
auto p = &a[0];
u = a.capacity;
a ~= [5, 6, 7, 8];
assert(p == &a[0]);      //a should not have been reallocated
assert(u == a.capacity); //a should not have been extended

nothrow ref @system inout(T[]) assumeSafeAppend(T)(auto ref inout(T[]) arr);

Предположим, что добавление в этот массив безопасно. Добавления, сделанные в этот массив после вызова этой функции, могут добавляться на месте, даже если массив был срезом большего массива с самого начала.

Используйте это только тогда, когда точно известно, что нет элементов, используемых за пределами массива в блоке памяти. Если они есть, эти элементы будут перезаписаны добавлением в этот массив.

Предупреждение

Вызов этой функции и последующее использование ссылок на данные, расположенные после данного массива, приводит к неопределенному поведению.

Возвращает:

Возвращается входной параметр.

Примеры:

int[] a = [1, 2, 3, 4];

// Without assumeSafeAppend. Appending relocates.
int[] b = a [0 .. 3];
b ~= 5;
assert(a.ptr != b.ptr);

debug(SENTINEL) {} else
{
    // With assumeSafeAppend. Appending overwrites.
    int[] c = a [0 .. 3];
    c.assumeSafeAppend() ~= 5;
    assert(a.ptr == c.ptr);
}

void destroy(bool initialize = true, T)(ref T obj)
Constraints: if (is(T == struct));

void destroy(bool initialize = true, T)(T obj)
Constraints: if (is(T == class));

void destroy(bool initialize = true, T)(T obj)
Constraints: if (is(T == interface));

void destroy(bool initialize = true, T : U[n], U, size_t n)(ref T obj)
Constraints: if (!is(T == struct) && !is(T == class) && !is(T == interface));

void destroy(bool initialize = true, T)(ref T obj)
Constraints: if (!is(T == struct) && !is(T == interface) && !is(T == class) && !__traits(isStaticArray, T));

Удаляет данный объект и, по желанию, сбрасывает в исходное состояние. Используется для удаления объекта, вызывая его деструктор или финализатор, чтобы он больше не ссылался на другие объекты. Это не запускает цикл сборки мусора или освобождает память сборщика мусора. Если initialize указано false, объект считается недействительным после удаления и не должен ссылаться на него.

Примеры:

Демонстрация типа ссылки

class C
{
    struct Agg
    {
        static int dtorCount;

        int x = 10;
        ~this() { dtorCount++; }
    }

    static int dtorCount;

    string s = "S";
    Agg a;
    ~this() { dtorCount++; }
}

C c = new C();
assert(c.dtorCount == 0);   // destructor not yet called
assert(c.s == "S");         // initial state `c.s` is `"S"`
assert(c.a.dtorCount == 0); // destructor not yet called
assert(c.a.x == 10);        // initial state `c.a.x` is `10`
c.s = "T";
c.a.x = 30;
assert(c.s == "T");         // `c.s` is `"T"`
destroy(c);
assert(c.dtorCount == 1);   // `c`'s destructor was called
assert(c.s == "S");         // `c.s` is back to its inital state, `"S"`
assert(c.a.dtorCount == 1); // `c.a`'s destructor was called
assert(c.a.x == 10);        // `c.a.x` is back to its inital state, `10`

// check C++ classes work too!
extern (C++) class CPP
{
    struct Agg
    {
        __gshared int dtorCount;

        int x = 10;
        ~this() { dtorCount++; }
    }

    __gshared int dtorCount;

    string s = "S";
    Agg a;
    ~this() { dtorCount++; }
}

CPP cpp = new CPP();
assert(cpp.dtorCount == 0);   // destructor not yet called
assert(cpp.s == "S");         // initial state `cpp.s` is `"S"`
assert(cpp.a.dtorCount == 0); // destructor not yet called
assert(cpp.a.x == 10);        // initial state `cpp.a.x` is `10`
cpp.s = "T";
cpp.a.x = 30;
assert(cpp.s == "T");         // `cpp.s` is `"T"`
destroy!false(cpp);           // destroy without initialization
assert(cpp.dtorCount == 1);   // `cpp`'s destructor was called
assert(cpp.s == "T");         // `cpp.s` is not initialized
assert(cpp.a.dtorCount == 1); // `cpp.a`'s destructor was called
assert(cpp.a.x == 30);        // `cpp.a.x` is not initialized
destroy(cpp);
assert(cpp.dtorCount == 2);   // `cpp`'s destructor was called again
assert(cpp.s == "S");         // `cpp.s` is back to its inital state, `"S"`
assert(cpp.a.dtorCount == 2); // `cpp.a`'s destructor was called again
assert(cpp.a.x == 10);        // `cpp.a.x` is back to its inital state, `10`

Примеры:

Демонстрация типа значения

int i;
assert(i == 0);           // `i`'s initial state is `0`
i = 1;
assert(i == 1);           // `i` changed to `1`
destroy!false(i);
assert(i == 1);           // `i` was not initialized
destroy(i);
assert(i == 0);           // `i` is back to its initial state `0`