.editorconfig

@@ -1,9 +0,0 @@
-root = true
-
-[*]
-end_of_line = lf
-insert_final_newline = true
-charset = utf-8
-indent_style = space
-indent_size = 4
-trim_trailing_whitespace = true

.gitignore

@@ -1,21 +1,10 @@
 # Binary
 *.[oa]
-*.exe
-*.lib
 
 # D
 .dub
-dub.selections.json
-
 __test__*__
 __test__*__.core
-tanya-*test-*
-/dub_platform_probe[_-]*
 
 /docs/
 /docs.json
-
-/*.lst
-
-# Ninja build
-.ninja_*

.travis.yml

@@ -0,0 +1,17 @@
+sudo: false
+
+os:
+ - linux
+
+language: d
+
+d:
+ - dmd-2.072.2
+ - dmd-2.071.2
+
+env: 
+ matrix:
+  - ARCH=x86_64
+
+script:
+ - dub test --arch=$ARCH

README.md

@@ -1,186 +1,69 @@
 # Tanya
 
+[![Build Status](https://travis-ci.org/caraus-ecms/tanya.svg?branch=master)](https://travis-ci.org/caraus-ecms/tanya)
 [![Dub version](https://img.shields.io/dub/v/tanya.svg)](https://code.dlang.org/packages/tanya)
 [![Dub downloads](https://img.shields.io/dub/dt/tanya.svg)](https://code.dlang.org/packages/tanya)
-[![License: MPL 2.0](https://img.shields.io/badge/license-MPL_2.0-blue.svg)](https://opensource.org/licenses/MPL-2.0)
+[![License](https://img.shields.io/badge/license-MPL_2.0-blue.svg)](https://raw.githubusercontent.com/caraus-ecms/tanya/master/LICENSE)
 
 Tanya is a general purpose library for D programming language.
 
 Its aim is to simplify the manual memory management in D and to provide a
 guarantee with @nogc attribute that there are no hidden allocations on the
 Garbage Collector heap. Everything in the library is usable in @nogc code.
-Tanya provides data structures and utilities to facilitate painless systems
-programming in D.
-
-- [API Documentation](https://docs.caraus.tech/tanya)
+Tanya extends Phobos functionality and provides alternative implementations for
+data structures and utilities that depend on the Garbage Collector in Phobos.
 
 ## Overview
 
-Tanya consists of the following packages and (top-level) modules:
+Tanya consists of the following packages:
 
-* `algorithm`: Collection of generic algorithms.
-* `bitmanip`: Bit manipulation.
-* `container`: Queue, Array, Singly and doubly linked lists, Buffers, UTF-8
-string, Set, Hash table.
-* `conv`: This module provides functions for converting between different
-types.
-* `format`: Formatting and conversion functions.
-* `hash`: Hash algorithms.
-* `math`: Arbitrary precision integer and a set of functions.
-* `memory`: Tools for manual memory management (allocators, smart pointers).
-* `meta`: Template metaprogramming. This package contains utilities to acquire
-type information at compile-time, to transform from one type to another. It has
-also different algorithms for iterating, searching and modifying template
-arguments.
-* `net`: URL-Parsing, network programming.
-* `os`: Platform-independent interfaces to operating system functionality.
-* `range`: Generic functions and templates for D ranges.
-* `test`: Test suite for unittest-blocks.
-* `typecons`: Templates that allow to build new types based on the available
-ones.
-
-
-## NogcD
-
-To achieve programming without the Garbage Collection tanya uses a subset of D:
-NogcD.
-
-### Allocators
-
-Memory management is done with allocators. Instead of using `new` to create an
-instance of a class, an allocator is used:
-
-```d
-import tanya.memory;
-
-class A
-{
-    this(int arg)
-    {
-    }
-}
-
-A a = defaultAllocator.make!A(5);
-
-defaultAllocator.dispose(a);
-```
-
-As you can see, the user is responsible for deallocation, therefore `dispose`
-is called at the end.
-
-If you want to change the `defaultAllocator` to something different, you
-probably want to do it at the program's beginning. Or you can invoke another
-allocator directly. It is important to ensure that the object is destroyed
-using the same allocator that was used to allocate it.
-
-What if I get an allocated object from some function? The generic rule is: If
-you haven't requested the memory yourself (with `make`), you don't need to free
-it.
-
-`tanya.memory.smartref` contains smart pointers, helpers that can take care of
-a proper deallocation in some cases for you.
-
-### Exceptions
-
-Since exceptions are normal classes in D, they are allocated and dellocated the
-same as described above, but:
-
-1. The caller is **always** responsible for destroying a caught exception.
-2. Exceptions are **always** allocated and should be always allocated with the
-`defaultAllocator`.
-
-```d
-import tanya.memory;
-
-void functionThatThrows()
-{
-    throw defaultAlocator.make!Exception("An error occurred");
-}
-
-try
-{
-    functionThatThrows()
-}
-catch (Exception e)
-{
-    defaultAllocator.dispose(e);
-}
-```
-
-### Built-in array operations and containers
-
-Arrays are commonly used in programming. D's built-in arrays often rely on the
-GC. It is inconvenient to change their size, reserve memory for future use and
-so on. Containers can help here. The following example demonstrates how
-`tanya.container.array.Array` can be used instead of `int[]`.
-
-```d
-import tanya.container.array;
-
-Array!int arr;
-
-// Reserve memory if I know that my container will contain approximately 15
-// elements.
-arr.reserve(15);
-
-arr.insertBack(5); // Add one element.
-arr.length = 10; // New elements are initialized to 0.
-
-// Iterate over the first five elements.
-foreach (el; arr[0 .. 5])
-{
-}
-
-int i = arr[7]; // Access 8th element.
-```
-
-There are more containers in the `tanya.container` package.
-
-
-### Immutability
-
-Immutability doesn't play nice with manual memory management since the
-allocated storage should be initialized (mutated) and then released (mutated).
-`immutable` is used only for non-local immutable declarations (that are
-evaluated at compile time), static immutable data, strings (`immutable(char)[]`,
-`immutable(wchar)[]` and `immutable(dchar)[]`).
-
-
-### Unsupported features
-
-The following features depend on GC and aren't supported:
-
-- `lazy` parameters (allocate a closure which is evaluated when then the
-parameter is used)
-
-- `synchronized` blocks
-
-
-## Development
+* `async`: Event loop (epoll, kqueue and IOCP).
+* `container`: Queue, Vector, Singly linked list, buffers.
+* `crypto`: Work in progress TLS implementation.
+* `math`: Multiple precision integer and a set of functions.
+* `memory`: Tools for manual memory management (allocator, reference counting,
+helper functions).
+* `network`: URL-Parsing, sockets.
 
 ### Supported compilers
 
-| DMD     | GCC       |
-|:-------:|:---------:|
-| 2.100.0 | 12.1      |
+* dmd 2.072.2
+* dmd 2.071.2
 
-## Further characteristics
+### Current status
 
-- Tanya is a native D library
+The library is currently under development, but some parts of it can already be
+used.
 
-- Tanya is cross-platform. The development happens on a 64-bit Linux, but it
-is being tested on Windows and FreeBSD as well
+`network` and `async` exist for quite some time and could be better tested than
+other components.
 
-- Tanya favours generic algorithms therefore there is no auto-decoding. Char
-arrays are handled as any other array type
+Containers were newly reworked and the API won't change significantly, but will
+be only extended. The same is true for the `memory` package.
 
-- The library isn't thread-safe yet
+`math` package contains an arbitrary precision integer implementation that has
+a stable API (that mostly consists of operator overloads), but still needs
+testing and work on its performance.
 
-- Complex numbers (`cfloat`, `cdouble`, `creal`, `ifloat`, `idouble`, `ireal`)
-aren't supported
+I'm currently mostly working on `crypto` that is not a complete cryptographic
+suite, but contains (will contain) algorithm implementations required by TLS.
 
+### Further characteristics
 
-## Feedback
+* Tanya is a native D library.
 
-Any feedback about your experience with tanya would be greatly appreciated. Feel free to
-[contact me](mailto:belka@caraus.de).
+* Documentation and usage examples can be found in the source code.
+Online documentation will be published soon.
+
+* Tanya is cross-platform. The development happens on a 64-bit Linux, but it
+is being tested on Windows and FreeBSD as well.
+
+* The library isn't thread-safe. Thread-safity should be added later.
+
+## Contributing
+
+Since I'm mostly busy writing new code and implementing new features I would
+appreciate, if anyone uses the library. It would help me to improve the
+codebase and fix issues.
+
+Feel free to contact me if you have any questions.

dscanner.ini

@@ -1,81 +0,0 @@
-; Configure which static analysis checks are skip-unittest
-[analysis.config.StaticAnalysisConfig]
-; Check variable, class, struct, interface, union, and function names against t
-; he Phobos style guide
-style_check="disabled"
-; Check for array literals that cause unnecessary allocation
-enum_array_literal_check="skip-unittest"
-; Check for poor exception handling practices
-exception_check="skip-unittest"
-; Check for use of the deprecated 'delete' keyword
-delete_check="skip-unittest"
-; Check for use of the deprecated floating point operators
-float_operator_check="skip-unittest"
-; Check number literals for readability
-number_style_check="disabled"
-; Checks that opEquals, opCmp, toHash, and toString are either const, immutable
-; , or inout.
-object_const_check="disabled"
-; Checks for .. expressions where the left side is larger than the right.
-backwards_range_check="skip-unittest"
-; Checks for if statements whose 'then' block is the same as the 'else' block
-if_else_same_check="skip-unittest"
-; Checks for some problems with constructors
-constructor_check="skip-unittest"
-; Checks for unused variables and function parameters
-unused_variable_check="skip-unittest"
-; Checks for unused labels
-unused_label_check="skip-unittest"
-; Checks for duplicate attributes
-duplicate_attribute="skip-unittest"
-; Checks that opEquals and toHash are both defined or neither are defined
-opequals_tohash_check="disabled"
-; Checks for subtraction from .length properties
-length_subtraction_check="disabled"
-; Checks for methods or properties whose names conflict with built-in propertie
-; s
-builtin_property_names_check="skip-unittest"
-; Checks for confusing code in inline asm statements
-asm_style_check="skip-unittest"
-; Checks for confusing logical operator precedence
-logical_precedence_check="skip-unittest"
-; Checks for undocumented public declarations
-undocumented_declaration_check="disabled"
-; Checks for poor placement of function attributes
-function_attribute_check="skip-unittest"
-; Checks for use of the comma operator
-comma_expression_check="skip-unittest"
-; Checks for local imports that are too broad
-local_import_check="disabled"
-; Checks for variables that could be declared immutable
-could_be_immutable_check="disabled"
-; Checks for redundant expressions in if statements
-redundant_if_check="skip-unittest"
-; Checks for redundant parenthesis
-redundant_parens_check="skip-unittest"
-; Checks for mismatched argument and parameter names
-mismatched_args_check="skip-unittest"
-; Checks for labels with the same name as variables
-label_var_same_name_check="disabled"
-; Checks for lines longer than 120 characters
-long_line_check="skip-unittest"
-; Checks for assignment to auto-ref function parameters
-auto_ref_assignment_check="disabled"
-; Checks for incorrect infinite range definitions
-incorrect_infinite_range_check="skip-unittest"
-; Checks for asserts that are always true
-useless_assert_check="skip-unittest"
-; Check for uses of the old-style alias syntax
-alias_syntax_check="disabled"
-; Checks for else if that should be else static if
-static_if_else_check="skip-unittest"
-; Check for unclear lambda syntax
-lambda_return_check="skip-unittest"
-; Check for auto function without return statement
-auto_function_check="skip-unittest"
-; Check for sortedness of imports
-imports_sortedness="skip-unittest"
-; Check for explicitly annotated unittests
-explicitly_annotated_unittests="disabled"
-; Check for useless usage of the final attribute
-final_attribute_check="skip-unittest"

dub.json

@@ -1,76 +1,17 @@
 {
 	"name": "tanya",
-	"description": "@nogc library. Containers, networking, metaprogramming, memory management, utilities",
+	"description": "D library with event loop",
 	"license": "MPL-2.0",
-	"copyright": "© Eugene Wissner <belka@caraus.de>",
+	"copyright": "(c) Eugene Wissner <info@caraus.de>",
 	"authors": [
 		"Eugene Wissner"
 	],
 
 	"targetType": "library",
 
-	"dependencies": {
-		"tanya:meta": "*",
-		"tanya:os": "*",
-		"tanya:middle": "*",
-		"tanya:test": "*",
-		"mir-linux-kernel": "~>1.0.0"
-	},
-
-	"subPackages": [
-		"./meta",
-		"./os",
-		"./middle",
-		"./test"
-	],
-
 	"configurations": [
 		{
-			"name": "library",
-			"targetType": "staticLibrary",
-			"versions": ["TanyaPhobos"]
-		},
-		{
-			"name": "dynamic",
-			"targetType": "dynamicLibrary",
-			"versions": ["TanyaPhobos"]
-		},
-		{
-			"name": "native",
-			"targetType": "library",
-			"platforms": ["linux-x86_64"],
-			"versions": ["TanyaNative"]
-		},
-		{
-			"name": "unittest",
-			"versions": ["TanyaPhobos"],
-			"importPaths": [
-				"./source",
-				"./tests"
-			],
-			"sourcePaths": [
-				"./source",
-				"./tests"
-			]
-		},
-		{
-			"name": "unittest-native",
-			"platforms": ["linux-x86_64"],
-			"versions": ["TanyaNative"],
-			"importPaths": [
-				"./source",
-				"./tests"
-			],
-			"sourcePaths": [
-				"./source",
-				"./tests"
-			]
+			"name": "library"
 		}
-	],
-
-	"dflags-dmd": ["-dip1000"],
-
-	"libs-windows": ["advapi32"],
-	"libs-windows-x86_mscoff": ["iphlpapi"],
-	"libs-windows-x86_64": ["iphlpapi"]
+	]
 }

meta/dub.json

@@ -1,13 +0,0 @@
-{
-	"name": "meta",
-	"description": "Template metaprogramming",
-	"targetType": "library",
-
-	"sourcePaths": [
-		"."
-	],
-	"importPaths": [
-		"."
-	],
-	"dflags-dmd": ["-dip1000"]
-}

meta/tanya/meta/package.d

@@ -1,23 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-/**
- * Template metaprogramming.
- *
- * This package contains utilities to acquire type information at compile-time,
- * to transform from one type to another. It has also different algorithms for
- * iterating, searching and modifying template arguments.
- *
- * Copyright: Eugene Wissner 2017-2020.
- * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
- *                  Mozilla Public License, v. 2.0).
- * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
- * Source: $(LINK2 https://github.com/caraus-ecms/tanya/blob/master/meta/tanya/meta/package.d,
- *                 tanya/meta/package.d)
- */
-module tanya.meta;
-
-public import tanya.meta.metafunction;
-public import tanya.meta.trait;
-public import tanya.meta.transform;

meta/tanya/meta/transform.d

@@ -1,504 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-/**
- * Type transformations.
- *
- * Templates in this module can be used to modify type qualifiers or transform
- * types. They take some type as argument and return a different type after
- * perfoming the specified transformation.
- *
- * Copyright: Eugene Wissner 2017-2020.
- * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
- *                  Mozilla Public License, v. 2.0).
- * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
- * Source: $(LINK2 https://github.com/caraus-ecms/tanya/blob/master/meta/tanya/meta/transform.d,
- *                 tanya/meta/transform.d)
- */
-module tanya.meta.transform;
-
-import tanya.meta.metafunction;
-import tanya.meta.trait;
-
-/**
- * Removes any type qualifiers from $(D_PARAM T).
- *
- * Removed qualifiers are:
- * $(UL
- *  $(LI const)
- *  $(LI immutable)
- *  $(LI inout)
- *  $(LI shared)
- * )
- * and combinations of these.
- *
- * If the type $(D_PARAM T) doesn't have any qualifieres,
- * $(D_INLINECODE Unqual!T) becomes an alias for $(D_PARAM T).
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_PARAM T) without any type qualifiers.
- */
-template Unqual(T)
-{
-    static if (is(T U == shared const U)
-            || is(T U == shared inout U)
-            || is(T U == shared inout const U)
-            || is(T U == inout const U)
-            || is(T U == const U)
-            || is(T U == immutable U)
-            || is(T U == inout U)
-            || is(T U == shared U))
-    {
-        alias Unqual = U;
-    }
-    else
-    {
-        alias Unqual = T;
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(Unqual!bool == bool));
-    static assert(is(Unqual!(immutable bool) == bool));
-    static assert(is(Unqual!(inout bool) == bool));
-    static assert(is(Unqual!(inout const bool) == bool));
-    static assert(is(Unqual!(shared bool) == bool));
-    static assert(is(Unqual!(shared const bool) == bool));
-    static assert(is(Unqual!(shared inout const bool) == bool));
-}
-
-/**
- * If $(D_PARAM T) is an $(D_KEYWORD enum), $(D_INLINECODE OriginalType!T)
- * evaluates to the most base type of that $(D_KEYWORD enum) and to
- * $(D_PARAM T) otherwise.
- *
- * Params:
- *  T = A type.
- *
- * Returns: Base type of the $(D_KEYWORD enum) $(D_PARAM T) or $(D_PARAM T)
- *          itself.
- */
-template OriginalType(T)
-{
-    static if (is(T U == enum))
-    {
-        alias OriginalType = OriginalType!U;
-    }
-    else
-    {
-        alias OriginalType = T;
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    enum E1 : const(int)
-    {
-        n = 0,
-    }
-    enum E2 : bool
-    {
-        t = true,
-    }
-    enum E3 : E2
-    {
-        t = E2.t,
-    }
-    enum E4 : const(E2)
-    {
-        t = E2.t,
-    }
-
-    static assert(is(OriginalType!E1 == const int));
-    static assert(is(OriginalType!E2 == bool));
-    static assert(is(OriginalType!E3 == bool));
-    static assert(is(OriginalType!E4 == bool));
-    static assert(is(OriginalType!(const E4) == bool));
-}
-
-/**
- * Copies constness of $(D_PARAM From) to $(D_PARAM To).
- *
- * The following type qualifiers affect the constness and hence are copied:
- * $(UL
- *  $(LI const)
- *  $(LI immutable)
- *  $(LI inout)
- *  $(LI inout const)
- * )
- *
- * Params:
- *  From = Source type.
- *  To   = Target type.
- *
- * Returns: $(D_PARAM To) with the constness of $(D_PARAM From).
- */
-template CopyConstness(From, To)
-{
-    static if (is(From T == immutable T))
-    {
-        alias CopyConstness = immutable To;
-    }
-    else static if (is(From T == const T) || is(From T == shared const T))
-    {
-        alias CopyConstness = const To;
-    }
-    else static if (is(From T == inout T) || is(From T == shared inout T))
-    {
-        alias CopyConstness = inout To;
-    }
-    else static if (is(From T == inout const T)
-                 || is(From T == shared inout const T))
-    {
-        alias CopyConstness = inout const To;
-    }
-    else
-    {
-        alias CopyConstness = To;
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(CopyConstness!(int, char) == char));
-    static assert(is(CopyConstness!(const int, char) == const char));
-    static assert(is(CopyConstness!(immutable int, char) == immutable char));
-    static assert(is(CopyConstness!(inout int, char) == inout char));
-    static assert(is(CopyConstness!(inout const int, char) == inout const char));
-
-    static assert(is(CopyConstness!(shared int, char) == char));
-    static assert(is(CopyConstness!(shared const int, char) == const char));
-    static assert(is(CopyConstness!(shared inout int, char) == inout char));
-    static assert(is(CopyConstness!(shared inout const int, char) == inout const char));
-
-    static assert(is(CopyConstness!(const int, shared char) == shared const char));
-    static assert(is(CopyConstness!(const int, immutable char) == immutable char));
-    static assert(is(CopyConstness!(immutable int, const char) == immutable char));
-}
-
-/**
- * Retrieves the target type `U` of a pointer `U*`.
- *
- * Params:
- *  T = Pointer type.
- *
- * Returns: Pointer target type.
- */
-template PointerTarget(T)
-{
-    static if (is(T U : U*))
-    {
-        alias PointerTarget = U;
-    }
-    else
-    {
-        static assert(T.stringof ~ " isn't a pointer type");
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(PointerTarget!(bool*) == bool));
-    static assert(is(PointerTarget!(const bool*) == const bool));
-    static assert(is(PointerTarget!(const shared bool*) == const shared bool));
-    static assert(!is(PointerTarget!bool));
-}
-
-/**
- * Params:
- *  T = The type of the associative array.
- *
- * Returns: The key type of the associative array $(D_PARAM T).
- */
-template KeyType(T)
-{
-    static if (is(T V : V[K], K))
-    {
-        alias KeyType = K;
-    }
-    else
-    {
-        static assert(false, T.stringof ~ " isn't an associative array");
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(KeyType!(int[string]) == string));
-    static assert(!is(KeyType!(int[15])));
-}
-
-/**
- * Params:
- *  T = The type of the associative array.
- *
- * Returns: The value type of the associative array $(D_PARAM T).
- */
-template ValueType(T)
-{
-    static if (is(T V : V[K], K))
-    {
-        alias ValueType = V;
-    }
-    else
-    {
-        static assert(false, T.stringof ~ " isn't an associative array");
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(ValueType!(int[string]) == int));
-    static assert(!is(ValueType!(int[15])));
-}
-
-/**
- * Adds $(D_KEYWORD inout) qualifier to the type $(D_PARAM T).
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_INLINECODE inout(T)).
- */
-alias InoutOf(T) = inout(T);
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(InoutOf!int == inout int));
-}
-
-/**
- * Adds $(D_KEYWORD inout) qualifier to the type $(D_PARAM T).
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_INLINECODE inout(T)).
- */
-alias ConstOf(T) = const(T);
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(ConstOf!int == const int));
-}
-
-/**
- * Adds $(D_KEYWORD inout) qualifier to the type $(D_PARAM T).
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_INLINECODE inout(T)).
- */
-alias SharedOf(T) = shared(T);
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(SharedOf!int == shared int));
-}
-
-/**
- * Adds $(D_KEYWORD inout) qualifier to the type $(D_PARAM T).
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_INLINECODE inout(T)).
- */
-alias SharedInoutOf(T) = shared(inout T);
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(SharedInoutOf!int == shared inout int));
-}
-
-/**
- * Adds $(D_KEYWORD shared const) qualifier to the type $(D_PARAM T).
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_INLINECODE shared(const T)).
- */
-alias SharedConstOf(T) = shared(const T);
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(SharedConstOf!int == shared const int));
-}
-
-/**
- * Adds $(D_KEYWORD immutable) qualifier to the type $(D_PARAM T).
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_INLINECODE immutable(T)).
- */
-alias ImmutableOf(T) = immutable(T);
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(ImmutableOf!int == immutable int));
-}
-
-/**
- * Adds $(D_KEYWORD inout const) qualifier to the type $(D_PARAM T).
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_INLINECODE inout(const T)).
- */
-alias InoutConstOf(T) = inout(const T);
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(InoutConstOf!int == inout const int));
-}
-
-/**
- * Adds $(D_KEYWORD shared inout const) qualifier to the type $(D_PARAM T).
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_INLINECODE shared(inout const T)).
- */
-alias SharedInoutConstOf(T) = shared(inout const T);
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(SharedInoutConstOf!int == shared inout const int));
-}
-
-/**
- * Determines the type of $(D_PARAM T). If $(D_PARAM T) is already a type,
- * $(D_PSYMBOL TypeOf) aliases itself to $(D_PARAM T).
- *
- * $(D_PSYMBOL TypeOf) evaluates to $(D_KEYWORD void) for template arguments.
- *
- * The symbols that don't have a type and aren't types cannot be used as
- * arguments to $(D_PSYMBOL TypeOf).
- *
- * Params:
- *  T = Expression, type or template.
- *
- * Returns: The type of $(D_PARAM T).
- */
-alias TypeOf(T) = T;
-
-/// ditto
-template TypeOf(alias T)
-if (isExpressions!T || __traits(isTemplate, T))
-{
-    alias TypeOf = typeof(T);
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    struct S(T)
-    {
-    }
-    static assert(is(TypeOf!S == void));
-    static assert(is(TypeOf!int == int));
-    static assert(is(TypeOf!true == bool));
-    static assert(!is(TypeOf!(tanya.meta)));
-}
-
-/**
- * Finds the type with the smallest size in the $(D_PARAM Args) list. If
- * several types have the same type, the leftmost is returned.
- *
- * Params:
- *  Args = Type list.
- *
- * Returns: The smallest type.
- *
- * See_Also: $(D_PSYMBOL Largest).
- */
-template Smallest(Args...)
-if (Args.length >= 1)
-{
-    static assert(is(Args[0]), T.stringof ~ " doesn't have .sizeof property");
-
-    static if (Args.length == 1)
-    {
-        alias Smallest = Args[0];
-    }
-    else static if (Smallest!(Args[1 .. $]).sizeof < Args[0].sizeof)
-    {
-        alias Smallest = Smallest!(Args[1 .. $]);
-    }
-    else
-    {
-        alias Smallest = Args[0];
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(Smallest!(int, ushort, uint, short) == ushort));
-    static assert(is(Smallest!(short) == short));
-    static assert(is(Smallest!(ubyte[8], ubyte[5]) == ubyte[5]));
-    static assert(!is(Smallest!(short, 5)));
-}
-
-/**
- * Finds the type with the largest size in the $(D_PARAM Args) list. If several
- * types have the same type, the leftmost is returned.
- *
- * Params:
- *  Args = Type list.
- *
- * Returns: The largest type.
- *
- * See_Also: $(D_PSYMBOL Smallest).
- */
-template Largest(Args...)
-if (Args.length >= 1)
-{
-    static assert(is(Args[0]), T.stringof ~ " doesn't have .sizeof property");
-
-    static if (Args.length == 1)
-    {
-        alias Largest = Args[0];
-    }
-    else static if (Largest!(Args[1 .. $]).sizeof > Args[0].sizeof)
-    {
-        alias Largest = Largest!(Args[1 .. $]);
-    }
-    else
-    {
-        alias Largest = Args[0];
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(Largest!(int, short, uint) == int));
-    static assert(is(Largest!(short) == short));
-    static assert(is(Largest!(ubyte[8], ubyte[5]) == ubyte[8]));
-    static assert(!is(Largest!(short, 5)));
-}

middle/dub.json

@@ -1,22 +0,0 @@
-{
-	"name": "middle",
-	"description": "Runtime, middle-level utilities",
-	"targetType": "library",
-
-	"dependencies": {
-		"tanya:meta": "*",
-		"tanya:os": "*"
-	},
-
-	"dependencies-linux": {
-		"mir-linux-kernel": "~>1.0.0"
-	},
-
-	"sourcePaths": [
-		"."
-	],
-	"importPaths": [
-		"."
-	],
-	"dflags-dmd": ["-dip1000"]
-}

middle/tanya/memory/allocator.d

@@ -1,529 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-/**
- * This module contains the interface for implementing custom allocators.
- *
- * Allocators are classes encapsulating memory allocation strategy. This allows
- * to decouple memory management from the algorithms and the data. 
- *
- * Copyright: Eugene Wissner 2016-2020.
- * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
- *                  Mozilla Public License, v. 2.0).
- * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
- * Source: $(LINK2 https://github.com/caraus-ecms/tanya/blob/master/middle/tanya/memory/allocator.d,
- *                 tanya/memory/allocator.d)
- */
-module tanya.memory.allocator;
-
-import tanya.memory.lifetime;
-import tanya.meta.trait;
-
-/**
- * Abstract class implementing a basic allocator.
- */
-interface Allocator
-{
-    /**
-     * Returns: Alignment offered.
-     */
-    @property uint alignment() const shared pure nothrow @safe @nogc;
-
-    /**
-     * Allocates $(D_PARAM size) bytes of memory.
-     *
-     * Params:
-     *  size = Amount of memory to allocate.
-     *
-     * Returns: Pointer to the new allocated memory.
-     */
-    void[] allocate(size_t size) shared pure nothrow @nogc;
-
-    /**
-     * Deallocates a memory block.
-     *
-     * Params:
-     *  p = A pointer to the memory block to be freed.
-     *
-     * Returns: Whether the deallocation was successful.
-     */
-    bool deallocate(void[] p) shared pure nothrow @nogc;
-
-    /**
-     * Increases or decreases the size of a memory block.
-     *
-     * Params:
-     *  p    = A pointer to the memory block.
-     *  size = Size of the reallocated block.
-     *
-     * Returns: Pointer to the allocated memory.
-     */
-    bool reallocate(ref void[] p, size_t size) shared pure nothrow @nogc;
-
-    /**
-     * Reallocates a memory block in place if possible or returns
-     * $(D_KEYWORD false). This function cannot be used to allocate or
-     * deallocate memory, so if $(D_PARAM p) is $(D_KEYWORD null) or
-     * $(D_PARAM size) is `0`, it should return $(D_KEYWORD false).
-     *
-     * Params:
-     *  p    = A pointer to the memory block.
-     *  size = Size of the reallocated block.
-     *
-     * Returns: $(D_KEYWORD true) if successful, $(D_KEYWORD false) otherwise.
-     */
-    bool reallocateInPlace(ref void[] p, size_t size)
-    shared pure nothrow @nogc;
-}
-
-package template GetPureInstance(T : Allocator)
-{
-    alias GetPureInstance = shared(T) function()
-                            pure nothrow @nogc;
-}
-
-/**
- * The mixin generates common methods for classes and structs using
- * allocators. It provides a protected member, constructor and a read-only property,
- * that checks if an allocator was already set and sets it to the default
- * one, if not (useful for structs which don't have a default constructor).
- */
-mixin template DefaultAllocator()
-{
-    /// Allocator.
-    protected shared Allocator allocator_;
-
-    /**
-     * Params:
-     *  allocator = The allocator should be used.
-     *
-     * Precondition: $(D_INLINECODE allocator_ !is null)
-     */
-    this(shared Allocator allocator) @nogc nothrow pure @safe
-    in
-    {
-        assert(allocator !is null);
-    }
-    do
-    {
-        this.allocator_ = allocator;
-    }
-
-    /**
-     * This property checks if the allocator was set in the constructor
-     * and sets it to the default one, if not.
-     *
-     * Returns: Used allocator.
-     *
-     * Postcondition: $(D_INLINECODE allocator !is null)
-     */
-    @property shared(Allocator) allocator() @nogc nothrow pure @safe
-    out (allocator)
-    {
-        assert(allocator !is null);
-    }
-    do
-    {
-        if (allocator_ is null)
-        {
-            allocator_ = defaultAllocator;
-        }
-        return allocator_;
-    }
-
-    /// ditto
-    @property shared(Allocator) allocator() const @nogc nothrow pure @trusted
-    out (allocator)
-    {
-        assert(allocator !is null);
-    }
-    do
-    {
-        if (allocator_ is null)
-        {
-            return defaultAllocator;
-        }
-        return cast(shared Allocator) allocator_;
-    }
-}
-
-shared Allocator allocator;
-
-private shared(Allocator) getAllocatorInstance() @nogc nothrow
-{
-    if (allocator is null)
-    {
-        version (TanyaNative)
-        {
-            import tanya.memory.mmappool : MmapPool;
-            defaultAllocator = MmapPool.instance;
-        }
-        else
-        {
-            import tanya.memory.mallocator : Mallocator;
-            defaultAllocator = Mallocator.instance;
-        }
-    }
-    return allocator;
-}
-
-/**
- * Returns: Default allocator.
- *
- * Postcondition: $(D_INLINECODE allocator !is null).
- */
-@property shared(Allocator) defaultAllocator() @nogc nothrow pure @trusted
-out (allocator)
-{
-    assert(allocator !is null);
-}
-do
-{
-    return (cast(GetPureInstance!Allocator) &getAllocatorInstance)();
-}
-
-/**
- * Sets the default allocator.
- *
- * Params:
- *  allocator = $(D_PSYMBOL Allocator) instance.
- *
- * Precondition: $(D_INLINECODE allocator !is null).
- */
-@property void defaultAllocator(shared(Allocator) allocator) @nogc nothrow @safe
-in
-{
-    assert(allocator !is null);
-}
-do
-{
-    .allocator = allocator;
-}
-
-/**
- * Params:
- *  size      = Raw size.
- *  alignment = Alignment.
- *
- * Returns: Aligned size.
- */
-size_t alignedSize(const size_t size, const size_t alignment = 8)
-pure nothrow @safe @nogc
-{
-    return (size - 1) / alignment * alignment + alignment;
-}
-
-/**
- * Error thrown if memory allocation fails.
- */
-final class OutOfMemoryError : Error
-{
-    /**
-     * Constructs new error.
-     *
-     * Params:
-     *  msg  = The message for the exception.
-     *  file = The file where the exception occurred.
-     *  line = The line number where the exception occurred.
-     *  next = The previous exception in the chain of exceptions, if any.
-     */
-    this(string msg = "Out of memory",
-         string file = __FILE__,
-         size_t line = __LINE__,
-         Throwable next = null) @nogc nothrow pure @safe
-    {
-        super(msg, file, line, next);
-    }
-
-    /// ditto
-    this(string msg,
-         Throwable next,
-         string file = __FILE__,
-         size_t line = __LINE__) @nogc nothrow pure @safe
-    {
-        super(msg, file, line, next);
-    }
-}
-
-/**
- * Destroys and deallocates $(D_PARAM p) of type $(D_PARAM T).
- * It is assumed the respective entities had been allocated with the same
- * allocator.
- *
- * Params:
- *  T         = Type of $(D_PARAM p).
- *  allocator = Allocator the $(D_PARAM p) was allocated with.
- *  p         = Object or array to be destroyed.
- */
-void dispose(T)(shared Allocator allocator, auto ref T p)
-{
-    () @trusted { allocator.deallocate(finalize(p)); }();
-    p = null;
-}
-
-/**
- * Constructs a new class instance of type $(D_PARAM T) using $(D_PARAM args)
- * as the parameter list for the constructor of $(D_PARAM T).
- *
- * Params:
- *  T         = Class type.
- *  A         = Types of the arguments to the constructor of $(D_PARAM T).
- *  allocator = Allocator.
- *  args      = Constructor arguments of $(D_PARAM T).
- *
- * Returns: Newly created $(D_PSYMBOL T).
- *
- * Precondition: $(D_INLINECODE allocator !is null)
- */
-T make(T, A...)(shared Allocator allocator, auto ref A args)
-if (is(T == class))
-in
-{
-    assert(allocator !is null);
-}
-do
-{
-    auto mem = (() @trusted => allocator.allocate(stateSize!T))();
-    if (mem is null)
-    {
-        onOutOfMemoryError();
-    }
-    scope (failure)
-    {
-        () @trusted { allocator.deallocate(mem); }();
-    }
-
-    return emplace!T(mem[0 .. stateSize!T], args);
-}
-
-/**
- * Constructs a value object of type $(D_PARAM T) using $(D_PARAM args)
- * as the parameter list for the constructor of $(D_PARAM T) and returns a
- * pointer to the new object.
- *
- * Params:
- *  T         = Object type.
- *  A         = Types of the arguments to the constructor of $(D_PARAM T).
- *  allocator = Allocator.
- *  args      = Constructor arguments of $(D_PARAM T).
- *
- * Returns: Pointer to the created object.
- *
- * Precondition: $(D_INLINECODE allocator !is null)
- */
-T* make(T, A...)(shared Allocator allocator, auto ref A args)
-if (!isPolymorphicType!T && !isAssociativeArray!T && !isArray!T)
-in
-{
-    assert(allocator !is null);
-}
-do
-{
-    auto mem = (() @trusted => allocator.allocate(stateSize!T))();
-    if (mem is null)
-    {
-        onOutOfMemoryError();
-    }
-    scope (failure)
-    {
-        () @trusted { allocator.deallocate(mem); }();
-    }
-    return emplace!T(mem[0 .. stateSize!T], args);
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    int* i = defaultAllocator.make!int(5);
-    assert(*i == 5);
-    defaultAllocator.dispose(i);
-}
-
-/**
- * Constructs a new array with $(D_PARAM n) elements.
- *
- * Params:
- *  T         = Array type.
- *  E         = Array element type.
- *  allocator = Allocator.
- *  n         = Array size.
- *
- * Returns: Newly created array.
- *
- * Precondition: $(D_INLINECODE allocator !is null
- *                           && n <= size_t.max / E.sizeof)
- */
-T make(T : E[], E)(shared Allocator allocator, size_t n)
-in
-{
-    assert(allocator !is null);
-    assert(n <= size_t.max / E.sizeof);
-}
-do
-{
-    auto ret = allocator.resize!E(null, n);
-
-    static if (hasElaborateDestructor!E)
-    {
-        for (auto range = ret; range.length != 0; range = range[1 .. $])
-        {
-            emplace!E(cast(void[]) range[0 .. 1], E.init);
-        }
-    }
-    else
-    {
-        ret[] = E.init;
-    }
-
-    return ret;
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    int[] i = defaultAllocator.make!(int[])(2);
-    assert(i.length == 2);
-    assert(i[0] == int.init && i[1] == int.init);
-    defaultAllocator.dispose(i);
-}
-
-/*
- * Destroys the object.
- * Returns the memory should be freed.
- */
-package void[] finalize(T)(ref T* p)
-{
-    if (p is null)
-    {
-        return null;
-    }
-    static if (hasElaborateDestructor!T)
-    {
-        destroy(*p);
-    }
-    return (cast(void*) p)[0 .. T.sizeof];
-}
-
-package void[] finalize(T)(ref T p)
-if (isPolymorphicType!T)
-{
-    if (p is null)
-    {
-        return null;
-    }
-    static if (is(T == interface))
-    {
-        version(Windows)
-        {
-            import core.sys.windows.unknwn : IUnknown;
-            static assert(!is(T : IUnknown), "COM interfaces can't be destroyed in "
-                                           ~ __PRETTY_FUNCTION__);
-        }
-        auto ob = cast(Object) p;
-    }
-    else
-    {
-        alias ob = p;
-    }
-    auto ptr = cast(void*) ob;
-    auto support = ptr[0 .. typeid(ob).initializer.length];
-
-    auto ppv = cast(void**) ptr;
-    if (!*ppv)
-    {
-        return null;
-    }
-    auto pc = cast(ClassInfo*) *ppv;
-    scope (exit)
-    {
-        *ppv = null;
-    }
-
-    auto c = *pc;
-    do
-    {
-        // Assume the destructor is @nogc. Leave it nothrow since the destructor
-        // shouldn't throw and if it does, it is an error anyway.
-        if (c.destructor)
-        {
-            alias DtorType = void function(Object) pure nothrow @safe @nogc;
-            (cast(DtorType) c.destructor)(ob);
-        }
-    }
-    while ((c = c.base) !is null);
-
-    if (ppv[1]) // if monitor is not null
-    {
-        _d_monitordelete(cast(Object) ptr, true);
-    }
-    return support;
-}
-
-package void[] finalize(T)(ref T[] p)
-{
-    destroyAllImpl!(T[], T)(p);
-    return p;
-}
-
-/**
- * Allocates $(D_PSYMBOL OutOfMemoryError) in a static storage and throws it.
- *
- * Params:
- *  msg = Custom error message.
- *
- * Throws: $(D_PSYMBOL OutOfMemoryError).
- */
-void onOutOfMemoryError(string msg = "Out of memory")
-@nogc nothrow pure @trusted
-{
-    static ubyte[stateSize!OutOfMemoryError] memory;
-    alias PureType = OutOfMemoryError function(string) @nogc nothrow pure;
-    throw (cast(PureType) () => emplace!OutOfMemoryError(memory))(msg);
-}
-
-// From druntime
-extern (C)
-private void _d_monitordelete(Object h, bool det) @nogc nothrow pure;
-
-/*
- * Internal function used to create, resize or destroy a dynamic array. It
- * may throw $(D_PSYMBOL OutOfMemoryError). The new
- * allocated part of the array isn't initialized. This function can be trusted
- * only in the data structures that can ensure that the array is
- * allocated/rellocated/deallocated with the same allocator.
- *
- * Params:
- *  T         = Element type of the array being created.
- *  allocator = The allocator used for getting memory.
- *  array     = A reference to the array being changed.
- *  length    = New array length.
- *
- * Returns: $(D_PARAM array).
- */
-package(tanya) T[] resize(T)(shared Allocator allocator,
-                             auto ref T[] array,
-                             const size_t length) @trusted
-{
-    if (length == 0)
-    {
-        if (allocator.deallocate(array))
-        {
-            return null;
-        }
-        else
-        {
-            onOutOfMemoryError();
-        }
-    }
-
-    void[] buf = array;
-    if (!allocator.reallocate(buf, length * T.sizeof))
-    {
-        onOutOfMemoryError();
-    }
-    // Casting from void[] is unsafe, but we know we cast to the original type.
-    array = cast(T[]) buf;
-
-    return array;
-}

middle/tanya/memory/lifetime.d

@@ -1,540 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-/**
- * Lifetime management functions, types and related exceptions.
- *
- * Copyright: Eugene Wissner 2019-2020.
- * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
- *                  Mozilla Public License, v. 2.0).
- * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
- * Source: $(LINK2 https://github.com/caraus-ecms/tanya/blob/master/middle/tanya/memory/lifetime.d,
- *                 tanya/memory/lifetime.d)
- */
-module tanya.memory.lifetime;
-
-import tanya.memory.allocator;
-import tanya.meta.metafunction;
-import tanya.meta.trait;
-
-package(tanya) void destroyAllImpl(R, E)(R p)
-{
-    static if (hasElaborateDestructor!E)
-    {
-        foreach (ref e; p)
-        {
-            destroy(e);
-        }
-    }
-}
-
-/**
- * Constructs a new object of type $(D_PARAM T) in $(D_PARAM memory) with the
- * given arguments.
- *
- * If $(D_PARAM T) is a $(D_KEYWORD class), emplace returns a class reference
- * of type $(D_PARAM T), otherwise a pointer to the constructed object is
- * returned.
- *
- * If $(D_PARAM T) is a nested class inside another class, $(D_PARAM outer)
- * should be an instance of the outer class.
- *
- * $(D_PARAM args) are arguments for the constructor of $(D_PARAM T). If
- * $(D_PARAM T) isn't an aggregate type and doesn't have a constructor,
- * $(D_PARAM memory) can be initialized to `args[0]` if `Args.length == 1`,
- * `Args[0]` should be implicitly convertible to $(D_PARAM T) then.
- *
- * Params:
- *  T     = Constructed type.
- *  U     = Type of the outer class if $(D_PARAM T) is a nested class.
- *  Args  = Types of the constructor arguments if $(D_PARAM T) has a constructor
- *          or the type of the initial value.
- *  outer = Outer class instance if $(D_PARAM T) is a nested class.
- *  args  = Constructor arguments if $(D_PARAM T) has a constructor or the
- *          initial value.
- *
- * Returns: New instance of type $(D_PARAM T) constructed in $(D_PARAM memory).
- *
- * Precondition: `memory.length == stateSize!T`.
- * Postcondition: $(D_PARAM memory) and the result point to the same memory.
- */
-T emplace(T, U, Args...)(void[] memory, U outer, auto ref Args args)
-if (!isAbstractClass!T && isInnerClass!T && is(typeof(T.outer) == U))
-in
-{
-    assert(memory.length >= stateSize!T);
-}
-out (result)
-{
-    assert(memory.ptr is (() @trusted => cast(void*) result)());
-}
-do
-{
-    import tanya.memory.op : copy;
-
-    copy(typeid(T).initializer, memory);
-
-    auto result = (() @trusted => cast(T) memory.ptr)();
-    result.outer = outer;
-
-    static if (is(typeof(result.__ctor(args))))
-    {
-        result.__ctor(args);
-    }
-
-    return result;
-}
-
-/// ditto
-T emplace(T, Args...)(void[] memory, auto ref Args args)
-if (is(T == class) && !isAbstractClass!T && !isInnerClass!T)
-in
-{
-    assert(memory.length == stateSize!T);
-}
-out (result)
-{
-    assert(memory.ptr is (() @trusted => cast(void*) result)());
-}
-do
-{
-    import tanya.memory.op : copy;
-
-    copy(typeid(T).initializer, memory);
-
-    auto result = (() @trusted => cast(T) memory.ptr)();
-    static if (is(typeof(result.__ctor(args))))
-    {
-        result.__ctor(args);
-    }
-    return result;
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    class C
-    {
-        int i = 5;
-        class Inner
-        {
-            int i;
-
-            this(int param) pure nothrow @safe @nogc
-            {
-                this.i = param;
-            }
-        }
-    }
-    ubyte[stateSize!C] memory1;
-    ubyte[stateSize!(C.Inner)] memory2;
-
-    auto c = emplace!C(memory1);
-    assert(c.i == 5);
-
-    auto inner = emplace!(C.Inner)(memory2, c, 8);
-    assert(c.i == 5);
-    assert(inner.i == 8);
-    assert(inner.outer is c);
-}
-
-/// ditto
-T* emplace(T, Args...)(void[] memory, auto ref Args args)
-if (!isAggregateType!T && (Args.length <= 1))
-in
-{
-    assert(memory.length >= T.sizeof);
-}
-out (result)
-{
-    assert(memory.ptr is result);
-}
-do
-{
-    auto result = (() @trusted => cast(T*) memory.ptr)();
-    static if (Args.length == 1)
-    {
-        *result = T(args[0]);
-    }
-    else
-    {
-        *result = T.init;
-    }
-    return result;
-}
-
-private void initializeOne(T)(ref void[] memory, ref T* result) @trusted
-{
-    import tanya.memory.op : copy, fill;
-
-    static if (!hasElaborateAssign!T && isAssignable!T)
-    {
-        *result = T.init;
-    }
-    else static if (__VERSION__ >= 2083 // __traits(isZeroInit) available.
-        && __traits(isZeroInit, T))
-    {
-        memory.ptr[0 .. T.sizeof].fill!0;
-    }
-    else
-    {
-        static immutable T init = T.init;
-        copy((&init)[0 .. 1], memory);
-    }
-}
-
-/// ditto
-T* emplace(T, Args...)(void[] memory, auto ref Args args)
-if (!isPolymorphicType!T && isAggregateType!T)
-in
-{
-    assert(memory.length >= T.sizeof);
-}
-out (result)
-{
-    assert(memory.ptr is result);
-}
-do
-{
-    auto result = (() @trusted => cast(T*) memory.ptr)();
-
-    static if (Args.length == 0)
-    {
-        static assert(is(typeof({ static T t; })),
-                      "Default constructor is disabled");
-        initializeOne(memory, result);
-    }
-    else static if (is(typeof(result.__ctor(args))))
-    {
-        initializeOne(memory, result);
-        result.__ctor(args);
-    }
-    else static if (Args.length == 1 && is(typeof({ T t = args[0]; })))
-    {
-        import tanya.memory.op : copy;
-
-        ((ref arg) @trusted =>
-            copy((cast(void*) &arg)[0 .. T.sizeof], memory))(args[0]);
-        static if (hasElaborateCopyConstructor!T)
-        {
-            result.__postblit();
-        }
-    }
-    else static if (is(typeof({ T t = T(args); })))
-    {
-        auto init = T(args);
-        (() @trusted => moveEmplace(init, *result))();
-    }
-    else
-    {
-        static assert(false,
-                      "Unable to construct value with the given arguments");
-    }
-    return result;
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    ubyte[4] memory;
-
-    auto i = emplace!int(memory);
-    static assert(is(typeof(i) == int*));
-    assert(*i == 0);
-
-    i = emplace!int(memory, 5);
-    assert(*i == 5);
-
-    static struct S
-    {
-        int i;
-        @disable this();
-        @disable this(this);
-        this(int i) @nogc nothrow pure @safe
-        {
-            this.i = i;
-        }
-    }
-    auto s = emplace!S(memory, 8);
-    static assert(is(typeof(s) == S*));
-    assert(s.i == 8);
-}
-
-private void deinitialize(bool zero, T)(ref T value)
-{
-    static if (is(T == U[S], U, size_t S))
-    {
-        foreach (ref e; value)
-        {
-            deinitialize!zero(e);
-        }
-    }
-    else
-    {
-        import tanya.memory.op : copy, fill;
-
-        static if (isNested!T)
-        {
-            // Don't override the context pointer.
-            enum size_t size = T.sizeof - (void*).sizeof;
-        }
-        else
-        {
-            enum size_t size = T.sizeof;
-        }
-        static if (zero)
-        {
-            fill!0((cast(void*) &value)[0 .. size]);
-        }
-        else
-        {
-            copy(typeid(T).initializer()[0 .. size], (&value)[0 .. 1]);
-        }
-    }
-}
-
-/**
- * Moves $(D_PARAM source) into $(D_PARAM target) assuming that
- * $(D_PARAM target) isn't initialized.
- *
- * Moving the $(D_PARAM source) copies it into the $(D_PARAM target) and places
- * the $(D_PARAM source) into a valid but unspecified state, which means that
- * after moving $(D_PARAM source) can be destroyed or assigned a new value, but
- * accessing it yields an unspecified value. No postblits or destructors are
- * called. If the $(D_PARAM target) should be destroyed before, use
- * $(D_PSYMBOL move).
- *
- * $(D_PARAM source) and $(D_PARAM target) must be different objects.
- *
- * Params:
- *  T      = Object type.
- *  source = Source object.
- *  target = Target object.
- *
- * See_Also: $(D_PSYMBOL move),
- *           $(D_PSYMBOL hasElaborateCopyConstructor),
- *           $(D_PSYMBOL hasElaborateDestructor).
- *
- * Precondition: `&source !is &target`.
- */
-void moveEmplace(T)(ref T source, ref T target) @system
-in
-{
-    assert(&source !is &target, "Source and target must be different");
-}
-do
-{
-    static if (is(T == struct) || isStaticArray!T)
-    {
-        import tanya.memory.op : copy;
-
-        copy((&source)[0 .. 1], (&target)[0 .. 1]);
-
-        static if (hasElaborateCopyConstructor!T || hasElaborateDestructor!T)
-        {
-            static if (__VERSION__ >= 2083) // __traits(isZeroInit) available.
-            {
-                deinitialize!(__traits(isZeroInit, T))(source);
-            }
-            else
-            {
-                if (typeid(T).initializer().ptr is null)
-                {
-                    deinitialize!true(source);
-                }
-                else
-                {
-                    deinitialize!false(source);
-                }
-            }
-        }
-    }
-    else
-    {
-        target = source;
-    }
-}
-
-///
-@nogc nothrow pure @system unittest
-{
-    static struct S
-    {
-        int member = 5;
-
-        this(this) @nogc nothrow pure @safe
-        {
-            assert(false);
-        }
-    }
-    S source, target = void;
-    moveEmplace(source, target);
-    assert(target.member == 5);
-
-    int x1 = 5, x2;
-    moveEmplace(x1, x2);
-    assert(x2 == 5);
-}
-
-/**
- * Moves $(D_PARAM source) into $(D_PARAM target) assuming that
- * $(D_PARAM target) isn't initialized.
- *
- * Moving the $(D_PARAM source) copies it into the $(D_PARAM target) and places
- * the $(D_PARAM source) into a valid but unspecified state, which means that
- * after moving $(D_PARAM source) can be destroyed or assigned a new value, but
- * accessing it yields an unspecified value. $(D_PARAM target) is destroyed before
- * the new value is assigned. If $(D_PARAM target) isn't initialized and
- * therefore shouldn't be destroyed, $(D_PSYMBOL moveEmplace) can be used.
- *
- * If $(D_PARAM target) isn't specified, $(D_PSYMBOL move) returns the source
- * as rvalue without calling its copy constructor or destructor.
- *
- * $(D_PARAM source) and $(D_PARAM target) are the same object,
- * $(D_PSYMBOL move) does nothing.
- *
- * Params:
- *  T      = Object type.
- *  source = Source object.
- *  target = Target object.
- *
- * See_Also: $(D_PSYMBOL moveEmplace).
- */
-void move(T)(ref T source, ref T target)
-{
-    if ((() @trusted => &source is &target)())
-    {
-        return;
-    }
-    static if (hasElaborateDestructor!T)
-    {
-        target.__xdtor();
-    }
-    (() @trusted => moveEmplace(source, target))();
-}
-
-/// ditto
-T move(T)(ref T source) @trusted
-{
-    static if (hasElaborateCopyConstructor!T || hasElaborateDestructor!T)
-    {
-        T target = void;
-        moveEmplace(source, target);
-        return target;
-    }
-    else
-    {
-        return source;
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static struct S
-    {
-        int member = 5;
-
-        this(this) @nogc nothrow pure @safe
-        {
-            assert(false);
-        }
-    }
-    S source, target = void;
-    move(source, target);
-    assert(target.member == 5);
-    assert(move(target).member == 5);
-
-    int x1 = 5, x2;
-    move(x1, x2);
-    assert(x2 == 5);
-    assert(move(x2) == 5);
-}
-
-/**
- * Exchanges the values of $(D_PARAM a) and $(D_PARAM b).
- *
- * $(D_PSYMBOL swap) moves the contents of $(D_PARAM a) and $(D_PARAM b)
- * without calling its postblits or destructors.
- *
- * Params:
- *  a = The first object.
- *  b = The second object.
- */
-void swap(T)(ref T a, ref T b) @trusted
-{
-    T tmp = void;
-    moveEmplace(a, tmp);
-    moveEmplace(b, a);
-    moveEmplace(tmp, b);
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    int a = 3, b = 5;
-    swap(a, b);
-    assert(a == 5);
-    assert(b == 3);
-}
-
-/**
- * Forwards its argument list preserving $(D_KEYWORD ref) and $(D_KEYWORD out)
- * storage classes.
- *
- * $(D_PSYMBOL forward) accepts a list of variables or literals. It returns an
- * argument list of the same length that can be for example passed to a
- * function accepting the arguments of this type.
- *
- * Params:
- *  args = Argument list.
- *
- * Returns: $(D_PARAM args) with their original storage classes.
- */
-template forward(args...)
-{
-    static if (args.length == 0)
-    {
-        alias forward = AliasSeq!();
-    }
-    else static if (__traits(isRef, args[0]) || __traits(isOut, args[0]))
-    {
-        static if (args.length == 1)
-        {
-            alias forward = args[0];
-        }
-        else
-        {
-            alias forward = AliasSeq!(args[0], forward!(args[1 .. $]));
-        }
-    }
-    else
-    {
-        @property auto forwardOne()
-        {
-            return move(args[0]);
-        }
-        static if (args.length == 1)
-        {
-            alias forward = forwardOne;
-        }
-        else
-        {
-            alias forward = AliasSeq!(forwardOne, forward!(args[1 .. $]));
-        }
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(typeof((int i) { int v = forward!i; })));
-    static assert(is(typeof((ref int i) { int v = forward!i; })));
-    static assert(is(typeof({
-        void f(int i, ref int j, out int k)
-        {
-            f(forward!(i, j, k));
-        }
-    })));
-}

middle/tanya/memory/mallocator.d

@@ -1,213 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-/**
- * Allocator based on $(D_PSYMBOL malloc), $(D_PSYMBOL realloc) and
- * $(D_PSYMBOL free).
- *
- * Copyright: Eugene Wissner 2017-2020.
- * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
- *                  Mozilla Public License, v. 2.0).
- * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
- * Source: $(LINK2 https://github.com/caraus-ecms/tanya/blob/master/middle/tanya/memory/mallocator.d,
- *                 tanya/memory/mallocator.d)
- */
-module tanya.memory.mallocator;
-
-import core.stdc.stdlib;
-import tanya.memory.allocator;
-
-/**
- * Wrapper for $(D_PSYMBOL malloc)/$(D_PSYMBOL realloc)/$(D_PSYMBOL free) from
- * the C standard library.
- */
-final class Mallocator : Allocator
-{
-    private alias MallocType = extern (C) void* function(size_t)
-                               @nogc nothrow pure @system;
-    private alias FreeType = extern (C) void function(void*)
-                             @nogc nothrow pure @system;
-    private alias ReallocType = extern (C) void* function(void*, size_t)
-                                @nogc nothrow pure @system;
-
-    /**
-     * Allocates $(D_PARAM size) bytes of memory.
-     *
-     * Params:
-     *  size = Amount of memory to allocate.
-     *
-     * Returns: The pointer to the new allocated memory.
-     */
-    void[] allocate(size_t size) @nogc nothrow pure shared @system
-    {
-        if (size == 0)
-        {
-            return null;
-        }
-        auto p = (cast(MallocType) &malloc)(size + psize);
-
-        return p is null ? null : p[psize .. psize + size];
-    }
-
-    ///
-    @nogc nothrow pure @system unittest
-    {
-        auto p = Mallocator.instance.allocate(20);
-        assert(p.length == 20);
-        Mallocator.instance.deallocate(p);
-
-        p = Mallocator.instance.allocate(0);
-        assert(p.length == 0);
-    }
-
-    /**
-     * Deallocates a memory block.
-     *
-     * Params:
-     *  p = A pointer to the memory block to be freed.
-     *
-     * Returns: Whether the deallocation was successful.
-     */
-    bool deallocate(void[] p) @nogc nothrow pure shared @system
-    {
-        if (p !is null)
-        {
-            (cast(FreeType) &free)(p.ptr - psize);
-        }
-        return true;
-    }
-
-    ///
-    @nogc nothrow pure @system unittest
-    {
-        void[] p;
-        assert(Mallocator.instance.deallocate(p));
-
-        p = Mallocator.instance.allocate(10);
-        assert(Mallocator.instance.deallocate(p));
-    }
-
-    /**
-     * Reallocating in place isn't supported.
-     *
-     * Params:
-     *  p    = A pointer to the memory block.
-     *  size = Size of the reallocated block.
-     *
-     * Returns: $(D_KEYWORD false).
-     */
-    bool reallocateInPlace(ref void[] p, size_t size)
-    @nogc nothrow pure shared @system
-    {
-        cast(void) size;
-        return false;
-    }
-
-    ///
-    @nogc nothrow pure @system unittest
-    {
-        void[] p;
-        assert(!Mallocator.instance.reallocateInPlace(p, 8));
-    }
-
-    /**
-     * Increases or decreases the size of a memory block.
-     *
-     * Params:
-     *  p    = A pointer to the memory block.
-     *  size = Size of the reallocated block.
-     *
-     * Returns: Whether the reallocation was successful.
-     */
-    bool reallocate(ref void[] p, size_t size)
-    @nogc nothrow pure shared @system
-    {
-        if (size == 0)
-        {
-            if (deallocate(p))
-            {
-                p = null;
-                return true;
-            }
-        }
-        else if (p is null)
-        {
-            p = allocate(size);
-            return p is null ? false : true;
-        }
-        else
-        {
-            auto r = (cast(ReallocType) &realloc)(p.ptr - psize, size + psize);
-
-            if (r !is null)
-            {
-                p = r[psize .. psize + size];
-                return true;
-            }
-        }
-        return false;
-    }
-
-    ///
-    @nogc nothrow pure @system unittest
-    {
-        void[] p;
-
-        assert(Mallocator.instance.reallocate(p, 20));
-        assert(p.length == 20);
-
-        assert(Mallocator.instance.reallocate(p, 30));
-        assert(p.length == 30);
-
-        assert(Mallocator.instance.reallocate(p, 10));
-        assert(p.length == 10);
-
-        assert(Mallocator.instance.reallocate(p, 0));
-        assert(p is null);
-    }
-
-    /**
-     * Returns: The alignment offered.
-     */
-    @property uint alignment() const @nogc nothrow pure @safe shared
-    {
-        return (void*).alignof;
-    }
-
-    static private shared(Mallocator) instantiate() @nogc nothrow @system
-    {
-        if (instance_ is null)
-        {
-            const size = __traits(classInstanceSize, Mallocator) + psize;
-            void* p = malloc(size);
-
-            if (p !is null)
-            {
-                p[psize .. size] = typeid(Mallocator).initializer[];
-                instance_ = cast(shared Mallocator) p[psize .. size].ptr;
-            }
-        }
-        return instance_;
-    }
-
-    /**
-     * Static allocator instance and initializer.
-     *
-     * Returns: The global $(D_PSYMBOL Allocator) instance.
-     */
-    static @property shared(Mallocator) instance() @nogc nothrow pure @system
-    {
-        return (cast(GetPureInstance!Mallocator) &instantiate)();
-    }
-
-    ///
-    @nogc nothrow pure @system unittest
-    {
-        assert(instance is instance);
-    }
-
-    private enum ushort psize = 8;
-
-    private shared static Mallocator instance_;
-}

middle/tanya/memory/mmappool.d

@@ -1,544 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-/*
- * Native allocator.
- *
- * Copyright: Eugene Wissner 2016-2020.
- * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
- *                  Mozilla Public License, v. 2.0).
- * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
- * Source: $(LINK2 https://github.com/caraus-ecms/tanya/blob/master/middle/tanya/memory/mmappool.d,
- *                 tanya/memory/mmappool.d)
- */
-module tanya.memory.mmappool;
-
-import core.sys.linux.sys.mman;
-import tanya.memory.allocator;
-import tanya.memory.op;
-import tanya.os.error;
-
-version (Windows)
-{
-    import core.sys.windows.basetsd : SIZE_T;
-    import core.sys.windows.windef : BOOL, DWORD;
-    import core.sys.windows.winnt : MEM_COMMIT, MEM_RELEASE, PAGE_READWRITE, PVOID;
-
-    extern (Windows)
-    private PVOID VirtualAlloc(PVOID, SIZE_T, DWORD, DWORD)
-    @nogc nothrow pure @system;
-
-    extern (Windows)
-    private BOOL VirtualFree(shared PVOID, SIZE_T, DWORD)
-    @nogc nothrow pure @system;
-}
-else
-{
-    extern(C) pragma(mangle, "mmap")
-    private void* mapMemory(void *addr, size_t length, int prot, int flags, int fd, off_t offset)
-    @nogc nothrow pure @system;
-
-    extern(C) pragma(mangle, "munmap")
-    private bool unmapMemory(shared void* addr, size_t length)
-    @nogc nothrow pure @system;
-}
-
-/*
- * This allocator allocates memory in regions (multiple of 64 KB for example).
- * Each region is then splitted in blocks. So it doesn't request the memory
- * from the operating system on each call, but only if there are no large
- * enough free blocks in the available regions.
- * Deallocation works in the same way. Deallocation doesn't immediately
- * gives the memory back to the operating system, but marks the appropriate
- * block as free and only if all blocks in the region are free, the complete
- * region is deallocated.
- *
- * <pre>
- * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- * |      |     |         |     |            ||      |     |                  |
- * |      |prev <-----------    |            ||      |     |                  |
- * |  R   |  B  |         |  B  |            ||   R  |  B  |                  |
- * |  E   |  L  |         |  L  |           next  E  |  L  |                  |
- * |  G   |  O  |  DATA   |  O  |   FREE    --->  G  |  O  |       DATA       |
- * |  I   |  C  |         |  C  |           <---  I  |  C  |                  |
- * |  O   |  K  |         |  K  |           prev  O  |  K  |                  |
- * |  N   |    -----------> next|            ||   N  |     |                  |
- * |      |     |         |     |            ||      |     |                  |
- * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- * </pre>
- */
-final class MmapPool : Allocator
-{
-    version (none)
-    {
-        @nogc nothrow pure @system invariant
-        {
-            for (auto r = &head; *r !is null; r = &((*r).next))
-            {
-                auto block = cast(Block) (cast(void*) *r + RegionEntry.sizeof);
-                do
-                {
-                    assert(block.prev is null || block.prev.next is block);
-                    assert(block.next is null || block.next.prev is block);
-                    assert(block.region is *r);
-                }
-                while ((block = block.next) !is null);
-            }
-        }
-    }
-
-    /*
-     * Allocates $(D_PARAM size) bytes of memory.
-     *
-     * Params:
-     *  size = Amount of memory to allocate.
-     *
-     * Returns: Pointer to the new allocated memory.
-     */
-    void[] allocate(size_t size) @nogc nothrow pure shared @system
-    {
-        if (size == 0)
-        {
-            return null;
-        }
-        const dataSize = addAlignment(size);
-        if (dataSize < size)
-        {
-            return null;
-        }
-
-        void* data = findBlock(dataSize);
-        if (data is null)
-        {
-            data = initializeRegion(dataSize);
-        }
-
-        return data is null ? null : data[0 .. size];
-    }
-
-    /*
-     * Search for a block large enough to keep $(D_PARAM size) and split it
-     * into two blocks if the block is too large.
-     *
-     * Params:
-     *  size = Minimum size the block should have (aligned).
-     *
-     * Returns: Data the block points to or $(D_KEYWORD null).
-     */
-    private void* findBlock(const ref size_t size)
-    @nogc nothrow pure shared @system
-    {
-        Block block1;
-        RegionLoop: for (auto r = head; r !is null; r = r.next)
-        {
-            block1 = cast(Block) (cast(void*) r + RegionEntry.sizeof);
-            do
-            {
-                if (block1.free && block1.size >= size)
-                {
-                    break RegionLoop;
-                }
-            }
-            while ((block1 = block1.next) !is null);
-        }
-        if (block1 is null)
-        {
-            return null;
-        }
-        else if (block1.size >= size + alignment_ + BlockEntry.sizeof)
-        { // Split the block if needed
-            Block block2 = cast(Block) (cast(void*) block1 + BlockEntry.sizeof + size);
-            block2.prev = block1;
-            block2.next = block1.next;
-            block2.free = true;
-            block2.size = block1.size - BlockEntry.sizeof - size;
-            block2.region = block1.region;
-
-            if (block1.next !is null)
-            {
-                block1.next.prev = block2;
-            }
-            block1.next = block2;
-            block1.size = size;
-        }
-        block1.free = false;
-        block1.region.blocks = block1.region.blocks + 1;
-
-        return cast(void*) block1 + BlockEntry.sizeof;
-    }
-
-    // Merge block with the next one.
-    private void mergeNext(Block block) const @nogc nothrow pure @safe shared
-    {
-        block.size = block.size + BlockEntry.sizeof + block.next.size;
-        if (block.next.next !is null)
-        {
-            block.next.next.prev = block;
-        }
-        block.next = block.next.next;
-    }
-
-    /*
-     * Deallocates a memory block.
-     *
-     * Params:
-     *  p = A pointer to the memory block to be freed.
-     *
-     * Returns: Whether the deallocation was successful.
-     */
-    bool deallocate(void[] p) @nogc nothrow pure shared @system
-    {
-        if (p.ptr is null)
-        {
-            return true;
-        }
-
-        Block block = cast(Block) (p.ptr - BlockEntry.sizeof);
-        if (block.region.blocks <= 1)
-        {
-            if (block.region.prev !is null)
-            {
-                block.region.prev.next = block.region.next;
-            }
-            else // Replace the list head. It is being deallocated
-            {
-                head = block.region.next;
-            }
-            if (block.region.next !is null)
-            {
-                block.region.next.prev = block.region.prev;
-            }
-            version (Windows)
-                return VirtualFree(block.region, 0, MEM_RELEASE) != 0;
-            else
-                return unmapMemory(block.region, block.region.size) == 0;
-        }
-        // Merge blocks if neigbours are free.
-        if (block.next !is null && block.next.free)
-        {
-            mergeNext(block);
-        }
-        if (block.prev !is null && block.prev.free)
-        {
-            block.prev.size = block.prev.size + BlockEntry.sizeof + block.size;
-            if (block.next !is null)
-            {
-                block.next.prev = block.prev;
-            }
-            block.prev.next = block.next;
-        }
-        else
-        {
-            block.free = true;
-        }
-        block.region.blocks = block.region.blocks - 1;
-        return true;
-    }
-
-    /*
-     * Reallocates a memory block in place if possible or returns
-     * $(D_KEYWORD false). This function cannot be used to allocate or
-     * deallocate memory, so if $(D_PARAM p) is $(D_KEYWORD null) or
-     * $(D_PARAM size) is `0`, it should return $(D_KEYWORD false).
-     *
-     * Params:
-     *  p    = A pointer to the memory block.
-     *  size = Size of the reallocated block.
-     *
-     * Returns: $(D_KEYWORD true) if successful, $(D_KEYWORD false) otherwise.
-     */
-    bool reallocateInPlace(ref void[] p, size_t size)
-    @nogc nothrow pure shared @system
-    {
-        if (p is null || size == 0)
-        {
-            return false;
-        }
-        if (size <= p.length)
-        {
-            // Leave the block as is.
-            p = p.ptr[0 .. size];
-            return true;
-        }
-        Block block1 = cast(Block) (p.ptr - BlockEntry.sizeof);
-
-        if (block1.size >= size)
-        {
-            // Enough space in the current block.
-            p = p.ptr[0 .. size];
-            return true;
-        }
-        const dataSize = addAlignment(size);
-        const pAlignment = addAlignment(p.length);
-        assert(pAlignment >= p.length, "Invalid memory chunk length");
-        const delta = dataSize - pAlignment;
-
-        if (block1.next is null
-         || !block1.next.free
-         || dataSize < size
-         || block1.next.size + BlockEntry.sizeof < delta)
-        {
-            /* - It is the last block in the region
-             * - The next block isn't free
-             * - The next block is too small
-             * - Requested size is too large
-             */
-            return false;
-        }
-        if (block1.next.size >= delta + alignment_)
-        {
-            // Move size from block2 to block1.
-            block1.next.size = block1.next.size - delta;
-            block1.size = block1.size + delta;
-
-            auto block2 = cast(Block) (p.ptr + dataSize);
-            if (block1.next.next !is null)
-            {
-                block1.next.next.prev = block2;
-            }
-            copyBackward((cast(void*) block1.next)[0 .. BlockEntry.sizeof],
-                         (cast(void*) block2)[0 .. BlockEntry.sizeof]);
-            block1.next = block2;
-        }
-        else
-        {
-            // The next block has enough space, but is too small for further
-            // allocations. Merge it with the current block.
-            mergeNext(block1);
-        }
-
-        p = p.ptr[0 .. size];
-        return true;
-    }
-
-    /*
-     * Increases or decreases the size of a memory block.
-     *
-     * Params:
-     *  p    = A pointer to the memory block.
-     *  size = Size of the reallocated block.
-     *
-     * Returns: Whether the reallocation was successful.
-     */
-    bool reallocate(ref void[] p, size_t size)
-    @nogc nothrow pure shared @system
-    {
-        if (size == 0)
-        {
-            if (deallocate(p))
-            {
-                p = null;
-                return true;
-            }
-            return false;
-        }
-        else if (reallocateInPlace(p, size))
-        {
-            return true;
-        }
-        // Can't reallocate in place, allocate a new block,
-        // copy and delete the previous one.
-        void[] reallocP = allocate(size);
-        if (reallocP is null)
-        {
-            return false;
-        }
-        if (p !is null)
-        {
-            copy(p[0 .. p.length < size ? p.length : size], reallocP);
-            deallocate(p);
-        }
-        p = reallocP;
-
-        return true;
-    }
-
-    static private shared(MmapPool) instantiate() @nogc nothrow @system
-    {
-        if (instance_ is null)
-        {
-            const instanceSize = addAlignment(__traits(classInstanceSize,
-                                              MmapPool));
-
-            Region head; // Will become soon our region list head
-            void* data = initializeRegion(instanceSize, head);
-            if (data !is null)
-            {
-                copy(typeid(MmapPool).initializer, data[0 .. instanceSize]);
-                instance_ = cast(shared MmapPool) data;
-                instance_.head = head;
-            }
-        }
-        return instance_;
-    }
-
-    /*
-     * Static allocator instance and initializer.
-     *
-     * Returns: Global $(D_PSYMBOL MmapPool) instance.
-     */
-    static @property shared(MmapPool) instance() @nogc nothrow pure @system
-    {
-        return (cast(GetPureInstance!MmapPool) &instantiate)();
-    }
-
-    /*
-     * Initializes a region for one element.
-     *
-     * Params:
-     *  size = Aligned size of the first data block in the region.
-     *  head = Region list head.
-     *
-     * Returns: A pointer to the data.
-     */
-    private static void* initializeRegion(const size_t size, ref Region head)
-    @nogc nothrow pure @system
-    {
-        const regionSize = calculateRegionSize(size);
-        if (regionSize < size)
-        {
-            return null;
-        }
-        version (Windows)
-        {
-            void* p = VirtualAlloc(null,
-                    regionSize,
-                    MEM_COMMIT,
-                    PAGE_READWRITE);
-            if (p is null)
-            {
-                return null;
-            }
-        }
-        else
-        {
-            void* p = mapMemory(null,
-                    regionSize,
-                    PROT_READ | PROT_WRITE,
-                    MAP_PRIVATE | MAP_ANONYMOUS,
-                    -1,
-                    0);
-            if (cast(ptrdiff_t) p == -1)
-            {
-                return null;
-            }
-        }
-
-        Region region = cast(Region) p;
-        region.blocks = 1;
-        region.size = regionSize;
-
-        // Set the pointer to the head of the region list
-        if (head !is null)
-        {
-            head.prev = region;
-        }
-        region.next = head;
-        region.prev = null;
-        head = region;
-
-        // Initialize the data block
-        void* memoryPointer = p + RegionEntry.sizeof;
-        Block block1 = cast(Block) memoryPointer;
-        block1.size = size;
-        block1.free = false;
-
-        // It is what we want to return
-        void* data = memoryPointer + BlockEntry.sizeof;
-
-        // Free block after data
-        memoryPointer = data + size;
-        Block block2 = cast(Block) memoryPointer;
-        block1.prev = block2.next = null;
-        block1.next = block2;
-        block2.prev = block1;
-        block2.size = regionSize - size - RegionEntry.sizeof - BlockEntry.sizeof * 2;
-        block2.free = true;
-        block1.region = block2.region = region;
-
-        return data;
-    }
-
-    private void* initializeRegion(const size_t size)
-    @nogc nothrow pure shared @system
-    {
-        return initializeRegion(size, this.head);
-    }
-
-    /*
-     * Params:
-     *  x = Space to be aligned.
-     *
-     * Returns: Aligned size of $(D_PARAM x).
-     */
-    private static size_t addAlignment(const size_t x) @nogc nothrow pure @safe
-    {
-        return (x - 1) / alignment_ * alignment_ + alignment_;
-    }
-
-    /*
-     * Params:
-     *  x = Required space.
-     *
-     * Returns: Minimum region size (a multiple of $(D_PSYMBOL pageSize)).
-     */
-    private static size_t calculateRegionSize(ref const size_t x)
-    @nogc nothrow pure @safe
-    {
-        return (x + RegionEntry.sizeof + BlockEntry.sizeof * 2)
-             / pageSize * pageSize + pageSize;
-    }
-
-    /*
-     * Returns: Alignment offered.
-     */
-    @property uint alignment() const @nogc nothrow pure @safe shared
-    {
-        return alignment_;
-    }
-
-    private enum uint alignment_ = 8;
-
-    private shared static MmapPool instance_;
-
-    // Page size.
-    enum size_t pageSize = 65536;
-
-    private shared struct RegionEntry
-    {
-        Region prev;
-        Region next;
-        uint blocks;
-        size_t size;
-    }
-    private alias Region = shared RegionEntry*;
-    private shared Region head;
-
-    private shared struct BlockEntry
-    {
-        Block prev;
-        Block next;
-        Region region;
-        size_t size;
-        bool free;
-    }
-    private alias Block = shared BlockEntry*;
-}
-
-@nogc nothrow pure @system unittest
-{
-    // allocate() check.
-    size_t tooMuchMemory = size_t.max
-        - MmapPool.alignment_
-        - MmapPool.BlockEntry.sizeof * 2
-        - MmapPool.RegionEntry.sizeof
-        - MmapPool.pageSize;
-    assert(MmapPool.instance.allocate(tooMuchMemory) is null);
-
-    assert(MmapPool.instance.allocate(size_t.max) is null);
-
-    // initializeRegion() check.
-    tooMuchMemory = size_t.max - MmapPool.alignment_;
-    assert(MmapPool.instance.allocate(tooMuchMemory) is null);
-}

middle/tanya/memory/op.d

@@ -1,330 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-/**
- * Set of operations on memory blocks.
- *
- * Copyright: Eugene Wissner 2017-2020.
- * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
- *                  Mozilla Public License, v. 2.0).
- * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
- * Source: $(LINK2 https://github.com/caraus-ecms/tanya/blob/master/middle/tanya/memory/op.d,
- *                 tanya/memory/op.d)
- */
-module tanya.memory.op;
-
-import core.stdc.string;
-
-private enum alignMask = size_t.sizeof - 1;
-
-/**
- * Copies $(D_PARAM source) into $(D_PARAM target).
- *
- * $(D_PARAM source) and $(D_PARAM target) shall not overlap so that
- * $(D_PARAM source) points ahead of $(D_PARAM target).
- *
- * $(D_PARAM target) shall have enough space for $(D_INLINECODE source.length)
- * elements.
- *
- * Params:
- *  source = Memory to copy from.
- *  target = Destination memory.
- *
- * See_Also: $(D_PSYMBOL copyBackward).
- *
- * Precondition: $(D_INLINECODE source.length <= target.length).
- */
-void copy(const void[] source, void[] target) @nogc nothrow pure @trusted
-in
-{
-    assert(source.length <= target.length);
-    assert(source.length == 0 || source.ptr !is null);
-    assert(target.length == 0 || target.ptr !is null);
-}
-do
-{
-    memcpy(target.ptr, source.ptr, source.length);
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    ubyte[9] source = [1, 2, 3, 4, 5, 6, 7, 8, 9];
-    ubyte[9] target;
-    source.copy(target);
-    assert(equal(source, target));
-}
-
-/*
- * size_t value each of which bytes is set to `Byte`.
- */
-private template filledBytes(ubyte Byte, ubyte I = 0)
-{
-    static if (I == size_t.sizeof)
-    {
-        enum size_t filledBytes = Byte;
-    }
-    else
-    {
-        enum size_t filledBytes = (filledBytes!(Byte, I + 1) << 8) | Byte;
-    }
-}
-
-/**
- * Fills $(D_PARAM memory) with the single byte $(D_PARAM c).
- *
- * Param:
- *  c      = The value to fill $(D_PARAM memory) with.
- *  memory = Memory block.
- */
-void fill(ubyte c = 0)(void[] memory) @trusted
-in
-{
-    assert(memory.length == 0 || memory.ptr !is null);
-}
-do
-{
-    memset(memory.ptr, c, memory.length);
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    ubyte[9] memory = [1, 2, 3, 4, 5, 6, 7, 8, 9];
-    memory.fill!0();
-    foreach (ubyte v; memory)
-    {
-        assert(v == 0);
-    }
-}
-
-/**
- * Copies starting from the end of $(D_PARAM source) into the end of
- * $(D_PARAM target).
- *
- * $(D_PSYMBOL copyBackward) copies the elements in reverse order, but the
- * order of elements in the $(D_PARAM target) is exactly the same as in the
- * $(D_PARAM source).
- *
- * $(D_PARAM source) and $(D_PARAM target) shall not overlap so that
- * $(D_PARAM target) points ahead of $(D_PARAM source).
- *
- * $(D_PARAM target) shall have enough space for $(D_INLINECODE source.length)
- * elements.
- *
- * Params:
- *  source = Memory to copy from.
- *  target = Destination memory.
- *
- * See_Also: $(D_PSYMBOL copy).
- *
- * Precondition: $(D_INLINECODE source.length <= target.length).
- */
-void copyBackward(const void[] source, void[] target) @nogc nothrow pure @trusted
-in
-{
-    assert(source.length <= target.length);
-    assert(source.length == 0 || source.ptr !is null);
-    assert(target.length == 0 || target.ptr !is null);
-}
-do
-{
-    memmove(target.ptr, source.ptr, source.length);
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    ubyte[6] mem = [ 'a', 'a', 'b', 'b', 'c', 'c' ];
-    ubyte[6] expected = [ 'a', 'a', 'a', 'a', 'b', 'b' ];
-
-    copyBackward(mem[0 .. 4], mem[2 .. $]);
-    assert(equal(expected, mem));
-}
-
-/**
- * Finds the first occurrence of $(D_PARAM needle) in $(D_PARAM haystack) if
- * any.
- *
- * Params:
- *  haystack = Memory block.
- *  needle   = A byte.
- *
- * Returns: The subrange of $(D_PARAM haystack) whose first element is the
- *          first occurrence of $(D_PARAM needle). If $(D_PARAM needle)
- *          couldn't be found, an empty `inout void[]` is returned.
- */
-inout(void[]) find(return inout void[] haystack, ubyte needle)
-@nogc nothrow pure @trusted
-in
-{
-    assert(haystack.length == 0 || haystack.ptr !is null);
-}
-do
-{
-    auto length = haystack.length;
-    const size_t needleWord = size_t.max * needle;
-    enum size_t highBits = filledBytes!(0x01, 0);
-    enum size_t mask = filledBytes!(0x80, 0);
-
-    // Align
-    auto bytes = cast(inout(ubyte)*) haystack;
-    while (length > 0 && ((cast(size_t) bytes) & 3) != 0)
-    {
-        if (*bytes == needle)
-        {
-            return bytes[0 .. length];
-        }
-        ++bytes;
-        --length;
-    }
-
-    // Check if some of the words has the needle
-    auto words = cast(inout(size_t)*) bytes;
-    while (length >= size_t.sizeof)
-    {
-        if ((((*words ^ needleWord) - highBits) & (~*words) & mask) != 0)
-        {
-            break;
-        }
-        ++words;
-        length -= size_t.sizeof;
-    }
-
-    // Find the exact needle position in the word
-    bytes = cast(inout(ubyte)*) words;
-    while (length > 0)
-    {
-        if (*bytes == needle)
-        {
-            return bytes[0 .. length];
-        }
-        ++bytes;
-        --length;
-    }
-
-    return haystack[$ .. $];
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    const ubyte[9] haystack = ['a', 'b', 'c', 'd', 'e', 'f', 'b', 'g', 'h'];
-
-    assert(equal(find(haystack, 'a'), haystack[]));
-    assert(equal(find(haystack, 'b'), haystack[1 .. $]));
-    assert(equal(find(haystack, 'c'), haystack[2 .. $]));
-    assert(equal(find(haystack, 'd'), haystack[3 .. $]));
-    assert(equal(find(haystack, 'e'), haystack[4 .. $]));
-    assert(equal(find(haystack, 'f'), haystack[5 .. $]));
-    assert(equal(find(haystack, 'h'), haystack[8 .. $]));
-    assert(find(haystack, 'i').length == 0);
-
-    assert(find(null, 'a').length == 0);
-}
-
-/**
- * Looks for `\0` in the $(D_PARAM haystack) and returns the part of the
- * $(D_PARAM haystack) ahead of it.
- *
- * Returns $(D_KEYWORD null) if $(D_PARAM haystack) doesn't contain a null
- * character.
- *
- * Params:
- *  haystack = Memory block.
- *
- * Returns: The subrange that spans all bytes before the null character or
- *          $(D_KEYWORD null) if the $(D_PARAM haystack) doesn't contain any.
- */
-inout(char[]) findNullTerminated(return inout char[] haystack)
-@nogc nothrow pure @trusted
-in
-{
-    assert(haystack.length == 0 || haystack.ptr !is null);
-}
-do
-{
-    auto length = haystack.length;
-    enum size_t highBits = filledBytes!(0x01, 0);
-    enum size_t mask = filledBytes!(0x80, 0);
-
-    // Align
-    auto bytes = cast(inout(ubyte)*) haystack;
-    while (length > 0 && ((cast(size_t) bytes) & 3) != 0)
-    {
-        if (*bytes == '\0')
-        {
-            return haystack[0 .. haystack.length - length];
-        }
-        ++bytes;
-        --length;
-    }
-
-    // Check if some of the words contains 0
-    auto words = cast(inout(size_t)*) bytes;
-    while (length >= size_t.sizeof)
-    {
-        if (((*words - highBits) & (~*words) & mask) != 0)
-        {
-            break;
-        }
-        ++words;
-        length -= size_t.sizeof;
-    }
-
-    // Find the exact 0 position in the word
-    bytes = cast(inout(ubyte)*) words;
-    while (length > 0)
-    {
-        if (*bytes == '\0')
-        {
-            return haystack[0 .. haystack.length - length];
-        }
-        ++bytes;
-        --length;
-    }
-
-    return null;
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    assert(equal(findNullTerminated("abcdef\0gh"), "abcdef"));
-    assert(equal(findNullTerminated("\0garbage"), ""));
-    assert(equal(findNullTerminated("\0"), ""));
-    assert(equal(findNullTerminated("cstring\0"), "cstring"));
-    assert(findNullTerminated(null) is null);
-    assert(findNullTerminated("abcdef") is null);
-}
-
-/**
- * Compares two memory areas $(D_PARAM r1) and $(D_PARAM r2) for equality.
- *
- * Params:
- *  r1 = First memory block.
- *  r2 = Second memory block.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM r1) and $(D_PARAM r2) are equal,
- *          $(D_KEYWORD false) otherwise.
- */
-bool equal(const void[] r1, const void[] r2) @nogc nothrow pure @trusted
-in
-{
-    assert(r1.length == 0 || r1.ptr !is null);
-    assert(r2.length == 0 || r2.ptr !is null);
-}
-do
-{
-    return r1.length == r2.length && memcmp(r1.ptr, r2.ptr, r1.length) == 0;
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    assert(equal("asdf", "asdf"));
-    assert(!equal("asd", "asdf"));
-    assert(!equal("asdf", "asd"));
-    assert(!equal("asdf", "qwer"));
-}

middle/tanya/memory/package.d

@@ -1,18 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-/**
- * Dynamic memory management.
- *
- * Copyright: Eugene Wissner 2016-2020.
- * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
- *                  Mozilla Public License, v. 2.0).
- * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
- * Source: $(LINK2 https://github.com/caraus-ecms/tanya/blob/master/middle/tanya/memory/package.d,
- *                 tanya/memory/package.d)
- */
-module tanya.memory;
-
-public import tanya.memory.allocator;
-public import tanya.memory.lifetime;

middle/tanya/memory/smartref.d

@@ -1,667 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-/**
- * Smart pointers.
- *
- * A smart pointer is an object that wraps a raw pointer or a reference
- * (class, dynamic array) to manage its lifetime.
- *
- * This module provides two kinds of lifetime management strategies:
- * $(UL
- *  $(LI Reference counting)
- *  $(LI Unique ownership)
- * )
- *
- * Copyright: Eugene Wissner 2016-2020.
- * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
- *                  Mozilla Public License, v. 2.0).
- * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
- * Source: $(LINK2 https://github.com/caraus-ecms/tanya/blob/master/middle/tanya/memory/smartref.d,
- *                 tanya/memory/smartref.d)
- */
-module tanya.memory.smartref;
-
-import tanya.memory.allocator;
-import tanya.memory.lifetime;
-import tanya.meta.trait;
-
-private template Payload(T)
-{
-    static if (isPolymorphicType!T || isDynamicArray!T)
-    {
-        alias Payload = T;
-    }
-    else
-    {
-        alias Payload = T*;
-    }
-}
-
-private final class RefCountedStore(T)
-{
-    T payload;
-    size_t counter = 1;
-
-    size_t opUnary(string op)()
-    if (op == "--" || op == "++")
-    in
-    {
-        assert(this.counter > 0);
-    }
-    do
-    {
-        mixin("return " ~ op ~ "counter;");
-    }
-
-    int opCmp(const size_t counter)
-    {
-        if (this.counter > counter)
-        {
-            return 1;
-        }
-        else if (this.counter < counter)
-        {
-            return -1;
-        }
-        else
-        {
-            return 0;
-        }
-    }
-}
-
-private void separateDeleter(T)(RefCountedStore!T storage,
-                                shared Allocator allocator)
-{
-    allocator.dispose(storage.payload);
-    allocator.dispose(storage);
-}
-
-private void unifiedDeleter(T)(RefCountedStore!T storage,
-                               shared Allocator allocator)
-{
-    auto ptr1 = finalize(storage);
-    auto ptr2 = finalize(storage.payload);
-    allocator.deallocate(ptr1.ptr[0 .. ptr1.length + ptr2.length]);
-}
-
-/**
- * Reference-counted object containing a $(D_PARAM T) value as payload.
- * $(D_PSYMBOL RefCounted) keeps track of all references of an object, and
- * when the reference count goes down to zero, frees the underlying store.
- *
- * Params:
- *  T = Type of the reference-counted value.
- */
-struct RefCounted(T)
-{
-    private alias Storage = RefCountedStore!(Payload!T);
-
-    private Storage storage;
-    private void function(Storage storage,
-                          shared Allocator allocator) @nogc deleter;
-
-    invariant
-    {
-        assert(this.storage is null || this.allocator_ !is null);
-        assert(this.storage is null || this.deleter !is null);
-    }
-
-    /**
-     * Takes ownership over $(D_PARAM value), setting the counter to 1.
-     * $(D_PARAM value) may be a pointer, an object or a dynamic array.
-     *
-     * Params:
-     *  value     = Value whose ownership is taken over.
-     *  allocator = Allocator used to destroy the $(D_PARAM value) and to
-     *              allocate/deallocate internal storage.
-     *
-     * Precondition: $(D_INLINECODE allocator !is null)
-     */
-    this(Payload!T value, shared Allocator allocator = defaultAllocator)
-    {
-        this(allocator);
-        this.storage = allocator.make!Storage();
-        this.deleter = &separateDeleter!(Payload!T);
-
-        this.storage.payload = value;
-    }
-
-    /// ditto
-    this(shared Allocator allocator)
-    in
-    {
-        assert(allocator !is null);
-    }
-    do
-    {
-        this.allocator_ = allocator;
-    }
-
-    /**
-     * Increases the reference counter by one.
-     */
-    this(this)
-    {
-        if (count != 0)
-        {
-            ++this.storage;
-        }
-    }
-
-    /**
-     * Decreases the reference counter by one.
-     *
-     * If the counter reaches 0, destroys the owned object.
-     */
-    ~this()
-    {
-        if (this.storage !is null && !(this.storage > 0 && --this.storage))
-        {
-            deleter(this.storage, allocator);
-        }
-    }
-
-    /**
-     * Takes ownership over $(D_PARAM rhs). Initializes this
-     * $(D_PSYMBOL RefCounted) if needed.
-     *
-     * If it is the last reference of the previously owned object,
-     * it will be destroyed.
-     *
-     * To reset $(D_PSYMBOL RefCounted) assign $(D_KEYWORD null).
-     *
-     * If the allocator wasn't set before, $(D_PSYMBOL defaultAllocator) will
-     * be used. If you need a different allocator, create a new
-     * $(D_PSYMBOL RefCounted) and assign it.
-     *
-     * Params:
-     *  rhs = New object.
-     *
-     * Returns: $(D_KEYWORD this).
-     */
-    ref typeof(this) opAssign(Payload!T rhs)
-    {
-        if (this.storage is null)
-        {
-            this.storage = allocator.make!Storage();
-            this.deleter = &separateDeleter!(Payload!T);
-        }
-        else if (this.storage > 1)
-        {
-            --this.storage;
-            this.storage = allocator.make!Storage();
-            this.deleter = &separateDeleter!(Payload!T);
-        }
-        else
-        {
-            finalize(this.storage.payload);
-            this.storage.payload = Payload!T.init;
-        }
-        this.storage.payload = rhs;
-        return this;
-    }
-
-    /// ditto
-    ref typeof(this) opAssign(typeof(null))
-    {
-        if (this.storage is null)
-        {
-            return this;
-        }
-        else if (this.storage > 1)
-        {
-            --this.storage;
-        }
-        else
-        {
-            deleter(this.storage, allocator);
-        }
-        this.storage = null;
-
-        return this;
-    }
-
-    /// ditto
-    ref typeof(this) opAssign(typeof(this) rhs)
-    {
-        swap(this.allocator_, rhs.allocator_);
-        swap(this.storage, rhs.storage);
-        swap(this.deleter, rhs.deleter);
-        return this;
-    }
-
-    /**
-     * Returns: Reference to the owned object.
-     *
-     * Precondition: $(D_INLINECODE cound > 0).
-     */
-    inout(Payload!T) get() inout
-    in
-    {
-        assert(count > 0, "Attempted to access an uninitialized reference");
-    }
-    do
-    {
-        return this.storage.payload;
-    }
-
-    version (D_Ddoc)
-    {
-        /**
-         * Dereferences the pointer. It is defined only for pointers, not for
-         * reference types like classes, that can be accessed directly.
-         *
-         * Params:
-         *  op = Operation.
-         *
-         * Returns: Reference to the pointed value.
-         */
-        ref inout(T) opUnary(string op)() inout
-        if (op == "*");
-    }
-    else static if (isPointer!(Payload!T))
-    {
-        ref inout(T) opUnary(string op)() inout
-        if (op == "*")
-        {
-            return *this.storage.payload;
-        }
-    }
-
-    /**
-     * Returns: Whether this $(D_PSYMBOL RefCounted) already has an internal
-     *          storage.
-     */
-    @property bool isInitialized() const
-    {
-        return this.storage !is null;
-    }
-
-    /**
-     * Returns: The number of $(D_PSYMBOL RefCounted) instances that share
-     *          ownership over the same pointer (including $(D_KEYWORD this)).
-     *          If this $(D_PSYMBOL RefCounted) isn't initialized, returns `0`.
-     */
-    @property size_t count() const
-    {
-        return this.storage is null ? 0 : this.storage.counter;
-    }
-
-    mixin DefaultAllocator;
-    alias get this;
-}
-
-///
-@nogc @system unittest
-{
-    auto rc = RefCounted!int(defaultAllocator.make!int(5), defaultAllocator);
-    auto val = rc.get();
-
-    *val = 8;
-    assert(*rc.get == 8);
-
-    val = null;
-    assert(rc.get !is null);
-    assert(*rc.get == 8);
-
-    *rc = 9;
-    assert(*rc.get == 9);
-}
-
-/**
- * Constructs a new object of type $(D_PARAM T) and wraps it in a
- * $(D_PSYMBOL RefCounted) using $(D_PARAM args) as the parameter list for
- * the constructor of $(D_PARAM T).
- *
- * This function is more efficient than the using of $(D_PSYMBOL RefCounted)
- * directly, since it allocates only ones (the internal storage and the
- * object).
- *
- * Params:
- *  T         = Type of the constructed object.
- *  A         = Types of the arguments to the constructor of $(D_PARAM T).
- *  allocator = Allocator.
- *  args      = Constructor arguments of $(D_PARAM T).
- *
- * Returns: Newly created $(D_PSYMBOL RefCounted!T).
- *
- * Precondition: $(D_INLINECODE allocator !is null)
- */
-RefCounted!T refCounted(T, A...)(shared Allocator allocator, auto ref A args)
-if (!is(T == interface) && !isAbstractClass!T
- && !isAssociativeArray!T && !isArray!T)
-in
-{
-    assert(allocator !is null);
-}
-do
-{
-    auto rc = typeof(return)(allocator);
-
-    const storageSize = alignedSize(stateSize!(RefCounted!T.Storage));
-    const size = alignedSize(stateSize!T + storageSize);
-
-    auto mem = (() @trusted => allocator.allocate(size))();
-    if (mem is null)
-    {
-        onOutOfMemoryError();
-    }
-    scope (failure)
-    {
-        () @trusted { allocator.deallocate(mem); }();
-    }
-    rc.storage = emplace!(RefCounted!T.Storage)(mem[0 .. storageSize]);
-    rc.storage.payload = emplace!T(mem[storageSize .. $], args);
-
-    rc.deleter = &unifiedDeleter!(Payload!T);
-    return rc;
-}
-
-/**
- * Constructs a new array with $(D_PARAM size) elements and wraps it in a
- * $(D_PSYMBOL RefCounted).
- *
- * Params:
- *  T         = Array type.
- *  E         = Array element type.
- *  size      = Array size.
- *  allocator = Allocator.
- *
- * Returns: Newly created $(D_PSYMBOL RefCounted!T).
- *
- * Precondition: $(D_INLINECODE allocator !is null
- *                           && size <= size_t.max / E.sizeof)
- */
-RefCounted!T refCounted(T : E[], E)(shared Allocator allocator, size_t size)
-@trusted
-in
-{
-    assert(allocator !is null);
-    assert(size <= size_t.max / E.sizeof);
-}
-do
-{
-    return RefCounted!T(allocator.make!T(size), allocator);
-}
-
-///
-@nogc @system unittest
-{
-    auto rc = defaultAllocator.refCounted!int(5);
-    assert(rc.count == 1);
-
-    void func(RefCounted!int param) @nogc
-    {
-        if (param.count == 2)
-        {
-            func(param);
-        }
-        else
-        {
-            assert(param.count == 3);
-        }
-    }
-    func(rc);
-
-    assert(rc.count == 1);
-}
-
-/**
- * $(D_PSYMBOL Unique) stores an object that gets destroyed at the end of its scope.
- *
- * Params:
- *  T = Value type.
- */
-struct Unique(T)
-{
-    private Payload!T payload;
-
-    invariant
-    {
-        assert(payload is null || allocator_ !is null);
-    }
-
-    /**
-     * Takes ownership over $(D_PARAM value), setting the counter to 1.
-     * $(D_PARAM value) may be a pointer, an object or a dynamic array.
-     *
-     * Params:
-     *  value     = Value whose ownership is taken over.
-     *  allocator = Allocator used to destroy the $(D_PARAM value) and to
-     *              allocate/deallocate internal storage.
-     *
-     * Precondition: $(D_INLINECODE allocator !is null)
-     */
-    this(Payload!T value, shared Allocator allocator = defaultAllocator)
-    {
-        this(allocator);
-        this.payload = value;
-    }
-
-    /// ditto
-    this(shared Allocator allocator)
-    in
-    {
-        assert(allocator !is null);
-    }
-    do
-    {
-        this.allocator_ = allocator;
-    }
-
-    /**
-     * $(D_PSYMBOL Unique) is noncopyable.
-     */
-    @disable this(this);
-
-    /**
-     * Destroys the owned object.
-     */
-    ~this()
-    {
-        allocator.dispose(this.payload);
-    }
-
-    /**
-     * Initialized this $(D_PARAM Unique) and takes ownership over
-     * $(D_PARAM rhs).
-     *
-     * To reset $(D_PSYMBOL Unique) assign $(D_KEYWORD null).
-     *
-     * If the allocator wasn't set before, $(D_PSYMBOL defaultAllocator) will
-     * be used. If you need a different allocator, create a new
-     * $(D_PSYMBOL Unique) and assign it.
-     *
-     * Params:
-     *  rhs = New object.
-     *
-     * Returns: $(D_KEYWORD this).
-     */
-    ref typeof(this) opAssign(Payload!T rhs)
-    {
-        allocator.dispose(this.payload);
-        this.payload = rhs;
-        return this;
-    }
-
-    /// ditto
-    ref typeof(this) opAssign(typeof(null))
-    {
-        allocator.dispose(this.payload);
-        return this;
-    }
-
-    /// ditto
-    ref typeof(this) opAssign(typeof(this) rhs)
-    {
-        swap(this.allocator_, rhs.allocator_);
-        swap(this.payload, rhs.payload);
-
-        return this;
-    }
-
-    ///
-    @nogc nothrow pure @system unittest
-    {
-        auto rc = defaultAllocator.unique!int(5);
-        rc = defaultAllocator.make!int(7);
-        assert(*rc == 7);
-    }
-
-    /**
-     * Returns: Reference to the owned object.
-     */
-    inout(Payload!T) get() inout
-    {
-        return this.payload;
-    }
-
-    version (D_Ddoc)
-    {
-        /**
-         * Dereferences the pointer. It is defined only for pointers, not for
-         * reference types like classes, that can be accessed directly.
-         *
-         * Params:
-         *  op = Operation.
-         *
-         * Returns: Reference to the pointed value.
-         */
-        ref inout(T) opUnary(string op)() inout
-        if (op == "*");
-    }
-    else static if (isPointer!(Payload!T))
-    {
-        ref inout(T) opUnary(string op)() inout
-        if (op == "*")
-        {
-            return *this.payload;
-        }
-    }
-
-    /**
-     * Returns: Whether this $(D_PSYMBOL Unique) holds some value.
-     */
-    @property bool isInitialized() const
-    {
-        return this.payload !is null;
-    }
-
-    ///
-    @nogc nothrow pure @system unittest
-    {
-        Unique!int u;
-        assert(!u.isInitialized);
-    }
-
-    /**
-     * Sets the internal pointer to $(D_KEYWORD). The allocator isn't changed.
-     *
-     * Returns: Reference to the owned object.
-     */
-    Payload!T release()
-    {
-        auto payload = this.payload;
-        this.payload = null;
-        return payload;
-    }
-
-    ///
-    @nogc nothrow pure @system unittest
-    {
-        auto u = defaultAllocator.unique!int(5);
-        assert(u.isInitialized);
-
-        auto i = u.release();
-        assert(*i == 5);
-        assert(!u.isInitialized);
-    }
-
-    mixin DefaultAllocator;
-    alias get this;
-}
-
-///
-@nogc nothrow pure @system unittest
-{
-    auto p = defaultAllocator.make!int(5);
-    auto s = Unique!int(p, defaultAllocator);
-    assert(*s == 5);
-}
-
-///
-@nogc nothrow @system unittest
-{
-    static bool destroyed;
-
-    static struct F
-    {
-        ~this() @nogc nothrow @safe
-        {
-            destroyed = true;
-        }
-    }
-    {
-        auto s = Unique!F(defaultAllocator.make!F(), defaultAllocator);
-    }
-    assert(destroyed);
-}
-
-/**
- * Constructs a new object of type $(D_PARAM T) and wraps it in a
- * $(D_PSYMBOL Unique) using $(D_PARAM args) as the parameter list for
- * the constructor of $(D_PARAM T).
- *
- * Params:
- *  T         = Type of the constructed object.
- *  A         = Types of the arguments to the constructor of $(D_PARAM T).
- *  allocator = Allocator.
- *  args      = Constructor arguments of $(D_PARAM T).
- *
- * Returns: Newly created $(D_PSYMBOL Unique!T).
- *
- * Precondition: $(D_INLINECODE allocator !is null)
- */
-Unique!T unique(T, A...)(shared Allocator allocator, auto ref A args)
-if (!is(T == interface) && !isAbstractClass!T
- && !isAssociativeArray!T && !isArray!T)
-in
-{
-    assert(allocator !is null);
-}
-do
-{
-    auto payload = allocator.make!(T, A)(args);
-    return Unique!T(payload, allocator);
-}
-
-/**
- * Constructs a new array with $(D_PARAM size) elements and wraps it in a
- * $(D_PSYMBOL Unique).
- *
- * Params:
- *  T         = Array type.
- *  E         = Array element type.
- *  size      = Array size.
- *  allocator = Allocator.
- *
- * Returns: Newly created $(D_PSYMBOL Unique!T).
- *
- * Precondition: $(D_INLINECODE allocator !is null
- *                           && size <= size_t.max / E.sizeof)
- */
-Unique!T unique(T : E[], E)(shared Allocator allocator, size_t size)
-@trusted
-in
-{
-    assert(allocator !is null);
-    assert(size <= size_t.max / E.sizeof);
-}
-do
-{
-    auto payload = allocator.resize!E(null, size);
-    return Unique!T(payload, allocator);
-}

os/dub.json

@@ -1,17 +0,0 @@
-{
-	"name": "os",
-	"description": "Platform-independent interfaces to operating system functionality",
-	"targetType": "library",
-
-	"dependencies": {
-		"tanya:meta": "*"
-	},
-
-	"sourcePaths": [
-		"."
-	],
-	"importPaths": [
-		"."
-	],
-	"dflags-dmd": ["-dip1000"]
-}

os/tanya/os/error.d

@@ -1,413 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-/**
- * This module provides a portable way of using operating system error codes.
- *
- * Copyright: Eugene Wissner 2017-2020.
- * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
- *                  Mozilla Public License, v. 2.0).
- * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
- * Source: $(LINK2 https://github.com/caraus-ecms/tanya/blob/master/os/tanya/os/error.d,
- *                 tanya/os/error.d)
- */
-module tanya.os.error;
-
-import tanya.meta.trait;
-
-// Socket API error.
-private template SAError(int posix, int wsa = posix)
-{
-    version (Windows)
-    {
-        enum SAError = 10000 + wsa;
-    }
-    else
-    {
-        alias SAError = posix;
-    }
-}
-
-// Error for Windows and Posix separately.
-private template NativeError(int posix, int win)
-{
-    version (Windows)
-    {
-        alias NativeError = win;
-    }
-    else
-    {
-        alias NativeError = posix;
-    }
-}
-
-version (Windows)
-{
-    private enum eProtocolError = -71;
-}
-else version (OpenBSD)
-{
-    private enum eProtocolError = -71;
-}
-else
-{
-    private enum eProtocolError = 71;
-}
-
-/**
- * System error code.
- */
-struct ErrorCode
-{
-    /**
-     * Error code numbers.
-     */
-    enum ErrorNo : int
-    {
-        /// The operation completed successfully.
-        success                   = 0,
-
-        /// Operation not permitted.
-        noPermission              = NativeError!(1, 5),
-
-        /// Interrupted system call.
-        interrupted               = SAError!4,
-
-        /// Bad file descriptor.
-        badDescriptor             = SAError!9,
-
-        /// An operation on a non-blocking socket would block.
-        wouldBlock                = SAError!(11, 35),
-
-        /// Out of memory.
-        noMemory                  = NativeError!(12, 14),
-
-        /// Access denied.
-        accessDenied              = SAError!13,
-
-        /// An invalid pointer address detected.
-        fault                     = SAError!14,
-
-        /// No such device.
-        noSuchDevice              = NativeError!(19, 20),
-
-        /// An invalid argument was supplied.
-        invalidArgument           = SAError!22,
-
-        /// The limit on the number of open file descriptors.
-        tooManyDescriptors        = NativeError!(23, 331),
-
-        /// The limit on the number of open file descriptors.
-        noDescriptors             = SAError!24,
-
-        /// Broken pipe.
-        brokenPipe                = NativeError!(32, 109),
-
-        /// The name was too long.
-        nameTooLong               = SAError!(36, 63),
-
-        /// A socket operation was attempted on a non-socket.
-        notSocket                 = SAError!(88, 38),
-
-        /// Protocol error.
-        protocolError             = eProtocolError,
-
-        /// Message too long.
-        messageTooLong            = SAError!(90, 40),
-
-        /// Wrong protocol type for socket.
-        wrongProtocolType         = SAError!(91, 41),
-
-        /// Protocol not available.
-        noProtocolOption          = SAError!(92, 42),
-
-        /// The protocol is not implemented or has not been configured.
-        protocolNotSupported      = SAError!(93, 43),
-
-        /// The support for the specified socket type does not exist in this
-        /// address family.
-        socketNotSupported        = SAError!(94, 44),
-
-        /// The address family is no supported by the protocol family.
-        operationNotSupported     = SAError!(95, 45),
-
-        /// Address family specified is not supported.
-        addressFamilyNotSupported = SAError!(97, 47),
-
-        /// Address already in use.
-        addressInUse              = SAError!(98, 48),
-
-        /// The network is not available.
-        networkDown               = SAError!(100, 50),
-
-        /// No route to host.
-        networkUnreachable        = SAError!(101, 51),
-
-        /// Network dropped connection because of reset.
-        networkReset              = SAError!(102, 52),
-
-        /// The connection has been aborted.
-        connectionAborted         = SAError!(103, 53),
-
-        /// Connection reset by peer.
-        connectionReset           = SAError!(104, 54),
-
-        /// No free buffer space is available for a socket operation.
-        noBufferSpace             = SAError!(105, 55),
-
-        /// Transport endpoint is already connected.
-        alreadyConnected          = SAError!(106, 56),
-
-        /// Transport endpoint is not connected.
-        notConnected              = SAError!(107, 57),
-
-        /// Cannot send after transport endpoint shutdown.
-        shutdown                  = SAError!(108, 58),
-
-        /// The connection attempt timed out, or the connected host has failed
-        /// to respond.
-        timedOut                  = SAError!(110, 60),
-
-        /// Connection refused.
-        connectionRefused         = SAError!(111, 61),
-
-        /// Host is down.
-        hostDown                  = SAError!(112, 64),
-
-        /// No route to host.
-        hostUnreachable           = SAError!(113, 65),
-
-        /// Operation already in progress.
-        alreadyStarted            = SAError!(114, 37),
-
-        /// Operation now in progress.
-        inProgress                = SAError!(115, 36),
-
-        /// Operation cancelled.
-        cancelled                 = SAError!(125, 103),
-    }
-
-    /**
-     * Error descriptions.
-     */
-    private enum ErrorStr : string
-    {
-        success                   = "The operation completed successfully",
-        noPermission              = "Operation not permitted",
-        interrupted               = "Interrupted system call",
-        badDescriptor             = "Bad file descriptor",
-        wouldBlock                = "An operation on a non-blocking socket would block",
-        noMemory                  = "Out of memory",
-        accessDenied              = "Access denied",
-        fault                     = "An invalid pointer address detected",
-        noSuchDevice              = "No such device",
-        invalidArgument           = "An invalid argument was supplied",
-        tooManyDescriptors        = "The limit on the number of open file descriptors",
-        noDescriptors             = "The limit on the number of open file descriptors",
-        brokenPipe                = "Broken pipe",
-        nameTooLong               = "The name was too long",
-        notSocket                 = "A socket operation was attempted on a non-socket",
-        protocolError             = "Protocol error",
-        messageTooLong            = "Message too long",
-        wrongProtocolType         = "Wrong protocol type for socket",
-        noProtocolOption          = "Protocol not available",
-        protocolNotSupported      = "The protocol is not implemented or has not been configured",
-        socketNotSupported        = "Socket type not supported",
-        operationNotSupported     = "The address family is no supported by the protocol family",
-        addressFamilyNotSupported = "Address family specified is not supported",
-        addressInUse              = "Address already in use",
-        networkDown               = "The network is not available",
-        networkUnreachable        = "No route to host",
-        networkReset              = "Network dropped connection because of reset",
-        connectionAborted         = "The connection has been aborted",
-        connectionReset           = "Connection reset by peer",
-        noBufferSpace             = "No free buffer space is available for a socket operation",
-        alreadyConnected          = "Transport endpoint is already connected",
-        notConnected              = "Transport endpoint is not connected",
-        shutdown                  = "Cannot send after transport endpoint shutdown",
-        timedOut                  = "Operation timed out",
-        connectionRefused         = "Connection refused",
-        hostDown                  = "Host is down",
-        hostUnreachable           = "No route to host",
-        alreadyStarted            = "Operation already in progress",
-        inProgress                = "Operation now in progress",
-        cancelled                 = "Operation cancelled",
-    }
-
-    /**
-     * Constructor.
-     *
-     * Params:
-     *  value = Numeric error code.
-     */
-    this(const ErrorNo value) @nogc nothrow pure @safe
-    {
-        this.value_ = value;
-    }
-
-    ///
-    @nogc nothrow pure @safe unittest
-    {
-        ErrorCode ec;
-        assert(ec == ErrorCode.success);
-
-        ec = ErrorCode.fault;
-        assert(ec == ErrorCode.fault);
-    }
-
-    /**
-     * Resets this $(D_PSYMBOL ErrorCode) to default
-     * ($(D_PSYMBOL ErrorCode.success)).
-     */
-    void reset() @nogc nothrow pure @safe
-    {
-        this.value_ = ErrorNo.success;
-    }
-
-    ///
-    @nogc nothrow pure @safe unittest
-    {
-        auto ec = ErrorCode(ErrorCode.fault);
-        assert(ec == ErrorCode.fault);
-
-        ec.reset();
-        assert(ec == ErrorCode.success);
-    }
-
-    /**
-     * Returns: Numeric error code.
-     */
-    ErrorNo opCast(T : ErrorNo)() const
-    {
-        return this.value_;
-    }
-
-    /// ditto
-    ErrorNo opCast(T : int)() const
-    {
-        return this.value_;
-    }
-
-    ///
-    @nogc nothrow pure @safe unittest
-    {
-        ErrorCode ec = ErrorCode.fault;
-        auto errorNo = cast(ErrorCode.ErrorNo) ec;
-
-        assert(errorNo == ErrorCode.fault);
-        static assert(is(typeof(cast(int) ec)));
-    }
-
-    /**
-     * Assigns another error code or error code number.
-     *
-     * Params:
-     *  that = Numeric error code.
-     *
-     * Returns: $(D_KEYWORD this).
-     */
-    ref ErrorCode opAssign(const ErrorNo that) return @nogc nothrow pure @safe
-    {
-        this.value_ = that;
-        return this;
-    }
-
-    /// ditto
-    ref ErrorCode opAssign(const ErrorCode that) return @nogc nothrow pure @safe
-    {
-        this.value_ = that.value_;
-        return this;
-    }
-
-    ///
-    @nogc nothrow pure @safe unittest
-    {
-        ErrorCode ec;
-        assert(ec == ErrorCode.success);
-
-        ec = ErrorCode.fault;
-        assert(ec == ErrorCode.fault);
-    }
-
-    ///
-    @nogc nothrow pure @safe unittest
-    {
-        auto ec1 = ErrorCode(ErrorCode.fault);
-        ErrorCode ec2;
-        assert(ec2 == ErrorCode.success);
-
-        ec2 = ec1;
-        assert(ec1 == ec2);
-    }
-
-    /**
-     * Equality with another error code or error code number.
-     *
-     * Params:
-     *  that = Numeric error code.
-     *
-     * Returns: Whether $(D_KEYWORD this) and $(D_PARAM that) are equal.
-     */
-    bool opEquals(const ErrorNo that) const @nogc nothrow pure @safe
-    {
-        return this.value_ == that;
-    }
-
-    /// ditto
-    bool opEquals(const ErrorCode that) const @nogc nothrow pure @safe
-    {
-        return this.value_ == that.value_;
-    }
-
-    ///
-    @nogc nothrow pure @safe unittest
-    {
-        ErrorCode ec1 = ErrorCode.fault;
-        ErrorCode ec2 = ErrorCode.accessDenied;
-
-        assert(ec1 != ec2);
-        assert(ec1 != ErrorCode.accessDenied);
-        assert(ErrorCode.fault != ec2);
-    }
-
-    ///
-    @nogc nothrow pure @safe unittest
-    {
-        ErrorCode ec1 = ErrorCode.fault;
-        ErrorCode ec2 = ErrorCode.fault;
-
-        assert(ec1 == ec2);
-        assert(ec1 == ErrorCode.fault);
-        assert(ErrorCode.fault == ec2);
-    }
-
-    /**
-     * Returns string describing the error number. If a description for a
-     * specific error number is not available, returns $(D_KEYWORD null).
-     *
-     * Returns: String describing the error number.
-     */
-    string toString() const @nogc nothrow pure @safe
-    {
-        foreach (e; __traits(allMembers, ErrorNo))
-        {
-            if (__traits(getMember, ErrorNo, e) == this.value_)
-            {
-                return __traits(getMember, ErrorStr, e);
-            }
-        }
-        return null;
-    }
-
-    ///
-    @nogc nothrow pure @safe unittest
-    {
-        ErrorCode ec = ErrorCode.fault;
-        assert(ec.toString() == "An invalid pointer address detected");
-    }
-
-    private ErrorNo value_ = ErrorNo.success;
-
-    alias ErrorNo this;
-}

os/tanya/os/package.d

@@ -1,18 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-/**
- * This package provides platform-independent interfaces to operating system
- * functionality.
- *
- * Copyright: Eugene Wissner 2017-2020.
- * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
- *                  Mozilla Public License, v. 2.0).
- * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
- * Source: $(LINK2 https://github.com/caraus-ecms/tanya/blob/master/os/tanya/os/package.d,
- *                 tanya/os/package.d)
- */
-module tanya.os;
-
-public import tanya.os.error;

source/tanya/algorithm/iteration.d

@@ -1,259 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-/**
- * Iteration algorithms.
- *
- * These algorithms wrap other ranges and modify the way, how the original
- * range is iterated, or the order in which its elements are accessed.
- *
- * All algorithms in this module are lazy, they request the next element of the
- * original range on demand.
- *
- * Copyright: Eugene Wissner 2018-2021.
- * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
- *                  Mozilla Public License, v. 2.0).
- * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
- * Source: $(LINK2 https://github.com/caraus-ecms/tanya/blob/master/source/tanya/algorithm/iteration.d,
- *                 tanya/algorithm/iteration.d)
- */
-module tanya.algorithm.iteration;
-
-import std.typecons;
-import tanya.memory.lifetime;
-import tanya.meta.trait;
-import tanya.meta.transform;
-import tanya.range;
-
-private struct SingletonByValue(E)
-{
-    private Nullable!E element;
-
-    @disable this();
-
-    private this(U)(ref U element)
-    if (is(U == E))
-    {
-        this.element = move(element);
-    }
-
-    private this(U)(ref U element)
-    if (is(Unqual!U == Nullable!(Unqual!E)) || is(Unqual!U == Nullable!(const E)))
-    {
-        if (!element.isNull)
-        {
-            this.element = element.get;
-        }
-    }
-
-    @property ref inout(E) front() inout
-    in
-    {
-        assert(!empty);
-    }
-    do
-    {
-        return this.element.get;
-    }
-
-    alias back = front;
-
-    void popFront()
-    in
-    {
-        assert(!empty);
-    }
-    do
-    {
-        this.element.nullify();
-    }
-
-    alias popBack = popFront;
-
-    @property bool empty() const
-    {
-        return this.element.isNull;
-    }
-
-    @property size_t length() const
-    {
-        return !this.element.isNull;
-    }
-
-    auto save()
-    {
-        return SingletonByValue!E(this.element);
-    }
-
-    ref inout(E) opIndex(size_t i) inout
-    in
-    {
-        assert(!empty);
-        assert(i == 0);
-    }
-    do
-    {
-        return this.element.get;
-    }
-}
-
-private struct SingletonByRef(E)
-{
-    private E* element;
-
-    @disable this();
-
-    private this(return ref E element) @trusted
-    {
-        this.element = &element;
-    }
-
-    @property ref inout(E) front() inout return
-    in
-    {
-        assert(!empty);
-    }
-    do
-    {
-        return *this.element;
-    }
-
-    alias back = front;
-
-    void popFront()
-    in
-    {
-        assert(!empty);
-    }
-    do
-    {
-        this.element = null;
-    }
-
-    alias popBack = popFront;
-
-    @property bool empty() const
-    {
-        return this.element is null;
-    }
-
-    @property size_t length() const
-    {
-        return this.element !is null;
-    }
-
-    auto save() return
-    {
-        return typeof(this)(*this.element);
-    }
-
-    ref inout(E) opIndex(size_t i) inout return
-    in
-    {
-        assert(!empty);
-        assert(i == 0);
-    }
-    do
-    {
-        return *this.element;
-    }
-}
-
-/**
- * Creates a bidirectional and random-access range with the single element
- * $(D_PARAM element).
- *
- * If $(D_PARAM element) is passed by value the resulting range stores it
- * internally. If $(D_PARAM element) is passed by reference, the resulting
- * range keeps only a pointer to the element.
- *
- * Params:
- *  E       = Element type.
- *  element = Element.
- *
- * Returns: A range with one element.
- */
-auto singleton(E)(return E element)
-if (isMutable!E)
-{
-    return SingletonByValue!E(element);
-}
-
-/// ditto
-auto singleton(E)(return ref E element)
-{
-    return SingletonByRef!E(element);
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    auto singleChar = singleton('a');
-
-    assert(singleChar.length == 1);
-    assert(singleChar.front == 'a');
-
-    singleChar.popFront();
-    assert(singleChar.empty);
-}
-
-/**
- * Accumulates all elements of a range using a function.
- *
- * $(D_PSYMBOL foldr) takes a function, a bidirectional range and the initial
- * value. The function takes this initial value and the first element of the
- * range (in this order), puts them together and returns the result. The return
- * type of the function should be the same as the type of the initial value.
- * This is than repeated for all the remaining elements of the range, whereby
- * the value returned by the passed function is used at the place of the
- * initial value.
- *
- * $(D_PSYMBOL foldr) accumulates from right to left.
- *
- * Params:
- *  F = Callable accepting the accumulator and a range element.
- */
-template foldr(F...)
-if (F.length == 1)
-{
-    /**
-     * Params:
-     *  R     = Bidirectional range type.
-     *  T     = Type of the accumulated value.
-     *  range = Bidirectional range.
-     *  init  = Initial value.
-     *
-     * Returns: Accumulated value.
-     */
-    auto foldr(R, T)(scope R range, auto ref T init)
-    if (isBidirectionalRange!R)
-    {
-        if (range.empty)
-        {
-            return init;
-        }
-        else
-        {
-            auto acc = F[0](init, getAndPopBack(range));
-            return foldr(range, acc);
-        }
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    int[3] range = [1, 2, 3];
-    int[3] output;
-    const int[3] expected = [3, 2, 1];
-
-    alias f = (acc, x) {
-        acc.front = x;
-        acc.popFront;
-        return acc;
-    };
-    const actual = foldr!f(range[], output[]);
-
-    assert(output[] == expected[]);
-}

source/tanya/algorithm/mutation.d

@@ -1,244 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-/**
- * Algorithms that modify its arguments.
- *
- * Copyright: Eugene Wissner 2017-2020.
- * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
- *                  Mozilla Public License, v. 2.0).
- * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
- * Source: $(LINK2 https://github.com/caraus-ecms/tanya/blob/master/source/tanya/algorithm/mutation.d,
- *                 tanya/algorithm/mutation.d)
- */
-module tanya.algorithm.mutation;
-
-static import tanya.memory.lifetime;
-static import tanya.memory.op;
-import tanya.meta.trait;
-import tanya.meta.transform;
-import tanya.range;
-
-/**
- * Copies the $(D_PARAM source) range into the $(D_PARAM target) range.
- *
- * Params:
- *  Source = Input range type.
- *  Target = Output range type.
- *  source = Source input range.
- *  target = Target output range.
- *
- * Returns: $(D_PARAM target) range, whose front element is the one past the
- *          last element copied.
- *
- * Precondition: $(D_PARAM target) should be large enough to accept all
- *               $(D_PARAM source) elements.
- */
-Target copy(Source, Target)(Source source, Target target)
-if (isInputRange!Source && isOutputRange!(Target, ElementType!Source))
-in
-{
-    static if (hasLength!Source && hasLength!Target)
-    {
-        assert(target.length >= source.length);
-    }
-}
-do
-{
-    alias E = ElementType!Source;
-    static if (isDynamicArray!Source
-            && is(Unqual!E == ElementType!Target)
-            && !hasElaborateCopyConstructor!E
-            && !hasElaborateAssign!E
-            && !hasElaborateDestructor!E)
-    {
-        if (source.ptr < target.ptr
-         && (() @trusted => (target.ptr - source.ptr) < source.length)())
-        {
-            tanya.memory.op.copyBackward(source, target);
-        }
-        else if (source.ptr !is target.ptr)
-        {
-            tanya.memory.op.copy(source, target);
-        }
-        return target[source.length .. $];
-    }
-    else
-    {
-        for (; !source.empty; source.popFront())
-        {
-            put(target, source.front);
-        }
-        return target;
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    import std.algorithm.comparison : equal;
-
-    const int[2] source = [1, 2];
-    int[2] target = [3, 4];
-
-    copy(source[], target[]);
-    assert(equal(source[], target[]));
-}
-
-/**
- * Fills $(D_PARAM range) with $(D_PARAM value).
- *
- * Params:
- *  Range = Input range type.
- *  Value = Filler type.
- *  range = Input range.
- *  value = Filler.
- */
-void fill(Range, Value)(Range range, auto ref Value value)
-if (isInputRange!Range && isAssignable!(ElementType!Range, Value))
-{
-    static if (!isDynamicArray!Range && is(typeof(range[] = value)))
-    {
-        range[] = value;
-    }
-    else
-    {
-        for (; !range.empty; range.popFront())
-        {
-            range.front = value;
-        }
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    import std.algorithm.comparison : equal;
-
-    int[6] actual;
-    const int[6] expected = [1, 1, 1, 1, 1, 1];
-
-    fill(actual[], 1);
-    assert(equal(actual[], expected[]));
-}
-
-/**
- * Fills $(D_PARAM range) with $(D_PARAM value) assuming the elements of the
- * $(D_PARAM range) aren't initialized.
- *
- * Params:
- *  Range = Input range type.
- *  Value = Initializer type.
- *  range = Input range.
- *  value = Initializer.
- */
-void uninitializedFill(Range, Value)(Range range, auto ref Value value)
-if (isInputRange!Range && hasLvalueElements!Range
- && isAssignable!(ElementType!Range, Value))
-{
-    static if (hasElaborateDestructor!(ElementType!Range))
-    {
-        for (; !range.empty; range.popFront())
-        {
-            ElementType!Range* p = &range.front;
-            tanya.memory.lifetime.emplace!(ElementType!Range)(cast(void[]) (p[0 .. 1]), value);
-        }
-    }
-    else
-    {
-        fill(range, value);
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    import std.algorithm.comparison : equal;
-
-    int[6] actual = void;
-    const int[6] expected = [1, 1, 1, 1, 1, 1];
-
-    uninitializedFill(actual[], 1);
-    assert(equal(actual[], expected[]));
-}
-
-/**
- * Initializes all elements of the $(D_PARAM range) assuming that they are
- * uninitialized.
- *
- * Params:
- *  Range = Input range type
- *  range = Input range.
- */
-void initializeAll(Range)(Range range) @trusted
-if (isInputRange!Range && hasLvalueElements!Range)
-{
-    import tanya.memory.op : copy, fill;
-    alias T = ElementType!Range;
-
-    static if (isDynamicArray!Range && __traits(isZeroInit, T))
-    {
-        fill!0(range);
-    }
-    else
-    {
-        static immutable init = T.init;
-        for (; !range.empty; range.popFront())
-        {
-            copy((&init)[0 .. 1], (&range.front)[0 .. 1]);
-        }
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    import std.algorithm.comparison : equal;
-
-    int[2] actual = void;
-    const int[2] expected = [0, 0];
-
-    initializeAll(actual[]);
-    assert(equal(actual[], expected[]));
-}
-
-/**
- * Destroys all elements in the $(D_PARAM range).
- *
- * This function has effect only if the element type of $(D_PARAM Range) has
- * an elaborate destructor, i.e. it is a $(D_PSYMBOL struct) with an explicit
- * or generated by the compiler destructor.
- *
- * Params:
- *  Range = Input range type.
- *  range = Input range.
- */
-void destroyAll(Range)(Range range)
-if (isInputRange!Range && hasLvalueElements!Range)
-{
-    tanya.memory.lifetime.destroyAllImpl!(Range, ElementType!Range)(range);
-}
-
-///
-@nogc nothrow pure @trusted unittest
-{
-    static struct WithDtor
-    {
-        private size_t* counter;
-        ~this() @nogc nothrow pure
-        {
-            if (this.counter !is null)
-            {
-                ++(*this.counter);
-            }
-        }
-    }
-
-    size_t counter;
-    WithDtor[2] withDtor = [WithDtor(&counter), WithDtor(&counter)];
-
-    destroyAll(withDtor[]);
-
-    assert(counter == 2);
-}

source/tanya/algorithm/package.d

@@ -1,18 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-/**
- * Collection of generic algorithms.
- *
- * Copyright: Eugene Wissner 2017-2021.
- * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
- *                  Mozilla Public License, v. 2.0).
- * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
- * Source: $(LINK2 https://github.com/caraus-ecms/tanya/blob/master/source/tanya/algorithm/package.d,
- *                 tanya/algorithm/package.d)
- */
-module tanya.algorithm;
-
-public import tanya.algorithm.iteration;
-public import tanya.algorithm.mutation;

source/tanya/async/event/epoll.d

@@ -0,0 +1,187 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Copyright: Eugene Wissner 2016.
+ * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
+ *                  Mozilla Public License, v. 2.0).
+ * Authors: $(LINK2 mailto:belka@caraus.de, Eugene Wissner)
+ */
+module tanya.async.event.epoll;
+
+version (linux):
+
+public import core.sys.linux.epoll;
+import tanya.async.protocol;
+import tanya.async.event.selector;
+import tanya.async.loop;
+import tanya.async.transport;
+import tanya.async.watcher;
+import tanya.memory;
+import tanya.memory.mmappool;
+import tanya.network.socket;
+import core.stdc.errno;
+import core.sys.posix.unistd;
+import core.time;
+import std.algorithm.comparison;
+
+extern (C) nothrow @nogc
+{
+	int epoll_create1(int flags);
+	int epoll_ctl (int epfd, int op, int fd, epoll_event *event);
+	int epoll_wait (int epfd, epoll_event *events, int maxevents, int timeout);
+}
+
+class EpollLoop : SelectorLoop
+{
+	protected int fd;
+	private epoll_event[] events;
+
+	/**
+	 * Initializes the loop.
+	 */
+	this() @nogc
+	{
+		if ((fd = epoll_create1(EPOLL_CLOEXEC)) < 0)
+		{
+			throw MmapPool.instance.make!BadLoopException("epoll initialization failed");
+		}
+		super();
+		MmapPool.instance.resizeArray(events, maxEvents);
+	}
+
+	/**
+	 * Free loop internals.
+	 */
+	~this() @nogc
+	{
+		MmapPool.instance.dispose(events);
+		close(fd);
+	}
+
+	/**
+	 * Should be called if the backend configuration changes.
+	 *
+	 * Params:
+	 * 	watcher   = Watcher.
+	 * 	oldEvents = The events were already set.
+	 * 	events    = The events should be set.
+	 *
+	 * Returns: $(D_KEYWORD true) if the operation was successful.
+	 */
+	protected override bool reify(ConnectionWatcher watcher,
+	                              EventMask oldEvents,
+	                              EventMask events) @nogc
+	in
+	{
+		assert(watcher !is null);
+	}
+	body
+	{
+		int op = EPOLL_CTL_DEL;
+		epoll_event ev;
+
+		if (events == oldEvents)
+		{
+			return true;
+		}
+		if (events && oldEvents)
+		{
+			op = EPOLL_CTL_MOD;
+		}
+		else if (events && !oldEvents)
+		{
+			op = EPOLL_CTL_ADD;
+		}
+
+		ev.data.fd = watcher.socket.handle;
+		ev.events = (events & (Event.read | Event.accept) ? EPOLLIN | EPOLLPRI : 0)
+				  | (events & Event.write ? EPOLLOUT : 0)
+				  | EPOLLET;
+
+		return epoll_ctl(fd, op, watcher.socket.handle, &ev) == 0;
+	}
+
+	/**
+	 * Does the actual polling.
+	 */
+	protected override void poll() @nogc
+	{
+		// Don't block
+		immutable timeout = cast(immutable int) blockTime.total!"msecs";
+		auto eventCount = epoll_wait(fd, events.ptr, maxEvents, timeout);
+
+		if (eventCount < 0)
+		{
+			if (errno != EINTR)
+			{
+				throw defaultAllocator.make!BadLoopException();
+			}
+			return;
+		}
+
+		for (auto i = 0; i < eventCount; ++i)
+		{
+			auto io = cast(IOWatcher) connections[events[i].data.fd];
+
+			if (io is null)
+			{
+				acceptConnections(connections[events[i].data.fd]);
+			}
+			else if (events[i].events & EPOLLERR)
+			{
+				kill(io, null);
+			}
+			else if (events[i].events & (EPOLLIN | EPOLLPRI | EPOLLHUP))
+			{
+				auto transport = cast(SelectorStreamTransport) io.transport;
+				assert(transport !is null);
+
+				SocketException exception;
+				try
+				{
+					ptrdiff_t received;
+					do
+					{
+						received = transport.socket.receive(io.output[]);
+						io.output += received;
+					}
+					while (received);
+				}
+				catch (SocketException e)
+				{
+					exception = e;
+				}
+				if (transport.socket.disconnected)
+				{
+					kill(io, exception);
+				}
+				else if (io.output.length)
+				{
+					swapPendings.enqueue(io);
+				}
+			}
+			else if (events[i].events & EPOLLOUT)
+			{
+				auto transport = cast(SelectorStreamTransport) io.transport;
+				assert(transport !is null);
+
+				transport.writeReady = true;
+				if (transport.input.length)
+				{
+					feed(transport);
+				}
+			}
+		}
+	}
+
+	/**
+	 * Returns: The blocking time.
+	 */
+	override protected @property inout(Duration) blockTime()
+	inout @safe pure nothrow
+	{
+		return min(super.blockTime, 1.dur!"seconds");
+	}
+}

source/tanya/async/event/iocp.d

@@ -0,0 +1,291 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Copyright: Eugene Wissner 2016.
+ * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
+ *                  Mozilla Public License, v. 2.0).
+ * Authors: $(LINK2 mailto:belka@caraus.de, Eugene Wissner)
+ */
+module tanya.async.event.iocp;
+
+version (Windows):
+
+import tanya.container.buffer;
+import tanya.async.loop;
+import tanya.async.protocol;
+import tanya.async.transport;
+import tanya.async.watcher;
+import tanya.memory;
+import tanya.memory.mmappool;
+import tanya.network.socket;
+import core.sys.windows.basetyps;
+import core.sys.windows.mswsock;
+import core.sys.windows.winbase;
+import core.sys.windows.windef;
+import core.sys.windows.winsock2;
+
+class IOCPStreamTransport : StreamTransport
+{
+	private OverlappedConnectedSocket socket_;
+
+	private WriteBuffer!ubyte input;
+
+	/**
+	 * Creates new completion port transport.
+	 * Params:
+	 * 	socket = Socket.
+	 */
+	this(OverlappedConnectedSocket socket) @nogc
+	in
+	{
+		assert(socket !is null);
+	}
+	body
+	{
+		socket_ = socket;
+		input = WriteBuffer!ubyte(8192, MmapPool.instance);
+	}
+
+	@property inout(OverlappedConnectedSocket) socket()
+	inout pure nothrow @safe @nogc
+	{
+		return socket_;
+	}
+
+	/**
+	 * Write some data to the transport.
+	 *
+	 * Params:
+	 * 	data = Data to send.
+	 */
+	void write(ubyte[] data) @nogc
+	{
+		immutable empty = input.length == 0;
+		input ~= data;
+		if (empty)
+		{
+			SocketState overlapped;
+			try
+			{
+				overlapped = MmapPool.instance.make!SocketState;
+				socket.beginSend(input[], overlapped);
+			}
+			catch (SocketException e)
+			{
+				MmapPool.instance.dispose(overlapped);
+				MmapPool.instance.dispose(e);
+			}
+		}
+	}
+}
+
+class IOCPLoop : Loop
+{
+	protected HANDLE completionPort;
+
+	protected OVERLAPPED overlap;
+
+	/**
+	 * Initializes the loop.
+	 */
+	this() @nogc
+	{
+		super();
+
+		completionPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
+		if (!completionPort)
+		{
+			throw make!BadLoopException(defaultAllocator,
+			                            "Creating completion port failed");
+		}
+	}
+
+	/**
+	 * Should be called if the backend configuration changes.
+	 *
+	 * Params:
+	 * 	watcher   = Watcher.
+	 * 	oldEvents = The events were already set.
+	 * 	events    = The events should be set.
+	 *
+	 * Returns: $(D_KEYWORD true) if the operation was successful.
+	 */
+	override protected bool reify(ConnectionWatcher watcher,
+								  EventMask oldEvents,
+								  EventMask events) @nogc
+	{
+		SocketState overlapped;
+		if (!(oldEvents & Event.accept) && (events & Event.accept))
+		{
+			auto socket = cast(OverlappedStreamSocket) watcher.socket;
+			assert(socket !is null);
+
+			if (CreateIoCompletionPort(cast(HANDLE) socket.handle,
+									   completionPort,
+									   cast(ULONG_PTR) (cast(void*) watcher),
+									   0) !is completionPort)
+			{
+				return false;
+			}
+
+			try
+			{
+				overlapped = MmapPool.instance.make!SocketState;
+				socket.beginAccept(overlapped);
+			}
+			catch (SocketException e)
+			{
+				MmapPool.instance.dispose(overlapped);
+				defaultAllocator.dispose(e);
+				return false;
+			}
+		}
+		if (!(oldEvents & Event.read) && (events & Event.read)
+			|| !(oldEvents & Event.write) && (events & Event.write))
+		{
+			auto io = cast(IOWatcher) watcher;
+			assert(io !is null);
+
+			auto transport = cast(IOCPStreamTransport) io.transport;
+			assert(transport !is null);
+
+			if (CreateIoCompletionPort(cast(HANDLE) transport.socket.handle,
+									   completionPort,
+									   cast(ULONG_PTR) (cast(void*) watcher),
+									   0) !is completionPort)
+			{
+				return false;
+			}
+
+			// Begin to read
+			if (!(oldEvents & Event.read) && (events & Event.read))
+			{
+				try
+				{
+					overlapped = MmapPool.instance.make!SocketState;
+					transport.socket.beginReceive(io.output[], overlapped);
+				}
+				catch (SocketException e)
+				{
+					MmapPool.instance.dispose(overlapped);
+					defaultAllocator.dispose(e);
+					return false;
+				}
+			}
+		}
+		return true;
+	}
+
+	/**
+	 * Does the actual polling.
+	 */
+	override protected void poll() @nogc
+	{
+		DWORD lpNumberOfBytes;
+		ULONG_PTR key;
+		LPOVERLAPPED overlap;
+		immutable timeout = cast(immutable int) blockTime.total!"msecs";
+
+		auto result = GetQueuedCompletionStatus(completionPort,
+												&lpNumberOfBytes,
+												&key,
+												&overlap,
+												timeout);
+		if (result == FALSE && overlap == NULL)
+		{
+			return; // Timeout
+		}
+
+		auto overlapped = (cast(SocketState) ((cast(void*) overlap) - 8));
+		assert(overlapped !is null);
+		scope (failure)
+		{
+			MmapPool.instance.dispose(overlapped);
+		}
+
+		switch (overlapped.event)
+		{
+			case OverlappedSocketEvent.accept:
+				auto connection = cast(ConnectionWatcher) (cast(void*) key);
+				assert(connection !is null);
+
+				auto listener = cast(OverlappedStreamSocket) connection.socket;
+				assert(listener !is null);
+
+				auto socket = listener.endAccept(overlapped);
+				auto transport = MmapPool.instance.make!IOCPStreamTransport(socket);
+				auto io = MmapPool.instance.make!IOWatcher(transport, connection.protocol);
+
+				connection.incoming.enqueue(io);
+
+				reify(io, EventMask(Event.none), EventMask(Event.read, Event.write));
+
+				swapPendings.enqueue(connection);
+				listener.beginAccept(overlapped);
+				break;
+			case OverlappedSocketEvent.read:
+				auto io = cast(IOWatcher) (cast(void*) key);
+				assert(io !is null);
+				if (!io.active)
+				{
+					MmapPool.instance.dispose(io);
+					MmapPool.instance.dispose(overlapped);
+					return;
+				}
+
+				auto transport = cast(IOCPStreamTransport) io.transport;
+				assert(transport !is null);
+
+				int received;
+				SocketException exception;
+				try
+				{
+					received = transport.socket.endReceive(overlapped);
+				}
+				catch (SocketException e)
+				{
+					exception = e;
+				}
+				if (transport.socket.disconnected)
+				{
+					// We want to get one last notification to destroy the watcher
+					transport.socket.beginReceive(io.output[], overlapped);
+					kill(io, exception);
+				}
+				else if (received > 0)
+				{
+					immutable full = io.output.free == received;
+
+					io.output += received;
+					// Receive was interrupted because the buffer is full. We have to continue
+					if (full)
+					{
+						transport.socket.beginReceive(io.output[], overlapped);
+					}
+					swapPendings.enqueue(io);
+				}
+				break;
+			case OverlappedSocketEvent.write:
+				auto io = cast(IOWatcher) (cast(void*) key);
+				assert(io !is null);
+
+				auto transport = cast(IOCPStreamTransport) io.transport;
+				assert(transport !is null);
+
+				transport.input += transport.socket.endSend(overlapped);
+				if (transport.input.length)
+				{
+					transport.socket.beginSend(transport.input[], overlapped);
+				}
+				else
+				{
+					transport.socket.beginReceive(io.output[], overlapped);
+				}
+				break;
+			default:
+				assert(false, "Unknown event");
+		}
+	}
+}

source/tanya/async/event/kqueue.d

@@ -0,0 +1,326 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Copyright: Eugene Wissner 2016.
+ * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
+ *                  Mozilla Public License, v. 2.0).
+ * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
+ */
+module tanya.async.event.kqueue;
+
+version (OSX)
+{
+	version = MacBSD;
+}
+else version (iOS)
+{
+	version = MacBSD;
+}
+else version (TVOS)
+{
+	version = MacBSD;
+}
+else version (WatchOS)
+{
+	version = MacBSD;
+}
+else version (FreeBSD)
+{
+	version = MacBSD;
+}
+else version (OpenBSD)
+{
+	version = MacBSD;
+}
+else version (DragonFlyBSD)
+{
+	version = MacBSD;
+}
+
+version (MacBSD):
+
+import core.stdc.stdint;    // intptr_t, uintptr_t
+import core.sys.posix.time; // timespec
+
+void EV_SET(kevent_t* kevp, typeof(kevent_t.tupleof) args) pure nothrow @nogc
+{
+	*kevp = kevent_t(args);
+}
+
+enum : short
+{
+	EVFILT_READ     =  -1,
+	EVFILT_WRITE    =  -2,
+	EVFILT_AIO      =  -3, /* attached to aio requests */
+	EVFILT_VNODE    =  -4, /* attached to vnodes */
+	EVFILT_PROC     =  -5, /* attached to struct proc */
+	EVFILT_SIGNAL   =  -6, /* attached to struct proc */
+	EVFILT_TIMER    =  -7, /* timers */
+	EVFILT_MACHPORT =  -8, /* Mach portsets */
+	EVFILT_FS       =  -9, /* filesystem events */
+	EVFILT_USER     = -10, /* User events */
+	EVFILT_VM       = -12, /* virtual memory events */
+	EVFILT_SYSCOUNT =  11
+}
+
+struct kevent_t
+{
+	uintptr_t    ident; /* identifier for this event */
+	short       filter; /* filter for event */
+	ushort       flags;
+	uint        fflags;
+	intptr_t      data;
+	void        *udata; /* opaque user data identifier */
+}
+
+enum
+{
+	/* actions */
+	EV_ADD      = 0x0001, /* add event to kq (implies enable) */
+	EV_DELETE   = 0x0002, /* delete event from kq */
+	EV_ENABLE   = 0x0004, /* enable event */
+	EV_DISABLE  = 0x0008, /* disable event (not reported) */
+
+	/* flags */
+	EV_ONESHOT  = 0x0010, /* only report one occurrence */
+	EV_CLEAR    = 0x0020, /* clear event state after reporting */
+	EV_RECEIPT  = 0x0040, /* force EV_ERROR on success, data=0 */
+	EV_DISPATCH = 0x0080, /* disable event after reporting */
+
+	EV_SYSFLAGS = 0xF000, /* reserved by system */
+	EV_FLAG1    = 0x2000, /* filter-specific flag */
+
+	/* returned values */
+	EV_EOF      = 0x8000, /* EOF detected */
+	EV_ERROR    = 0x4000, /* error, data contains errno */
+}
+
+extern(C) int kqueue() nothrow @nogc;
+extern(C) int kevent(int kq, const kevent_t *changelist, int nchanges,
+                     kevent_t *eventlist, int nevents, const timespec *timeout)
+                     nothrow @nogc;
+
+import tanya.async.event.selector;
+import tanya.async.loop;
+import tanya.async.transport;
+import tanya.async.watcher;
+import tanya.memory;
+import tanya.memory.mmappool;
+import tanya.network.socket;
+import core.stdc.errno;
+import core.sys.posix.unistd;
+import core.sys.posix.sys.time;
+import core.time;
+import std.algorithm.comparison;
+
+class KqueueLoop : SelectorLoop
+{
+	protected int fd;
+	private kevent_t[] events;
+	private kevent_t[] changes;
+	private size_t changeCount;
+
+	/**
+	 * Returns: Maximal event count can be got at a time
+	 *          (should be supported by the backend).
+	 */
+	override protected @property inout(uint) maxEvents()
+	inout const pure nothrow @safe @nogc
+	{
+		return cast(uint) events.length;
+	}
+
+	this() @nogc
+	{
+		super();
+
+		if ((fd = kqueue()) == -1)
+		{
+			throw MmapPool.instance.make!BadLoopException("epoll initialization failed");
+		}
+		MmapPool.instance.resizeArray(events, 64);
+		MmapPool.instance.resizeArray(changes, 64);
+	}
+
+	/**
+	 * Free loop internals.
+	 */
+	~this() @nogc
+	{
+		MmapPool.instance.dispose(events);
+		MmapPool.instance.dispose(changes);
+		close(fd);
+	}
+
+	private void set(socket_t socket, short filter, ushort flags) @nogc
+	{
+		if (changes.length <= changeCount)
+		{
+			MmapPool.instance.resizeArray(changes, changeCount + maxEvents);
+		}
+		EV_SET(&changes[changeCount],
+			   cast(ulong) socket,
+			   filter,
+			   flags,
+			   0U,
+			   0L,
+			   null);
+		++changeCount;
+	}
+
+	/**
+	 * Should be called if the backend configuration changes.
+	 *
+	 * Params:
+	 * 	watcher   = Watcher.
+	 * 	oldEvents = The events were already set.
+	 * 	events    = The events should be set.
+	 *
+	 * Returns: $(D_KEYWORD true) if the operation was successful.
+	 */
+	override protected bool reify(ConnectionWatcher watcher,
+	                              EventMask oldEvents,
+	                              EventMask events) @nogc
+	{
+		if (events != oldEvents)
+		{
+			if (oldEvents & Event.read || oldEvents & Event.accept)
+			{
+				set(watcher.socket.handle, EVFILT_READ, EV_DELETE);
+			}
+			if (oldEvents & Event.write)
+			{
+				set(watcher.socket.handle, EVFILT_WRITE, EV_DELETE);
+			}
+		}
+		if (events & (Event.read | events & Event.accept))
+		{
+			set(watcher.socket.handle, EVFILT_READ, EV_ADD | EV_ENABLE);
+		}
+		if (events & Event.write)
+		{
+			set(watcher.socket.handle, EVFILT_WRITE, EV_ADD | EV_DISPATCH);
+		}
+		return true;
+	}
+
+	/**
+	 * Does the actual polling.
+	 */
+	protected override void poll() @nogc
+	{
+		timespec ts;
+		blockTime.split!("seconds", "nsecs")(ts.tv_sec, ts.tv_nsec);
+
+		if (changeCount > maxEvents) 
+		{
+			MmapPool.instance.resizeArray(events, changes.length);
+		}
+
+		auto eventCount = kevent(fd, changes.ptr, cast(int) changeCount, events.ptr, maxEvents, &ts);
+		changeCount = 0;
+
+		if (eventCount < 0)
+		{
+			if (errno != EINTR)
+			{
+				throw defaultAllocator.make!BadLoopException();
+			}
+			return;
+		}
+
+		for (int i; i < eventCount; ++i)
+		{
+			assert(connections.length > events[i].ident);
+
+			IOWatcher io = cast(IOWatcher) connections[events[i].ident];
+			// If it is a ConnectionWatcher. Accept connections.
+			if (io is null)
+			{
+				acceptConnections(connections[events[i].ident]);
+			}
+			else if (events[i].flags & EV_ERROR)
+			{
+				kill(io, null);
+			}
+			else if (events[i].filter == EVFILT_READ)
+			{
+				auto transport = cast(SelectorStreamTransport) io.transport;
+				assert(transport !is null);
+
+				SocketException exception;
+				try
+				{
+					ptrdiff_t received;
+					do
+					{
+						received = transport.socket.receive(io.output[]);
+						io.output += received;
+					}
+					while (received);
+				}
+				catch (SocketException e)
+				{
+					exception = e;
+				}
+				if (transport.socket.disconnected)
+				{
+					kill(io, exception);
+				}
+				else if (io.output.length)
+				{
+					swapPendings.enqueue(io);
+				}
+			}
+			else if (events[i].filter == EVFILT_WRITE)
+			{
+				auto transport = cast(SelectorStreamTransport) io.transport;
+				assert(transport !is null);
+
+				transport.writeReady = true;
+				if (transport.input.length)
+				{
+					feed(transport);
+				}
+			}
+		}
+	}
+
+	/**
+	 * Returns: The blocking time.
+	 */
+	override protected @property inout(Duration) blockTime()
+	inout @nogc @safe pure nothrow
+	{
+		return min(super.blockTime, 1.dur!"seconds");
+	}
+
+	/**
+	 * If the transport couldn't send the data, the further sending should
+	 * be handled by the event loop.
+	 *
+	 * Params:
+	 * 	transport = Transport.
+	 * 	exception = Exception thrown on sending.
+	 *
+	 * Returns: $(D_KEYWORD true) if the operation could be successfully
+	 *          completed or scheduled, $(D_KEYWORD false) otherwise (the
+	 *          transport is be destroyed then).
+	 */
+	protected override bool feed(SelectorStreamTransport transport,
+	                             SocketException exception = null) @nogc
+	{
+		if (!super.feed(transport, exception))
+		{
+			return false;
+		}
+		if (!transport.writeReady)
+		{
+			set(transport.socket.handle, EVFILT_WRITE, EV_DISPATCH);
+			return true;
+		}
+		return false;
+	}
+}

source/tanya/async/event/selector.d

@@ -0,0 +1,259 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Copyright: Eugene Wissner 2016.
+ * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
+ *                  Mozilla Public License, v. 2.0).
+ * Authors: $(LINK2 mailto:belka@caraus.de, Eugene Wissner)
+ */
+module tanya.async.event.selector;
+
+version (Posix):
+
+import tanya.async.loop;
+import tanya.async.transport;
+import tanya.async.watcher;
+import tanya.container.buffer;
+import tanya.memory;
+import tanya.memory.mmappool;
+import tanya.network.socket;
+import core.sys.posix.netinet.in_;
+import core.stdc.errno;
+
+/**
+ * Transport for stream sockets.
+ */
+class SelectorStreamTransport : StreamTransport
+{
+	private ConnectedSocket socket_;
+
+	/// Input buffer.
+	package WriteBuffer!ubyte input;
+
+	private SelectorLoop loop;
+
+	/// Received notification that the underlying socket is write-ready.
+	package bool writeReady;
+
+	/**
+	 * Params:
+	 * 	loop     = Event loop.
+	 * 	socket   = Socket.
+	 */
+	this(SelectorLoop loop, ConnectedSocket socket) @nogc
+	{
+		socket_ = socket;
+		this.loop = loop;
+		input = WriteBuffer!ubyte(8192, MmapPool.instance);
+	}
+
+	/**
+	 * Returns: Transport socket.
+	 */
+	inout(ConnectedSocket) socket() inout pure nothrow @safe @nogc
+	{
+		return socket_;
+	}
+
+	/**
+	 * Write some data to the transport.
+	 *
+	 * Params:
+	 * 	data = Data to send.
+	 */
+	void write(ubyte[] data) @nogc
+	{
+		if (!data.length)
+		{
+			return;
+		}
+		// Try to write if the socket is write ready.
+		if (writeReady)
+		{
+			ptrdiff_t sent;
+			SocketException exception;
+			try
+			{
+				sent = socket.send(data);
+				if (sent == 0)
+				{
+					writeReady = false;
+				}
+			}
+			catch (SocketException e)
+			{
+				writeReady = false;
+				exception = e;
+			}
+			if (sent < data.length)
+			{
+				input ~= data[sent..$];
+				loop.feed(this, exception);
+			}
+		}
+		else
+		{
+			input ~= data;
+		}
+	}
+}
+
+abstract class SelectorLoop : Loop
+{
+	/// Pending connections.
+	protected ConnectionWatcher[] connections;
+
+	this() @nogc
+	{
+		super();
+		MmapPool.instance.resizeArray(connections, maxEvents);
+	}
+
+	~this() @nogc
+	{
+		foreach (ref connection; connections)
+		{
+			// We want to free only IOWatchers. ConnectionWatcher are created by the
+			// user and should be freed by himself.
+			auto io = cast(IOWatcher) connection;
+			if (io !is null)
+			{
+				MmapPool.instance.dispose(io);
+				connection = null;
+			}
+		}
+		MmapPool.instance.dispose(connections);
+	}
+
+	/**
+	 * If the transport couldn't send the data, the further sending should
+	 * be handled by the event loop.
+	 *
+	 * Params:
+	 * 	transport = Transport.
+	 * 	exception = Exception thrown on sending.
+	 *
+	 * Returns: $(D_KEYWORD true) if the operation could be successfully
+	 *          completed or scheduled, $(D_KEYWORD false) otherwise (the
+	 *          transport will be destroyed then).
+	 */
+	protected bool feed(SelectorStreamTransport transport,
+	                    SocketException exception = null) @nogc
+	{
+		while (transport.input.length && transport.writeReady)
+		{
+			try
+			{
+				ptrdiff_t sent = transport.socket.send(transport.input[]);
+				if (sent == 0)
+				{
+					transport.writeReady = false;
+				}
+				else
+				{
+					transport.input += sent;
+				}
+			}
+			catch (SocketException e)
+			{
+				exception = e;
+				transport.writeReady = false;
+			}
+		}
+		if (exception !is null)
+		{
+			auto watcher = cast(IOWatcher) connections[transport.socket.handle];
+			assert(watcher !is null);
+
+			kill(watcher, exception);
+			return false;
+		}
+		return true;
+	}
+
+	/**
+	 * Start watching.
+	 *
+	 * Params:
+	 * 	watcher = Watcher.
+	 */
+	override void start(ConnectionWatcher watcher) @nogc
+	{
+		if (watcher.active)
+		{
+			return;
+		}
+
+		if (connections.length <= watcher.socket)
+		{
+			MmapPool.instance.resizeArray(connections, watcher.socket.handle + maxEvents / 2);
+		}
+		connections[watcher.socket.handle] = watcher;
+
+		super.start(watcher);
+	}
+
+	/**
+	 * Accept incoming connections.
+	 *
+	 * Params:
+	 * 	connection = Connection watcher ready to accept.
+	 */
+	package void acceptConnections(ConnectionWatcher connection) @nogc
+	in
+	{
+		assert(connection !is null);
+	}
+	body
+	{
+		while (true)
+		{
+			ConnectedSocket client;
+			try
+			{
+				client = (cast(StreamSocket) connection.socket).accept();
+			}
+			catch (SocketException e)
+			{
+				defaultAllocator.dispose(e);
+				break;
+			}
+			if (client is null)
+			{
+				break;
+			}
+
+			IOWatcher io;
+			auto transport = MmapPool.instance.make!SelectorStreamTransport(this, client);
+
+			if (connections.length > client.handle)
+			{
+				io = cast(IOWatcher) connections[client.handle];
+			}
+			else
+			{
+				MmapPool.instance.resizeArray(connections, client.handle + maxEvents / 2);
+			}
+			if (io is null)
+			{
+				io = MmapPool.instance.make!IOWatcher(transport,
+				                                      connection.protocol);
+				connections[client.handle] = io;
+			}
+			else
+			{
+				io(transport, connection.protocol);
+			}
+
+			reify(io, EventMask(Event.none), EventMask(Event.read, Event.write));
+			connection.incoming.enqueue(io);
+		}
+
+		if (!connection.incoming.empty)
+		{
+			swapPendings.enqueue(connection);
+		}
+	}
+}

source/tanya/async/iocp.d

@@ -0,0 +1,32 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Copyright: Eugene Wissner 2016.
+ * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
+ *                  Mozilla Public License, v. 2.0).
+ * Authors: $(LINK2 mailto:belka@caraus.de, Eugene Wissner)
+ */
+module tanya.async.iocp;
+
+version (Windows):
+
+import core.sys.windows.winbase;
+import core.sys.windows.windef;
+
+/**
+ * Provides an extendable representation of a Win32 $(D_PSYMBOL OVERLAPPED)
+ * structure.
+ */
+class State
+{
+	/// For internal use by Windows API.
+	align(1) OVERLAPPED overlapped;
+
+	/// File/socket handle.
+	HANDLE handle;
+
+	/// For keeping events or event masks.
+	int event;
+}

source/tanya/async/loop.d

@@ -0,0 +1,371 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Copyright: Eugene Wissner 2016.
+ * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
+ *                  Mozilla Public License, v. 2.0).
+ * Authors: $(LINK2 mailto:belka@caraus.de, Eugene Wissner)
+ *
+ * ---
+ * import tanya.async;
+ * import tanya.memory;
+ * import tanya.network.socket;
+ *
+ * class EchoProtocol : TransmissionControlProtocol
+ * {
+ * 	private DuplexTransport transport;
+ *
+ * 	void received(ubyte[] data) @nogc
+ * 	{
+ * 		transport.write(data);
+ * 	}
+ *
+ * 	void connected(DuplexTransport transport) @nogc
+ * 	{
+ * 		this.transport = transport;
+ * 	}
+ *
+ * 	void disconnected(SocketException e = null) @nogc
+ * 	{
+ * 	}
+ * }
+ *
+ * void main()
+ * {
+ * 	auto address = defaultAllocator.make!InternetAddress("127.0.0.1", cast(ushort) 8192);
+ *
+ * 	version (Windows)
+ * 	{
+ * 		auto sock = defaultAllocator.make!OverlappedStreamSocket(AddressFamily.INET);
+ * 	}
+ * 	else
+ * 	{
+ * 		auto sock = defaultAllocator.make!StreamSocket(AddressFamily.INET);
+ * 		sock.blocking = false;
+ * 	}
+ *
+ * 	sock.bind(address);
+ * 	sock.listen(5);
+ *
+ * 	auto io = defaultAllocator.make!ConnectionWatcher(sock);
+ * 	io.setProtocol!EchoProtocol;
+ *
+ * 	defaultLoop.start(io);
+ * 	defaultLoop.run();
+ *
+ * 	sock.shutdown();
+ * 	defaultAllocator.dispose(io);
+ * 	defaultAllocator.dispose(sock);
+ * 	defaultAllocator.dispose(address);
+ * }
+ * ---
+ */
+module tanya.async.loop;
+
+import core.time;
+import std.algorithm.iteration;
+import std.algorithm.mutation;
+import std.typecons;
+import tanya.async.protocol;
+import tanya.async.transport;
+import tanya.async.watcher;
+import tanya.container.buffer;
+import tanya.container.queue;
+import tanya.memory;
+import tanya.memory.mmappool;
+import tanya.network.socket;
+
+version (DisableBackends)
+{
+}
+else version (linux)
+{
+	import tanya.async.event.epoll;
+	version = Epoll;
+}
+else version (Windows)
+{
+	import tanya.async.event.iocp;
+	version = IOCP;
+}
+else version (OSX)
+{
+	version = Kqueue;
+}
+else version (iOS)
+{
+	version = Kqueue;
+}
+else version (FreeBSD)
+{
+	version = Kqueue;
+}
+else version (OpenBSD)
+{
+	version = Kqueue;
+}
+else version (DragonFlyBSD)
+{
+	version = Kqueue;
+}
+
+/**
+ * Events.
+ */
+enum Event : uint
+{
+	none   = 0x00,       /// No events.
+	read   = 0x01,       /// Non-blocking read call.
+	write  = 0x02,       /// Non-blocking write call.
+	accept = 0x04,       /// Connection made.
+	error  = 0x80000000, /// Sent when an error occurs.
+}
+
+alias EventMask = BitFlags!Event;
+
+/**
+ * Event loop.
+ */
+abstract class Loop
+{
+	/// Pending watchers.
+	protected Queue!Watcher* pendings;
+
+	/// Ditto.
+	protected Queue!Watcher* swapPendings;
+
+	/**
+	 * Returns: Maximal event count can be got at a time
+	 *          (should be supported by the backend).
+	 */
+	protected @property inout(uint) maxEvents()
+	inout const pure nothrow @safe @nogc
+	{
+		return 128U;
+	}
+
+	/**
+	 * Initializes the loop.
+	 */
+	this() @nogc
+	{
+		pendings = MmapPool.instance.make!(Queue!Watcher)(MmapPool.instance);
+		swapPendings = MmapPool.instance.make!(Queue!Watcher)(MmapPool.instance);
+	}
+
+	/**
+	 * Frees loop internals.
+	 */
+	~this() @nogc
+	{
+		foreach (w; *pendings)
+		{
+			MmapPool.instance.dispose(w);
+		}
+		MmapPool.instance.dispose(pendings);
+
+		foreach (w; *swapPendings)
+		{
+			MmapPool.instance.dispose(w);
+		}
+		MmapPool.instance.dispose(swapPendings);
+	}
+
+	/**
+	 * Starts the loop.
+	 */
+	void run() @nogc
+	{
+		done_ = false;
+		do
+		{
+			poll();
+
+			// Invoke pendings
+			foreach (ref w; *swapPendings)
+			{
+				w.invoke();
+			}
+			swap(pendings, swapPendings);
+		}
+		while (!done_);
+	}
+
+	/**
+	 * Break out of the loop.
+	 */
+	void unloop() @safe pure nothrow @nogc
+	{
+		done_ = true;
+	}
+
+	/**
+	 * Start watching.
+	 *
+	 * Params:
+	 * 	watcher = Watcher.
+	 */
+	void start(ConnectionWatcher watcher) @nogc
+	{
+		if (watcher.active)
+		{
+			return;
+		}
+		watcher.active = true;
+		reify(watcher, EventMask(Event.none), EventMask(Event.accept));
+	}
+
+	/**
+	 * Stop watching.
+	 *
+	 * Params:
+	 * 	watcher = Watcher.
+	 */
+	void stop(ConnectionWatcher watcher) @nogc
+	{
+		if (!watcher.active)
+		{
+			return;
+		}
+		watcher.active = false;
+
+		reify(watcher, EventMask(Event.accept), EventMask(Event.none));
+	}
+
+	/**
+	 * Should be called if the backend configuration changes.
+	 *
+	 * Params:
+	 * 	watcher   = Watcher.
+	 * 	oldEvents = The events were already set.
+	 * 	events    = The events should be set.
+	 *
+	 * Returns: $(D_KEYWORD true) if the operation was successful.
+	 */
+	abstract protected bool reify(ConnectionWatcher watcher,
+								  EventMask oldEvents,
+								  EventMask events) @nogc;
+
+	/**
+	 * Returns: The blocking time.
+	 */
+	protected @property inout(Duration) blockTime()
+	inout @safe pure nothrow @nogc
+	{
+		// Don't block if we have to do.
+		return swapPendings.empty ? blockTime_ : Duration.zero;
+	}
+
+	/**
+	 * Sets the blocking time for IO watchers.
+	 *
+	 * Params:
+	 * 	blockTime = The blocking time. Cannot be larger than
+	 * 	            $(D_PSYMBOL maxBlockTime).
+	 */
+	protected @property void blockTime(in Duration blockTime) @safe pure nothrow @nogc
+	in
+	{
+		assert(blockTime <= 1.dur!"hours", "Too long to wait.");
+		assert(!blockTime.isNegative);
+	}
+	body
+	{
+		blockTime_ = blockTime;
+	}
+
+	/**
+	 * Kills the watcher and closes the connection.
+	 */
+	protected void kill(IOWatcher watcher, SocketException exception) @nogc
+	{
+		watcher.socket.shutdown();
+		defaultAllocator.dispose(watcher.socket);
+		MmapPool.instance.dispose(watcher.transport);
+		watcher.exception = exception;
+		swapPendings.enqueue(watcher);
+	}
+
+	/**
+	 * Does the actual polling.
+	 */
+	abstract protected void poll() @nogc;
+
+	/// Whether the event loop should be stopped.
+	private bool done_;
+
+	/// Maximal block time.
+	protected Duration blockTime_ = 1.dur!"minutes";
+}
+
+/**
+ * Exception thrown on errors in the event loop.
+ */
+class BadLoopException : Exception
+{
+	/**
+	 * Params:
+	 * 	file = The file where the exception occurred.
+	 * 	line = The line number where the exception occurred.
+	 * 	next = The previous exception in the chain of exceptions, if any.
+	 */
+	this(string file = __FILE__, size_t line = __LINE__, Throwable next = null)
+	pure nothrow const @safe @nogc
+	{
+		super("Event loop cannot be initialized.", file, line, next);
+	}
+}
+
+/**
+ * Returns the event loop used by default. If an event loop wasn't set with
+ * $(D_PSYMBOL defaultLoop) before, $(D_PSYMBOL defaultLoop) will try to
+ * choose an event loop supported on the system.
+ *
+ * Returns: The default event loop.
+ */
+@property Loop defaultLoop() @nogc
+{
+	if (defaultLoop_ !is null)
+	{
+		return defaultLoop_;
+	}
+	version (Epoll)
+	{
+		defaultLoop_ = MmapPool.instance.make!EpollLoop;
+	}
+	else version (IOCP)
+	{
+		defaultLoop_ = MmapPool.instance.make!IOCPLoop;
+	}
+	else version (Kqueue)
+	{
+		import tanya.async.event.kqueue;
+		defaultLoop_ = MmapPool.instance.make!KqueueLoop;
+	}
+	return defaultLoop_;
+}
+
+/**
+ * Sets the default event loop.
+ *
+ * This property makes it possible to implement your own backends or event
+ * loops, for example, if the system is not supported or if you want to
+ * extend the supported implementation. Just extend $(D_PSYMBOL Loop) and pass
+ * your implementation to this property.
+ *
+ * Params:
+ * 	loop = The event loop.
+ */
+@property void defaultLoop(Loop loop) @nogc
+in
+{
+	assert(loop !is null);
+}
+body
+{
+	defaultLoop_ = loop;
+}
+
+private Loop defaultLoop_;

source/tanya/async/package.d

@@ -0,0 +1,16 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Copyright: Eugene Wissner 2016.
+ * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
+ *                  Mozilla Public License, v. 2.0).
+ * Authors: $(LINK2 mailto:belka@caraus.de, Eugene Wissner)
+ */
+module tanya.async;
+
+public import tanya.async.loop;
+public import tanya.async.protocol;
+public import tanya.async.transport;
+public import tanya.async.watcher;

source/tanya/async/protocol.d

@@ -0,0 +1,50 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Copyright: Eugene Wissner 2016.
+ * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
+ *                  Mozilla Public License, v. 2.0).
+ * Authors: $(LINK2 mailto:belka@caraus.de, Eugene Wissner)
+ */
+module tanya.async.protocol;
+
+import tanya.network.socket;
+import tanya.async.transport;
+
+/**
+ * Common protocol interface.
+ */
+interface Protocol
+{
+	/**
+	 * Params:
+	 * 	data = Read data.
+	 */
+	void received(ubyte[] data) @nogc;
+
+	/**
+	 * Called when a connection is made.
+	 *
+	 * Params:
+	 * 	transport = Protocol transport.
+	 */
+	void connected(DuplexTransport transport) @nogc;
+
+	/**
+	 * Called when a connection is lost.
+	 *
+	 * Params:
+	 * 	exception = $(D_PSYMBOL Exception) if an error caused
+	 * 	            the disconnect, $(D_KEYWORD null) otherwise.
+	 */
+	void disconnected(SocketException exception = null) @nogc;
+}
+
+/**
+ * Interface for TCP.
+ */
+interface TransmissionControlProtocol  : Protocol
+{
+}

source/tanya/async/transport.d

@@ -0,0 +1,63 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Copyright: Eugene Wissner 2016.
+ * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
+ *                  Mozilla Public License, v. 2.0).
+ * Authors: $(LINK2 mailto:belka@caraus.de, Eugene Wissner)
+ */
+module tanya.async.transport;
+
+import tanya.network.socket;
+
+/**
+ * Base transport interface.
+ */
+interface Transport
+{
+}
+
+/**
+ * Interface for read-only transports.
+ */
+interface ReadTransport : Transport
+{
+}
+
+/**
+ * Interface for write-only transports.
+ */
+interface WriteTransport : Transport
+{
+	/**
+	 * Write some data to the transport.
+	 *
+	 * Params:
+	 * 	data = Data to send.
+	 */
+	void write(ubyte[] data) @nogc;
+}
+
+/**
+ * Represents a bidirectional transport.
+ */
+interface DuplexTransport : ReadTransport, WriteTransport
+{
+}
+
+/**
+ * Represents a socket transport.
+ */
+interface SocketTransport : Transport
+{
+	@property inout(Socket) socket() inout pure nothrow @safe @nogc;
+}
+
+/**
+ * Represents a connection-oriented socket transport.
+ */
+package interface StreamTransport : DuplexTransport, SocketTransport
+{
+}

source/tanya/async/watcher.d

@@ -0,0 +1,245 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Copyright: Eugene Wissner 2016.
+ * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
+ *                  Mozilla Public License, v. 2.0).
+ * Authors: $(LINK2 mailto:belka@caraus.de, Eugene Wissner)
+ */
+module tanya.async.watcher;
+
+import std.functional;
+import std.exception;
+import tanya.async.loop;
+import tanya.async.protocol;
+import tanya.async.transport;
+import tanya.container.buffer;
+import tanya.container.queue;
+import tanya.memory;
+import tanya.memory.mmappool;
+import tanya.network.socket;
+
+version (Windows)
+{
+	import core.sys.windows.basetyps;
+	import core.sys.windows.mswsock;
+	import core.sys.windows.winbase;
+	import core.sys.windows.windef;
+	import core.sys.windows.winsock2;
+}
+
+/**
+ * A watcher is an opaque structure that you allocate and register to record
+ * your interest in some event. 
+ */
+abstract class Watcher
+{
+	/// Whether the watcher is active.
+	bool active;
+
+	/**
+	 * Invoke some action on event.
+	 */
+	void invoke() @nogc;
+}
+
+class ConnectionWatcher : Watcher
+{
+	/// Watched socket.
+	private Socket socket_;
+
+	/// Protocol factory.
+	protected Protocol delegate() @nogc protocolFactory;
+
+	package Queue!IOWatcher incoming;
+
+	/**
+	 * Params:
+	 * 	socket = Socket.
+	 */
+	this(Socket socket) @nogc
+	{
+		socket_ = socket;
+	}
+
+	/// Ditto.
+	protected this() pure nothrow @safe @nogc
+	{
+	}
+
+	~this() @nogc
+	{
+		foreach (w; incoming)
+		{
+			MmapPool.instance.dispose(w);
+		}
+	}
+
+	/**
+	 * Params:
+	 * 	P = Protocol should be used.
+	 */
+	void setProtocol(P : Protocol)() @nogc
+	{
+		this.protocolFactory = () @nogc => cast(Protocol) MmapPool.instance.make!P;
+	}
+
+	/**
+	 * Returns: Socket.
+	 */
+	@property inout(Socket) socket() inout pure nothrow @nogc
+	{
+		return socket_;
+	}
+
+	/**
+	 * Returns: New protocol instance.
+	 */
+	@property Protocol protocol() @nogc
+	in
+	{
+		assert(protocolFactory !is null, "Protocol isn't set.");
+	}
+	body
+	{
+		return protocolFactory();
+	}
+
+	/**
+	 * Invokes new connection callback.
+	 */
+	override void invoke() @nogc
+	{
+		foreach (io; incoming)
+		{
+			io.protocol.connected(cast(DuplexTransport) io.transport);
+		}
+	}
+}
+
+/**
+ * Contains a pending watcher with the invoked events or a transport can be
+ * read from.
+ */
+class IOWatcher : ConnectionWatcher
+{
+	/// If an exception was thrown the transport should be already invalid.
+	private union
+	{
+		StreamTransport transport_;
+		SocketException exception_;
+	}
+
+	private Protocol protocol_;
+
+	/**
+	 * Returns: Underlying output buffer.
+	 */
+	package ReadBuffer!ubyte output;
+
+	/**
+	 * Params:
+	 * 	transport = Transport.
+	 * 	protocol  = New instance of the application protocol.
+	 */
+	this(StreamTransport transport, Protocol protocol) @nogc
+	in
+	{
+		assert(transport !is null);
+		assert(protocol !is null);
+	}
+	body
+	{
+		super();
+		transport_ = transport;
+		protocol_ = protocol;
+		output = ReadBuffer!ubyte(8192, 1024, MmapPool.instance);
+		active = true;
+	}
+
+	/**
+	 * Destroys the watcher.
+	 */
+	~this() @nogc
+	{
+		MmapPool.instance.dispose(protocol_);
+	}
+
+	/**
+	 * Assigns a transport.
+	 *
+	 * Params:
+	 * 	transport = Transport.
+	 * 	protocol  = Application protocol.
+	 *
+	 * Returns: $(D_KEYWORD this).
+	 */
+	IOWatcher opCall(StreamTransport transport, Protocol protocol)
+	pure nothrow @nogc
+	in
+	{
+		assert(transport !is null);
+		assert(protocol !is null);
+	}
+	body
+	{
+		transport_ = transport;
+		protocol_ = protocol;
+		active = true;
+		return this;
+	}
+
+	/**
+	 * Returns: Transport used by this watcher.
+	 */
+	@property inout(StreamTransport) transport() inout pure nothrow @nogc
+	{
+		return transport_;
+	}
+
+	/**
+	 * Sets an exception occurred during a read/write operation.
+	 *
+	 * Params:
+	 * 	exception = Thrown exception.
+	 */
+	@property void exception(SocketException exception) pure nothrow @nogc
+	{
+		exception_ = exception;
+	}
+
+	/**
+	 * Returns: Application protocol.
+	 */
+	override @property Protocol protocol() pure nothrow @safe @nogc
+	{
+		return protocol_;
+	}
+
+	/**
+	 * Returns: Socket.
+	 */
+	override @property inout(Socket) socket() inout pure nothrow @nogc
+	{
+		return transport.socket;
+	}
+
+	/**
+	 * Invokes the watcher callback.
+	 */
+	override void invoke() @nogc
+	{
+		if (output.length)
+		{
+			protocol.received(output[0..$]);
+			output.clear();
+		}
+		else
+		{
+			protocol.disconnected(exception_);
+			active = false;
+		}
+	}
+}

source/tanya/container/entry.d

@@ -5,327 +5,41 @@
 /*
  * Internal package used by containers that rely on entries/nodes.
  *
- * Copyright: Eugene Wissner 2016-2022.
+ * Copyright: Eugene Wissner 2016.
  * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
  *                  Mozilla Public License, v. 2.0).
  * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
- * Source: $(LINK2 https://github.com/caraus-ecms/tanya/blob/master/source/tanya/container/entry.d,
- *                 tanya/container/entry.d)
- */
+ */  
 module tanya.container.entry;
 
-import tanya.container.array;
-import tanya.memory.allocator;
-import tanya.memory.lifetime;
-import tanya.meta.trait;
-import tanya.meta.transform;
-
-package struct SEntry(T)
+version (unittest)
 {
-    // Item content.
-    T content;
+	package struct ConstEqualsStruct
+	{
+		int opEquals(typeof(this) that) const @nogc
+		{
+			return true;
+		}
+	}
 
-    // Next item.
-    SEntry* next;
+	package struct MutableEqualsStruct
+	{
+		int opEquals(typeof(this) that) @nogc
+		{
+			return true;
+		}
+	}
+
+	package struct NoEqualsStruct
+	{
+	}
 }
 
-package struct DEntry(T)
+package struct Entry(T)
 {
-    // Item content.
-    T content;
+	/// Item content.
+	T content;
 
-    // Previous and next item.
-    DEntry* next, prev;
-}
-
-package enum BucketStatus : byte
-{
-    deleted = -1,
-    empty = 0,
-    used = 1,
-}
-
-package struct Bucket(K, V = void)
-{
-    static if (is(V == void))
-    {
-        K key_;
-    }
-    else
-    {
-        package struct KV
-        {
-            package K key;
-            package V value;
-        }
-        KV kv;
-    }
-    BucketStatus status = BucketStatus.empty;
-
-    this()(ref K key)
-    {
-        this.key = key;
-    }
-
-    @property void key()(ref K key)
-    {
-        this.key() = key;
-        this.status = BucketStatus.used;
-    }
-
-    @property ref inout(K) key() inout
-    {
-        static if (is(V == void))
-        {
-            return this.key_;
-        }
-        else
-        {
-            return this.kv.key;
-        }
-    }
-
-    void moveKey(ref K key)
-    {
-        move(key, this.key());
-        this.status = BucketStatus.used;
-    }
-
-    bool opEquals(T)(ref const T key) const
-    {
-        return this.status == BucketStatus.used && this.key == key;
-    }
-
-    bool opEquals(ref const(typeof(this)) that) const
-    {
-        return key == that.key && this.status == that.status;
-    }
-
-    void remove()
-    {
-        static if (hasElaborateDestructor!K)
-        {
-            destroy(key);
-        }
-        this.status = BucketStatus.deleted;
-    }
-}
-
-// Possible sizes for the hash-based containers.
-package static immutable size_t[33] primes = [
-    0, 3, 7, 13, 23, 37, 53, 97, 193, 389, 769, 1543, 3079, 6151, 12289,
-    24593, 49157, 98317, 196613, 393241, 786433, 1572869, 3145739, 6291469,
-    12582917, 25165843, 50331653, 100663319, 201326611, 402653189,
-    805306457, 1610612741, 3221225473
-];
-
-package(tanya.container) struct HashArray(alias hasher, K, V = void)
-{
-    alias Key = K;
-    alias Value = V;
-    alias Bucket = .Bucket!(Key, Value);
-    alias Buckets = Array!Bucket;
-
-    Buckets array;
-    size_t lengthIndex;
-    size_t length;
-
-    this(shared Allocator allocator)
-    in
-    {
-        assert(allocator !is null);
-    }
-    do
-    {
-        this.array = Buckets(allocator);
-    }
-
-    this(T)(ref T data, shared Allocator allocator)
-    if (is(Unqual!T == HashArray))
-    in
-    {
-        assert(allocator !is null);
-    }
-    do
-    {
-        this.array = Buckets(data.array, allocator);
-        this.lengthIndex = data.lengthIndex;
-        this.length = data.length;
-    }
-
-    // Move constructor
-    void move(ref HashArray data, shared Allocator allocator)
-    in
-    {
-        assert(allocator !is null);
-    }
-    do
-    {
-        this.array = Buckets(.move(data.array), allocator);
-        this.lengthIndex = data.lengthIndex;
-        this.length = data.length;
-    }
-
-    void swap(ref HashArray data)
-    {
-        .swap(this.array, data.array);
-        .swap(this.lengthIndex, data.lengthIndex);
-        .swap(this.length, data.length);
-    }
-
-    void opAssign()(ref typeof(this) that)
-    {
-        this.array = that.array;
-        this.lengthIndex = that.lengthIndex;
-        this.length = that.length;
-    }
-
-    @property size_t bucketCount() const
-    {
-        return primes[this.lengthIndex];
-    }
-
-    /*
-     * Returns bucket position for `hash`. `0` may mean the 0th position or an
-     * empty `buckets` array.
-     */
-    size_t locateBucket(T)(ref const T key) const
-    {
-        return this.array.length == 0 ? 0 : hasher(key) % bucketCount;
-    }
-
-    /*
-     * If the key doesn't already exists, returns an empty bucket the key can
-     * be inserted in and adjusts the element count. Otherwise returns the
-     * bucket containing the key.
-     */
-    ref Bucket insert(ref Key key)
-    {
-        const newLengthIndex = this.lengthIndex + 1;
-        if (newLengthIndex != primes.length)
-        {
-            foreach (ref e; this.array[locateBucket(key) .. $])
-            {
-                if (e == key)
-                {
-                    return e;
-                }
-                else if (e.status != BucketStatus.used)
-                {
-                    ++this.length;
-                    return e;
-                }
-            }
-
-            this.rehashToSize(newLengthIndex);
-        }
-
-        foreach (ref e; this.array[locateBucket(key) .. $])
-        {
-            if (e == key)
-            {
-                return e;
-            }
-            else if (e.status != BucketStatus.used)
-            {
-                ++this.length;
-                return e;
-            }
-        }
-
-        this.array.length = this.array.length + 1;
-        ++this.length;
-        return this.array[$ - 1];
-    }
-
-    // Takes an index in the primes array.
-    void rehashToSize(const size_t n)
-    in
-    {
-        assert(n < primes.length);
-    }
-    do
-    {
-        auto storage = typeof(this.array)(primes[n], this.array.allocator);
-        DataLoop: foreach (ref e1; this.array[])
-        {
-            if (e1.status == BucketStatus.used)
-            {
-                auto bucketPosition = hasher(e1.key) % primes[n];
-
-                foreach (ref e2; storage[bucketPosition .. $])
-                {
-                    if (e2.status != BucketStatus.used) // Insert the key
-                    {
-                        .move(e1, e2);
-                        continue DataLoop;
-                    }
-                }
-                storage.insertBack(.move(e1));
-            }
-        }
-        .move(storage, this.array);
-        this.lengthIndex = n;
-    }
-
-    void rehash(const size_t n)
-    {
-        size_t lengthIndex;
-        for (; lengthIndex < primes.length; ++lengthIndex)
-        {
-            if (primes[lengthIndex] >= n)
-            {
-                break;
-            }
-        }
-        if (lengthIndex > this.lengthIndex)
-        {
-            this.rehashToSize(lengthIndex);
-        }
-    }
-
-    @property size_t capacity() const
-    {
-        return this.array.length;
-    }
-
-    void clear()
-    {
-        this.array.clear();
-        this.length = 0;
-    }
-
-    size_t remove(ref Key key)
-    {
-        foreach (ref e; this.array[locateBucket(key) .. $])
-        {
-            if (e == key) // Found.
-            {
-                e.remove();
-                --this.length;
-                return 1;
-            }
-            else if (e.status == BucketStatus.empty)
-            {
-                break;
-            }
-        }
-        return 0;
-    }
-
-    bool opBinaryRight(string op : "in", T)(ref const T key) const
-    {
-        foreach (ref e; this.array[locateBucket(key) .. $])
-        {
-            if (e == key) // Found.
-            {
-                return true;
-            }
-            else if (e.status == BucketStatus.empty)
-            {
-                break;
-            }
-        }
-        return false;
-    }
+	/// Next item.
+	Entry* next;
 }

source/tanya/container/package.d

@@ -3,20 +3,14 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /**
- * Abstract data types whose instances are collections of other objects.
- *
- * Copyright: Eugene Wissner 2016-2020.
+ * Copyright: Eugene Wissner 2016.
  * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
  *                  Mozilla Public License, v. 2.0).
  * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
- * Source: $(LINK2 https://github.com/caraus-ecms/tanya/blob/master/source/tanya/container/package.d,
- *                 tanya/container/package.d)
- */
+ */  
 module tanya.container;
 
-public import tanya.container.array;
 public import tanya.container.buffer;
-public import tanya.container.hashtable;
 public import tanya.container.list;
-public import tanya.container.set;
-public import tanya.container.string;
+public import tanya.container.vector;
+public import tanya.container.queue;

source/tanya/container/queue.d

@@ -0,0 +1,360 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Copyright: Eugene Wissner 2016.
+ * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
+ *                  Mozilla Public License, v. 2.0).
+ * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
+ */  
+module tanya.container.queue;
+
+import std.traits;
+import std.algorithm.mutation;
+import tanya.container.entry;
+import tanya.memory;
+
+/**
+ * FIFO queue.
+ *
+ * Params:
+ * 	T = Content type.
+ */
+struct Queue(T)
+{
+	/**
+	 * Removes all elements from the queue.
+	 */
+	~this()
+	{
+		while (!empty)
+		{
+			dequeue();
+		}
+	}
+
+	/**
+	 * Removes all elements from the queue.
+	 */
+	deprecated
+	void clear()
+	{
+		while (!empty)
+		{
+			dequeue();
+		}
+	}
+
+	/**
+	 * Returns how many elements are in the queue. It iterates through the queue
+	 * to count the elements.
+	 *
+	 * Returns: How many elements are in the queue.
+	 */
+	size_t length() const
+	{
+		size_t len;
+		for (const(Entry!T)* i = first.next; i !is null; i = i.next)
+		{
+			++len;
+		}
+		return len;
+	}
+
+	///
+	unittest
+	{
+		Queue!int q;
+
+		assert(q.length == 0);
+		q.enqueue(5);
+		assert(q.length == 1);
+		q.enqueue(4);
+		assert(q.length == 2);
+		q.enqueue(9);
+		assert(q.length == 3);
+
+		q.dequeue();
+		assert(q.length == 2);
+		q.dequeue();
+		assert(q.length == 1);
+		q.dequeue();
+		assert(q.length == 0);
+	}
+
+	version (D_Ddoc)
+	{
+		/**
+		 * Compares two queues. Checks if all elements of the both queues are equal.
+		 *
+		 * Returns: Whether $(D_KEYWORD this) and $(D_PARAM that) are equal.
+		 */
+		deprecated
+		int opEquals(ref typeof(this) that);
+
+		/// Ditto.
+		deprecated
+		int opEquals(typeof(this) that);
+	}
+	else static if (!hasMember!(T, "opEquals")
+	             || (functionAttributes!(T.opEquals) & FunctionAttribute.const_))
+	{
+		deprecated
+		bool opEquals(in ref typeof(this) that) const
+		{
+			const(Entry!T)* i = first.next;
+			const(Entry!T)* j = that.first.next;
+			while (i !is null && j !is null)
+			{
+				if (i.content != j.content)
+				{
+					return false;
+				}
+				i = i.next;
+				j = j.next;
+			}
+			return i is null && j is null;
+		}
+
+		deprecated
+		bool opEquals(in typeof(this) that) const
+		{
+			return opEquals(that);
+		}
+	}
+	else
+	{
+		deprecated
+		bool opEquals(ref typeof(this) that)
+		{
+			Entry!T* i = first.next;
+			Entry!T* j = that.first.next;
+			while (i !is null && j !is null)
+			{
+				if (i.content != j.content)
+				{
+					return false;
+				}
+				i = i.next;
+				j = j.next;
+			}
+			return i is null && j is null;
+		}
+
+		deprecated
+		bool opEquals(typeof(this) that)
+		{
+			return opEquals(that);
+		}
+	}
+
+	/**
+	 * Returns: First element.
+	 */
+	deprecated("Use dequeue instead.")
+	@property ref inout(T) front() inout
+	in
+	{
+		assert(!empty);
+	}
+	body
+	{
+		return first.next.content;
+	}
+
+	/**
+	 * Inserts a new element.
+	 *
+	 * Params:
+	 * 	x = New element.
+	 *
+	 * Returns: $(D_KEYWORD this).
+	 */
+	ref typeof(this) enqueue(ref T x)
+	{
+		auto temp = allocator.make!(Entry!T)(x);
+		if (empty)
+		{
+			first.next = rear = temp;
+		}
+		else
+		{
+			rear.next = temp;
+			rear = rear.next;
+		}
+		return this;
+	}
+
+	/// Ditto.
+	ref typeof(this) enqueue(T x)
+	{
+		return enqueue(x);
+	}
+
+	deprecated("Use enqueue instead.")
+	alias insert = enqueue;
+
+	deprecated("Use enqueue instead.")
+	alias insertBack = enqueue;
+
+	///
+	unittest
+	{
+		Queue!int q;
+
+		assert(q.empty);
+		q.enqueue(8).enqueue(9);
+		assert(q.dequeue() == 8);
+		assert(q.dequeue() == 9);
+	}
+
+	/**
+	 * Returns: $(D_KEYWORD true) if the queue is empty.
+	 */
+	@property bool empty() const
+	{
+		return first.next is null;
+	}
+
+	///
+	unittest
+	{
+		Queue!int q;
+		int value = 7;
+
+		assert(q.empty);
+		q.enqueue(value);
+		assert(!q.empty);
+	}
+
+	/**
+	 * Move the position to the next element.
+	 *
+	 * Returns: Dequeued element.
+	 */
+	T dequeue()
+	in
+	{
+		assert(!empty);
+		assert(allocator !is null);
+	}
+	body
+	{
+		auto n = first.next.next;
+		T ret = move(first.next.content);
+
+		dispose(allocator, first.next);
+		first.next = n;
+		return ret;
+	}
+
+	deprecated("Use dequeue instead.")
+	alias popFront = dequeue;
+
+	///
+	unittest
+	{
+		Queue!int q;
+
+		q.enqueue(8).enqueue(9);
+		assert(q.dequeue() == 8);
+		assert(q.dequeue() == 9);
+	}
+
+	/**
+	 * $(D_KEYWORD foreach) iteration. The elements will be automatically
+	 * dequeued.
+	 *
+	 * Params:
+	 * 	dg = $(D_KEYWORD foreach) body.
+	 */
+	int opApply(scope int delegate(ref size_t i, ref T) @nogc dg)
+	{
+		int result;
+
+		for (size_t i = 0; !empty; ++i)
+		{
+			auto e = dequeue();
+			if ((result = dg(i, e)) != 0)
+			{
+				return result;
+			}
+		}
+		return result;
+	}
+
+	/// Ditto.
+	int opApply(scope int delegate(ref T) @nogc dg)
+	{
+		int result;
+
+		while (!empty)
+		{
+			auto e = dequeue();
+			if ((result = dg(e)) != 0)
+			{
+				return result;
+			}
+		}
+		return result;
+	}
+
+	///
+	unittest
+	{
+		Queue!int q;
+
+		size_t j;
+		q.enqueue(5).enqueue(4).enqueue(9);
+		foreach (i, e; q)
+		{
+			assert(i != 2 || e == 9);
+			assert(i != 1 || e == 4);
+			assert(i != 0 || e == 5);
+			++j;
+		}
+		assert(j == 3);
+		assert(q.empty);
+
+		j = 0;
+		q.enqueue(5).enqueue(4).enqueue(9);
+		foreach (e; q)
+		{
+			assert(j != 2 || e == 9);
+			assert(j != 1 || e == 4);
+			assert(j != 0 || e == 5);
+			++j;
+		}
+		assert(j == 3);
+		assert(q.empty);
+	}
+
+	/// The first element of the list.
+	private Entry!T first;
+
+	/// The last element of the list.
+	private Entry!T* rear;
+
+	mixin DefaultAllocator;
+}
+
+///
+unittest
+{
+	Queue!int q;
+
+	q.enqueue(5);
+	assert(!q.empty);
+
+	q.enqueue(4).enqueue(9);
+
+	assert(q.dequeue() == 5);
+
+	foreach (i, ref e; q)
+	{
+		assert(i != 0 || e == 4);
+		assert(i != 1 || e == 9);
+	}
+	assert(q.empty);
+}

source/tanya/container/set.d

@@ -1,646 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-/**
- * This module implements a $(D_PSYMBOL Set) container that stores unique
- * values without any particular order.
- *
- * Copyright: Eugene Wissner 2017-2020.
- * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
- *                  Mozilla Public License, v. 2.0).
- * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
- * Source: $(LINK2 https://github.com/caraus-ecms/tanya/blob/master/source/tanya/container/set.d,
- *                 tanya/container/set.d)
- */
-module tanya.container.set;
-
-import tanya.container.array;
-import tanya.container.entry;
-import tanya.hash.lookup;
-import tanya.memory.allocator;
-import tanya.memory.lifetime;
-import tanya.meta.trait;
-import tanya.meta.transform;
-import tanya.range.primitive;
-
-/**
- * Bidirectional range that iterates over the $(D_PSYMBOL Set)'s values.
- *
- * Params:
- *  T = Type of the internal hash storage.
- */
-struct Range(T)
-{
-    private alias E = CopyConstness!(T, T.Key);
-    static if (isMutable!T)
-    {
-        private alias DataRange = T.array.Range;
-    }
-    else
-    {
-        private alias DataRange = T.array.ConstRange;
-    }
-    private DataRange dataRange;
-
-    @disable this();
-
-    private this(DataRange dataRange)
-    {
-        while (!dataRange.empty && dataRange.front.status != BucketStatus.used)
-        {
-            dataRange.popFront();
-        }
-        while (!dataRange.empty && dataRange.back.status != BucketStatus.used)
-        {
-            dataRange.popBack();
-        }
-        this.dataRange = dataRange;
-    }
-
-    @property Range save()
-    {
-        return this;
-    }
-
-    @property bool empty() const
-    {
-        return this.dataRange.empty();
-    }
-
-    void popFront()
-    in
-    {
-        assert(!empty);
-        assert(this.dataRange.front.status == BucketStatus.used);
-    }
-    out
-    {
-        assert(empty || this.dataRange.back.status == BucketStatus.used);
-    }
-    do
-    {
-        do
-        {
-            this.dataRange.popFront();
-        }
-        while (!empty && dataRange.front.status != BucketStatus.used);
-    }
-
-    void popBack()
-    in
-    {
-        assert(!empty);
-        assert(this.dataRange.back.status == BucketStatus.used);
-    }
-    out
-    {
-        assert(empty || this.dataRange.back.status == BucketStatus.used);
-    }
-    do
-    {
-        do
-        {
-            this.dataRange.popBack();
-        }
-        while (!empty && dataRange.back.status != BucketStatus.used);
-    }
-
-    @property ref inout(E) front() inout
-    in
-    {
-        assert(!empty);
-        assert(this.dataRange.front.status == BucketStatus.used);
-    }
-    do
-    {
-        return this.dataRange.front.key;
-    }
-
-    @property ref inout(E) back() inout
-    in
-    {
-        assert(!empty);
-        assert(this.dataRange.back.status == BucketStatus.used);
-    }
-    do
-    {
-        return this.dataRange.back.key;
-    }
-
-    Range opIndex()
-    {
-        return typeof(return)(this.dataRange[]);
-    }
-
-    Range!(const T) opIndex() const
-    {
-        return typeof(return)(this.dataRange[]);
-    }
-}
-
-/**
- * Set is a data structure that stores unique values without any particular
- * order.
- *
- * This $(D_PSYMBOL Set) is implemented using closed hashing. Hash collisions
- * are resolved with linear probing.
- *
- * $(D_PARAM T) should be hashable with $(D_PARAM hasher). $(D_PARAM hasher) is
- * a callable that accepts an argument of type $(D_PARAM T) and returns a hash
- * value for it ($(D_KEYWORD size_t)).
- *
- * Params:
- *  T      = Element type.
- *  hasher = Hash function for $(D_PARAM T).
- */
-struct Set(T, alias hasher = hash)
-if (isHashFunction!(hasher, T))
-{
-    private alias HashArray = .HashArray!(hasher, T);
-    private alias Buckets = HashArray.Buckets;
-
-    private HashArray data;
-
-    /// The range types for $(D_PSYMBOL Set).
-    alias Range = .Range!HashArray;
-
-    /// ditto
-    alias ConstRange = .Range!(const HashArray);
-
-    invariant
-    {
-        assert(this.data.lengthIndex < primes.length);
-        assert(this.data.array.length == 0
-                || this.data.array.length == primes[this.data.lengthIndex]);
-    }
-
-    /**
-     * Constructor.
-     *
-     * Params:
-     *  n         = Minimum number of buckets.
-     *  allocator = Allocator.
-     *
-     * Precondition: $(D_INLINECODE allocator !is null).
-     */
-    this(size_t n, shared Allocator allocator = defaultAllocator)
-    in
-    {
-        assert(allocator !is null);
-    }
-    do
-    {
-        this(allocator);
-        this.data.rehash(n);
-    }
-
-    ///
-    @nogc nothrow pure @safe unittest
-    {
-        auto set = Set!int(5);
-        assert(set.capacity == 7);
-    }
-
-    /// ditto
-    this(shared Allocator allocator)
-    in
-    {
-        assert(allocator !is null);
-    }
-    do
-    {
-        this.data = HashArray(allocator);
-    }
-
-    /**
-     * Initializes this $(D_PARAM Set) from another one.
-     *
-     * If $(D_PARAM init) is passed by reference, it will be copied.
-     * If $(D_PARAM init) is passed by value, it will be moved.
-     *
-     * Params:
-     *  S         = Source set type.
-     *  init      = Source set.
-     *  allocator = Allocator.
-     *
-     * Precondition: $(D_INLINECODE allocator !is null).
-     */
-    this(S)(ref S init, shared Allocator allocator = defaultAllocator)
-    if (is(Unqual!S == Set))
-    in
-    {
-        assert(allocator !is null);
-    }
-    do
-    {
-        this.data = HashArray(init.data, allocator);
-    }
-
-    /// ditto
-    this(S)(S init, shared Allocator allocator = defaultAllocator)
-    if (is(S == Set))
-    in
-    {
-        assert(allocator !is null);
-    }
-    do
-    {
-        this.data.move(init.data, allocator);
-    }
-
-    /**
-     * Initializes the set from a forward range.
-     *
-     * Params:
-     *  R         = Range type.
-     *  range     = Forward range.
-     *  allocator = Allocator.
-     *
-     * Precondition: $(D_INLINECODE allocator !is null).
-     */
-    this(R)(scope R range, shared Allocator allocator = defaultAllocator)
-    if (isForwardRange!R
-     && isImplicitlyConvertible!(ElementType!R, T)
-     && !isInfinite!R)
-    in
-    {
-        assert(allocator !is null);
-    }
-    do
-    {
-        this(allocator);
-        insert(range);
-    }
-
-    ///
-    @nogc nothrow pure @safe unittest
-    {
-        int[2] range = [1, 2];
-        Set!int set = Set!int(range[]);
-
-        assert(1 in set);
-        assert(2 in set);
-    }
-
-    /**
-     * Initializes the set from a static array.
-     *
-     * Params:
-     *  n         = Array size.
-     *  array     = Static array.
-     *  allocator = Allocator.
-     *
-     * Precondition: $(D_INLINECODE allocator !is null).
-     */
-    this(size_t n)(T[n] array, shared Allocator allocator = defaultAllocator)
-    in
-    {
-        assert(allocator !is null);
-    }
-    do
-    {
-        this(allocator);
-        insert(array[]);
-    }
-
-    ///
-    @nogc nothrow pure @safe unittest
-    {
-        Set!int set = Set!int([1, 2]);
-
-        assert(1 in set);
-        assert(2 in set);
-    }
-
-    /**
-     * Assigns another set.
-     *
-     * If $(D_PARAM that) is passed by reference, it will be copied.
-     * If $(D_PARAM that) is passed by value, it will be moved.
-     *
-     * Params:
-     *  S    = Content type.
-     *  that = The value should be assigned.
-     *
-     * Returns: $(D_KEYWORD this).
-     */
-    ref typeof(this) opAssign(S)(ref S that)
-    if (is(Unqual!S == Set))
-    {
-        this.data = that.data;
-        return this;
-    }
-
-    /// ditto
-    ref typeof(this) opAssign(S)(S that) @trusted
-    if (is(S == Set))
-    {
-        this.data.swap(that.data);
-        return this;
-    }
-
-    /**
-     * Returns: Used allocator.
-     *
-     * Postcondition: $(D_INLINECODE allocator !is null)
-     */
-    @property shared(Allocator) allocator() const
-    out (allocator)
-    {
-        assert(allocator !is null);
-    }
-    do
-    {
-        return this.data.array.allocator;
-    }
-
-    /**
-     * Maximum amount of elements this $(D_PSYMBOL Set) can hold without
-     * resizing and rehashing. Note that it doesn't mean that the
-     * $(D_PSYMBOL Set) will hold $(I exactly) $(D_PSYMBOL capacity) elements.
-     * $(D_PSYMBOL capacity) tells the size of the container under a best-case
-     * distribution of elements.
-     *
-     * Returns: $(D_PSYMBOL Set) capacity.
-     */
-    @property size_t capacity() const
-    {
-        return this.data.capacity;
-    }
-
-    ///
-    @nogc nothrow pure @safe unittest
-    {
-        Set!int set;
-        assert(set.capacity == 0);
-
-        set.insert(8);
-        assert(set.capacity == 3);
-    }
-
-    /**
-     * Iterates over the $(D_PSYMBOL Set) and counts the elements.
-     *
-     * Returns: Count of elements within the $(D_PSYMBOL Set).
-     */
-    @property size_t length() const
-    {
-        return this.data.length;
-    }
-
-    ///
-    @nogc nothrow pure @safe unittest
-    {
-        Set!int set;
-        assert(set.length == 0);
-
-        set.insert(8);
-        assert(set.length == 1);
-    }
-
-    /**
-     * Tells whether the container contains any elements.
-     *
-     * Returns: Whether the container is empty.
-     */
-    @property bool empty() const
-    {
-        return length == 0;
-    }
-
-    ///
-    @nogc nothrow pure @safe unittest
-    {
-        Set!int set;
-        assert(set.empty);
-        set.insert(5);
-        assert(!set.empty);
-    }
-
-    /**
-     * Removes all elements.
-     */
-    void clear()
-    {
-        this.data.clear();
-    }
-
-    ///
-    @nogc nothrow pure @safe unittest
-    {
-        Set!int set;
-        set.insert(5);
-        assert(!set.empty);
-        set.clear();
-        assert(set.empty);
-    }
-
-    /**
-     * Returns current bucket count in the container.
-     *
-     * Bucket count equals to the number of the elements can be saved in the
-     * container in the best case scenario for key distribution, i.d. every key
-     * has a unique hash value. In a worse case the bucket count can be less
-     * than the number of elements stored in the container.
-     *
-     * Returns: Current bucket count.
-     *
-     * See_Also: $(D_PSYMBOL rehash).
-     */
-    @property size_t bucketCount() const
-    {
-        return this.data.bucketCount;
-    }
-
-    /// The maximum number of buckets the container can have.
-    enum size_t maxBucketCount = primes[$ - 1];
-
-    /**
-     * Inserts a new element.
-     *
-     * Params:
-     *  value = Element value.
-     *
-     * Returns: Amount of new elements inserted.
-     */
-    size_t insert()(ref T value)
-    {
-        auto e = ((ref v) @trusted => &this.data.insert(v))(value);
-        if (e.status != BucketStatus.used)
-        {
-            e.moveKey(value);
-            return 1;
-        }
-        return 0;
-    }
-
-    size_t insert()(T value)
-    {
-        auto e = ((ref v) @trusted => &this.data.insert(v))(value);
-        if (e.status != BucketStatus.used)
-        {
-            e.key = value;
-            return 1;
-        }
-        return 0;
-    }
-
-    ///
-    @nogc nothrow pure @safe unittest
-    {
-        Set!int set;
-        assert(8 !in set);
-
-        assert(set.insert(8) == 1);
-        assert(set.length == 1);
-        assert(8 in set);
-
-        assert(set.insert(8) == 0);
-        assert(set.length == 1);
-        assert(8 in set);
-
-        assert(set.remove(8));
-        assert(set.insert(8) == 1);
-    }
-
-    /**
-     * Inserts the value from a forward range into the set.
-     *
-     * Params:
-     *  R     = Range type.
-     *  range = Forward range.
-     *
-     * Returns: The number of new elements inserted.
-     */
-    size_t insert(R)(scope R range)
-    if (isForwardRange!R
-     && isImplicitlyConvertible!(ElementType!R, T)
-     && !isInfinite!R)
-    {
-        size_t count;
-        foreach (e; range)
-        {
-            count += insert(e);
-        }
-        return count;
-    }
-
-    ///
-    @nogc nothrow pure @safe unittest
-    {
-        Set!int set;
-
-        int[3] range = [2, 1, 2];
-
-        assert(set.insert(range[]) == 2);
-        assert(1 in set);
-        assert(2 in set);
-    }
-
-    /**
-     * Removes an element.
-     *
-     * Params:
-     *  value = Element value.
-     *
-     * Returns: Number of elements removed, which is in the container with
-     *          unique values `1` if an element existed, and `0` otherwise.
-     */
-    size_t remove(T value)
-    {
-        return this.data.remove(value);
-    }
-
-    ///
-    @nogc nothrow pure @safe unittest
-    {
-        Set!int set;
-        set.insert(8);
-
-        assert(8 in set);
-        assert(set.remove(8) == 1);
-        assert(set.remove(8) == 0);
-        assert(8 !in set);
-    }
-
-    /**
-     * $(D_KEYWORD in) operator.
-     *
-     * Params:
-     *  U     = Type comparable with the element type, used for the lookup.
-     *  value = Element to be searched for.
-     *
-     * Returns: $(D_KEYWORD true) if the given element exists in the container,
-     *          $(D_KEYWORD false) otherwise.
-     */
-    bool opBinaryRight(string op : "in", U)(auto ref const U value) const
-    if (ifTestable!(U, a => T.init == a))
-    {
-        return value in this.data;
-    }
-
-    ///
-    @nogc nothrow pure @safe unittest
-    {
-        Set!int set;
-
-        assert(5 !in set);
-        set.insert(5);
-        assert(5 in set);
-        assert(8 !in set);
-    }
-
-    /**
-     * Sets the number of buckets in the container to at least $(D_PARAM n)
-     * and rearranges all the elements according to their hash values.
-     *
-     * If $(D_PARAM n) is greater than the current $(D_PSYMBOL bucketCount)
-     * and lower than or equal to $(D_PSYMBOL maxBucketCount), a rehash is
-     * forced.
-     *
-     * If $(D_PARAM n) is greater than $(D_PSYMBOL maxBucketCount),
-     * $(D_PSYMBOL maxBucketCount) is used instead as a new number of buckets.
-     *
-     * If $(D_PARAM n) is less than or equal to the current
-     * $(D_PSYMBOL bucketCount), the function may have no effect.
-     *
-     * Rehashing is automatically performed whenever the container needs space
-     * to insert new elements.
-     *
-     * Params:
-     *  n = Minimum number of buckets.
-     */
-    void rehash(size_t n)
-    {
-        this.data.rehash(n);
-    }
-
-    /**
-     * Returns a bidirectional range over the container.
-     *
-     * Returns: A bidirectional range that iterates over the container.
-     */
-    Range opIndex()
-    {
-        return typeof(return)(this.data.array[]);
-    }
-
-    /// ditto
-    ConstRange opIndex() const
-    {
-        return typeof(return)(this.data.array[]);
-    }
-
-    ///
-    @nogc nothrow pure @safe unittest
-    {
-        Set!int set;
-        assert(set[].empty);
-
-        set.insert(8);
-        assert(!set[].empty);
-        assert(set[].front == 8);
-        assert(set[].back == 8);
-    }
-}

source/tanya/conv.d

@@ -1,567 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-/**
- * This module provides functions for converting between different types.
- *
- * Copyright: Eugene Wissner 2017-2020.
- * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
- *                  Mozilla Public License, v. 2.0).
- * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
- * Source: $(LINK2 https://github.com/caraus-ecms/tanya/blob/master/source/tanya/conv.d,
- *                 tanya/conv.d)
- */
-module tanya.conv;
-
-import std.traits : Unsigned, isNumeric;
-import tanya.container.string;
-import tanya.memory.allocator;
-import tanya.meta.trait;
-import tanya.meta.transform;
-import tanya.range;
-
-/**
- * Thrown if a type conversion fails.
- */
-final class ConvException : Exception
-{
-    /**
-     * Params:
-     *  msg  = The message for the exception.
-     *  file = The file where the exception occurred.
-     *  line = The line number where the exception occurred.
-     *  next = The previous exception in the chain of exceptions, if any.
-     */
-    this(string msg,
-         string file = __FILE__,
-         size_t line = __LINE__,
-         Throwable next = null) @nogc @safe pure nothrow
-    {
-        super(msg, file, line, next);
-    }
-}
-
-/*
- * Converts a string $(D_PARAM range) into an integral value of type
- * $(D_PARAM T) in $(D_PARAM base).
- *
- * The convertion stops when $(D_PARAM range) is empty of if the next character
- * cannot be converted because it is not a digit (with respect to the
- * $(D_PARAM base)) or if the reading the next character would cause integer
- * overflow. The function returns the value converted so far then. The front
- * element of the $(D_PARAM range) points to the first character cannot be
- * converted or $(D_PARAM range) is empty if the whole string could be
- * converted.
- *
- * Base must be between 2 and 36 inclursive. Default base is 10.
- *
- * The function doesn't handle the sign (+ or -) or number prefixes (like 0x).
- */
-package T readIntegral(T, R)(ref R range, const ubyte base = 10)
-if (isInputRange!R
-        && isSomeChar!(ElementType!R)
-        && isIntegral!T
-        && isUnsigned!T)
-in
-{
-    assert(base >= 2);
-    assert(base <= 36);
-}
-do
-{
-    T boundary = cast(T) (T.max / base);
-    if (range.empty)
-    {
-        return T.init;
-    }
-
-    T n;
-    int digit;
-    do
-    {
-        if (range.front >= 'a')
-        {
-            digit = range.front - 'W';
-        }
-        else if (range.front >= 'A' && range.front <= 'Z')
-        {
-            digit = range.front - '7';
-        }
-        else if (range.front >= '0' && range.front <= '9')
-        {
-            digit = range.front - '0';
-        }
-        else
-        {
-            return n;
-        }
-        if (digit >= base)
-        {
-            return n;
-        }
-        n = cast(T) (n * base + digit);
-        range.popFront();
-
-        if (range.empty)
-        {
-            return n;
-        }
-    }
-    while (n < boundary);
-
-    if (range.front >= 'a')
-    {
-        digit = range.front - 'W';
-    }
-    else if (range.front >= 'A')
-    {
-        digit = range.front - '7';
-    }
-    else if (range.front >= '0')
-    {
-        digit = range.front - '0';
-    }
-    else
-    {
-        return n;
-    }
-    if (n > cast(T) ((T.max - digit) / base))
-    {
-        return n;
-    }
-    n = cast(T) (n * base + digit);
-    range.popFront();
-
-    return n;
-}
-
-/**
- * If the source type $(D_PARAM From) and the target type $(D_PARAM To) are
- * equal, does nothing. If $(D_PARAM From) can be implicitly converted to
- * $(D_PARAM To), just returns $(D_PARAM from).
- *
- * Params:
- *  To = Target type.
- *
- * Returns: $(D_PARAM from).
- */
-template to(To)
-{
-    /**
-     * Params:
-     *  From = Source type.
-     *  from = Source value.
-     */
-    ref To to(From)(ref From from)
-    if (is(To == From))
-    {
-        return from;
-    }
-
-    /// ditto
-    To to(From)(From from)
-    if (is(Unqual!To == Unqual!From) || (isNumeric!From && isFloatingPoint!To))
-    {
-        return from;
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    auto val = 5.to!int();
-    assert(val == 5);
-    static assert(is(typeof(val) == int));
-}
-
-/**
- * Performs checked conversion from an integral type $(D_PARAM From) to an
- * integral type $(D_PARAM To).
- *
- * Params:
- *  From = Source type.
- *  To   = Target type.
- *  from = Source value.
- *
- * Returns: $(D_PARAM from) converted to $(D_PARAM To).
- *
- * Throws: $(D_PSYMBOL ConvException) if $(D_PARAM from) is too small or too
- *         large to be represented by $(D_PARAM To).
- */
-To to(To, From)(From from)
-if (isIntegral!From
- && isIntegral!To
- && !is(Unqual!To == Unqual!From)
- && !is(To == enum))
-{
-    static if ((isUnsigned!From && isSigned!To && From.sizeof == To.sizeof)
-            || From.sizeof > To.sizeof)
-    {
-        if (from > To.max)
-        {
-            throw make!ConvException(defaultAllocator,
-                                     "Positive integer overflow");
-        }
-    }
-    static if (isSigned!From)
-    {
-        static if (isUnsigned!To)
-        {
-            if (from < 0)
-            {
-                throw make!ConvException(defaultAllocator,
-                                         "Negative integer overflow");
-            }
-        }
-        else static if (From.sizeof > To.sizeof)
-        {
-            if (from < To.min)
-            {
-                throw make!ConvException(defaultAllocator,
-                                         "Negative integer overflow");
-            }
-        }
-    }
-    static if (From.sizeof <= To.sizeof)
-    {
-        return from;
-    }
-    else static if (isSigned!To)
-    {
-        return cast(To) from;
-    }
-    else
-    {
-        return from & To.max;
-    }
-}
-
-/**
- * Converts a floating point number to an integral type.
- *
- * Params:
- *  From = Source type.
- *  To   = Target type.
- *  from = Source value.
- *
- * Returns: Truncated $(D_PARAM from) (everything after the decimal point is
- *          dropped).
- *
- * Throws: $(D_PSYMBOL ConvException) if
- *         $(D_INLINECODE from < To.min || from > To.max).
- */
-To to(To, From)(From from)
-if (isFloatingPoint!From
- && isIntegral!To
- && !is(Unqual!To == Unqual!From)
- && !is(To == enum))
-{
-    if (from > To.max)
-    {
-        throw make!ConvException(defaultAllocator,
-                                 "Positive number overflow");
-    }
-    else if (from < To.min)
-    {
-        throw make!ConvException(defaultAllocator,
-                                 "Negative number overflow");
-    }
-    return cast(To) from;
-}
-
-///
-@nogc pure @safe unittest
-{
-    assert(1.5.to!int == 1);
-    assert(2147483646.5.to!int == 2147483646);
-    assert((-2147483647.5).to!int == -2147483647);
-    assert(2147483646.5.to!uint == 2147483646);
-}
-
-/**
- * Performs checked conversion from an integral type $(D_PARAM From) to an
- * $(D_KEYWORD enum).
- *
- * Params:
- *  From = Source type.
- *  To   = Target type.
- *  from = Source value.
- *
- * Returns: $(D_KEYWORD enum) value.
- *
- * Throws: $(D_PSYMBOL ConvException) if $(D_PARAM from) is not a member of
- *         $(D_PSYMBOL To).
- */
-To to(To, From)(From from)
-if (isIntegral!From && is(To == enum))
-{
-    foreach (m; EnumMembers!To)
-    {
-        if (from == m)
-        {
-            return m;
-        }
-    }
-    throw make!ConvException(defaultAllocator,
-                             "Value not found in enum '" ~ To.stringof ~ "'");
-}
-
-///
-@nogc pure @safe unittest
-{
-    enum Test : int
-    {
-        one,
-        two,
-    }
-    static assert(is(typeof(1.to!Test) == Test));
-    assert(0.to!Test == Test.one);
-    assert(1.to!Test == Test.two);
-}
-
-/**
- * Converts $(D_PARAM from) to a boolean.
- *
- * If $(D_PARAM From) is a numeric type, then `1` becomes $(D_KEYWORD true),
- * `0` $(D_KEYWORD false). Otherwise $(D_PSYMBOL ConvException) is thrown.
- *
- * If $(D_PARAM To) is a string (built-in string or $(D_PSYMBOL String)),
- * then `"true"` or `"false"` are converted to the appropriate boolean value.
- * Otherwise $(D_PSYMBOL ConvException) is thrown.
- *
- * Params:
- *  From = Source type.
- *  To   = Target type.
- *  from = Source value.
- *
- * Returns: $(D_KEYWORD from) converted to a boolean.
- *
- * Throws: $(D_PSYMBOL ConvException) if $(D_PARAM from) isn't convertible.
- */
-To to(To, From)(From from)
-if (isNumeric!From && is(Unqual!To == bool) && !is(Unqual!To == Unqual!From))
-{
-    if (from == 0)
-    {
-        return false;
-    }
-    else if (from < 0)
-    {
-        throw make!ConvException(defaultAllocator,
-                                 "Negative number overflow");
-    }
-    else if (from <= 1)
-    {
-        return true;
-    }
-    throw make!ConvException(defaultAllocator,
-                             "Positive number overflow");
-}
-
-///
-@nogc pure @safe unittest
-{
-    assert(!0.0.to!bool);
-    assert(0.2.to!bool);
-    assert(0.5.to!bool);
-    assert(1.0.to!bool);
-
-    assert(!0.to!bool);
-    assert(1.to!bool);
-}
-
-/// ditto
-To to(To, From)(auto ref const From from)
-if ((is(From == String) || isSomeString!From) && is(Unqual!To == bool))
-{
-    if (from == "true")
-    {
-        return true;
-    }
-    else if (from == "false")
-    {
-        return false;
-    }
-    throw make!ConvException(defaultAllocator,
-                             "String doesn't contain a boolean value");
-}
-
-///
-@nogc pure @safe unittest
-{
-    assert("true".to!bool);
-    assert(!"false".to!bool);
-    assert(String("true").to!bool);
-    assert(!String("false").to!bool);
-
-}
-
-/**
- * Converts a boolean to $(D_PARAM To).
- *
- * If $(D_PARAM To) is a numeric type, then $(D_KEYWORD true) becomes `1`,
- * $(D_KEYWORD false) `0`.
- *
- * If $(D_PARAM To) is a $(D_PSYMBOL String), then `"true"` or `"false"`
- * is returned.
- *
- * Params:
- *  From = Source type.
- *  To   = Target type.
- *  from = Source value.
- *
- * Returns: $(D_PARAM from) converted to $(D_PARAM To).
- */
-To to(To, From)(From from)
-if (is(Unqual!From == bool) && isNumeric!To && !is(Unqual!To == Unqual!From))
-{
-    return from;
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    assert(true.to!float == 1.0);
-    assert(true.to!double == 1.0);
-    assert(true.to!ubyte == 1);
-    assert(true.to!byte == 1);
-    assert(true.to!ushort == 1);
-    assert(true.to!short == 1);
-    assert(true.to!uint == 1);
-    assert(true.to!int == 1);
-
-    assert(false.to!float == 0);
-    assert(false.to!double == 0);
-    assert(false.to!ubyte == 0);
-    assert(false.to!byte == 0);
-    assert(false.to!ushort == 0);
-    assert(false.to!short == 0);
-    assert(false.to!uint == 0);
-    assert(false.to!int == 0);
-}
-
-/**
- * Converts a stringish range to an integral value.
- *
- * Params:
- *  From = Source type.
- *  To   = Target type.
- *  from = Source value.
- *
- * Returns: $(D_PARAM from) converted to $(D_PARAM To).
- *
- * Throws: $(D_PSYMBOL ConvException) if $(D_PARAM from) doesn't contain an
- *         integral value.
- */
-To to(To, From)(auto ref From from)
-if (isInputRange!From && isSomeChar!(ElementType!From) && isIntegral!To)
-{
-    if (from.empty)
-    {
-        throw make!ConvException(defaultAllocator, "Input range is empty");
-    }
-
-    static if (isSigned!To)
-    {
-        bool negative;
-    }
-    if (from.front == '-')
-    {
-        static if (isUnsigned!To)
-        {
-            throw make!ConvException(defaultAllocator,
-                                     "Negative integer overflow");
-        }
-        else
-        {
-            negative = true;
-            from.popFront();
-        }
-    }
-
-    if (from.empty)
-    {
-        throw make!ConvException(defaultAllocator, "Input range is empty");
-    }
-
-    ubyte base = 10;
-    if (from.front == '0')
-    {
-        from.popFront();
-        if (from.empty)
-        {
-            return To.init;
-        }
-        else if (from.front == 'x' || from.front == 'X')
-        {
-            base = 16;
-            from.popFront();
-        }
-        else if (from.front == 'b' || from.front == 'B')
-        {
-            base = 2;
-            from.popFront();
-        }
-        else
-        {
-            base = 8;
-        }
-    }
-
-    auto unsigned = readIntegral!(Unsigned!To, From)(from, base);
-    if (!from.empty)
-    {
-        throw make!ConvException(defaultAllocator, "Integer overflow");
-    }
-
-    static if (isSigned!To)
-    {
-        if (negative)
-        {
-            auto predecessor = cast(Unsigned!To) (unsigned - 1);
-            if (predecessor > cast(Unsigned!To) To.max)
-            {
-                throw make!ConvException(defaultAllocator,
-                                         "Negative integer overflow");
-            }
-            return cast(To) (-(cast(Largest!(To, ptrdiff_t)) predecessor) - 1);
-        }
-        else if (unsigned > cast(Unsigned!To) To.max)
-        {
-            throw make!ConvException(defaultAllocator, "Integer overflow");
-        }
-        else
-        {
-            return unsigned;
-        }
-    }
-    else
-    {
-        return unsigned;
-    }
-}
-
-///
-@nogc pure @safe unittest
-{
-    assert("1234".to!uint() == 1234);
-    assert("1234".to!int() == 1234);
-    assert("1234".to!int() == 1234);
-
-    assert("0".to!int() == 0);
-    assert("-0".to!int() == 0);
-
-    assert("0x10".to!int() == 16);
-    assert("0X10".to!int() == 16);
-    assert("-0x10".to!int() == -16);
-
-    assert("0b10".to!int() == 2);
-    assert("0B10".to!int() == 2);
-    assert("-0b10".to!int() == -2);
-
-    assert("010".to!int() == 8);
-    assert("-010".to!int() == -8);
-
-    assert("-128".to!byte == cast(byte) -128);
-}

source/tanya/crypto/bit.d

@@ -0,0 +1,510 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Copyright: Eugene Wissner 2016.
+ * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
+ *                  Mozilla Public License, v. 2.0).
+ * Authors: $(LINK2 mailto:belka@caraus.de, Eugene Wissner)
+ */
+module tanya.crypto.bit;
+
+/**
+ * Wrapper that allows bit manipulation on $(D_KEYWORD ubyte[]) array.
+ */
+struct BitVector
+{
+    protected ubyte[] vector;
+
+    /**
+     * Params:
+     *     array = Array should be manipulated on.
+     */
+    this(inout(ubyte[]) array) inout pure nothrow @safe @nogc
+    in
+    {
+        assert(array.length <= size_t.max / 8);
+        assert(array !is null);
+    }
+    body
+    {
+        vector = array;
+    }
+
+    ///
+    unittest
+    {
+        ubyte[5] array1 = [234, 3, 252, 10, 18];
+        ubyte[3] array2 = [65, 13, 173];
+        auto bits = BitVector(array1);
+
+        assert(bits[] is array1);
+        assert(bits[] !is array2);
+
+        bits = BitVector(array2);
+        assert(bits[] is array2);
+
+    }
+
+    /**
+     * Returns: Number of bits in the vector.
+     */
+    @property inout(size_t) length() inout const pure nothrow @safe @nogc
+    {
+        return vector.length * 8;
+    }
+
+    /// Ditto.
+    inout(size_t) opDollar() inout const pure nothrow @safe @nogc
+    {
+        return vector.length * 8;
+    }
+
+    ///
+    unittest
+    {
+        // [01000001, 00001101, 10101101]
+        ubyte[3] arr = [65, 13, 173];
+        auto bits = BitVector(arr);
+
+        assert(bits.length == 24);
+    }
+
+    /**
+     * Params:
+     *     bit = Bit position.
+     *
+     * Returns: $(D_KEYWORD true) if the bit on position $(D_PARAM bit) is set,
+     *          $(D_KEYWORD false) if not set.
+     */
+    inout(bool) opIndex(size_t bit) inout const pure nothrow @safe @nogc
+    in
+    {
+        assert(bit / 8 <= vector.length);
+    }
+    body
+    {
+        return (vector[bit / 8] & (0x80 >> (bit % 8))) != 0;
+    }
+
+    ///
+    unittest
+    {
+        // [01000001, 00001101, 10101101]
+        ubyte[3] arr = [65, 13, 173];
+        auto bits = BitVector(arr);
+
+        assert(!bits[0]);
+        assert(bits[1]);
+        assert(bits[7]);
+        assert(!bits[8]);
+        assert(!bits[11]);
+        assert(bits[12]);
+        assert(bits[20]);
+        assert(bits[23]);
+    }
+
+    /**
+     * Returns: Underlying array.
+     */
+    inout(ubyte[]) opIndex() inout pure nothrow @safe @nogc
+    {
+        return vector;
+    }
+
+    ///
+    unittest
+    {
+        // [01000001, 00001101, 10101101]
+        ubyte[3] arr = [65, 13, 173];
+        auto bits = BitVector(arr);
+
+        assert(bits[] is arr);
+    }
+
+    /**
+     * Params:
+     *     value = $(D_KEYWORD true) if the bit should be set,
+     *             $(D_KEYWORD false) if cleared.
+     *     bit   = Bit position.
+     *
+     * Returns: $(D_PSYMBOL this).
+     */
+    bool opIndexAssign(bool value, size_t bit) pure nothrow @safe @nogc
+    in
+    {
+        assert(bit / 8 <= vector.length);
+    }
+    body
+    {
+        if (value)
+        {
+            vector[bit / 8] |= (0x80 >> (bit % 8));
+        }
+        else
+        {
+            vector[bit / 8] &= ~(0x80 >> (bit % 8));
+        }
+        return value;
+    }
+
+    ///
+    unittest
+    {
+        // [01000001, 00001101, 10101101]
+        ubyte[3] arr = [65, 13, 173];
+        auto bits = BitVector(arr);
+
+        bits[5] = bits[6] = true;
+        assert(bits[][0] == 71);
+
+        bits[14] = true;
+        bits[15] = false;
+        assert(bits[][1] == 14);
+
+        bits[16] = bits[23] = false;
+        assert(bits[][2] == 44);
+    }
+
+    /**
+     * Copies bits from $(D_PARAM vector) into this $(D_PSYMBOL BitVector).
+     *
+     * The array that should be assigned, can be smaller (but not larger) than
+     * the underlying array of this $(D_PSYMBOL BitVector), leading zeros will
+     * be added in this case to the left.
+     *
+     * Params:
+     *     vector = $(D_KEYWORD ubyte[]) array not larger than
+     *              `$(D_PSYMBOL length) / 8`.
+     *
+     * Returns: $(D_KEYWORD this).
+     */
+    BitVector opAssign(ubyte[] vector) pure nothrow @safe @nogc
+    in
+    {
+        assert(vector.length <= this.vector.length);
+    }
+    body
+    {
+        immutable delta = this.vector.length - vector.length;
+        if (delta > 0)
+        {
+            this.vector[0..delta] = 0;
+        }
+        this.vector[delta..$] = vector[0..$];
+        return this;
+    }
+
+    ///
+    unittest
+    {
+        ubyte[5] array1 = [234, 3, 252, 10, 18];
+        ubyte[3] array2 = [65, 13, 173];
+        auto bits = BitVector(array1);
+
+        bits = array2;
+        assert(bits[][0] == 0);
+        assert(bits[][1] == 0);
+        assert(bits[][2] == 65);
+        assert(bits[][3] == 13);
+        assert(bits[][4] == 173);
+
+        bits = array2[0..2];
+        assert(bits[][0] == 0);
+        assert(bits[][1] == 0);
+        assert(bits[][2] == 0);
+        assert(bits[][3] == 65);
+        assert(bits[][4] == 13);
+    }
+
+    /**
+     * Support for bitwise operations.
+     *
+     * Params:
+     *     that = Another bit vector.
+     *
+     * Returns: $(D_KEYWORD this).
+     */
+    BitVector opOpAssign(string op)(BitVector that) pure nothrow @safe @nogc
+        if ((op == "^") || (op == "|") || (op == "&"))
+    {
+        return opOpAssign(op)(that.vector);
+    }
+
+    /// Ditto.
+    BitVector opOpAssign(string op)(ubyte[] that) pure nothrow @safe @nogc
+        if ((op == "^") || (op == "|") || (op == "&"))
+    in
+    {
+        assert(that.length <= vector.length);
+    }
+    body
+    {
+        for (int i = cast(int) vector.length - 1; i >= 0; --i)
+        {
+            mixin("vector[i] " ~  op ~ "= " ~ "that[i];");
+        }
+        immutable delta = vector.length - that.length;
+        if (delta)
+        {
+            static if (op == "&")
+            {
+                vector[0..delta] = 0;
+            }
+        }
+        return this;
+    }
+
+    ///
+    unittest
+    {
+        // [01000001, 00001101, 10101101]
+        ubyte[3] array1 = [65, 13, 173];
+        ubyte[3] array2 = [0b01010010, 0b10111110, 0b10111110];
+        auto bits = BitVector(array1);
+
+        bits |= array2;
+        assert(bits[][0] == 0b01010011);
+        assert(bits[][1] == 0b10111111);
+        assert(bits[][2] == 0b10111111);
+
+        bits &= array2;
+        assert(bits[][0] == array2[0]);
+        assert(bits[][1] == array2[1]);
+        assert(bits[][2] == array2[2]);
+
+        bits ^= array2;
+        assert(bits[][0] == 0);
+        assert(bits[][1] == 0);
+        assert(bits[][2] == 0);
+    }
+
+    /**
+     * Support for shift operations.
+     *
+     * Params:
+     *     n = Number of bits.
+     *
+     * Returns: $(D_KEYWORD this).
+     */
+    BitVector opOpAssign(string op)(in size_t n) pure nothrow @safe @nogc
+        if ((op == "<<") || (op == ">>"))
+
+    {
+        if (n >= length)
+        {
+            vector[0..$] = 0;
+        }
+        else if (n != 0)
+        {
+            immutable bit = n % 8, step = n / 8;
+            immutable delta = 8 - bit;
+            size_t i, j;
+
+            static if (op == "<<")
+            {
+                for (j = step; j < vector.length - 1; ++i)
+                {
+                    vector[i] = cast(ubyte)((vector[j] << bit)
+                              | vector[++j] >> delta);
+                }
+                vector[i] = cast(ubyte)(vector[j] << bit);
+                vector[$ - step ..$] = 0;
+            }
+            else static if (op == ">>")
+            {
+                for (i = vector.length - 1, j = i - step; j > 0; --i)
+                {
+                    vector[i] = cast(ubyte)((vector[j] >> bit)
+                              | vector[--j] << delta);
+                }
+                vector[i] = cast(ubyte)(vector[j] >> bit);
+                vector[0..step] = 0;
+            }
+        }
+        return this;
+    }
+
+    ///
+    nothrow @safe @nogc unittest
+    {
+        ubyte[4] arr = [0b10111110, 0b11110010, 0b01010010, 0b01010011];
+        auto bits = BitVector(arr);
+
+        bits <<= 0;
+        assert(bits[][0] == 0b10111110 && bits[][1] == 0b11110010
+            && bits[][2] == 0b01010010 && bits[][3] == 0b01010011);
+
+        bits <<= 2;
+        assert(bits[][0] == 0b11111011 && bits[][1] == 0b11001001
+            && bits[][2] == 0b01001001 && bits[][3] == 0b01001100);
+
+        bits <<= 4;
+        assert(bits[][0] == 0b10111100 && bits[][1] == 0b10010100
+            && bits[][2] == 0b10010100 && bits[][3] == 0b11000000);
+
+        bits <<= 8;
+        assert(bits[][0] == 0b10010100 && bits[][1] == 0b10010100
+            && bits[][2] == 0b11000000 && bits[][3] == 0b00000000);
+
+        bits <<= 7;
+        assert(bits[][0] == 0b01001010 && bits[][1] == 0b01100000
+            && bits[][2] == 0b00000000 && bits[][3] == 0b00000000);
+
+        bits <<= 25;
+        assert(bits[][0] == 0b00000000 && bits[][1] == 0b00000000
+            && bits[][2] == 0b00000000 && bits[][3] == 0b00000000);
+
+        arr = [0b00110011, 0b11001100, 0b11111111, 0b01010101];
+        bits <<= 24;
+        assert(bits[][0] == 0b01010101 && bits[][1] == 0b00000000
+            && bits[][2] == 0b00000000 && bits[][3] == 0b00000000);
+
+        arr[1] = 0b11001100;
+        arr[2] = 0b11111111;
+        arr[3] = 0b01010101;
+        bits <<= 12;
+        assert(bits[][0] == 0b11001111 && bits[][1] == 0b11110101
+            && bits[][2] == 0b01010000 && bits[][3] == 0b00000000);
+
+        bits <<= 100;
+        assert(bits[][0] == 0b00000000 && bits[][1] == 0b00000000
+            && bits[][2] == 0b00000000 && bits[][3] == 0b00000000);
+
+        arr = [0b10111110, 0b11110010, 0b01010010, 0b01010011];
+        bits >>= 0;
+        assert(bits[][0] == 0b10111110 && bits[][1] == 0b11110010
+            && bits[][2] == 0b01010010 && bits[][3] == 0b01010011);
+
+        bits >>= 2;
+        assert(bits[][0] == 0b00101111 && bits[][1] == 0b10111100
+            && bits[][2] == 0b10010100 && bits[][3] == 0b10010100);
+
+        bits >>= 4;
+        assert(bits[][0] == 0b00000010 && bits[][1] == 0b11111011
+            && bits[][2] == 0b11001001 && bits[][3] == 0b01001001);
+
+        bits >>= 8;
+        assert(bits[][0] == 0b00000000 && bits[][1] == 0b00000010
+            && bits[][2] == 0b11111011 && bits[][3] == 0b11001001);
+
+        bits >>= 7;
+        assert(bits[][0] == 0b00000000 && bits[][1] == 0b00000000
+            && bits[][2] == 0b00000101 && bits[][3] == 0b11110111);
+
+        bits >>= 25;
+        assert(bits[][0] == 0b00000000 && bits[][1] == 0b00000000
+            && bits[][2] == 0b00000000 && bits[][3] == 0b00000000);
+
+        arr = [0b00110011, 0b11001100, 0b11111111, 0b01010101];
+        bits >>= 24;
+        assert(bits[][0] == 0b00000000 && bits[][1] == 0b00000000
+            && bits[][2] == 0b00000000 && bits[][3] == 0b00110011);
+
+        arr[1] = 0b11001100;
+        arr[2] = 0b11111111;
+        arr[3] = 0b01010101;
+        bits >>= 12;
+        assert(bits[][0] == 0b00000000 && bits[][1] == 0b00000000
+            && bits[][2] == 0b00001100 && bits[][3] == 0b11001111);
+
+        bits >>= 100;
+        assert(bits[][0] == 0b00000000 && bits[][1] == 0b00000000
+            && bits[][2] == 0b00000000 && bits[][3] == 0b00000000);
+    }
+
+    /**
+     * Negates all bits.
+     *
+     * Returns: $(D_KEYWORD this).
+     */
+    BitVector opUnary(string op)() pure nothrow @safe @nogc
+        if (op == "~")
+    {
+        foreach (ref b; vector)
+        {
+            b = ~b;
+        }
+        return this;
+    }
+
+    ///
+    unittest
+    {
+        // [01000001, 00001101, 10101101]
+        ubyte[3] arr = [65, 13, 173];
+        auto bits = BitVector(arr);
+
+        ~bits;
+        assert(bits[][0] == 0b10111110);
+        assert(bits[][1] == 0b11110010);
+        assert(bits[][2] == 0b01010010);
+    }
+
+    /**
+     * Iterates through all bits.
+     *
+     * Params:
+     *     dg = $(D_KEYWORD foreach) delegate.
+     *
+     * Returns: By $(D_PARAM dg) returned value.
+     */
+    int opApply(int delegate(size_t, bool) dg)
+    {
+        int result;
+        foreach (i, ref v; vector)
+        {
+            foreach (c; 0..8)
+            {
+                result = dg(i * 8 + c, (v & (0x80 >> c)) != 0);
+                if (result)
+                {
+                    return result;
+                }
+            }
+        }
+        return result;
+    }
+
+    /// Ditto.
+    int opApply(int delegate(bool) dg)
+    {
+        int result;
+        foreach (ref v; vector)
+        {
+            foreach (c; 0..8)
+            {
+                result = dg((v & (0x80 >> c)) != 0);
+                if (result)
+                {
+                    return result;
+                }
+            }
+        }
+        return result;
+    }
+
+    ///
+    unittest
+    {
+        ubyte[2] arr = [0b01000001, 0b00001101];
+        auto bits = BitVector(arr);
+        size_t c;
+
+        foreach (i, v; bits)
+        {
+            assert(i == c);
+            if (i == 1 || i == 7 || i == 15 || i == 13 || i == 12)
+            {
+                assert(v);
+            }
+            else
+            {
+                assert(!v);
+            }
+            ++c;
+        }
+        assert(c == 16);
+    }
+}

source/tanya/crypto/des.d

@@ -0,0 +1,607 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Copyright: Eugene Wissner 2016.
+ * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
+ *                  Mozilla Public License, v. 2.0).
+ * Authors: $(LINK2 mailto:belka@caraus.de, Eugene Wissner)
+ */
+module tanya.crypto.des;
+
+import tanya.crypto.bit;
+import tanya.crypto.symmetric;
+
+/// Initial permutation table.
+private immutable ubyte[64] ipTable = [58, 50, 42, 34, 26, 18, 10, 2,
+                                       60, 52, 44, 36, 28, 20, 12, 4,
+                                       62, 54, 46, 38, 30, 22, 14, 6,
+                                       64, 56, 48, 40, 32, 24, 16, 8,
+                                       57, 49, 41, 33, 25, 17, 9,  1,
+                                       59, 51, 43, 35, 27, 19, 11, 3,
+                                       61, 53, 45, 37, 29, 21, 13, 5,
+                                       63, 55, 47, 39, 31, 23, 15, 7];
+
+/// Final permutation table.
+private immutable ubyte[64] fpTable = [40, 8, 48, 16, 56, 24, 64, 32,
+                                       39, 7, 47, 15, 55, 23, 63, 31,
+                                       38, 6, 46, 14, 54, 22, 62, 30,
+                                       37, 5, 45, 13, 53, 21, 61, 29,
+                                       36, 4, 44, 12, 52, 20, 60, 28,
+                                       35, 3, 43, 11, 51, 19, 59, 27,
+                                       34, 2, 42, 10, 50, 18, 58, 26,
+                                       33, 1, 41, 9,  49, 17, 57, 25];
+
+/// Key permutation table 1.
+private immutable ubyte[64] pc1Table = [57, 49, 41, 33, 25, 17, 9, 1,
+                                        58, 50, 42, 34, 26, 18, 10, 2,
+                                        59, 51, 43, 35, 27, 19, 11, 3,
+                                        60, 52, 44, 36, 63, 55, 47, 39,
+                                        31, 23, 15, 7,  62, 54, 46, 38,
+                                        30, 22, 14, 6,  61, 53, 45, 37,
+                                        29, 21, 13, 5,  28, 20, 12, 4];
+
+/// Key permutation table 2.
+private immutable ubyte[48] pc2Table = [14, 17, 11, 24, 1,  5,  3,  28,
+                                        15, 6,  21, 10, 23, 19, 12, 4,
+                                        26, 8,  16, 7,  27, 20, 13, 2,
+                                        41, 52, 31, 37, 47, 55, 30, 40,
+                                        51, 45, 33, 48, 44, 49, 39, 56,
+                                        34, 53, 46, 42, 50, 36, 29, 32];
+
+/// Expansion table.
+private immutable ubyte[48] expansionTable = [32, 1,  2,  3,  4,  5,  4,  5,
+                                              6,  7,  8,  9,  8,  9,  10, 11,
+                                              12, 13, 12, 13, 14, 15, 16, 17,
+                                              16, 17, 18, 19, 20, 21, 20, 21,
+                                              22, 23, 24, 25, 24, 25, 26, 27,
+                                              28, 29, 28, 29, 30, 31, 32, 1];
+
+/// Final input block permutation.
+private immutable ubyte[32] pTable = [16, 7,  20, 21, 29, 12, 28, 17,
+                                      1,  15, 23, 26, 5,  18, 31, 10,
+                                      2,  8,  24, 14, 32, 27, 3,  9,
+                                      19, 13, 30, 6,  22, 11, 4, 25];
+
+/// The (in)famous S-boxes.
+private immutable ubyte[64][8] sBox = [[
+                                         14, 0,  4,  15, 13, 7,  1,  4,  2, 14,  15, 2, 11, 13, 8,  1,
+                                         3,  10, 10, 6,  6,  12, 12, 11, 5,  9,  9,  5, 0,  3,  7,  8,
+                                         4,  15, 1,  12, 14, 8,  8,  2,  13, 4,  6,  9, 2,  1,  11, 7,
+                                         15, 5,  12, 11, 9,  3,  7,  14, 3,  10, 10, 0, 5,  6,  0,  13,
+                                      ],[
+                                         15, 3,  1,  13, 8,  4,  14, 7,  6,  15, 11, 2,  3,  8,  4,  14,
+                                         9,  12, 7,  0,  2,  1,  13, 10, 12, 6,  0,  9,  5,  11, 10, 5,
+                                         0,  13, 14, 8,  7,  10, 11, 1,  10, 3,  4,  15, 13, 4,  1,  2,
+                                         5,  11, 8,  6,  12, 7,  6,  12, 9,  0,  3,  5,  2,  14, 15, 9,
+                                      ],[
+                                         10, 13, 0,  7,  9,  0,  14, 9,  6,  3,  3,  4,  15, 6,  5,  10,
+                                         1,  2,  13, 8,  12, 5,  7,  14, 11, 12, 4,  11, 2,  15, 8,  1,
+                                         13, 1,  6,  10, 4,  13, 9,  0,  8,  6,  15, 9,  3,  8,  0,  7,
+                                         11, 4,  1,  15, 2,  14, 12, 3,  5,  11, 10, 5,  14, 2,  7,  12,
+                                      ],[
+                                         7,  13, 13, 8,  14, 11, 3,  5,  0,  6,  6,  15, 9,  0,  10, 3,
+                                         1,  4,  2,  7,  8,  2,  5,  12, 11, 1,  12, 10, 4,  14, 15, 9,
+                                         10, 3,  6,  15, 9,  0,  0,  6,  12, 10, 11, 1,  7,  13, 13, 8,
+                                         15, 9,  1,  4,  3,  5,  14, 11, 5,  12, 2,  7,  8,  2,  4,  14,
+                                      ],[
+                                         2,  14, 12, 11, 4,  2,  1,  12, 7,  4,  10, 7,  11, 13, 6,  1,
+                                         8,  5,  5,  0,  3,  15, 15, 10, 13, 3,  0,  9,  14, 8,  9,  6,
+                                         4,  11, 2,  8,  1,  12, 11, 7,  10, 1,  13, 14, 7,  2,  8,  13,
+                                         15, 6,  9,  15, 12, 0,  5,  9,  6,  10, 3,  4,  0,  5,  14, 3,
+                                      ],[
+                                         12, 10, 1,  15, 10, 4,  15, 2,  9,  7,  2,  12, 6,  9,  8,  5,
+                                         0,  6,  13, 1,  3,  13, 4,  14, 14, 0,  7,  11, 5,  3,  11, 8,
+                                         9,  4,  14, 3,  15, 2,  5,  12, 2,  9,  8,  5,  12, 15, 3,  10,
+                                         7,  11, 0,  14, 4,  1,  10, 7,  1,  6,  13, 0,  11, 8,  6,  13,
+                                      ],[
+                                         4,  13, 11, 0,  2,  11, 14, 7,  15, 4,  0,  9,  8,  1,  13, 10,
+                                         3,  14, 12, 3,  9,  5,  7,  12, 5,  2,  10, 15, 6,  8,  1,  6,
+                                         1,  6,  4,  11, 11, 13, 13, 8,  12, 1,  3,  4,  7,  10, 14, 7,
+                                         10, 9,  15, 5,  6,  0,  8,  15, 0,  14, 5,  2,  9,  3,  2,  12,
+                                      ],[
+                                         13, 1,  2,  15, 8,  13, 4,  8,  6,  10, 15, 3,  11, 7,  1,  4,
+                                         10, 12, 9,  5,  3,  6,  14, 11, 5,  0,  0,  14, 12, 9,  7,  2,
+                                         7,  2,  11, 1,  4,  14, 1,  7,  9,  4,  12, 10, 14, 8,  2,  13,
+                                         0,  15, 6,  12, 10, 9,  13, 0,  15, 3,  3,  5,  5,  6,  8,  11,
+                                      ]];
+
+/**
+ * Data Encryption Standard.
+ *
+ * Params:
+ *     L = Number of keys.
+ */
+class DES(ushort L = 1) : BlockCipher
+    if (L == 1)
+{
+    mixin FixedBlockSize!8;
+    mixin KeyLength!8;
+
+    private enum expansionBlockSize = 6;
+    private enum pc1KeyLength = 7;
+    private enum subkeyLength = 6;
+    private ubyte[] key_;
+
+    /**
+     * Params:
+     *     key = Key.
+     */
+    @property void key(ubyte[] key) pure nothrow @safe @nogc
+    in
+    {
+        assert(key.length >= minKeyLength);
+        assert(key.length <= maxKeyLength);
+    }
+    body
+    {
+        key_ = key;
+    }
+
+    /**
+     * Encrypts a block.
+     *
+     * Params:
+     *    plain  = Plain text, input.
+     *    cipher = Cipher text, output.
+     */
+    void encrypt(in ubyte[] plain, ubyte[] cipher)
+    nothrow
+    in
+    {
+        assert(plain.length == blockSize);
+        assert(cipher.length == blockSize);
+    }
+    body
+    {
+        operateBlock!(Direction.encryption)(plain, cipher);
+    }
+
+    /**
+     * Decrypts a block.
+     *
+     * Params:
+     *    cipher = Cipher text, input.
+     *    plain  = Plain text, output.
+     */
+    void decrypt(in ubyte[] cipher, ubyte[] plain)
+    nothrow
+    in
+    {
+        assert(plain.length == blockSize);
+        assert(cipher.length == blockSize);
+    }
+    body
+    {
+        operateBlock!(Direction.decryption)(cipher, plain);
+    }
+
+    private void operateBlock(Direction D)(in ubyte[] source, ref ubyte[] target)
+    {
+        ubyte[blockSize_] ipBlock;
+        ubyte[expansionBlockSize] expansionBlock;
+        ubyte[4] substitutionBlock;
+        ubyte[4] pBoxTarget;
+        ubyte[pc1KeyLength] pc1Key;
+        ubyte[subkeyLength] subkey;
+
+        // Initial permutation
+        permute(source, ipBlock, ipTable, blockSize);
+
+        // Key schedule computation
+        permute(key_, pc1Key, pc1Table, pc1KeyLength);
+
+        // Feistel function
+        for (ubyte round; round < 16; ++round)
+        {
+            auto bitVector = BitVector(expansionBlock);
+            /* Expansion. This permutation only looks at the first 4 bytes (32
+               bits of ipBlock); 16 of these are repeated in expansion table.*/
+            permute(BitVector(ipBlock[4..$]), bitVector, expansionTable, 6);
+
+            // Key mixing
+            static if (D == Direction.encryption)
+            {
+                rotateLeft(pc1Key);
+                if (!(round <= 1 || round == 8 || round == 15))
+                {
+                    // Rotate twice.
+                    rotateLeft(pc1Key);
+                }
+            }
+            permute(pc1Key, subkey, pc2Table, subkeyLength);
+            static if (D == Direction.decryption)
+            {
+                rotateRight(pc1Key);
+                if (!(round >= 14 || round == 7 || round == 0))
+                {
+                    // Rotate twice.
+                    rotateRight(pc1Key);
+                }
+            }
+
+            bitVector ^= subkey;
+
+            // Substitution; copy from updated expansion block to ciphertext block
+            substitutionBlock[0] = cast(ubyte) (sBox[0][(expansionBlock[0] & 0xfc ) >> 2] << 4);
+            substitutionBlock[0] |= sBox[1][(expansionBlock[0] & 0x03) << 4 | (expansionBlock[1] & 0xf0) >> 4];
+            substitutionBlock[1] = cast(ubyte) (sBox[2][(expansionBlock[1] & 0x0f) << 2 | (expansionBlock[2] & 0xc0) >> 6] << 4);
+            substitutionBlock[1] |= sBox[3][(expansionBlock[2] & 0x3f)];
+            substitutionBlock[2] = cast(ubyte) (sBox[4][(expansionBlock[3] & 0xfc) >> 2 ] << 4);
+            substitutionBlock[2] |= sBox[5][(expansionBlock[3] & 0x03) << 4 | (expansionBlock[4] & 0xf0) >> 4];
+            substitutionBlock[3] = cast(ubyte) (sBox[6][(expansionBlock[4] & 0x0F) << 2 | (expansionBlock[5] & 0xc0) >> 6] << 4);
+            substitutionBlock[3] |= sBox[7][(expansionBlock[5] & 0x3f)];
+
+            // Permutation
+            bitVector = BitVector(substitutionBlock);
+            permute(bitVector, pBoxTarget, pTable, blockSize / 2);
+
+            // Swap the halves.
+            substitutionBlock = ipBlock[0..4];
+            ipBlock[0..4] = ipBlock[4..$];
+
+            bitVector ^= pBoxTarget;
+            ipBlock[4..$] = substitutionBlock;
+        }
+
+        substitutionBlock = ipBlock[0..4];
+        ipBlock[0..4] = ipBlock[4..$];
+        ipBlock[4..$] = substitutionBlock;
+
+        // Final permutaion (undo initial permuation).
+        permute(ipBlock, target, fpTable, blockSize);
+    }
+
+    /**
+     * Performs the left rotation operation on the key.
+     *
+     * Params:
+     *     key = The key to rotate.
+     */
+    private void rotateLeft(ref ubyte[7] key) const pure nothrow @safe @nogc
+    {
+        immutable carryLeft = (key[0] & 0x80) >> 3;
+
+        key[0] = cast(ubyte) ((key[0] << 1) | ((key[1] & 0x80) >> 7));
+        key[1] = cast(ubyte) ((key[1] << 1) | ((key[2] & 0x80) >> 7));
+        key[2] = cast(ubyte) ((key[2] << 1) | ((key[3] & 0x80) >> 7));
+
+        immutable carryRight = (key[3] & 0x08) >> 3;
+        key[3] = cast(ubyte) ((((key[3] << 1) | ((key[4] & 0x80) >> 7)) & ~0x10) | carryLeft);
+
+        key[4] = cast(ubyte) ((key[4] << 1) | ((key[5] & 0x80) >> 7));
+        key[5] = cast(ubyte) ((key[5] << 1) | ((key[6] & 0x80) >> 7));
+        key[6] = cast(ubyte) ((key[6] << 1) | carryRight);
+    }
+
+    /**
+     * Performs the right rotation operation on the key.
+     *
+     * Params:
+     *     key = The key to rotate.
+     */
+    private void rotateRight(ref ubyte[7] key) const pure nothrow @safe @nogc
+    {
+        immutable carryRight = (key[6] & 0x01) << 3;
+
+        key[6] = cast(ubyte) ((key[6] >> 1) | ((key[5] & 0x01) << 7));
+        key[5] = cast(ubyte) ((key[5] >> 1) | ((key[4] & 0x01) << 7));
+        key[4] = cast(ubyte) ((key[4] >> 1) | ((key[3] & 0x01) << 7));
+
+        immutable carryLeft = (key[3] & 0x10) << 3;
+        key[3] = cast(ubyte) ((((key[3] >> 1) | ((key[2] & 0x01) << 7)) & ~0x08) | carryRight);
+
+        key[2] = cast(ubyte) ((key[2] >> 1) | ((key[1] & 0x01) << 7));
+        key[1] = cast(ubyte) ((key[1] >> 1) | ((key[0] & 0x01) << 7));
+        key[0] = cast(ubyte) ((key[0] >> 1) | carryLeft);
+    }
+
+    private void permute(in ubyte[] source, ubyte[] target, immutable(ubyte[]) permuteTable, size_t length)
+    const pure nothrow @safe @nogc
+    {
+        const sourceVector = const BitVector(source);
+        auto targetVector = BitVector(target);
+
+        permute(sourceVector, targetVector, permuteTable, length);
+    }
+
+    private void permute(in BitVector source, ubyte[] target, immutable(ubyte[]) permuteTable, size_t length)
+    const pure nothrow @safe @nogc
+    {
+        auto targetVector = BitVector(target);
+
+        permute(source, targetVector, permuteTable, length);
+    }
+
+    private void permute(in BitVector source, ref BitVector target, immutable(ubyte[]) permuteTable, size_t length)
+    const pure nothrow @safe @nogc
+    {
+        for (uint i; i < length * 8; ++i)
+        {
+            target[i] = source[permuteTable[i] - 1];
+        }
+    }
+}
+
+version (unittest)
+{
+    import std.typecons;
+
+    /* Test vectors for DES. Source:
+       "Validating the Correctness of Hardware 
+       Implementations of the NBS Data Encryption Standard"
+       NBS Special Publication 500-20, 1980. Appendix B */
+
+    // Initial and reverse Permutation and Expansion tests. Encrypt.
+    ubyte[8][64] desTestVectors1 = [
+        [0x95, 0xf8, 0xa5, 0xe5, 0xdd, 0x31, 0xd9, 0x00],
+        [0xdd, 0x7f, 0x12, 0x1c, 0xa5, 0x01, 0x56, 0x19],
+        [0x2e, 0x86, 0x53, 0x10, 0x4f, 0x38, 0x34, 0xea],
+        [0x4b, 0xd3, 0x88, 0xff, 0x6c, 0xd8, 0x1d, 0x4f],
+        [0x20, 0xb9, 0xe7, 0x67, 0xb2, 0xfb, 0x14, 0x56],
+        [0x55, 0x57, 0x93, 0x80, 0xd7, 0x71, 0x38, 0xef],
+        [0x6c, 0xc5, 0xde, 0xfa, 0xaf, 0x04, 0x51, 0x2f],
+        [0x0d, 0x9f, 0x27, 0x9b, 0xa5, 0xd8, 0x72, 0x60],
+        [0xd9, 0x03, 0x1b, 0x02, 0x71, 0xbd, 0x5a, 0x0a],
+        [0x42, 0x42, 0x50, 0xb3, 0x7c, 0x3d, 0xd9, 0x51],
+        [0xb8, 0x06, 0x1b, 0x7e, 0xcd, 0x9a, 0x21, 0xe5],
+        [0xf1, 0x5d, 0x0f, 0x28, 0x6b, 0x65, 0xbd, 0x28],
+        [0xad, 0xd0, 0xcc, 0x8d, 0x6e, 0x5d, 0xeb, 0xa1],
+        [0xe6, 0xd5, 0xf8, 0x27, 0x52, 0xad, 0x63, 0xd1],
+        [0xec, 0xbf, 0xe3, 0xbd, 0x3f, 0x59, 0x1a, 0x5e],
+        [0xf3, 0x56, 0x83, 0x43, 0x79, 0xd1, 0x65, 0xcd],
+        [0x2b, 0x9f, 0x98, 0x2f, 0x20, 0x03, 0x7f, 0xa9],
+        [0x88, 0x9d, 0xe0, 0x68, 0xa1, 0x6f, 0x0b, 0xe6],
+        [0xe1, 0x9e, 0x27, 0x5d, 0x84, 0x6a, 0x12, 0x98],
+        [0x32, 0x9a, 0x8e, 0xd5, 0x23, 0xd7, 0x1a, 0xec],
+        [0xe7, 0xfc, 0xe2, 0x25, 0x57, 0xd2, 0x3c, 0x97],
+        [0x12, 0xa9, 0xf5, 0x81, 0x7f, 0xf2, 0xd6, 0x5d],
+        [0xa4, 0x84, 0xc3, 0xad, 0x38, 0xdc, 0x9c, 0x19],
+        [0xfb, 0xe0, 0x0a, 0x8a, 0x1e, 0xf8, 0xad, 0x72],
+        [0x75, 0x0d, 0x07, 0x94, 0x07, 0x52, 0x13, 0x63],
+        [0x64, 0xfe, 0xed, 0x9c, 0x72, 0x4c, 0x2f, 0xaf],
+        [0xf0, 0x2b, 0x26, 0x3b, 0x32, 0x8e, 0x2b, 0x60],
+        [0x9d, 0x64, 0x55, 0x5a, 0x9a, 0x10, 0xb8, 0x52],
+        [0xd1, 0x06, 0xff, 0x0b, 0xed, 0x52, 0x55, 0xd7],
+        [0xe1, 0x65, 0x2c, 0x6b, 0x13, 0x8c, 0x64, 0xa5],
+        [0xe4, 0x28, 0x58, 0x11, 0x86, 0xec, 0x8f, 0x46],
+        [0xae, 0xb5, 0xf5, 0xed, 0xe2, 0x2d, 0x1a, 0x36],
+        [0xe9, 0x43, 0xd7, 0x56, 0x8a, 0xec, 0x0c, 0x5c],
+        [0xdf, 0x98, 0xc8, 0x27, 0x6f, 0x54, 0xb0, 0x4b],
+        [0xb1, 0x60, 0xe4, 0x68, 0x0f, 0x6c, 0x69, 0x6f],
+        [0xfa, 0x07, 0x52, 0xb0, 0x7d, 0x9c, 0x4a, 0xb8],
+        [0xca, 0x3a, 0x2b, 0x03, 0x6d, 0xbc, 0x85, 0x02],
+        [0x5e, 0x09, 0x05, 0x51, 0x7b, 0xb5, 0x9b, 0xcf],
+        [0x81, 0x4e, 0xeb, 0x3b, 0x91, 0xd9, 0x07, 0x26],
+        [0x4d, 0x49, 0xdb, 0x15, 0x32, 0x91, 0x9c, 0x9f],
+        [0x25, 0xeb, 0x5f, 0xc3, 0xf8, 0xcf, 0x06, 0x21],
+        [0xab, 0x6a, 0x20, 0xc0, 0x62, 0x0d, 0x1c, 0x6f],
+        [0x79, 0xe9, 0x0d, 0xbc, 0x98, 0xf9, 0x2c, 0xca],
+        [0x86, 0x6e, 0xce, 0xdd, 0x80, 0x72, 0xbb, 0x0e],
+        [0x8b, 0x54, 0x53, 0x6f, 0x2f, 0x3e, 0x64, 0xa8],
+        [0xea, 0x51, 0xd3, 0x97, 0x55, 0x95, 0xb8, 0x6b],
+        [0xca, 0xff, 0xc6, 0xac, 0x45, 0x42, 0xde, 0x31],
+        [0x8d, 0xd4, 0x5a, 0x2d, 0xdf, 0x90, 0x79, 0x6c],
+        [0x10, 0x29, 0xd5, 0x5e, 0x88, 0x0e, 0xc2, 0xd0],
+        [0x5d, 0x86, 0xcb, 0x23, 0x63, 0x9d, 0xbe, 0xa9],
+        [0x1d, 0x1c, 0xa8, 0x53, 0xae, 0x7c, 0x0c, 0x5f],
+        [0xce, 0x33, 0x23, 0x29, 0x24, 0x8f, 0x32, 0x28],
+        [0x84, 0x05, 0xd1, 0xab, 0xe2, 0x4f, 0xb9, 0x42],
+        [0xe6, 0x43, 0xd7, 0x80, 0x90, 0xca, 0x42, 0x07],
+        [0x48, 0x22, 0x1b, 0x99, 0x37, 0x74, 0x8a, 0x23],
+        [0xdd, 0x7c, 0x0b, 0xbd, 0x61, 0xfa, 0xfd, 0x54],
+        [0x2f, 0xbc, 0x29, 0x1a, 0x57, 0x0d, 0xb5, 0xc4],
+        [0xe0, 0x7c, 0x30, 0xd7, 0xe4, 0xe2, 0x6e, 0x12],
+        [0x09, 0x53, 0xe2, 0x25, 0x8e, 0x8e, 0x90, 0xa1],
+        [0x5b, 0x71, 0x1b, 0xc4, 0xce, 0xeb, 0xf2, 0xee],
+        [0xcc, 0x08, 0x3f, 0x1e, 0x6d, 0x9e, 0x85, 0xf6],
+        [0xd2, 0xfd, 0x88, 0x67, 0xd5, 0x0d, 0x2d, 0xfe],
+        [0x06, 0xe7, 0xea, 0x22, 0xce, 0x92, 0x70, 0x8f],
+        [0x16, 0x6b, 0x40, 0xb4, 0x4a, 0xba, 0x4b, 0xd6],
+    ];
+
+    // Key Permutation test. Encrypt.
+    // Test of right-shifts. Decrypt.
+    ubyte[8][56] desTestVectors2 = [
+        [0x95, 0xa8, 0xd7, 0x28, 0x13, 0xda, 0xa9, 0x4d],
+        [0x0e, 0xec, 0x14, 0x87, 0xdd, 0x8c, 0x26, 0xd5],
+        [0x7a, 0xd1, 0x6f, 0xfb, 0x79, 0xc4, 0x59, 0x26],
+        [0xd3, 0x74, 0x62, 0x94, 0xca, 0x6a, 0x6c, 0xf3],
+        [0x80, 0x9f, 0x5f, 0x87, 0x3c, 0x1f, 0xd7, 0x61],
+        [0xc0, 0x2f, 0xaf, 0xfe, 0xc9, 0x89, 0xd1, 0xfc],
+        [0x46, 0x15, 0xaa, 0x1d, 0x33, 0xe7, 0x2f, 0x10],
+        [0x20, 0x55, 0x12, 0x33, 0x50, 0xc0, 0x08, 0x58],
+        [0xdf, 0x3b, 0x99, 0xd6, 0x57, 0x73, 0x97, 0xc8],
+        [0x31, 0xfe, 0x17, 0x36, 0x9b, 0x52, 0x88, 0xc9],
+        [0xdf, 0xdd, 0x3c, 0xc6, 0x4d, 0xae, 0x16, 0x42],
+        [0x17, 0x8c, 0x83, 0xce, 0x2b, 0x39, 0x9d, 0x94],
+        [0x50, 0xf6, 0x36, 0x32, 0x4a, 0x9b, 0x7f, 0x80],
+        [0xa8, 0x46, 0x8e, 0xe3, 0xbc, 0x18, 0xf0, 0x6d],
+        [0xa2, 0xdc, 0x9e, 0x92, 0xfd, 0x3c, 0xde, 0x92],
+        [0xca, 0xc0, 0x9f, 0x79, 0x7d, 0x03, 0x12, 0x87],
+        [0x90, 0xba, 0x68, 0x0b, 0x22, 0xae, 0xb5, 0x25],
+        [0xce, 0x7a, 0x24, 0xf3, 0x50, 0xe2, 0x80, 0xb6],
+        [0x88, 0x2b, 0xff, 0x0a, 0xa0, 0x1a, 0x0b, 0x87],
+        [0x25, 0x61, 0x02, 0x88, 0x92, 0x45, 0x11, 0xc2],
+        [0xc7, 0x15, 0x16, 0xc2, 0x9c, 0x75, 0xd1, 0x70],
+        [0x51, 0x99, 0xc2, 0x9a, 0x52, 0xc9, 0xf0, 0x59],
+        [0xc2, 0x2f, 0x0a, 0x29, 0x4a, 0x71, 0xf2, 0x9f],
+        [0xee, 0x37, 0x14, 0x83, 0x71, 0x4c, 0x02, 0xea],
+        [0xa8, 0x1f, 0xbd, 0x44, 0x8f, 0x9e, 0x52, 0x2f],
+        [0x4f, 0x64, 0x4c, 0x92, 0xe1, 0x92, 0xdf, 0xed],
+        [0x1a, 0xfa, 0x9a, 0x66, 0xa6, 0xdf, 0x92, 0xae],
+        [0xb3, 0xc1, 0xcc, 0x71, 0x5c, 0xb8, 0x79, 0xd8],
+        [0x19, 0xd0, 0x32, 0xe6, 0x4a, 0xb0, 0xbd, 0x8b],
+        [0x3c, 0xfa, 0xa7, 0xa7, 0xdc, 0x87, 0x20, 0xdc],
+        [0xb7, 0x26, 0x5f, 0x7f, 0x44, 0x7a, 0xc6, 0xf3],
+        [0x9d, 0xb7, 0x3b, 0x3c, 0x0d, 0x16, 0x3f, 0x54],
+        [0x81, 0x81, 0xb6, 0x5b, 0xab, 0xf4, 0xa9, 0x75],
+        [0x93, 0xc9, 0xb6, 0x40, 0x42, 0xea, 0xa2, 0x40],
+        [0x55, 0x70, 0x53, 0x08, 0x29, 0x70, 0x55, 0x92],
+        [0x86, 0x38, 0x80, 0x9e, 0x87, 0x87, 0x87, 0xa0],
+        [0x41, 0xb9, 0xa7, 0x9a, 0xf7, 0x9a, 0xc2, 0x08],
+        [0x7a, 0x9b, 0xe4, 0x2f, 0x20, 0x09, 0xa8, 0x92],
+        [0x29, 0x03, 0x8d, 0x56, 0xba, 0x6d, 0x27, 0x45],
+        [0x54, 0x95, 0xc6, 0xab, 0xf1, 0xe5, 0xdf, 0x51],
+        [0xae, 0x13, 0xdb, 0xd5, 0x61, 0x48, 0x89, 0x33],
+        [0x02, 0x4d, 0x1f, 0xfa, 0x89, 0x04, 0xe3, 0x89],
+        [0xd1, 0x39, 0x97, 0x12, 0xf9, 0x9b, 0xf0, 0x2e],
+        [0x14, 0xc1, 0xd7, 0xc1, 0xcf, 0xfe, 0xc7, 0x9e],
+        [0x1d, 0xe5, 0x27, 0x9d, 0xae, 0x3b, 0xed, 0x6f],
+        [0xe9, 0x41, 0xa3, 0x3f, 0x85, 0x50, 0x13, 0x03],
+        [0xda, 0x99, 0xdb, 0xbc, 0x9a, 0x03, 0xf3, 0x79],
+        [0xb7, 0xfc, 0x92, 0xf9, 0x1d, 0x8e, 0x92, 0xe9],
+        [0xae, 0x8e, 0x5c, 0xaa, 0x3c, 0xa0, 0x4e, 0x85],
+        [0x9c, 0xc6, 0x2d, 0xf4, 0x3b, 0x6e, 0xed, 0x74],
+        [0xd8, 0x63, 0xdb, 0xb5, 0xc5, 0x9a, 0x91, 0xa0],
+        [0xa1, 0xab, 0x21, 0x90, 0x54, 0x5b, 0x91, 0xd7],
+        [0x08, 0x75, 0x04, 0x1e, 0x64, 0xc5, 0x70, 0xf7],
+        [0x5a, 0x59, 0x45, 0x28, 0xbe, 0xbe, 0xf1, 0xcc],
+        [0xfc, 0xdb, 0x32, 0x91, 0xde, 0x21, 0xf0, 0xc0],
+        [0x86, 0x9e, 0xfd, 0x7f, 0x9f, 0x26, 0x5a, 0x09],
+    ];
+
+    // Data permutation test. Encrypt.
+    ubyte[8][2][32] desTestVectors3 = [
+        [[0x10, 0x46, 0x91, 0x34, 0x89, 0x98, 0x01, 0x31], [0x88, 0xd5, 0x5e, 0x54, 0xf5, 0x4c, 0x97, 0xb4]],
+        [[0x10, 0x07, 0x10, 0x34, 0x89, 0x98, 0x80, 0x20], [0x0c, 0x0c, 0xc0, 0x0c, 0x83, 0xea, 0x48, 0xfd]],
+        [[0x10, 0x07, 0x10, 0x34, 0xc8, 0x98, 0x01, 0x20], [0x83, 0xbc, 0x8e, 0xf3, 0xa6, 0x57, 0x01, 0x83]],
+        [[0x10, 0x46, 0x10, 0x34, 0x89, 0x98, 0x80, 0x20], [0xdf, 0x72, 0x5d, 0xca, 0xd9, 0x4e, 0xa2, 0xe9]],
+        [[0x10, 0x86, 0x91, 0x15, 0x19, 0x19, 0x01, 0x01], [0xe6, 0x52, 0xb5, 0x3b, 0x55, 0x0b, 0xe8, 0xb0]],
+        [[0x10, 0x86, 0x91, 0x15, 0x19, 0x58, 0x01, 0x01], [0xaf, 0x52, 0x71, 0x20, 0xc4, 0x85, 0xcb, 0xb0]],
+        [[0x51, 0x07, 0xb0, 0x15, 0x19, 0x58, 0x01, 0x01], [0x0f, 0x04, 0xce, 0x39, 0x3d, 0xb9, 0x26, 0xd5]],
+        [[0x10, 0x07, 0xb0, 0x15, 0x19, 0x19, 0x01, 0x01], [0xc9, 0xf0, 0x0f, 0xfc, 0x74, 0x07, 0x90, 0x67]],
+        [[0x31, 0x07, 0x91, 0x54, 0x98, 0x08, 0x01, 0x01], [0x7c, 0xfd, 0x82, 0xa5, 0x93, 0x25, 0x2b, 0x4e]],
+        [[0x31, 0x07, 0x91, 0x94, 0x98, 0x08, 0x01, 0x01], [0xcb, 0x49, 0xa2, 0xf9, 0xe9, 0x13, 0x63, 0xe3]],
+        [[0x10, 0x07, 0x91, 0x15, 0xb9, 0x08, 0x01, 0x40], [0x00, 0xb5, 0x88, 0xbe, 0x70, 0xd2, 0x3f, 0x56]],
+        [[0x31, 0x07, 0x91, 0x15, 0x98, 0x08, 0x01, 0x40], [0x40, 0x6a, 0x9a, 0x6a, 0xb4, 0x33, 0x99, 0xae]],
+        [[0x10, 0x07, 0xd0, 0x15, 0x89, 0x98, 0x01, 0x01], [0x6c, 0xb7, 0x73, 0x61, 0x1d, 0xca, 0x9a, 0xda]],
+        [[0x91, 0x07, 0x91, 0x15, 0x89, 0x98, 0x01, 0x01], [0x67, 0xfd, 0x21, 0xc1, 0x7d, 0xbb, 0x5d, 0x70]],
+        [[0x91, 0x07, 0xd0, 0x15, 0x89, 0x19, 0x01, 0x01], [0x95, 0x92, 0xcb, 0x41, 0x10, 0x43, 0x07, 0x87]],
+        [[0x10, 0x07, 0xd0, 0x15, 0x98, 0x98, 0x01, 0x20], [0xa6, 0xb7, 0xff, 0x68, 0xa3, 0x18, 0xdd, 0xd3]],
+        [[0x10, 0x07, 0x94, 0x04, 0x98, 0x19, 0x01, 0x01], [0x4d, 0x10, 0x21, 0x96, 0xc9, 0x14, 0xca, 0x16]],
+        [[0x01, 0x07, 0x91, 0x04, 0x91, 0x19, 0x04, 0x01], [0x2d, 0xfa, 0x9f, 0x45, 0x73, 0x59, 0x49, 0x65]],
+        [[0x01, 0x07, 0x91, 0x04, 0x91, 0x19, 0x01, 0x01], [0xb4, 0x66, 0x04, 0x81, 0x6c, 0x0e, 0x07, 0x74]],
+        [[0x01, 0x07, 0x94, 0x04, 0x91, 0x19, 0x04, 0x01], [0x6e, 0x7e, 0x62, 0x21, 0xa4, 0xf3, 0x4e, 0x87]],
+        [[0x19, 0x07, 0x92, 0x10, 0x98, 0x1a, 0x01, 0x01], [0xaa, 0x85, 0xe7, 0x46, 0x43, 0x23, 0x31, 0x99]],
+        [[0x10, 0x07, 0x91, 0x19, 0x98, 0x19, 0x08, 0x01], [0x2e, 0x5a, 0x19, 0xdb, 0x4d, 0x19, 0x62, 0xd6]],
+        [[0x10, 0x07, 0x91, 0x19, 0x98, 0x1a, 0x08, 0x01], [0x23, 0xa8, 0x66, 0xa8, 0x09, 0xd3, 0x08, 0x94]],
+        [[0x10, 0x07, 0x92, 0x10, 0x98, 0x19, 0x01, 0x01], [0xd8, 0x12, 0xd9, 0x61, 0xf0, 0x17, 0xd3, 0x20]],
+        [[0x10, 0x07, 0x91, 0x15, 0x98, 0x19, 0x01, 0x0b], [0x05, 0x56, 0x05, 0x81, 0x6e, 0x58, 0x60, 0x8f]],
+        [[0x10, 0x04, 0x80, 0x15, 0x98, 0x19, 0x01, 0x01], [0xab, 0xd8, 0x8e, 0x8b, 0x1b, 0x77, 0x16, 0xf1]],
+        [[0x10, 0x04, 0x80, 0x15, 0x98, 0x19, 0x01, 0x02], [0x53, 0x7a, 0xc9, 0x5b, 0xe6, 0x9d, 0xa1, 0xe1]],
+        [[0x10, 0x04, 0x80, 0x15, 0x98, 0x19, 0x01, 0x08], [0xae, 0xd0, 0xf6, 0xae, 0x3c, 0x25, 0xcd, 0xd8]],
+        [[0x10, 0x02, 0x91, 0x14, 0x98, 0x10, 0x01, 0x04], [0xb3, 0xe3, 0x5a, 0x5e, 0xe5, 0x3e, 0x7b, 0x8d]],
+        [[0x10, 0x02, 0x91, 0x15, 0x98, 0x19, 0x01, 0x04], [0x61, 0xc7, 0x9c, 0x71, 0x92, 0x1a, 0x2e, 0xf8]],
+        [[0x10, 0x02, 0x91, 0x15, 0x98, 0x10, 0x02, 0x01], [0xe2, 0xf5, 0x72, 0x8f, 0x09, 0x95, 0x01, 0x3c]],
+        [[0x10, 0x02, 0x91, 0x16, 0x98, 0x10, 0x01, 0x01], [0x1a, 0xea, 0xc3, 0x9a, 0x61, 0xf0, 0xa4, 0x64]],
+    ];
+
+    // S-Box test. Encrypt.
+    ubyte[8][3][19] desTestVectors4 = [
+        [[0x7c, 0xa1, 0x10, 0x45, 0x4a, 0x1a, 0x6e, 0x57], [0x01, 0xa1, 0xd6, 0xd0, 0x39, 0x77, 0x67, 0x42],
+        [0x69, 0x0f, 0x5b, 0x0d, 0x9a, 0x26, 0x93, 0x9b]],
+        [[0x01, 0x31, 0xd9, 0x61, 0x9d, 0xc1, 0x37, 0x6e], [0x5c, 0xd5, 0x4c, 0xa8, 0x3d, 0xef, 0x57, 0xda],
+        [0x7a, 0x38, 0x9d, 0x10, 0x35, 0x4b, 0xd2, 0x71]],
+        [[0x07, 0xa1, 0x13, 0x3e, 0x4a, 0x0b, 0x26, 0x86], [0x02, 0x48, 0xd4, 0x38, 0x06, 0xf6, 0x71, 0x72],
+        [0x86, 0x8e, 0xbb, 0x51, 0xca, 0xb4, 0x59, 0x9a]],
+        [[0x38, 0x49, 0x67, 0x4c, 0x26, 0x02, 0x31, 0x9e], [0x51, 0x45, 0x4b, 0x58, 0x2d, 0xdf, 0x44, 0x0a],
+        [0x71, 0x78, 0x87, 0x6e, 0x01, 0xf1, 0x9b, 0x2a]],
+        [[0x04, 0xb9, 0x15, 0xba, 0x43, 0xfe, 0xb5, 0xb6], [0x42, 0xfd, 0x44, 0x30, 0x59, 0x57, 0x7f, 0xa2],
+        [0xaf, 0x37, 0xfb, 0x42, 0x1f, 0x8c, 0x40, 0x95]],
+        [[0x01, 0x13, 0xb9, 0x70, 0xfd, 0x34, 0xf2, 0xce], [0x05, 0x9b, 0x5e, 0x08, 0x51, 0xcf, 0x14, 0x3a],
+        [0x86, 0xa5, 0x60, 0xf1, 0x0e, 0xc6, 0xd8, 0x5b]],
+        [[0x01, 0x70, 0xf1, 0x75, 0x46, 0x8f, 0xb5, 0xe6], [0x07, 0x56, 0xd8, 0xe0, 0x77, 0x47, 0x61, 0xd2],
+        [0x0c, 0xd3, 0xda, 0x02, 0x00, 0x21, 0xdc, 0x09]],
+        [[0x43, 0x29, 0x7f, 0xad, 0x38, 0xe3, 0x73, 0xfe], [0x76, 0x25, 0x14, 0xb8, 0x29, 0xbf, 0x48, 0x6a],
+        [0xea, 0x67, 0x6b, 0x2c, 0xb7, 0xdb, 0x2b, 0x7a]],
+        [[0x07, 0xa7, 0x13, 0x70, 0x45, 0xda, 0x2a, 0x16], [0x3b, 0xdd, 0x11, 0x90, 0x49, 0x37, 0x28, 0x02],
+        [0xdf, 0xd6, 0x4a, 0x81, 0x5c, 0xaf, 0x1a, 0x0f]],
+        [[0x04, 0x68, 0x91, 0x04, 0xc2, 0xfd, 0x3b, 0x2f], [0x26, 0x95, 0x5f, 0x68, 0x35, 0xaf, 0x60, 0x9a],
+        [0x5c, 0x51, 0x3c, 0x9c, 0x48, 0x86, 0xc0, 0x88]],
+        [[0x37, 0xd0, 0x6b, 0xb5, 0x16, 0xcb, 0x75, 0x46], [0x16, 0x4d, 0x5e, 0x40, 0x4f, 0x27, 0x52, 0x32],
+        [0x0a, 0x2a, 0xee, 0xae, 0x3f, 0xf4, 0xab, 0x77]],
+        [[0x1f, 0x08, 0x26, 0x0d, 0x1a, 0xc2, 0x46, 0x5e], [0x6b, 0x05, 0x6e, 0x18, 0x75, 0x9f, 0x5c, 0xca],
+        [0xef, 0x1b, 0xf0, 0x3e, 0x5d, 0xfa, 0x57, 0x5a]],
+        [[0x58, 0x40, 0x23, 0x64, 0x1a, 0xba, 0x61, 0x76], [0x00, 0x4b, 0xd6, 0xef, 0x09, 0x17, 0x60, 0x62],
+        [0x88, 0xbf, 0x0d, 0xb6, 0xd7, 0x0d, 0xee, 0x56]],
+        [[0x02, 0x58, 0x16, 0x16, 0x46, 0x29, 0xb0, 0x07], [0x48, 0x0d, 0x39, 0x00, 0x6e, 0xe7, 0x62, 0xf2],
+        [0xa1, 0xf9, 0x91, 0x55, 0x41, 0x02, 0x0b, 0x56]],
+        [[0x49, 0x79, 0x3e, 0xbc, 0x79, 0xb3, 0x25, 0x8f], [0x43, 0x75, 0x40, 0xc8, 0x69, 0x8f, 0x3c, 0xfa],
+        [0x6f, 0xbf, 0x1c, 0xaf, 0xcf, 0xfd, 0x05, 0x56]],
+        [[0x4f, 0xb0, 0x5e, 0x15, 0x15, 0xab, 0x73, 0xa7], [0x07, 0x2d, 0x43, 0xa0, 0x77, 0x07, 0x52, 0x92],
+        [0x2f, 0x22, 0xe4, 0x9b, 0xab, 0x7c, 0xa1, 0xac]],
+        [[0x49, 0xe9, 0x5d, 0x6d, 0x4c, 0xa2, 0x29, 0xbf], [0x02, 0xfe, 0x55, 0x77, 0x81, 0x17, 0xf1, 0x2a],
+        [0x5a, 0x6b, 0x61, 0x2c, 0xc2, 0x6c, 0xce, 0x4a]],
+        [[0x01, 0x83, 0x10, 0xdc, 0x40, 0x9b, 0x26, 0xd6], [0x1d, 0x9d, 0x5c, 0x50, 0x18, 0xf7, 0x28, 0xc2],
+        [0x5f, 0x4c, 0x03, 0x8e, 0xd1, 0x2b, 0x2e, 0x41]],
+        [[0x1c, 0x58, 0x7f, 0x1c, 0x13, 0x92, 0x4f, 0xef], [0x30, 0x55, 0x32, 0x28, 0x6d, 0x6f, 0x29, 0x5a],
+        [0x63, 0xfa, 0xc0, 0xd0, 0x34, 0xd9, 0xf7, 0x93]],
+    ];
+}
+
+///
+unittest
+{
+    auto des = scoped!(DES!1);
+    ubyte[8] key = [0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01];
+    ubyte[8] plain = [0x80, 0, 0, 0, 0, 0, 0, 0];
+    ubyte[8] cipher;
+
+    des.key = key;
+    foreach (ubyte i; 0..64)
+    {
+        if (i != 0)
+        {
+            plain[i / 8] = i % 8 ? plain[i / 8] >> 1 : 0x80;
+            if (i % 8 == 0)
+            {
+                plain[i / 8 - 1] = 0;
+            }
+        }
+        // Initial Permutation and Expansion test.
+        des.encrypt(plain, cipher);
+        assert(cipher == desTestVectors1[i]);
+
+        // Inverse Permutation and Expansion test.
+        des.encrypt(cipher, cipher);
+        assert(cipher == plain);
+    }
+
+    plain[0..$] = 0;
+    foreach (ubyte i; 0..56)
+    {
+        key[i / 7] = i % 7 ? key[i / 7] >> 1 : 0x80;
+        if (i % 7 == 0 && i != 0)
+        {
+            key[i / 7 - 1] = 0x01;
+        }
+        des.key = key;
+
+        // Initial Permutation and Expansion test.
+        des.encrypt(plain, cipher);
+        assert(cipher == desTestVectors2[i]);
+
+        // Test of right-shifts in Decryption.
+        des.decrypt(desTestVectors2[i], cipher);
+        assert(cipher == plain);
+    }
+
+    // Data permutation test.
+    plain[0..$] = 0;
+    foreach (i; desTestVectors3)
+    {
+        des.key = i[0];
+        des.encrypt(plain, cipher);
+        assert(cipher == i[1]);
+    }
+
+    // S-Box test.
+    foreach (i; desTestVectors4)
+    {
+        des.key = i[0];
+        des.encrypt(i[1], cipher);
+        assert(cipher == i[2]);
+    }
+}

source/tanya/crypto/mode.d

@@ -0,0 +1,279 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Block cipher modes of operation.
+ *
+ * Copyright: Eugene Wissner 2016.
+ * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
+ *                  Mozilla Public License, v. 2.0).
+ * Authors: $(LINK2 mailto:belka@caraus.de, Eugene Wissner)
+ */
+module tanya.crypto.mode;
+
+import tanya.memory;
+import std.algorithm.iteration;
+import std.typecons;
+
+/**
+ * Supported padding mode.
+ *
+ * See_Also:
+ * 	$(D_PSYMBOL pad)
+ */
+enum PaddingMode
+{
+	zero,
+	pkcs7,
+	ansiX923,
+}
+
+/**
+ * Params:
+ * 	input     = Sequence that should be padded.
+ * 	mode      = Padding mode.
+ * 	blockSize = Block size.
+ * 	allocator = Allocator was used to allocate $(D_PARAM input).
+ *
+ * Returns: The function modifies the initial array and returns it.
+ *
+ * See_Also:
+ * 	$(D_PSYMBOL PaddingMode)
+ */
+ubyte[] pad(ref ubyte[] input,
+            in PaddingMode mode,
+            in ushort blockSize,
+            shared Allocator allocator = defaultAllocator)
+in
+{
+	assert(blockSize > 0 && blockSize <= 256);
+	assert(blockSize % 64 == 0);
+	assert(input.length > 0);
+}
+body
+{
+	immutable rest = cast(ubyte) input.length % blockSize;
+	immutable size_t lastBlock = input.length - (rest > 0 ? rest : blockSize);
+	immutable needed = cast(ubyte) (rest > 0 ? blockSize - rest : 0);
+
+	final switch (mode) with (PaddingMode)
+	{
+		case zero:
+			allocator.resizeArray(input, input.length + needed);
+			break;
+		case pkcs7:
+			if (needed)
+			{
+				allocator.resizeArray(input, input.length + needed);
+				input[input.length - needed ..$].each!((ref e) => e = needed);
+			}
+			else
+			{
+				allocator.resizeArray(input, input.length + blockSize);
+			}
+			break;
+		case ansiX923:
+			allocator.resizeArray(input, input.length + (needed ? needed : blockSize));
+			input[$ - 1] = needed;
+			break;
+	}
+
+	return input;
+}
+
+///
+unittest
+{
+	{ // Zeros
+		auto input = defaultAllocator.makeArray!ubyte(50);
+
+		pad(input, PaddingMode.zero, 64);
+		assert(input.length == 64);
+
+		pad(input, PaddingMode.zero, 64);
+		assert(input.length == 64);
+		assert(input[63] == 0);
+
+		defaultAllocator.dispose(input);
+	}
+	{ // PKCS#7
+		auto input = defaultAllocator.makeArray!ubyte(50);
+		for (ubyte i; i < 40; ++i)
+		{
+			input[i] = i;
+		}
+
+		pad(input, PaddingMode.pkcs7, 64);
+		assert(input.length == 64);
+		for (ubyte i; i < 64; ++i)
+		{
+			if (i >= 40 && i < 50)
+			{
+				assert(input[i] == 0);
+			}
+			else if (i >= 50)
+			{
+				assert(input[i] == 14);
+			}
+			else
+			{
+				assert(input[i] == i);
+			}
+		}
+
+		pad(input, PaddingMode.pkcs7, 64);
+		assert(input.length == 128);
+		for (ubyte i; i < 128; ++i)
+		{
+			if (i >= 64 || (i >= 40 && i < 50))
+			{
+				assert(input[i] == 0);
+			}
+			else if (i >= 50 && i < 64)
+			{
+				assert(input[i] == 14);
+			}
+			else
+			{
+				assert(input[i] == i);
+			}
+		}
+
+		defaultAllocator.dispose(input);
+	}
+	{ // ANSI X.923
+		auto input = defaultAllocator.makeArray!ubyte(50);
+		for (ubyte i; i < 40; ++i)
+		{
+			input[i] = i;
+		}
+
+		pad(input, PaddingMode.ansiX923, 64);
+		assert(input.length == 64);
+		for (ubyte i; i < 64; ++i)
+		{
+			if (i < 40)
+			{
+				assert(input[i] == i);
+			}
+			else if (i == 63)
+			{
+				assert(input[i] == 14);
+			}
+			else
+			{
+				assert(input[i] == 0);
+			}
+		}
+
+		pad(input, PaddingMode.pkcs7, 64);
+		assert(input.length == 128);
+		for (ubyte i = 0; i < 128; ++i)
+		{
+			if (i < 40)
+			{
+				assert(input[i] == i);
+			}
+			else if (i == 63)
+			{
+				assert(input[i] == 14);
+			}
+			else
+			{
+				assert(input[i] == 0);
+			}
+		}
+
+		defaultAllocator.dispose(input);
+	}
+}
+
+/**
+ * Params:
+ * 	input     = Sequence that should be padded.
+ * 	mode      = Padding mode.
+ * 	blockSize = Block size.
+ * 	allocator = Allocator was used to allocate $(D_PARAM input).
+ *
+ * Returns: The function modifies the initial array and returns it.
+ *
+ * See_Also:
+ * 	$(D_PSYMBOL pad)
+ */
+ref ubyte[] unpad(ref ubyte[] input,
+                  in PaddingMode mode,
+                  in ushort blockSize,
+                  shared Allocator allocator = defaultAllocator)
+in
+{
+	assert(input.length != 0);
+	assert(input.length % 64 == 0);
+}
+body
+{
+	final switch (mode) with (PaddingMode)
+	{
+		case zero:
+			break;
+		case pkcs7:
+		case ansiX923:
+			immutable last = input[$ - 1];
+
+			allocator.resizeArray(input, input.length - (last ? last : blockSize));
+			break;
+	}
+
+	return input;
+}
+
+///
+unittest
+{
+	{ // Zeros
+		auto input = defaultAllocator.makeArray!ubyte(50);
+		auto inputDup = defaultAllocator.makeArray!ubyte(50);
+
+		pad(input, PaddingMode.zero, 64);
+		pad(inputDup, PaddingMode.zero, 64);
+
+		unpad(input, PaddingMode.zero, 64);
+		assert(input == inputDup);
+
+		defaultAllocator.dispose(input);
+		defaultAllocator.dispose(inputDup);
+
+	}
+	{ // PKCS#7
+		auto input = defaultAllocator.makeArray!ubyte(50);
+		auto inputDup = defaultAllocator.makeArray!ubyte(50);
+		for (ubyte i; i < 40; ++i)
+		{
+			input[i] = i;
+			inputDup[i] = i;
+		}
+
+		pad(input, PaddingMode.pkcs7, 64);
+		unpad(input, PaddingMode.pkcs7, 64);
+		assert(input == inputDup);
+
+		defaultAllocator.dispose(input);
+		defaultAllocator.dispose(inputDup);
+	}
+	{ // ANSI X.923
+		auto input = defaultAllocator.makeArray!ubyte(50);
+		auto inputDup = defaultAllocator.makeArray!ubyte(50);
+		for (ubyte i; i < 40; ++i)
+		{
+			input[i] = i;
+			inputDup[i] = i;
+		}
+
+		pad(input, PaddingMode.pkcs7, 64);
+		unpad(input, PaddingMode.pkcs7, 64);
+		assert(input == inputDup);
+
+		defaultAllocator.dispose(input);
+		defaultAllocator.dispose(inputDup);
+	}
+}

source/tanya/crypto/package.d

@@ -0,0 +1,16 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Copyright: Eugene Wissner 2016.
+ * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
+ *                  Mozilla Public License, v. 2.0).
+ * Authors: $(LINK2 mailto:belka@caraus.de, Eugene Wissner)
+ */
+module tanya.crypto;
+
+public import tanya.crypto.bit;
+public import tanya.crypto.des;
+public import tanya.crypto.mode;
+public import tanya.crypto.symmetric;

source/tanya/crypto/symmetric.d

@@ -0,0 +1,177 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Interfaces for implementing secret key algorithms.
+ *
+ * Copyright: Eugene Wissner 2016.
+ * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
+ *                  Mozilla Public License, v. 2.0).
+ * Authors: $(LINK2 mailto:belka@caraus.de, Eugene Wissner)
+ */
+module tanya.crypto.symmetric;
+
+/**
+ * Implemented by secret key algorithms.
+ */
+interface SymmetricCipher
+{
+    /**
+     * Returns: Key length.
+     */
+    @property inout(uint) keyLength() inout const pure nothrow @safe @nogc;
+
+    /**
+     * Returns: Minimum key length.
+     */
+    @property inout(uint) minKeyLength() inout const pure nothrow @safe @nogc;
+
+    /**
+     * Returns: Maximum key length.
+     */
+    @property inout(uint) maxKeyLength() inout const pure nothrow @safe @nogc;
+
+    /// Cipher direction.
+    protected enum Direction : ushort
+    {
+        encryption,
+        decryption,
+    }
+
+    /**
+     * Params:
+     *     key = Key.
+     */
+    @property void key(ubyte[] key) pure nothrow @safe @nogc
+    in
+    {
+        assert(key.length >= minKeyLength);
+        assert(key.length <= maxKeyLength);
+    }
+}
+
+/**
+ * Implemented by block ciphers.
+ */
+interface BlockCipher : SymmetricCipher
+{
+    /**
+     * Returns: Block size.
+     */
+    @property inout(uint) blockSize() inout const pure nothrow @safe @nogc;
+
+    /**
+     * Encrypts a block.
+     *
+     * Params:
+     *    plain  = Plain text, input.
+     *    cipher = Cipher text, output.
+     */
+    void encrypt(in ubyte[] plain, ubyte[] cipher)
+    in
+    {
+        assert(plain.length == blockSize);
+        assert(cipher.length == blockSize);
+    }
+
+    /**
+     * Decrypts a block.
+     *
+     * Params:
+     *    cipher = Cipher text, input.
+     *    plain  = Plain text, output.
+     */
+    void decrypt(in ubyte[] cipher, ubyte[] plain)
+    in
+    {
+        assert(plain.length == blockSize);
+        assert(cipher.length == blockSize);
+    }
+}
+
+/**
+ * Mixed in by algorithms with fixed block size.
+ *
+ * Params:
+ *     N = Block size.
+ */
+mixin template FixedBlockSize(uint N)
+    if (N != 0)
+{
+    private enum uint blockSize_ = N;
+
+    /**
+     * Returns: Fixed block size.
+     */
+    final @property inout(uint) blockSize() inout const pure nothrow @safe @nogc
+    {
+        return blockSize_;
+    }
+}
+
+/**
+ * Mixed in by symmetric algorithms.
+ * If $(D_PARAM Min) equals $(D_PARAM Max) fixed key length is assumed.
+ *
+ * Params:
+ *     Min = Minimum key length.
+ *     Max = Maximum key length.
+ */
+mixin template KeyLength(uint Min, uint Max = Min)
+    if (Min != 0 && Max != 0)
+{
+    static if (Min == Max)
+    {
+        private enum uint keyLength_ = Min;
+
+        /**
+         * Returns: Key length.
+         */
+        final @property inout(uint) keyLength() inout const pure nothrow @safe @nogc
+        {
+            return keyLength_;
+        }
+
+        /**
+         * Returns: Minimum key length.
+         */
+        final @property inout(uint) minKeyLength() inout const pure nothrow @safe @nogc
+        {
+            return keyLength_;
+        }
+
+        /**
+         * Returns: Maximum key length.
+         */
+        final @property inout(uint) maxKeyLength() inout const pure nothrow @safe @nogc
+        {
+            return keyLength_;
+        }
+    }
+    else static if (Min < Max)
+    {
+        private enum uint minKeyLength_ = Min;
+        private enum uint maxKeyLength_ = Max;
+
+        /**
+         * Returns: Minimum key length.
+         */
+        final @property inout(uint) minKeyLength() inout const pure nothrow @safe @nogc
+        {
+            return minKeyLength_;
+        }
+
+        /**
+         * Returns: Maximum key length.
+         */
+        final @property inout(uint) maxKeyLength() inout const pure nothrow @safe @nogc
+        {
+            return maxKeyLength_;
+        }
+    }
+    else
+    {
+        static assert(false, "Max should be larger or equal to Min");
+    }
+}

source/tanya/hash/lookup.d

@@ -1,341 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-/**
- * Non-cryptographic, lookup hash functions.
- *
- * Copyright: Eugene Wissner 2018-2020.
- * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
- *                  Mozilla Public License, v. 2.0).
- * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
- * Source: $(LINK2 https://github.com/caraus-ecms/tanya/blob/master/source/tanya/hash/lookup.d,
- *                 tanya/hash/lookup.d)
- */
-module tanya.hash.lookup;
-
-import std.traits : isScalarType;
-import tanya.meta.trait;
-import tanya.range.primitive;
-
-private struct Hasher
-{
-    static if (size_t.sizeof == 4)
-    {
-        enum uint offsetBasis = 2166136261;
-        enum uint prime = 16777619;
-    }
-    else static if (size_t.sizeof == 8)
-    {
-        enum ulong offsetBasis = 14695981039346656037UL;
-        enum ulong prime = 1099511628211UL;
-    }
-    else static if (size_t.sizeof == 16)
-    {
-        enum size_t offsetBasis = (size_t(0x6c62272e07bb0142UL) << 64) + 0x62b821756295c58dUL;
-        enum size_t prime = (size_t(1) << 88) + (1 << 8) + 0x3b;
-    }
-    else
-    {
-        static assert(false, "FNV requires at least 32-bit hash length");
-    }
-
-    size_t hash = offsetBasis;
-
-    void opCall(T)(auto ref T key)
-    {
-        static if (is(typeof(key.toHash()) == size_t))
-        {
-            opCall(key.toHash()); // Combine user-defined hashes
-        }
-        else static if (isScalarType!T || isPointer!T)
-        {
-            // Treat as an array of words
-            static if (T.sizeof % size_t.sizeof == 0
-                    && T.alignof >= size_t.alignof)
-                alias CastT = size_t;
-            // (64-bit or 128-bit) Treat as an array of ints
-            else static if (T.sizeof % uint.sizeof == 0
-                    && T.alignof >= uint.alignof)
-                alias CastT = uint;
-            // Treat as an array of bytes
-            else
-                alias CastT = ubyte;
-            add((() @trusted => (cast(const CastT*) &key)[0 .. T.sizeof / CastT.sizeof])());
-        }
-        else static if (isArray!T && isScalarType!(ElementType!T))
-        {
-            // Treat as an array of words
-            static if (ElementType!T.sizeof % size_t.sizeof == 0
-                    && ElementType!T.alignof >= size_t.alignof)
-                alias CastT = size_t;
-            // (64-bit or 128-bit) Treat as an array of ints
-            else static if (ElementType!T.sizeof % uint.sizeof == 0
-                    && ElementType!T.alignof >= uint.alignof)
-                alias CastT = uint;
-            // Treat as an array of bytes
-            else
-                alias CastT = ubyte;
-            add(cast(const CastT[]) key);
-        }
-        else static if (is(T == typeof(null)))
-        {
-            add(key);
-        }
-        else static if (isInputRange!T && !isInfinite!T)
-        {
-            foreach (e; key)
-            {
-                opCall(e);
-            }
-        }
-        else
-        {
-            static assert(false, "Hash function is not available");
-        }
-    }
-
-    void add(scope const ubyte[] key) @nogc nothrow pure @safe
-    {
-        // FNV-1a
-        foreach (c; key)
-        {
-            this.hash = (this.hash ^ c) * prime;
-        }
-    }
-
-    void add(scope const size_t[] key) @nogc nothrow pure @safe
-    {
-        static if (size_t.sizeof == 4)
-        {
-            // Partial MurmurHash3_x86_32 (no finalization)
-            enum uint c1 = 0xcc9e2d51;
-            enum uint c2 = 0x1b873593;
-            alias h1 = hash;
-            foreach (x; key)
-            {
-                auto k1 = x * c1;
-                k1 = (k1 << 15) | (k1 >> (32 - 15));
-                k1 *= c2;
-
-                h1 ^= k1;
-                h1 = (h1 << 13) | (h1 >> (32 - 13));
-                h1 = h1 * 5 + 0xe6546b64;
-            }
-        }
-        else static if (size_t.sizeof == 8)
-        {
-            // Partial 64-bit MurmurHash64A (no finalization)
-            alias h = hash;
-            enum ulong m = 0xc6a4a7935bd1e995UL;
-            foreach (x; key)
-            {
-                auto k = x * m;
-                k ^= k >>> 47;
-                k *= m;
-
-                h ^= k;
-                h *= m;
-            }
-        }
-        else static if (size_t.sizeof == 16)
-        {
-            // Partial MurmurHash3_x64_128 (no finalization)
-            // treating each size_t as a pair of ulong.
-            ulong h1 = cast(ulong) hash;
-            ulong h2 = cast(ulong) (hash >> 64);
-
-            enum ulong c1 = 0x87c37b91114253d5UL;
-            enum ulong c2 = 0x4cf5ad432745937fUL;
-
-            foreach (x; key)
-            {
-                auto k1 = cast(ulong) x;
-                auto k2 = cast(ulong) (x >> 64);
-
-                k1 *= c1; k1 = (k1 << 32) | (k1 >> (64 - 31)); k1 *= c2; h1 ^= k1;
-                h1 = (h1 << 27) | (h1 >> (64 - 27)); h1 += h2; h1 = h1*5+0x52dce729;
-                k2 *= c2; k2 = (k2 << 33) | (k2 >> (64 - 33)); k2 *= c1; h2 ^= k2;
-                h2 = (h2 << 31) | (h2 >> (64 - 31)); h2 += h1; h2 = h2*5+0x38495ab5;
-            }
-
-            hash = cast(size_t) h1 + ((cast(size_t) h2) << 64);
-        }
-        else
-        {
-            static assert(0, "Hash length must be either 32, 64, or 128 bits.");
-        }
-    }
-
-    static if (size_t.sizeof != uint.sizeof)
-    void add(scope const uint[] key) @nogc nothrow pure @trusted
-    {
-        static if (size_t.sizeof == 8)
-        {
-            // Partial 32-bit MurmurHash64B (no finalization)
-            enum uint m = 0x5bd1e995;
-            enum r = 24;
-
-            uint h1 = cast(uint) hash;
-            uint h2 = cast(uint) (hash >> 32);
-            const(uint)* data = key.ptr;
-            auto len = key.length;
-
-            for (; len >= 2; data += 2, len -= 2)
-            {
-                uint k1 = data[0];
-                k1 *= m; k1 ^= k1 >> r; k1 *= m;
-                h1 *= m; h1 ^= k1;
-
-                uint k2 = data[1];
-                k2 *= m; k2 ^= k2 >> r; k2 *= m;
-                h2 *= m; h2 ^= k2;
-            }
-            if (len)
-            {
-                uint k1 = data[0];
-                k1 *= m; k1 ^= k1 >> r; k1 *= m;
-                h1 *= m; h1 ^= k1;
-            }
-            hash = cast(ulong) h1 + ((cast(ulong) h2) << 32);
-        }
-        else static if (size_t.sizeof == 16)
-        {
-            // Partial MurmurHash3_x86_128 (no finalization)
-            enum uint c1 = 0x239b961b;
-            enum uint c2 = 0xab0e9789;
-            enum uint c3 = 0x38b34ae5;
-            enum uint c4 = 0xa1e38b93;
-
-            uint h1 = cast(uint) hash;
-            uint h2 = cast(uint) (hash >> 32);
-            uint h3 = cast(uint) (hash >> 64);
-            uint h4 = cast(uint) (hash >> 96);
-            const(uint)* data = key.ptr;
-            auto len = key.length;
-
-            for (; len >= 4; data += 4, len -= 4)
-            {
-                uint k1 = data[0];
-                uint k2 = data[1];
-                uint k3 = data[2];
-                uint k4 = data[3];
-
-                h1 = (h1 << 19) | (h1 >> (32 - 19)); h1 += h2; h1 = h1*5+0x561ccd1b;
-                k2 *= c2; k2 = (k2 << 16) | (k2 >> (32 - 16)); k2 *= c3; h2 ^= k2;
-                h2 = (h2 << 17) | (h2 >> (32 - 17)); h2 += h3; h2 = h2*5+0x0bcaa747;
-                k3 *= c3; k3 = (k3 << 17) | (k3 >> (32 - 17)); k3 *= c4; h3 ^= k3;
-                h3 = (h3 << 15) | (h3 >> (32 - 15)); h3 += h4; h3 = h3*5+0x96cd1c35;
-                k4 *= c4; k4 = (k4 << 18) | (k4 >> (32 - 18)); k4 *= c1; h4 ^= k4;
-                h4 = (h4 << 13) | (h4 >> (32 - 13)); h4 += h1; h4 = h4*5+0x32ac3b17;
-            }
-            uint k1, k2, k3;
-            switch (len) // 0, 1, 2, 3
-            {
-                case 3:
-                    k3 = data[2];
-                    k3 *= c3; k3 = (k3 << 17) | (k3 >> (32 - 17)); k3 *= c4; h3 ^= k3;
-                    goto case;
-                case 2:
-                    k2 = data[1];
-                    k2 *= c2; k2 = (k2 << 16) | (k2 >> (32 - 16)); k2 *= c3; h2 ^= k2;
-                    goto case;
-                case 1:
-                    k1 = data[0];
-                    k1 *= c1; k1 = (k1 << 15) | (k1 >> (32 - 15)); k1 *= c2; h1 ^= k1;
-                    break;
-            }
-            hash = cast(size_t) h1 +
-                   ((cast(size_t) h2) << 32) +
-                   ((cast(size_t) h3) << 64) +
-                   ((cast(size_t) h4) << 96);
-        }
-        else
-        {
-            static assert(0, "Hash length must be either 32, 64, or 128 bits.");
-        }
-    }
-}
-
-/**
- * Takes an argument of an arbitrary type $(D_PARAM T) and calculates the hash
- * value.
- *
- * Hash calculation is supported for all scalar types. Aggregate types, like
- * $(D_KEYWORD struct)s, should implement `toHash`-function:
- * ---
- * size_t toHash() const
- * {
- *  return hash;
- * }
- * ---
- *
- * For pointers and for scalar types implicitly convertible to `size_t` this
- * is an identity operation (i.e. the value is cast to `size_t` and returned
- * unaltered). Integer types wider than `size_t` are XOR folded down to
- * `size_t`. Other scalar types use an architecture-dependent hash function
- * based on their width and alignment.
- * If the type provides a `toHash`-function, only `toHash()` is called and its
- * result is returned.
- *
- * This function also accepts input ranges that contain hashable elements.
- * Individual values are combined then and the resulting hash is returned.
- *
- * Params:
- *  T   = Hashable type.
- *  key = Hashable value.
- *
- * Returns: Calculated hash value.
- *
- * See_Also: $(LINK http://www.isthe.com/chongo/tech/comp/fnv/).
- */
-size_t hash(T)(auto ref T key)
-{
-    static if (is(typeof(key.toHash()) == size_t))
-    {
-        return key.toHash();
-    }
-    else static if ((isIntegral!T || isSomeChar!T || isBoolean!T)
-            && T.sizeof <= size_t.sizeof)
-    {
-        return cast(size_t) key;
-    }
-    else static if (isIntegral!T && T.sizeof > size_t.sizeof)
-    {
-        return cast(size_t) (key ^ (key >>> (size_t.sizeof * 8)));
-    }
-    else static if (isPointer!T || is(T : typeof(null)))
-    {
-        return (() @trusted => cast(size_t) key)();
-    }
-    else
-    {
-        Hasher hasher;
-        hasher(key);
-        return hasher.hash;
-    }
-}
-
-/**
- * Determines whether $(D_PARAM hasher) is hash function for $(D_PARAM T), i.e.
- * it is callable with a value of type $(D_PARAM T) and returns a
- * $(D_PSYMBOL size_t) value.
- *
- * Params:
- *  hasher = Hash function candidate.
- *  T      = Type to test the hash function with.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM hasher) is a hash function for
- *          $(D_PARAM T), $(D_KEYWORD false) otherwise.
- */
-template isHashFunction(alias hasher, T)
-{
-    private alias wrapper = (T x) => hasher(x);
-    enum bool isHashFunction = is(typeof(wrapper(T.init)) == size_t);
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(isHashFunction!(hash, int));
-}

source/tanya/math/package.d

@@ -3,543 +3,170 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /**
- * This package provides mathematical functions.
- *
- * The $(D_PSYMBOL tanya.math) package itself provides only representation
- * functions for built-in types, such as functions that provide information
- * about internal representation of floating-point numbers and low-level
- * operatons on these. Actual mathematical functions and additional types can
- * be found in its submodules. $(D_PSYMBOL tanya.math) doesn't import any
- * submodules publically, they should be imported explicitly.
- *
- * Copyright: Eugene Wissner 2016-2022.
+ * Copyright: Eugene Wissner 2016.
  * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
  *                  Mozilla Public License, v. 2.0).
- * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
- * Source: $(LINK2 https://github.com/caraus-ecms/tanya/blob/master/source/tanya/math/package.d,
- *                 tanya/math/package.d)
- */
+ * Authors: $(LINK2 mailto:belka@caraus.de, Eugene Wissner)
+ */  
 module tanya.math;
 
-import std.math;
-import tanya.meta.trait;
-import tanya.meta.transform;
+import std.traits;
+public import tanya.math.mp;
+public import tanya.math.random;
 
-/// Floating-point number precisions according to IEEE-754.
-enum IEEEPrecision : ubyte
+version (unittest)
 {
-    single = 4, /// Single precision: 64-bit.
-    double_ = 8, /// Single precision: 64-bit.
-    doubleExtended = 10, /// Double extended precision: 80-bit.
+	import std.algorithm.iteration;
 }
 
 /**
- * Tests the precision of floating-point type $(D_PARAM F).
+ * Computes $(D_PARAM x) to the power $(D_PARAM y) modulo $(D_PARAM z).
  *
- * For $(D_KEYWORD float) $(D_PSYMBOL ieeePrecision) always evaluates to
- * $(D_INLINECODE IEEEPrecision.single); for $(D_KEYWORD double) - to
- * $(D_INLINECODE IEEEPrecision.double). It returns different values only
- * for $(D_KEYWORD real), since $(D_KEYWORD real) is a platform-dependent type.
- *
- * If $(D_PARAM F) is a $(D_KEYWORD real) and the target platform isn't
- * currently supported, static assertion error will be raised (you can use
- * $(D_INLINECODE is(typeof(ieeePrecision!F))) for testing the platform support
- * without a compilation error).
+ * If $(D_PARAM I) is an $(D_PSYMBOL Integer), the allocator of $(D_PARAM x)
+ * is used to allocate the result.
  *
  * Params:
- *  F = Type to be tested.
+ * 	I = Base type.
+ * 	G = Exponent type.
+ * 	H = Divisor type:
+ * 	x = Base.
+ * 	y = Exponent.
+ * 	z = Divisor.
  *
- * Returns: Precision according to IEEE-754.
+ * Returns: Reminder of the division of $(D_PARAM x) to the power $(D_PARAM y)
+ *          by $(D_PARAM z).
  *
- * See_Also: $(D_PSYMBOL IEEEPrecision).
+ * Precondition: $(D_INLINECODE z > 0)
  */
-template ieeePrecision(F)
-if (isFloatingPoint!F)
+H pow(I, G, H)(in auto ref I x, in auto ref G y, in auto ref H z)
+	if (isIntegral!I && isIntegral!G && isIntegral!H)
+in
 {
-    static if (F.sizeof == float.sizeof)
-    {
-        enum IEEEPrecision ieeePrecision = IEEEPrecision.single;
-    }
-    else static if (F.sizeof == double.sizeof)
-    {
-        enum IEEEPrecision ieeePrecision = IEEEPrecision.double_;
-    }
-    else version (X86)
-    {
-        enum IEEEPrecision ieeePrecision = IEEEPrecision.doubleExtended;
-    }
-    else version (X86_64)
-    {
-        enum IEEEPrecision ieeePrecision = IEEEPrecision.doubleExtended;
-    }
-    else
-    {
-        static assert(false, "Unsupported IEEE 754 floating point precision");
-    }
+	assert(z > 0, "Division by zero.");
+}
+body
+{
+	G mask = G.max / 2 + 1;
+	H result;
+
+	if (y == 0)
+	{
+		return 1 % z;
+	}
+	else if (y == 1)
+	{
+		return x % z;
+	}
+	do
+	{
+		immutable bit = y & mask;
+		if (!result && bit)
+		{
+			result = x;
+			continue;
+		}
+
+		result *= result;
+		if (bit)
+		{
+			result *= x;
+		}
+		result %= z;
+	}
+	while (mask >>= 1);
+
+	return result;
+}
+
+/// Ditto.
+I pow(I)(in auto ref I x, in auto ref I y, in auto ref I z)
+	if (is(I == Integer))
+in
+{
+	assert(z.length > 0, "Division by zero.");
+}
+body
+{
+	size_t i = y.length;
+	auto tmp2 = Integer(x.allocator), tmp1 = Integer(x, x.allocator);
+	Integer result = Integer(x.allocator);
+
+	if (x.length == 0 && i != 0)
+	{
+		i = 0;
+	}
+	else
+	{
+		result = 1;
+	}
+	while (i)
+	{
+		--i;
+		for (ubyte mask = 0x01; mask; mask <<= 1)
+		{
+			if (y.rep[i] & mask)
+			{
+				result *= tmp1;
+				result %= z;
+			}
+			tmp2 = tmp1;
+			tmp1 *= tmp2;
+			tmp1 %= z;
+		}
+	}
+	return result;
 }
 
 ///
-@nogc nothrow pure @safe unittest
+pure nothrow @safe @nogc unittest
 {
-    static assert(ieeePrecision!float == IEEEPrecision.single);
-    static assert(ieeePrecision!double == IEEEPrecision.double_);
-}
-
-package(tanya) union FloatBits(F)
-{
-    Unqual!F floating;
-    static if (ieeePrecision!F == IEEEPrecision.single)
-    {
-        uint integral;
-        enum uint expMask = 0x7f800000;
-    }
-    else static if (ieeePrecision!F == IEEEPrecision.double_)
-    {
-        ulong integral;
-        enum ulong expMask = 0x7ff0000000000000;
-    }
-    else static if (ieeePrecision!F == IEEEPrecision.doubleExtended)
-    {
-        struct // Little-endian.
-        {
-            ulong mantissa;
-            ushort exp;
-        }
-        enum ulong mantissaMask = 0x7fffffffffffffff;
-        enum uint expMask = 0x7fff;
-    }
-    else
-    {
-        static assert(false, "Unsupported IEEE 754 floating point precision");
-    }
-}
-
-/**
- * Floating-point number classifications.
- */
-enum FloatingPointClass : ubyte
-{
-    /**
-     * Not a Number.
-     *
-     * See_Also: $(D_PSYMBOL isNaN).
-     */
-    nan,
-
-    /// Zero.
-    zero,
-
-    /**
-     * Infinity.
-     *
-     * See_Also: $(D_PSYMBOL isInfinity).
-     */
-    infinite,
-
-    /**
-     * Denormalized number.
-     *
-     * See_Also: $(D_PSYMBOL isSubnormal).
-     */
-    subnormal,
-
-    /**
-     * Normalized number.
-     *
-     * See_Also: $(D_PSYMBOL isNormal).
-     */
-    normal,
-}
-
-/**
- * Returns whether $(D_PARAM x) is a NaN, zero, infinity, subnormal or
- * normalized number.
- *
- * This function doesn't distinguish between negative and positive infinity,
- * negative and positive NaN or negative and positive zero.
- *
- * Params:
- *  F = Type of the floating point number.
- *  x = Floating point number.
- *
- * Returns: Classification of $(D_PARAM x).
- */
-FloatingPointClass classify(F)(F x)
-if (isFloatingPoint!F)
-{
-    if (x == 0)
-    {
-        return FloatingPointClass.zero;
-    }
-    FloatBits!F bits;
-    bits.floating = abs(x);
-
-    static if (ieeePrecision!F == IEEEPrecision.single)
-    {
-        if (bits.integral > bits.expMask)
-        {
-            return FloatingPointClass.nan;
-        }
-        else if (bits.integral == bits.expMask)
-        {
-            return FloatingPointClass.infinite;
-        }
-        else if (bits.integral < (1 << 23))
-        {
-            return FloatingPointClass.subnormal;
-        }
-    }
-    else static if (ieeePrecision!F == IEEEPrecision.double_)
-    {
-        if (bits.integral > bits.expMask)
-        {
-            return FloatingPointClass.nan;
-        }
-        else if (bits.integral == bits.expMask)
-        {
-            return FloatingPointClass.infinite;
-        }
-        else if (bits.integral < (1L << 52))
-        {
-            return FloatingPointClass.subnormal;
-        }
-    }
-    else static if (ieeePrecision!F == IEEEPrecision.doubleExtended)
-    {
-        if (bits.exp == bits.expMask)
-        {
-            if ((bits.mantissa & bits.mantissaMask) == 0)
-            {
-                return FloatingPointClass.infinite;
-            }
-            else
-            {
-                return FloatingPointClass.nan;
-            }
-        }
-        else if (bits.exp == 0)
-        {
-            return FloatingPointClass.subnormal;
-        }
-        else if (bits.mantissa < (1L << 63)) // "Unnormal".
-        {
-            return FloatingPointClass.nan;
-        }
-    }
-
-    return FloatingPointClass.normal;
+	assert(pow(3, 5, 7) == 5);
+	assert(pow(2, 2, 1) == 0);
+	assert(pow(3, 3, 3) == 0);
+	assert(pow(7, 4, 2) == 1);
+	assert(pow(53, 0, 2) == 1);
+	assert(pow(53, 1, 3) == 2);
+	assert(pow(53, 2, 5) == 4);
+	assert(pow(0, 0, 5) == 1);
+	assert(pow(0, 5, 5) == 0);
 }
 
 ///
-@nogc nothrow pure @safe unittest
+unittest
 {
-    assert(classify(0.0) == FloatingPointClass.zero);
-    assert(classify(double.nan) == FloatingPointClass.nan);
-    assert(classify(double.infinity) == FloatingPointClass.infinite);
-    assert(classify(-double.infinity) == FloatingPointClass.infinite);
-    assert(classify(1.4) == FloatingPointClass.normal);
-    assert(classify(1.11254e-307 / 10) == FloatingPointClass.subnormal);
-
-    assert(classify(0.0f) == FloatingPointClass.zero);
-    assert(classify(float.nan) == FloatingPointClass.nan);
-    assert(classify(float.infinity) == FloatingPointClass.infinite);
-    assert(classify(-float.infinity) == FloatingPointClass.infinite);
-    assert(classify(0.3) == FloatingPointClass.normal);
-    assert(classify(5.87747e-38f / 10) == FloatingPointClass.subnormal);
-
-    assert(classify(0.0L) == FloatingPointClass.zero);
-    assert(classify(real.nan) == FloatingPointClass.nan);
-    assert(classify(real.infinity) == FloatingPointClass.infinite);
-    assert(classify(-real.infinity) == FloatingPointClass.infinite);
+	assert(cast(long) pow(Integer(3), Integer(5), Integer(7)) == 5);
+	assert(cast(long) pow(Integer(2), Integer(2), Integer(1)) == 0);
+	assert(cast(long) pow(Integer(3), Integer(3), Integer(3)) == 0);
+	assert(cast(long) pow(Integer(7), Integer(4), Integer(2)) == 1);
+	assert(cast(long) pow(Integer(53), Integer(0), Integer(2)) == 1);
+	assert(cast(long) pow(Integer(53), Integer(1), Integer(3)) == 2);
+	assert(cast(long) pow(Integer(53), Integer(2), Integer(5)) == 4);
+	assert(cast(long) pow(Integer(0), Integer(0), Integer(5)) == 1);
+	assert(cast(long) pow(Integer(0), Integer(5), Integer(5)) == 0);
 }
 
 /**
- * Determines whether $(D_PARAM x) is a finite number.
+ * Checks if $(D_PARAM x) is a prime.
  *
  * Params:
- *  F = Type of the floating point number.
- *  x = Floating point number.
+ * 	x = The number should be checked.
  *
- * Returns: $(D_KEYWORD true) if $(D_PARAM x) is a finite number,
- *          $(D_KEYWORD false) otherwise.
- *
- * See_Also: $(D_PSYMBOL isInfinity).
- */
-bool isFinite(F)(F x)
-if (isFloatingPoint!F)
-{
-    FloatBits!F bits;
-    static if (ieeePrecision!F == IEEEPrecision.single
-            || ieeePrecision!F == IEEEPrecision.double_)
-    {
-        bits.floating = x;
-        bits.integral &= bits.expMask;
-        return bits.integral != bits.expMask;
-    }
-    else static if (ieeePrecision!F == IEEEPrecision.doubleExtended)
-    {
-        bits.floating = abs(x);
-        return (bits.exp != bits.expMask)
-            && (bits.exp == 0 || bits.mantissa >= (1L << 63));
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    assert(!isFinite(float.infinity));
-    assert(!isFinite(-double.infinity));
-    assert(isFinite(0.0));
-    assert(!isFinite(float.nan));
-    assert(isFinite(5.87747e-38f / 10));
-    assert(isFinite(1.11254e-307 / 10));
-    assert(isFinite(0.5));
-}
-
-/**
- * Determines whether $(D_PARAM x) is $(B n)ot $(B a) $(B n)umber (NaN).
- *
- * Params:
- *  F = Type of the floating point number.
- *  x = Floating point number.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM x) is not a number,
+ * Returns: $(D_KEYWORD true) if $(D_PARAM x) is a prime number,
  *          $(D_KEYWORD false) otherwise.
  */
-bool isNaN(F)(F x)
-if (isFloatingPoint!F)
+bool isPseudoprime(ulong x) nothrow pure @safe @nogc
 {
-    FloatBits!F bits;
-    bits.floating = abs(x);
-
-    static if (ieeePrecision!F == IEEEPrecision.single
-            || ieeePrecision!F == IEEEPrecision.double_)
-    {
-        return bits.integral > bits.expMask;
-    }
-    else static if (ieeePrecision!F == IEEEPrecision.doubleExtended)
-    {
-        const maskedMantissa = bits.mantissa & bits.mantissaMask;
-        if ((bits.exp == bits.expMask && maskedMantissa != 0)
-         || ((bits.exp != 0) && (bits.mantissa < (1L << 63))))
-        {
-            return true;
-        }
-        return false;
-    }
+	return pow(2, x - 1, x) == 1;
 }
 
 ///
-@nogc nothrow pure @safe unittest
+unittest
 {
-    assert(isNaN(float.init));
-    assert(isNaN(double.init));
-    assert(isNaN(real.init));
-}
-
-/**
- * Determines whether $(D_PARAM x) is a positive or negative infinity.
- *
- * Params:
- *  F = Type of the floating point number.
- *  x = Floating point number.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM x) is infinity, $(D_KEYWORD false)
- *          otherwise.
- *
- * See_Also: $(D_PSYMBOL isFinite).
- */
-bool isInfinity(F)(F x)
-if (isFloatingPoint!F)
-{
-    FloatBits!F bits;
-    bits.floating = abs(x);
-    static if (ieeePrecision!F == IEEEPrecision.single
-            || ieeePrecision!F == IEEEPrecision.double_)
-    {
-        return bits.integral == bits.expMask;
-    }
-    else static if (ieeePrecision!F == IEEEPrecision.doubleExtended)
-    {
-        return (bits.exp == bits.expMask)
-            && ((bits.mantissa & bits.mantissaMask) == 0);
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    assert(isInfinity(float.infinity));
-    assert(isInfinity(-float.infinity));
-    assert(isInfinity(double.infinity));
-    assert(isInfinity(-double.infinity));
-    assert(isInfinity(real.infinity));
-    assert(isInfinity(-real.infinity));
-}
-
-/**
- * Determines whether $(D_PARAM x) is a denormilized number or not.
- *
- * Denormalized number is a number between `0` and `1` that cannot be
- * represented as
- *
- * <pre>
- * m*2<sup>e</sup>
- * </pre>
- *
- * where $(I m) is the mantissa and $(I e) is an exponent that fits into the
- * exponent field of the type $(D_PARAM F).
- *
- * `0` is neither normalized nor denormalized.
- *
- * Params:
- *  F = Type of the floating point number.
- *  x = Floating point number.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM x) is a denormilized number,
- *          $(D_KEYWORD false) otherwise.
- *
- * See_Also: $(D_PSYMBOL isNormal).
- */
-bool isSubnormal(F)(F x)
-if (isFloatingPoint!F)
-{
-    FloatBits!F bits;
-    bits.floating = abs(x);
-    static if (ieeePrecision!F == IEEEPrecision.single)
-    {
-        return bits.integral < (1 << 23) && bits.integral > 0;
-    }
-    else static if (ieeePrecision!F == IEEEPrecision.double_)
-    {
-        return bits.integral < (1L << 52) && bits.integral > 0;
-    }
-    else static if (ieeePrecision!F == IEEEPrecision.doubleExtended)
-    {
-        return bits.exp == 0 && bits.mantissa != 0;
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    assert(!isSubnormal(0.0f));
-    assert(!isSubnormal(float.nan));
-    assert(!isSubnormal(float.infinity));
-    assert(!isSubnormal(0.3f));
-    assert(isSubnormal(5.87747e-38f / 10));
-
-    assert(!isSubnormal(0.0));
-    assert(!isSubnormal(double.nan));
-    assert(!isSubnormal(double.infinity));
-    assert(!isSubnormal(1.4));
-    assert(isSubnormal(1.11254e-307 / 10));
-
-    assert(!isSubnormal(0.0L));
-    assert(!isSubnormal(real.nan));
-    assert(!isSubnormal(real.infinity));
-}
-
-/**
- * Determines whether $(D_PARAM x) is a normilized number or not.
- *
- * Normalized number is a number that can be represented as
- *
- * <pre>
- * m*2<sup>e</sup>
- * </pre>
- *
- * where $(I m) is the mantissa and $(I e) is an exponent that fits into the
- * exponent field of the type $(D_PARAM F).
- *
- * `0` is neither normalized nor denormalized.
- *
- * Params:
- *  F = Type of the floating point number.
- *  x = Floating point number.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM x) is a normilized number,
- *          $(D_KEYWORD false) otherwise.
- *
- * See_Also: $(D_PSYMBOL isSubnormal).
- */
-bool isNormal(F)(F x)
-if (isFloatingPoint!F)
-{
-    static if (ieeePrecision!F == IEEEPrecision.single
-            || ieeePrecision!F == IEEEPrecision.double_)
-    {
-        FloatBits!F bits;
-        bits.floating = x;
-        bits.integral &= bits.expMask;
-        return bits.integral != 0 && bits.integral != bits.expMask;
-    }
-    else static if (ieeePrecision!F == IEEEPrecision.doubleExtended)
-    {
-        return classify(x) == FloatingPointClass.normal;
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    assert(!isNormal(0.0f));
-    assert(!isNormal(float.nan));
-    assert(!isNormal(float.infinity));
-    assert(isNormal(0.3f));
-    assert(!isNormal(5.87747e-38f / 10));
-
-    assert(!isNormal(0.0));
-    assert(!isNormal(double.nan));
-    assert(!isNormal(double.infinity));
-    assert(isNormal(1.4));
-    assert(!isNormal(1.11254e-307 / 10));
-
-    assert(!isNormal(0.0L));
-    assert(!isNormal(real.nan));
-    assert(!isNormal(real.infinity));
-}
-
-/**
- * Determines whether the sign bit of $(D_PARAM x) is set or not.
- *
- * If the sign bit, $(D_PARAM x) is a negative number, otherwise positive.
- *
- * Params:
- *  F = Type of the floating point number.
- *  x = Floating point number.
- *
- * Returns: $(D_KEYWORD true) if the sign bit of $(D_PARAM x) is set,
- *          $(D_KEYWORD false) otherwise.
- */
-bool signBit(F)(F x)
-if (isFloatingPoint!F)
-{
-    FloatBits!F bits;
-    bits.floating = x;
-    static if (ieeePrecision!F == IEEEPrecision.single)
-    {
-        return (bits.integral & (1 << 31)) != 0;
-    }
-    else static if (ieeePrecision!F == IEEEPrecision.double_)
-    {
-        return (bits.integral & (1L << 63)) != 0;
-    }
-    else static if (ieeePrecision!F == IEEEPrecision.doubleExtended)
-    {
-        return (bits.exp & (1 << 15)) != 0;
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    assert(signBit(-1.0f));
-    assert(!signBit(1.0f));
-
-    assert(signBit(-1.0));
-    assert(!signBit(1.0));
-
-    assert(signBit(-1.0L));
-    assert(!signBit(1.0L));
+	uint[30] known = [74623, 74653, 74687, 74699, 74707, 74713, 74717, 74719,
+	                  74843, 74747, 74759, 74761, 74771, 74779, 74797, 74821,
+	                  74827, 9973, 104729, 15485867, 49979693, 104395303,
+	                  593441861, 104729, 15485867, 49979693, 104395303,
+	                  593441861, 899809363, 982451653];
+
+	known.each!((ref x) => assert(isPseudoprime(x)));
 }

source/tanya/math/random.d

@@ -5,17 +5,19 @@
 /**
  * Random number generator.
  *
- * Copyright: Eugene Wissner 2016-2022.
+ * Copyright: Eugene Wissner 2016.
  * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
  *                  Mozilla Public License, v. 2.0).
- * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
- * Source: $(LINK2 https://github.com/caraus-ecms/tanya/blob/master/source/tanya/math/random.d,
- *                 tanya/math/random.d)
- */
+ * Authors: $(LINK2 mailto:belka@caraus.de, Eugene Wissner)
+ */  
 module tanya.math.random;
 
+import std.digest.sha;
 import std.typecons;
-import tanya.memory.allocator;
+import tanya.memory;
+
+/// Block size of entropy accumulator (SHA-512).
+enum blockSize = 64;
 
 /// Maximum amount gathered from the entropy sources.
 enum maxGather = 128;
@@ -25,20 +27,20 @@ enum maxGather = 128;
  */
 class EntropyException : Exception
 {
-    /**
-     * Params:
-     *  msg  = Message to output.
-     *  file = The file where the exception occurred.
-     *  line = The line number where the exception occurred.
-     *  next = The previous exception in the chain of exceptions, if any.
-     */
-    this(string msg,
-         string file = __FILE__,
-         size_t line = __LINE__,
-         Throwable next = null) const @nogc nothrow pure @safe
-    {
-        super(msg, file, line, next);
-    }
+	/**
+	 * Params:
+	 * 	msg  = Message to output.
+	 * 	file = The file where the exception occurred.
+	 * 	line = The line number where the exception occurred.
+	 * 	next = The previous exception in the chain of exceptions, if any.
+	 */
+	this(string msg,
+	     string file = __FILE__,
+	     size_t line = __LINE__,
+	     Throwable next = null) pure @safe nothrow const @nogc
+	{
+		super(msg, file, line, next);
+	}
 }
 
 /**
@@ -46,295 +48,273 @@ class EntropyException : Exception
  */
 abstract class EntropySource
 {
-    /// Amount of already generated entropy.
-    protected ushort size_;
+	/// Amount of already generated entropy.
+	protected ushort size_;
 
-    /**
-     * Returns: Minimum bytes required from the entropy source.
-     */
-    @property ubyte threshold() const @nogc nothrow pure @safe;
+	/**
+	 * Returns: Minimum bytes required from the entropy source.
+	 */
+	@property immutable(ubyte) threshold() const @safe pure nothrow;
 
-    /**
-     * Returns: Whether this entropy source is strong.
-     */
-    @property bool strong() const @nogc nothrow pure @safe;
+	/**
+	 * Returns: Whether this entropy source is strong.
+	 */
+	@property immutable(bool) strong() const @safe pure nothrow;
 
-    /**
-     * Returns: Amount of already generated entropy.
-     */
-    @property ushort size() const @nogc nothrow pure @safe
-    {
-        return size_;
-    }
+	/**
+	 * Returns: Amount of already generated entropy.
+	 */
+	@property ushort size() const @safe pure nothrow
+	{
+		return size_;
+	}
 
-    /**
-     * Params:
-     *  size = Amount of already generated entropy. Cannot be smaller than the
-     *         already set value.
-     */
-    @property void size(ushort size) @nogc nothrow pure @safe
-    {
-        size_ = size;
-    }
+	/**
+	 * Params:
+	 * 	size = Amount of already generated entropy. Cannot be smaller than the
+	 * 	       already set value.
+	 */
+	@property void size(ushort size) @safe pure nothrow
+	{
+		size_ = size;
+	}
 
-    /**
-     * Poll the entropy source.
-     *
-     * Params:
-     *  output = Buffer to save the generate random sequence (the method will
-     *           to fill the buffer).
-     *
-     * Returns: Number of bytes that were copied to the $(D_PARAM output)
-     *          or nothing on error.
-     *
-     * Postcondition: Returned length is less than or equal to
-     *                $(D_PARAM output) length.
-     */
-    Nullable!ubyte poll(out ubyte[maxGather] output) @nogc;
-}
-
-version (CRuntime_Bionic)
-{
-    version = SecureARC4Random;
-}
-else version (OSX)
-{
-    version = SecureARC4Random;
-}
-else version (OpenBSD)
-{
-    version = SecureARC4Random;
-}
-else version (NetBSD)
-{
-    version = SecureARC4Random;
-}
-else version (Solaris)
-{
-    version = SecureARC4Random;
+	/**
+	 * Poll the entropy source.
+	 *
+	 * Params:
+	 * 	output = Buffer to save the generate random sequence (the method will
+	 * 	         to fill the buffer).
+	 *
+	 * Returns: Number of bytes that were copied to the $(D_PARAM output)
+	 *          or $(D_PSYMBOL Nullable!ubyte.init) on error.
+	 */
+	Nullable!ubyte poll(out ubyte[maxGather] output);
 }
 
 version (linux)
 {
-    import core.stdc.config : c_long;
-    private extern(C) c_long syscall(c_long number, ...) @nogc nothrow @system;
+	extern (C) long syscall(long number, ...) nothrow;
 
-    /**
-     * Uses getrandom system call.
-     */
-    class PlatformEntropySource : EntropySource
-    {
-        /**
-         * Returns: Minimum bytes required from the entropy source.
-         */
-        override @property ubyte threshold() const @nogc nothrow pure @safe
-        {
-            return 32;
-        }
+	/**
+	 * Uses getrandom system call.
+	 */
+	class PlatformEntropySource : EntropySource
+	{
+		/**
+		 * Returns: Minimum bytes required from the entropy source.
+		 */
+		override @property immutable(ubyte) threshold() const @safe pure nothrow
+		{
+			return 32;
+		}
 
-        /**
-         * Returns: Whether this entropy source is strong.
-         */
-        override @property bool strong() const @nogc nothrow pure @safe
-        {
-            return true;
-        }
+		/**
+		 * Returns: Whether this entropy source is strong.
+		 */
+		override @property immutable(bool) strong() const @safe pure nothrow
+		{
+			return true;
+		}
 
-        /**
-         * Poll the entropy source.
-         *
-         * Params:
-         *  output = Buffer to save the generate random sequence (the method will
-         *           to fill the buffer).
-         *
-         * Returns: Number of bytes that were copied to the $(D_PARAM output)
-         *          or nothing on error.
-         */
-        override Nullable!ubyte poll(out ubyte[maxGather] output) @nogc nothrow
-        out (length)
-        {
-            assert(length.isNull || length.get <= maxGather);
-        }
-        do
-        {
-            // int getrandom(void *buf, size_t buflen, unsigned int flags);
-            import mir.linux._asm.unistd : NR_getrandom;
-            auto length = syscall(NR_getrandom, output.ptr, output.length, 0);
-            Nullable!ubyte ret;
+		/**
+		 * Poll the entropy source.
+		 *
+		 * Params:
+		 * 	output = Buffer to save the generate random sequence (the method will
+		 * 	         to fill the buffer).
+		 *
+		 * Returns: Number of bytes that were copied to the $(D_PARAM output)
+		 *          or $(D_PSYMBOL Nullable!ubyte.init) on error.
+		 */
+		override Nullable!ubyte poll(out ubyte[maxGather] output) nothrow
+		out (length)
+		{
+			assert(length <= maxGather);
+		}
+		body
+		{
+			// int getrandom(void *buf, size_t buflen, unsigned int flags);
+			auto length = syscall(318, output.ptr, output.length, 0);
+			Nullable!ubyte ret;
 
-            if (length >= 0)
-            {
-                ret = cast(ubyte) length;
-            }
-            return ret;
-        }
-    }
+			if (length >= 0)
+			{
+				ret = cast(ubyte) length;
+			}
+			return ret;
+		}
+	}
 }
-else version (SecureARC4Random)
+
+/**
+ * Pseudorandom number generator.
+ * ---
+ * auto entropy = defaultAllocator.make!Entropy();
+ *
+ * ubyte[blockSize] output;
+ *
+ * output = entropy.random;
+ *
+ * defaultAllocator.finalize(entropy);
+ * ---
+ */
+class Entropy
 {
-    private extern(C) void arc4random_buf(scope void* buf, size_t nbytes)
-    @nogc nothrow @system;
+	/// Entropy sources.
+	protected EntropySource[] sources;
 
-    /**
-     * Uses arc4random_buf.
-     */
-    class PlatformEntropySource : EntropySource
-    {
-        /**
-         * Returns: Minimum bytes required from the entropy source.
-         */
-        override @property ubyte threshold() const @nogc nothrow pure @safe
-        {
-            return 32;
-        }
+	private ubyte sourceCount_;
 
-        /**
-         * Returns: Whether this entropy source is strong.
-         */
-        override @property bool strong() const @nogc nothrow pure @safe
-        {
-            return true;
-        }
+	private shared Allocator allocator;
 
-        /**
-         * Poll the entropy source.
-         *
-         * Params:
-         *  output = Buffer to save the generate random sequence (the method will
-         *           to fill the buffer).
-         *
-         * Returns: Number of bytes that were copied to the $(D_PARAM output)
-         *          or nothing on error.
-         */
-        override Nullable!ubyte poll(out ubyte[maxGather] output)
-        @nogc nothrow @safe
-        out (length)
-        {
-            assert(length.isNull || length.get <= maxGather);
-        }
-        do
-        {
-            (() @trusted => arc4random_buf(output.ptr, output.length))();
-            return Nullable!ubyte(cast(ubyte) (output.length));
-        }
-    }
-}
-else version (Windows)
-{
-    import core.sys.windows.basetsd : ULONG_PTR;
-    import core.sys.windows.winbase : GetLastError;
-    import core.sys.windows.wincrypt;
-    import core.sys.windows.windef : BOOL, DWORD, PBYTE;
-    import core.sys.windows.winerror : NTE_BAD_KEYSET;
-    import core.sys.windows.winnt : LPCSTR, LPCWSTR;
-
-    private extern(Windows) @nogc nothrow
-    {
-        BOOL CryptGenRandom(HCRYPTPROV, DWORD, PBYTE);
-        BOOL CryptAcquireContextA(HCRYPTPROV*, LPCSTR, LPCSTR, DWORD, DWORD);
-        BOOL CryptAcquireContextW(HCRYPTPROV*, LPCWSTR, LPCWSTR, DWORD, DWORD);
-        BOOL CryptReleaseContext(HCRYPTPROV, ULONG_PTR);
-    }
-
-    private bool initCryptGenRandom(scope ref HCRYPTPROV hProvider)
-    @nogc nothrow @trusted
-    {
-        // https://msdn.microsoft.com/en-us/library/windows/desktop/aa379886(v=vs.85).aspx
-        // For performance reasons, we recommend that you set the pszContainer
-        // parameter to NULL and the dwFlags parameter to CRYPT_VERIFYCONTEXT
-        // in all situations where you do not require a persisted key.
-        // CRYPT_SILENT is intended for use with applications for which the UI
-        // cannot be displayed by the CSP.
-        if (!CryptAcquireContextW(&hProvider,
-                                  null,
-                                  null,
-                                  PROV_RSA_FULL,
-                                  CRYPT_VERIFYCONTEXT | CRYPT_SILENT))
-        {
-            if (GetLastError() != NTE_BAD_KEYSET)
-            {
-                return false;
-            }
-            // Attempt to create default container
-            if (!CryptAcquireContextA(&hProvider,
-                                      null,
-                                      null,
-                                      PROV_RSA_FULL,
-                                      CRYPT_NEWKEYSET | CRYPT_SILENT))
-            {
-                return false;
-            }
-        }
-
-        return true;
-    }
-
-    class PlatformEntropySource : EntropySource
-    {
-        private HCRYPTPROV hProvider;
-
-        /**
-         * Uses CryptGenRandom.
-         */
-        this() @nogc
-        {
-            if (!initCryptGenRandom(hProvider))
-            {
-                throw defaultAllocator.make!EntropyException("CryptAcquireContextW failed.");
-            }
-            assert(hProvider > 0, "hProvider not properly initialized.");
-        }
-
-        ~this() @nogc nothrow @safe
-        {
-            if (hProvider > 0)
-            {
-                (() @trusted => CryptReleaseContext(hProvider, 0))();
-            }
-        }
-
-        /**
-         * Returns: Minimum bytes required from the entropy source.
-         */
-        override @property ubyte threshold() const @nogc nothrow pure @safe
-        {
-            return 32;
-        }
-
-        /**
-         * Returns: Whether this entropy source is strong.
-         */
-        override @property bool strong() const @nogc nothrow pure @safe
-        {
-            return true;
-        }
-
-        /**
-         * Poll the entropy source.
-         *
-         * Params:
-         *  output = Buffer to save the generate random sequence (the method will
-         *           to fill the buffer).
-         *
-         * Returns: Number of bytes that were copied to the $(D_PARAM output)
-         *          or nothing on error.
-         */
-        override Nullable!ubyte poll(out ubyte[maxGather] output)
-        @nogc nothrow @safe
-        out (length)
-        {
-            assert(length.isNull || length.get <= maxGather);
-        }
-        do
-        {
-            Nullable!ubyte ret;
-
-            assert(hProvider > 0, "hProvider not properly initialized");
-            if ((() @trusted => CryptGenRandom(hProvider, output.length, cast(PBYTE) output.ptr))())
-            {
-                ret = cast(ubyte) (output.length);
-            }
-            return ret;
-        }
-    }
+	/// Entropy accumulator.
+	protected SHA!(maxGather * 8, 512) accumulator;
+
+	/**
+	 * Params:
+	 *  maxSources = Maximum amount of entropy sources can be set.
+	 * 	allocator  = Allocator to allocate entropy sources available on the
+	 * 	             system.
+	 */
+	this(size_t maxSources = 20, shared Allocator allocator = defaultAllocator)
+	in
+	{
+		assert(maxSources > 0 && maxSources <= ubyte.max);
+		assert(allocator !is null);
+	}
+	body
+	{
+		allocator.resizeArray(sources, maxSources);
+
+		version (linux)
+		{
+			this ~= allocator.make!PlatformEntropySource;
+		}
+	}
+
+	/**
+	 * Returns: Amount of the registered entropy sources.
+	 */
+	@property ubyte sourceCount() const @safe pure nothrow
+	{
+		return sourceCount_;
+	}
+
+	/**
+	 * Add an entropy source.
+	 *
+	 * Params:
+	 * 	source = Entropy source.
+	 *
+	 * Returns: $(D_PSYMBOL this).
+	 *
+	 * See_Also:
+	 * 	$(D_PSYMBOL EntropySource)
+	 */
+	Entropy opOpAssign(string Op)(EntropySource source) @safe pure nothrow
+		if (Op == "~")
+	in
+	{
+		assert(sourceCount_ <= sources.length);
+	}
+	body
+	{
+		sources[sourceCount_++] = source;
+		return this;
+	}
+
+	/**
+	 * Returns: Generated random sequence.
+	 *
+	 * Throws: $(D_PSYMBOL EntropyException) if no strong entropy source was
+	 *         registered or it failed.
+	 */
+	@property ubyte[blockSize] random()
+	in
+	{
+		assert(sourceCount_ > 0, "No entropy sources defined.");
+	}
+	body
+	{
+		bool haveStrong;
+		ushort done;
+		ubyte[blockSize] output;
+
+		do
+		{
+			ubyte[maxGather] buffer;
+
+			// Run through our entropy sources
+			for (ubyte i; i < sourceCount; ++i)
+			{
+				auto outputLength = sources[i].poll(buffer);
+
+				if (!outputLength.isNull)
+				{
+					if (outputLength > 0)
+					{
+						update(i, buffer, outputLength);
+						sources[i].size = cast(ushort) (sources[i].size + outputLength);
+					}
+					if (sources[i].size < sources[i].threshold)
+					{
+						continue;
+					}
+					else if (sources[i].strong)
+					{
+						haveStrong = true;
+					}
+				}
+				done = 257;
+			}
+		}
+		while (++done < 256);
+
+		if (!haveStrong)
+		{
+			throw allocator.make!EntropyException("No strong entropy source defined.");
+		}
+
+		output = accumulator.finish();
+
+		// Reset accumulator and counters and recycle existing entropy
+		accumulator.start();
+
+		// Perform second SHA-512 on entropy
+		output = sha512Of(output);
+
+		for (ubyte i = 0; i < sourceCount; ++i)
+		{
+			sources[i].size = 0;
+		}
+		return output;
+	}
+
+	/**
+	 * Update entropy accumulator.
+	 *
+	 * Params:
+	 * 	sourceId = Entropy source index in $(D_PSYMBOL sources).
+	 * 	data     = Data got from the entropy source.
+	 * 	length   = Length of the received data.
+	 */
+	protected void update(in ubyte sourceId,
+	                      ref ubyte[maxGather] data,
+	                      ubyte length) @safe pure nothrow
+	{
+		ubyte[2] header;
+
+		if (length > blockSize)
+		{
+			data[0..64] = sha512Of(data);
+			length = blockSize;
+		}
+
+		header[0] = sourceId;
+		header[1] = length;
+
+		accumulator.put(header);
+		accumulator.put(data[0..length]);
+	}
 }

source/tanya/memory/allocator.d

@@ -0,0 +1,127 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Copyright: Eugene Wissner 2016.
+ * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
+ *                  Mozilla Public License, v. 2.0).
+ * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
+ */
+module tanya.memory.allocator;
+
+/**
+ * Abstract class implementing a basic allocator.
+ */
+interface Allocator
+{
+	/**
+	 * Returns: Alignment offered.
+	 */
+	@property uint alignment() const shared pure nothrow @safe @nogc;
+
+	/**
+	 * Allocates $(D_PARAM size) bytes of memory.
+	 *
+	 * Params:
+	 * 	size = Amount of memory to allocate.
+	 *
+	 * Returns: Pointer to the new allocated memory.
+	 */
+	void[] allocate(in size_t size) shared nothrow @nogc;
+
+	/**
+	 * Deallocates a memory block.
+	 *
+	 * Params:
+	 * 	p = A pointer to the memory block to be freed.
+	 *
+	 * Returns: Whether the deallocation was successful.
+	 */
+	bool deallocate(void[] p) shared nothrow @nogc;
+
+	/**
+	 * Increases or decreases the size of a memory block.
+	 *
+	 * Params:
+	 * 	p    = A pointer to the memory block.
+	 * 	size = Size of the reallocated block.
+	 *
+	 * Returns: Pointer to the allocated memory.
+	 */
+	bool reallocate(ref void[] p, in size_t size) shared nothrow @nogc;
+
+	/**
+	 * Expands a memory block in place.
+	 *
+	 * Params:
+	 * 	p    = A pointer to the memory block.
+	 * 	size = Size of the reallocated block.
+	 *
+	 * Returns: $(D_KEYWORD true) if successful, $(D_KEYWORD false) otherwise.
+	 */
+	bool expand(ref void[] p, in size_t size) shared nothrow @nogc;
+}
+
+/**
+ * The mixin generates common methods for classes and structs using
+ * allocators. It provides a protected member, constructor and a read-only property,
+ * that checks if an allocator was already set and sets it to the default
+ * one, if not (useful for structs which don't have a default constructor).
+ */
+mixin template DefaultAllocator()
+{
+	/// Allocator.
+	protected shared Allocator allocator_;
+
+	/**
+	 * Params:
+	 * 	allocator = The allocator should be used.
+	 */
+	this(shared Allocator allocator)
+	in
+	{
+		assert(allocator !is null);
+	}
+	body
+	{
+		this.allocator_ = allocator;
+	}
+
+	/**
+	 * This property checks if the allocator was set in the constructor
+	 * and sets it to the default one, if not.
+	 *
+	 * Returns: Used allocator.
+	 *
+	 * Postcondition: $(D_INLINECODE allocator_ !is null)
+	 */
+	protected @property shared(Allocator) allocator() nothrow @safe @nogc
+	out (allocator)
+	{
+		assert(allocator !is null);
+	}
+	body
+	{
+		if (allocator_ is null)
+		{
+			allocator_ = defaultAllocator;
+		}
+		return allocator_;
+	}
+
+	/// Ditto.
+	@property shared(Allocator) allocator() const nothrow @trusted @nogc
+	out (allocator)
+	{
+		assert(allocator !is null);
+	}
+	body
+	{
+		if (allocator_ is null)
+		{
+			return defaultAllocator;
+		}
+		return cast(shared Allocator) allocator_;
+	}
+}

source/tanya/memory/mmappool.d

@@ -0,0 +1,576 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Copyright: Eugene Wissner 2016.
+ * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
+ *                  Mozilla Public License, v. 2.0).
+ * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
+ */
+module tanya.memory.mmappool;
+
+import core.stdc.string;
+import std.algorithm.comparison;
+import tanya.memory.allocator;
+
+version (Posix)
+{
+	import core.stdc.errno;
+	import core.sys.posix.sys.mman;
+	import core.sys.posix.unistd;
+}
+else version (Windows)
+{
+	import core.sys.windows.winbase;
+	import core.sys.windows.windows;
+}
+
+/**
+ * This allocator allocates memory in regions (multiple of 64 KB for example).
+ * Each region is then splitted in blocks. So it doesn't request the memory
+ * from the operating system on each call, but only if there are no large
+ * enough free blocks in the available regions.
+ * Deallocation works in the same way. Deallocation doesn't immediately
+ * gives the memory back to the operating system, but marks the appropriate
+ * block as free and only if all blocks in the region are free, the complete
+ * region is deallocated.
+ *
+ * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ * |      |     |         |     |            ||      |     |                  |
+ * |      |prev <-----------    |            ||      |     |                  |
+ * |  R   |  B  |         |  B  |            ||   R  |  B  |                  |
+ * |  E   |  L  |         |  L  |           next  E  |  L  |                  |
+ * |  G   |  O  |  DATA   |  O  |   FREE    --->  G  |  O  |       DATA       |
+ * |  I   |  C  |         |  C  |           <---  I  |  C  |                  |
+ * |  O   |  K  |         |  K  |           prev  O  |  K  |                  |
+ * |  N   |    -----------> next|            ||   N  |     |                  |
+ * |      |     |         |     |            ||      |     |                  |
+ * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ */
+final class MmapPool : Allocator
+{
+	/**
+	 * Allocates $(D_PARAM size) bytes of memory.
+	 *
+	 * Params:
+	 * 	size = Amount of memory to allocate.
+	 *
+	 * Returns: Pointer to the new allocated memory.
+	 */
+	void[] allocate(in size_t size) shared nothrow @nogc
+	{
+		if (!size)
+		{
+			return null;
+		}
+		immutable dataSize = addAlignment(size);
+
+		void* data = findBlock(dataSize);
+		if (data is null)
+		{
+			data = initializeRegion(dataSize);
+		}
+
+		return data is null ? null : data[0 .. size];
+	}
+
+	///
+	nothrow unittest
+	{
+		auto p = MmapPool.instance.allocate(20);
+
+		assert(p);
+
+		MmapPool.instance.deallocate(p);
+	}
+
+	/**
+	 * Search for a block large enough to keep $(D_PARAM size) and split it
+	 * into two blocks if the block is too large.
+	 *
+	 * Params:
+	 * 	size = Minimum size the block should have (aligned).
+	 *
+	 * Returns: Data the block points to or $(D_KEYWORD null).
+	 */
+	private void* findBlock(in ref size_t size) shared nothrow @nogc
+	{
+		Block block1;
+		RegionLoop: for (auto r = head; r !is null; r = r.next)
+		{
+			block1 = cast(Block) (cast(void*) r + RegionEntry.sizeof);
+			do
+			{
+				if (block1.free && block1.size >= size)
+				{
+					break RegionLoop;
+				}
+			}
+			while ((block1 = block1.next) !is null);
+		}
+		if (block1 is null)
+		{
+			return null;
+		}
+		else if (block1.size >= size + alignment_ + BlockEntry.sizeof)
+		{ // Split the block if needed
+			Block block2 = cast(Block) (cast(void*) block1 + BlockEntry.sizeof + size);
+			block2.prev = block1;
+			block2.next = block1.next;
+			block2.free = true;
+			block2.size = block1.size - BlockEntry.sizeof - size;
+			block2.region = block1.region;
+
+			if (block1.next !is null)
+			{
+				block1.next.prev = block2;
+			}
+			block1.next = block2;
+			block1.size = size;
+		}
+		block1.free = false;
+		block1.region.blocks = block1.region.blocks + 1;
+
+		return cast(void*) block1 + BlockEntry.sizeof;
+	}
+
+	// Merge block with the next one.
+	private void mergeNext(Block block) shared const pure nothrow @safe @nogc
+	{
+		block.size = block.size + BlockEntry.sizeof + block.next.size;
+		if (block.next.next !is null)
+		{
+			block.next.next.prev = block;
+		}
+		block.next = block.next.next;
+	}
+
+	/**
+	 * Deallocates a memory block.
+	 *
+	 * Params:
+	 * 	p = A pointer to the memory block to be freed.
+	 *
+	 * Returns: Whether the deallocation was successful.
+	 */
+	bool deallocate(void[] p) shared nothrow @nogc
+	{
+		if (p is null)
+		{
+			return true;
+		}
+
+		Block block = cast(Block) (p.ptr - BlockEntry.sizeof);
+		if (block.region.blocks <= 1)
+		{
+			if (block.region.prev !is null)
+			{
+				block.region.prev.next = block.region.next;
+			}
+			else // Replace the list head. It is being deallocated
+			{
+				head = block.region.next;
+			}
+			if (block.region.next !is null)
+			{
+				block.region.next.prev = block.region.prev;
+			}
+			version (Posix)
+			{
+				return munmap(cast(void*) block.region, block.region.size) == 0;
+			}
+			version (Windows)
+			{
+				return VirtualFree(cast(void*) block.region, 0, MEM_RELEASE) == 0;
+			}
+		}
+		// Merge blocks if neigbours are free.
+		if (block.next !is null && block.next.free)
+		{
+			mergeNext(block);
+		}
+		if (block.prev !is null && block.prev.free)
+		{
+			block.prev.size = block.prev.size + BlockEntry.sizeof + block.size;
+			if (block.next !is null)
+			{
+				block.next.prev = block.prev;
+			}
+			block.prev.next = block.next;
+		}
+		else
+		{
+			block.free = true;
+		}
+		block.region.blocks = block.region.blocks - 1;
+		return true;
+	}
+
+	///
+	nothrow unittest
+	{
+		auto p = MmapPool.instance.allocate(20);
+
+		assert(MmapPool.instance.deallocate(p));
+	}
+
+	/**
+	 * Expands a memory block in place.
+	 *
+	 * Params:
+	 * 	p    = A pointer to the memory block.
+	 * 	size = Size of the reallocated block.
+	 *
+	 * Returns: $(D_KEYWORD true) if successful, $(D_KEYWORD false) otherwise.
+	 */
+	bool expand(ref void[] p, in size_t size) shared nothrow @nogc
+	{
+		if (size <= p.length)
+		{
+			return true;
+		}
+		if (p is null)
+		{
+			return false;
+		}
+		Block block1 = cast(Block) (p.ptr - BlockEntry.sizeof);
+
+		if (block1.size >= size)
+		{
+			// Enough space in the current block. Can happen because of the alignment.
+			p = p.ptr[0 .. size];
+			return true;
+		}
+		immutable dataSize = addAlignment(size);
+		immutable delta = dataSize - p.length;
+
+		if (block1.next is null
+		 || !block1.next.free
+		 || block1.next.size + BlockEntry.sizeof < delta)
+		{
+			// It is the last block in the region or the next block is too small or not
+			// free.
+			return false;
+		}
+		if (block1.next.size >= delta + alignment_)
+		{
+			// We should move the start position of the next block. The order may be
+			// important because the old block and the new one can overlap.
+			auto block2 = cast(Block) (p.ptr + dataSize);
+			block2.size = block1.next.size - delta;
+			block2.free = true;
+			block2.region = block1.region;
+			block2.next = block1.next.next;
+			block2.prev = block1;
+
+			block1.size = block1.size + delta;
+
+			if (block1.next.next !is null)
+			{
+				block1.next.next.prev = block2;
+			}
+			block1.next = block2;
+		}
+		else
+		{
+			// The next block has enough space, but is too small for further
+			// allocations. Merge it with the current block.
+			mergeNext(block1);
+		}
+
+		p = p.ptr[0 .. size];
+		return true;
+	}
+
+	///
+	nothrow unittest
+	{
+		void[] p;
+		assert(!MmapPool.instance.expand(p, 5));
+		assert(p is null);
+
+		p = MmapPool.instance.allocate(1);
+		auto orig = p.ptr;
+
+		assert(MmapPool.instance.expand(p, 2));
+		assert(p.length == 2);
+		assert(p.ptr == orig);
+
+		assert(MmapPool.instance.expand(p, 4));
+		assert(p.length == 4);
+		assert(p.ptr == orig);
+
+		assert(MmapPool.instance.expand(p, 2));
+		assert(p.length == 4);
+		assert(p.ptr == orig);
+
+		MmapPool.instance.deallocate(p);
+	}
+
+	/**
+	 * Increases or decreases the size of a memory block.
+	 *
+	 * Params:
+	 * 	p    = A pointer to the memory block.
+	 * 	size = Size of the reallocated block.
+	 *
+	 * Returns: Whether the reallocation was successful.
+	 */
+	bool reallocate(ref void[] p, in size_t size) shared nothrow @nogc
+	{
+		if (size == 0)
+		{
+			if (deallocate(p))
+			{
+				p = null;
+				return true;
+			}
+			return false;
+		}
+		else if (size <= p.length)
+		{
+			// Leave the block as is.
+			p = p.ptr[0 .. size];
+			return true;
+		}
+		else if (expand(p, size))
+		{
+			return true;
+		}
+		// Can't extend, allocate a new block, copy and delete the previous.
+		void[] reallocP = allocate(size);
+		if (reallocP is null)
+		{
+			return false;
+		}
+		if (p !is null)
+		{
+			memcpy(reallocP.ptr, p.ptr, min(p.length, size));
+			deallocate(p);
+		}
+		p = reallocP;
+
+		return true;
+	}
+
+	///
+	nothrow unittest
+	{
+		void[] p;
+		MmapPool.instance.reallocate(p, 10 * int.sizeof);
+		(cast(int[]) p)[7] = 123;
+
+		assert(p.length == 40);
+
+		MmapPool.instance.reallocate(p, 8 * int.sizeof);
+
+		assert(p.length == 32);
+		assert((cast(int[]) p)[7] == 123);
+
+		MmapPool.instance.reallocate(p, 20 * int.sizeof);
+		(cast(int[]) p)[15] = 8;
+
+		assert(p.length == 80);
+		assert((cast(int[]) p)[15] == 8);
+		assert((cast(int[]) p)[7] == 123);
+
+		MmapPool.instance.reallocate(p, 8 * int.sizeof);
+
+		assert(p.length == 32);
+		assert((cast(int[]) p)[7] == 123);
+
+		MmapPool.instance.deallocate(p);
+	}
+
+	/**
+	 * Static allocator instance and initializer.
+	 *
+	 * Returns: Global $(D_PSYMBOL MmapPool) instance.
+	 */
+	static @property ref shared(MmapPool) instance() nothrow @nogc
+	{
+		if (instance_ is null)
+		{
+			// Get system dependend page size.
+			version (Posix)
+			{
+				pageSize = sysconf(_SC_PAGE_SIZE);
+				if (pageSize < 65536)
+				{
+					pageSize = pageSize * 65536 / pageSize;
+				}
+			}
+			else version (Windows)
+			{
+				SYSTEM_INFO si;
+				GetSystemInfo(&si);
+				pageSize = si.dwPageSize;
+			}
+
+			immutable instanceSize = addAlignment(__traits(classInstanceSize, MmapPool));
+
+			Region head; // Will become soon our region list head
+			void* data = initializeRegion(instanceSize, head);
+			if (data !is null)
+			{
+				memcpy(data, typeid(MmapPool).initializer.ptr, instanceSize);
+				instance_ = cast(shared MmapPool) data;
+				instance_.head = head;
+			}
+		}
+		return instance_;
+	}
+
+	///
+	nothrow unittest
+	{
+		assert(instance is instance);
+	}
+
+	/*
+	 * Initializes a region for one element.
+	 *
+	 * Params:
+	 * 	size = Aligned size of the first data block in the region.
+	 * 	head = Region list head.
+	 *
+	 * Returns: A pointer to the data.
+	 */
+	private static void* initializeRegion(size_t size, ref Region head)
+	nothrow @nogc
+	{
+		immutable regionSize = calculateRegionSize(size);
+		
+		version (Posix)
+		{
+			void* p = mmap(null,
+			               regionSize,
+			               PROT_READ | PROT_WRITE,
+			               MAP_PRIVATE | MAP_ANON,
+			               -1,
+			               0);
+			if (p is MAP_FAILED)
+			{
+				return null;
+			}
+		}
+		else version (Windows)
+		{
+			void* p = VirtualAlloc(null,
+			                       regionSize,
+			                       MEM_COMMIT,
+			                       PAGE_READWRITE);
+			if (p is null)
+			{
+				return null;
+			}
+		}
+
+		Region region = cast(Region) p;
+		region.blocks = 1;
+		region.size = regionSize;
+
+		// Set the pointer to the head of the region list
+		if (head !is null)
+		{
+			head.prev = region;
+		}
+		region.next = head;
+		region.prev = null;
+		head = region;
+
+		// Initialize the data block
+		void* memoryPointer = p + RegionEntry.sizeof;
+		Block block1 = cast(Block) memoryPointer;
+		block1.size = size;
+		block1.free = false;
+
+		// It is what we want to return
+		void* data = memoryPointer + BlockEntry.sizeof;
+
+		// Free block after data
+		memoryPointer = data + size;
+		Block block2 = cast(Block) memoryPointer;
+		block1.prev = block2.next = null;
+		block1.next = block2;
+		block2.prev = block1;
+		block2.size = regionSize - size - RegionEntry.sizeof - BlockEntry.sizeof * 2;
+		block2.free = true;
+		block1.region = block2.region = region;
+
+		return data;
+	}
+
+	private void* initializeRegion(size_t size) shared nothrow @nogc
+	{
+		return initializeRegion(size, head);
+	}
+
+	/*
+	 * Params:
+	 * 	x = Space to be aligned.
+	 *
+	 * Returns: Aligned size of $(D_PARAM x).
+	 */
+	private static immutable(size_t) addAlignment(size_t x)
+	pure nothrow @safe @nogc
+	out (result)
+	{
+		assert(result > 0);
+	}
+	body
+	{
+		return (x - 1) / alignment_ * alignment_ + alignment_;
+	}
+
+	/*
+	 * Params:
+	 * 	x = Required space.
+	 *
+	 * Returns: Minimum region size (a multiple of $(D_PSYMBOL pageSize)).
+	 */
+	private static immutable(size_t) calculateRegionSize(size_t x)
+	nothrow @safe @nogc
+	out (result)
+	{
+		assert(result > 0);
+	}
+	body
+	{
+		x += RegionEntry.sizeof + BlockEntry.sizeof * 2;
+		return x / pageSize * pageSize + pageSize;
+	}
+
+	/**
+	 * Returns: Alignment offered.
+	 */
+	@property uint alignment() shared const pure nothrow @safe @nogc
+	{
+		return alignment_;
+	}
+	private enum alignment_ = 8;
+
+	private shared static MmapPool instance_;
+	private shared static size_t pageSize;
+
+	private shared struct RegionEntry
+	{
+		Region prev;
+		Region next;
+		uint blocks;
+		size_t size;
+	}
+	private alias Region = shared RegionEntry*;
+	private shared Region head;
+
+	private shared struct BlockEntry
+	{
+		Block prev;
+		Block next;
+		Region region;
+		size_t size;
+		bool free;
+	}
+	private alias Block = shared BlockEntry*;
+}

source/tanya/memory/package.d

@@ -0,0 +1,234 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Copyright: Eugene Wissner 2016.
+ * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
+ *                  Mozilla Public License, v. 2.0).
+ * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
+ */
+module tanya.memory;
+
+import core.exception;
+public import std.experimental.allocator : make, makeArray;
+import std.traits;
+public import tanya.memory.allocator;
+public import tanya.memory.types;
+
+// From druntime
+private extern (C) void _d_monitordelete(Object h, bool det) nothrow @nogc;
+
+shared Allocator allocator;
+
+shared static this() nothrow @trusted @nogc
+{
+	import tanya.memory.mmappool;
+	allocator = MmapPool.instance;
+}
+
+@property ref shared(Allocator) defaultAllocator() nothrow @safe @nogc
+{
+	return allocator;
+}
+
+@property void defaultAllocator(shared(Allocator) allocator) nothrow @safe @nogc
+{
+	.allocator = allocator;
+}
+
+/**
+ * Returns the size in bytes of the state that needs to be allocated to hold an
+ * object of type $(D_PARAM T).
+ *
+ * Params:
+ * 	T = Object type.
+ */
+template stateSize(T)
+{
+	static if (is(T == class) || is(T == interface))
+	{
+		enum stateSize = __traits(classInstanceSize, T);
+	}
+	else
+	{
+		enum stateSize = T.sizeof;
+	}
+}
+
+/**
+ * Params:
+ * 	size      = Raw size.
+ * 	alignment = Alignment.
+ *
+ * Returns: Aligned size.
+ */
+size_t alignedSize(in size_t size, in size_t alignment = 8) pure nothrow @safe @nogc
+{
+	return (size - 1) / alignment * alignment + alignment;
+}
+
+/**
+ * Internal function used to create, resize or destroy a dynamic array. It
+ * throws $(D_PSYMBOL OutOfMemoryError) if $(D_PARAM Throws) is set. The new
+ * allocated part of the array is initialized only if $(D_PARAM Init) 
+ * is set. This function can be trusted only in the data structures that
+ * can ensure that the array is allocated/rellocated/deallocated with the
+ * same allocator.
+ *
+ * Params:
+ * 	T         = Element type of the array being created.
+ * 	Init      = If should be initialized.
+ * 	Throws    = If $(D_PSYMBOL OutOfMemoryError) should be throwsn.
+ * 	allocator = The allocator used for getting memory.
+ * 	array     = A reference to the array being changed.
+ * 	length    = New array length.
+ *
+ * Returns: $(D_KEYWORD true) upon success, $(D_KEYWORD false) if memory could
+ *          not be reallocated. In the latter
+ */
+package(tanya) bool resize(T,
+                           bool Init = true,
+                           bool Throws = true)
+                          (shared Allocator allocator,
+                           ref T[] array,
+                           in size_t length) @trusted
+{
+	void[] buf = array;
+	static if (Init)
+	{
+		immutable oldLength = array.length;
+	}
+	if (!allocator.reallocate(buf, length * T.sizeof))
+	{
+		static if (Throws)
+		{
+			onOutOfMemoryError;
+		}
+		return false;
+	}
+	// Casting from void[] is unsafe, but we know we cast to the original type.
+	array = cast(T[]) buf;
+
+	static if (Init)
+	{
+		if (oldLength < length)
+		{
+			array[oldLength .. $] = T.init;
+		}
+	}
+	return true;
+}
+package(tanya) alias resizeArray = resize;
+
+///
+unittest
+{
+	int[] p;
+
+	defaultAllocator.resizeArray(p, 20);
+	assert(p.length == 20);
+
+	defaultAllocator.resizeArray(p, 30);
+	assert(p.length == 30);
+
+	defaultAllocator.resizeArray(p, 10);
+	assert(p.length == 10);
+
+	defaultAllocator.resizeArray(p, 0);
+	assert(p is null);
+}
+
+/**
+ * Destroys and deallocates $(D_PARAM p) of type $(D_PARAM T).
+ * It is assumed the respective entities had been allocated with the same
+ * allocator.
+ *
+ * Params:
+ * 	T         = Type of $(D_PARAM p).
+ * 	allocator = Allocator the $(D_PARAM p) was allocated with.
+ * 	p         = Object or array to be destroyed.
+ */
+void dispose(T)(shared Allocator allocator, auto ref T* p)
+{
+	static if (hasElaborateDestructor!T)
+	{
+		destroy(*p);
+	}
+	() @trusted { allocator.deallocate((cast(void*) p)[0 .. T.sizeof]); }();
+	p = null;
+}
+
+/// Ditto.
+void dispose(T)(shared Allocator allocator, auto ref T p)
+	if (is(T == class) || is(T == interface))
+{
+	if (p is null)
+	{
+		return;
+	}
+	static if (is(T == interface))
+	{
+		version(Windows)
+		{
+			import core.sys.windows.unknwn : IUnknown;
+			static assert(!is(T: IUnknown), "COM interfaces can't be destroyed in "
+										 ~ __PRETTY_FUNCTION__);
+		}
+		auto ob = cast(Object) p;
+	}
+	else
+	{
+		alias ob = p;
+	}
+	auto ptr = cast(void *) ob;
+
+	auto support = ptr[0 .. typeid(ob).initializer.length];
+	scope (success)
+	{
+		() @trusted { allocator.deallocate(support); }();
+		p = null;
+	}
+
+	auto ppv = cast(void**) ptr;
+	if (!*ppv)
+	{
+		return;
+	}
+	auto pc = cast(ClassInfo*) *ppv;
+	scope (exit)
+	{
+		*ppv = null;
+	}
+
+	auto c = *pc;
+	do
+	{
+		// Assume the destructor is @nogc. Leave it nothrow since the destructor
+		// shouldn't throw and if it does, it is an error anyway.
+		if (c.destructor)
+		{
+			(cast(void function (Object) nothrow @safe @nogc) c.destructor)(ob);
+		}
+	}
+	while ((c = c.base) !is null);
+
+	if (ppv[1]) // if monitor is not null
+	{
+		_d_monitordelete(cast(Object) ptr, true);
+	}
+}
+
+/// Ditto.
+void dispose(T)(shared Allocator allocator, auto ref T[] array)
+{
+	static if (hasElaborateDestructor!(typeof(array[0])))
+	{
+	foreach (ref e; array)
+	{
+	    destroy(e);
+	}
+	}
+	() @trusted { allocator.deallocate(array); }();
+	array = null;
+}

source/tanya/memory/types.d

@@ -0,0 +1,458 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Copyright: Eugene Wissner 2016.
+ * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
+ *                  Mozilla Public License, v. 2.0).
+ * Authors: $(LINK2 mailto:belka@caraus.de, Eugene Wissner)
+ */
+module tanya.memory.types;
+
+import core.exception;
+import std.algorithm.comparison;
+import std.algorithm.mutation;
+import std.conv;
+import std.traits;
+import tanya.memory;
+
+/**
+ * Reference-counted object containing a $(D_PARAM T) value as payload.
+ * $(D_PSYMBOL RefCounted) keeps track of all references of an object, and
+ * when the reference count goes down to zero, frees the underlying store.
+ *
+ * Params:
+ * 	T = Type of the reference-counted value.
+ */
+struct RefCounted(T)
+{
+	static if (is(T == class) || is(T == interface))
+	{
+		private alias Payload = T;
+	}
+	else
+	{
+		private alias Payload = T*;
+	}
+
+	private class Storage
+	{
+		private Payload payload;
+		private size_t counter = 1;
+
+		private final size_t opUnary(string op)() pure nothrow @safe @nogc
+			if (op == "--" || op == "++")
+		in
+		{
+			assert(counter > 0);
+		}
+		body
+		{
+			mixin("return " ~ op ~ "counter;");
+		}
+
+		private final int opCmp(size_t counter) const pure nothrow @safe @nogc
+		{
+			if (this.counter > counter)
+			{
+				return 1;
+			}
+			else if (this.counter < counter)
+			{
+				return -1;
+			}
+			else
+			{
+				return 0;
+			}
+		}
+
+		private final int opEquals(size_t counter) const pure nothrow @safe @nogc
+		{
+			return this.counter == counter;
+		}
+	}
+
+	private final class RefCountedStorage : Storage
+	{
+		private shared Allocator allocator;
+
+		this(shared Allocator allocator) pure nothrow @safe @nogc
+		in
+		{
+			assert(allocator !is null);
+		}
+		body
+		{
+			this.allocator = allocator;
+		}
+
+		~this() nothrow @nogc
+		{
+			allocator.dispose(payload);
+		}
+	}
+
+	private Storage storage;
+
+	invariant
+	{
+		assert(storage is null || allocator_ !is null);
+	}
+
+	/**
+	 * Takes ownership over $(D_PARAM value), setting the counter to 1.
+	 * $(D_PARAM value) may be a pointer, an object or a dynamic array.
+	 *
+	 * Params:
+	 * 	value     = Value whose ownership is taken over.
+	 * 	allocator = Allocator used to destroy the $(D_PARAM value) and to
+	 * 	            allocate/deallocate internal storage.
+	 *
+	 * Precondition: $(D_INLINECODE allocator !is null)
+	 */
+	this(Payload value, shared Allocator allocator = defaultAllocator)
+	{
+		this(allocator);
+		storage = allocator.make!RefCountedStorage(allocator);
+		move(value, storage.payload);
+	}
+
+	/// Ditto.
+	this(shared Allocator allocator)
+	in
+	{
+		assert(allocator !is null);
+	}
+	body
+	{
+		this.allocator_ = allocator;
+	}
+
+	/**
+	 * Increases the reference counter by one.
+	 */
+	this(this)
+	{
+		if (count != 0)
+		{
+			++storage;
+		}
+	}
+
+	/**
+	 * Decreases the reference counter by one.
+	 *
+	 * If the counter reaches 0, destroys the owned object.
+	 */
+	~this()
+	{
+		if (storage !is null && !(storage.counter && --storage))
+		{
+			allocator_.dispose(storage);
+		}
+	}
+
+	/**
+	 * Takes ownership over $(D_PARAM rhs). Initializes this
+	 * $(D_PSYMBOL RefCounted) if needed.
+	 *
+	 * If it is the last reference of the previously owned object,
+	 * it will be destroyed.
+	 *
+	 * To reset the $(D_PSYMBOL RefCounted) assign $(D_KEYWORD null).
+	 *
+	 * If the allocator wasn't set before, $(D_PSYMBOL defaultAllocator) will
+	 * be used. If you need a different allocator, create a new
+	 * $(D_PSYMBOL RefCounted) and assign it.
+	 *
+	 * Params:
+	 * 	rhs = $(D_KEYWORD this).
+	 */
+	ref typeof(this) opAssign(Payload rhs)
+	{
+		if (storage is null)
+		{
+			storage = allocator.make!RefCountedStorage(allocator);
+		}
+		else if (storage > 1)
+		{
+			--storage;
+			storage = allocator.make!RefCountedStorage(allocator);
+		}
+		else if (cast(RefCountedStorage) storage is null)
+		{
+			// Created with refCounted. Always destroyed togethter with the pointer.
+			assert(storage.counter != 0);
+			allocator.dispose(storage);
+			storage = allocator.make!RefCountedStorage(allocator);
+		}
+		else
+		{
+			allocator.dispose(storage.payload);
+		}
+		move(rhs, storage.payload);
+		return this;
+	}
+
+	/// Ditto.
+	ref typeof(this) opAssign(typeof(null))
+	{
+		if (storage is null)
+		{
+			return this;
+		}
+		else if (storage > 1)
+		{
+			--storage;
+			storage = null;
+		}
+		else if (cast(RefCountedStorage) storage is null)
+		{
+			// Created with refCounted. Always destroyed togethter with the pointer.
+			assert(storage.counter != 0);
+			allocator.dispose(storage);
+			return this;
+		}
+		else
+		{
+			allocator.dispose(storage.payload);
+		}
+		return this;
+	}
+
+	/// Ditto.
+	ref typeof(this) opAssign(typeof(this) rhs)
+	{
+		swap(allocator_, rhs.allocator_);
+		swap(storage, rhs.storage);
+		return this;
+	}
+
+	/**
+	 * Returns: Reference to the owned object.
+	 */
+	inout(Payload) get() inout pure nothrow @safe @nogc
+	in
+	{
+		assert(count > 0, "Attempted to access an uninitialized reference.");
+	}
+	body
+	{
+		return storage.payload;
+	}
+
+	static if (isPointer!Payload)
+	{
+		/**
+		 * Params:
+		 * 	op = Operation. 
+		 *
+		 * Dereferences the pointer. It is defined only for pointers, not for
+		 * reference types like classes, that can be accessed directly.
+		 *
+		 * Returns: Reference to the pointed value.
+		 */
+		ref T opUnary(string op)()
+			if (op == "*")
+		{
+			return *storage.payload;
+		}
+	}
+
+	/**
+	 * Returns: Whether this $(D_PSYMBOL RefCounted) already has an internal 
+	 *          storage.
+	 */
+	@property bool isInitialized() const
+	{
+		return storage !is null;
+	}
+
+	/**
+	 * Returns: The number of $(D_PSYMBOL RefCounted) instances that share
+	 *          ownership over the same pointer (including $(D_KEYWORD this)).
+	 *          If this $(D_PSYMBOL RefCounted) isn't initialized, returns `0`.
+	 */
+	@property size_t count() const
+	{
+		return storage is null ? 0 : storage.counter;
+	}
+
+	mixin DefaultAllocator;
+	alias get this;
+}
+
+///
+unittest
+{
+	auto rc = RefCounted!int(defaultAllocator.make!int(5), defaultAllocator);
+	auto val = rc.get;
+
+	*val = 8;
+	assert(*rc.storage.payload == 8);
+
+	val = null;
+	assert(rc.storage.payload !is null);
+	assert(*rc.storage.payload == 8);
+
+	*rc = 9;
+	assert(*rc.storage.payload == 9);
+}
+
+version (unittest)
+{
+	private class A
+	{
+		uint *destroyed;
+
+		this(ref uint destroyed) @nogc
+		{
+			this.destroyed = &destroyed;
+		}
+
+		~this() @nogc
+		{
+			++(*destroyed);
+		}
+	}
+
+	private struct B
+	{
+		int prop;
+		@disable this();
+		this(int param1) @nogc
+		{
+			prop = param1;
+		}
+	}
+}
+
+private unittest
+{
+	uint destroyed;
+	auto a = defaultAllocator.make!A(destroyed);
+
+	assert(destroyed == 0);
+	{
+		auto rc = RefCounted!A(a, defaultAllocator);
+		assert(rc.count == 1);
+
+		void func(RefCounted!A rc)
+		{
+			assert(rc.count == 2);
+		}
+		func(rc);
+
+		assert(rc.count == 1);
+	}
+	assert(destroyed == 1);
+
+	RefCounted!int rc;
+	assert(rc.count == 0);
+	rc = defaultAllocator.make!int(8);
+	assert(rc.count == 1);
+}
+
+private unittest
+{
+	static assert(is(typeof(RefCounted!int.storage.payload) == int*));
+	static assert(is(typeof(RefCounted!A.storage.payload) == A));
+
+	static assert(is(RefCounted!B));
+	static assert(is(RefCounted!A));
+}
+
+/**
+ * Constructs a new object of type $(D_PARAM T) and wraps it in a
+ * $(D_PSYMBOL RefCounted) using $(D_PARAM args) as the parameter list for
+ * the constructor of $(D_PARAM T).
+ *
+ * This function is more efficient than the using of $(D_PSYMBOL RefCounted)
+ * directly, since it allocates only ones (the internal storage and the
+ * object).
+ *
+ * Params:
+ * 	T         = Type of the constructed object.
+ * 	A         = Types of the arguments to the constructor of $(D_PARAM T).
+ * 	allocator = Allocator.
+ * 	args      = Constructor arguments of $(D_PARAM T).
+ * 
+ * Returns: Newly created $(D_PSYMBOL RefCounted!T).
+ */
+RefCounted!T refCounted(T, A...)(shared Allocator allocator, auto ref A args)
+	if (!is(T == interface) && !isAbstractClass!T
+         && !isArray!T && !isAssociativeArray!T)
+{
+	auto rc = typeof(return)(allocator);
+
+	immutable storageSize = alignedSize(stateSize!(RefCounted!T.Storage));
+	immutable size = alignedSize(stateSize!T + storageSize);
+
+	auto mem = (() @trusted => allocator.allocate(size))();
+	if (mem is null)
+	{
+		onOutOfMemoryError();
+	}
+	scope (failure)
+	{
+		() @trusted { allocator.deallocate(mem); }();
+	}
+	rc.storage = emplace!(RefCounted!T.Storage)(mem[0 .. storageSize]);
+
+	static if (is(T == class))
+	{
+		rc.storage.payload = emplace!T(mem[storageSize .. $], args);
+	}
+	else
+	{
+		auto ptr = (() @trusted => (cast(T*) mem[storageSize .. $].ptr))();
+		rc.storage.payload = emplace!T(ptr, args);
+	}
+	return rc;
+}
+
+///
+unittest
+{
+	auto rc = defaultAllocator.refCounted!int(5);
+	assert(rc.count == 1);
+
+	void func(RefCounted!int param)
+	{
+		if (param.count == 2)
+		{
+			func(param);
+		}
+		else
+		{
+			assert(param.count == 3);
+		}
+	}
+	func(rc);
+
+	assert(rc.count == 1);
+}
+
+private @nogc unittest
+{
+	struct E
+	{
+	}
+	auto b = defaultAllocator.refCounted!B(15);
+	static assert(is(typeof(b.storage.payload) == B*));
+	static assert(is(typeof(b.prop) == int));
+	static assert(!is(typeof(defaultAllocator.refCounted!B())));
+
+	static assert(is(typeof(defaultAllocator.refCounted!E())));
+	static assert(!is(typeof(defaultAllocator.refCounted!E(5))));
+	{
+		auto rc = defaultAllocator.refCounted!B(3);
+		assert(rc.get.prop == 3);
+	}
+	{
+		auto rc = defaultAllocator.refCounted!E();
+		assert(rc.count);
+	}
+}

source/tanya/meta/gen.d

@@ -0,0 +1,49 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Templates that generate values.
+ *
+ * Copyright: Eugene Wissner 2016.
+ * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
+ *                  Mozilla Public License, v. 2.0).
+ * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
+ */
+module tanya.meta.gen;
+
+import std.traits;
+
+/**
+ * Initializer list.
+ *
+ * Generates a static array with elements from $(D_PARAM args). All elements
+ * should have the same type. It can be used in constructors which accept a
+ * list of the elements of the same type in the situations where variadic
+ * functions and templates can't be used.
+ *
+ * Params:
+ * 	Args = Argument type.
+ * 	args = Arguments.
+ */
+enum IL(Args...)(Args args)
+	if (Args.length > 0)
+{
+	alias BaseType = typeof(args[0]);
+
+	BaseType[args.length] result;
+
+	foreach (i, a; args)
+	{
+		static assert(isImplicitlyConvertible!(typeof(a), BaseType));
+		result[i] = a;
+	}
+	return result;
+}
+
+///
+unittest
+{
+	static assert(IL(1, 5, 8).length == 3);
+	static assert(IL(1, 5, 8).sizeof == 3 * int.sizeof);
+}

source/tanya/meta/package.d

@@ -3,13 +3,13 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /**
- * Copyright: Eugene Wissner 2018-2020.
+ * Metaprogramming.
+ *
+ * Copyright: Eugene Wissner 2016.
  * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
  *                  Mozilla Public License, v. 2.0).
  * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
- * Source: $(LINK2 https://github.com/caraus-ecms/tanya/blob/master/source/tanya/hash/package.d,
- *                 tanya/hash/package.d)
  */
-module tanya.hash;
+module tanya.meta;
 
-public import tanya.hash.lookup;
+public import tanya.meta.gen;

source/tanya/net/iface.d

@@ -1,178 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-/**
- * Network interfaces.
- *
- * Copyright: Eugene Wissner 2018-2020.
- * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
- *                  Mozilla Public License, v. 2.0).
- * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
- * Source: $(LINK2 https://github.com/caraus-ecms/tanya/blob/master/source/tanya/net/iface.d,
- *                 tanya/net/iface.d)
- */
-module tanya.net.iface;
-
-import tanya.algorithm.mutation;
-import tanya.container.string;
-import tanya.meta.trait;
-import tanya.meta.transform;
-import tanya.range;
-
-version (Windows)
-{
-    private union NET_LUID_LH { ulong Value, Info; }
-    private alias NET_LUID = NET_LUID_LH;
-    private alias NET_IFINDEX = uint;
-    private enum IF_MAX_STRING_SIZE = 256;
-    extern(Windows) @nogc nothrow private @system
-    {
-        uint ConvertInterfaceNameToLuidA(const(char)* InterfaceName,
-            NET_LUID* InterfaceLuid);
-        uint ConvertInterfaceLuidToIndex(const(NET_LUID)* InterfaceLuid,
-            NET_IFINDEX* InterfaceIndex);
-        uint ConvertInterfaceIndexToLuid(NET_IFINDEX InterfaceIndex,
-            NET_LUID* InterfaceLuid);
-        uint ConvertInterfaceLuidToNameA(const(NET_LUID)* InterfaceLuid,
-            char* InterfaceName,
-            size_t Length);
-    }
-}
-else version (Posix)
-{
-    import core.sys.posix.net.if_;
-}
-
-/**
- * Converts the name of a network interface to its index.
- *
- * If an interface with the name $(D_PARAM name) cannot be found or another
- * error occurres, returns 0.
- *
- * Params:
- *  name = Interface name.
- *
- * Returns: Returns interface index or 0.
- */
-uint nameToIndex(R)(R name) @trusted
-if (isInputRange!R && is(Unqual!(ElementType!R) == char) && hasLength!R)
-{
-    version (Windows)
-    {
-        if (name.length > IF_MAX_STRING_SIZE)
-        {
-            return 0;
-        }
-        char[IF_MAX_STRING_SIZE + 1] buffer;
-        NET_LUID luid;
-
-        copy(name, buffer[]);
-        buffer[name.length] = '\0';
-
-        if (ConvertInterfaceNameToLuidA(buffer.ptr, &luid) != 0)
-        {
-            return 0;
-        }
-        NET_IFINDEX index;
-        if (ConvertInterfaceLuidToIndex(&luid, &index) == 0)
-        {
-            return index;
-        }
-        return 0;
-    }
-    else version (Posix)
-    {
-        if (name.length >= IF_NAMESIZE)
-        {
-            return 0;
-        }
-        char[IF_NAMESIZE] buffer;
-
-        copy(name, buffer[]);
-        buffer[name.length] = '\0';
-
-        return if_nametoindex(buffer.ptr);
-    }
-}
-
-///
-@nogc nothrow @safe unittest
-{
-    version (linux)
-    {
-        assert(nameToIndex("lo") == 1);
-    }
-    else version (Windows)
-    {
-        assert(nameToIndex("loopback_0") == 1);
-    }
-    else
-    {
-        assert(nameToIndex("lo0") == 1);
-    }
-    assert(nameToIndex("ecafretni") == 0);
-}
-
-/**
- * Converts the index of a network interface to its name.
- *
- * If an interface with the $(D_PARAM index) cannot be found or another
- * error occurres, returns an empty $(D_PSYMBOL String).
- *
- * Params:
- *  index = Interface index.
- *
- * Returns: Returns interface name or an empty $(D_PSYMBOL String).
- */
-String indexToName(uint index) @nogc nothrow @trusted
-{
-    import tanya.memory.op : findNullTerminated;
-
-    version (Windows)
-    {
-        NET_LUID luid;
-        if (ConvertInterfaceIndexToLuid(index, &luid) != 0)
-        {
-            return String();
-        }
-
-        char[IF_MAX_STRING_SIZE + 1] buffer;
-        if (ConvertInterfaceLuidToNameA(&luid,
-                                        buffer.ptr,
-                                        IF_MAX_STRING_SIZE + 1) != 0)
-        {
-            return String();
-        }
-        return String(findNullTerminated(buffer));
-    }
-    else version (Posix)
-    {
-        char[IF_NAMESIZE] buffer;
-        if (if_indextoname(index, buffer.ptr) is null)
-        {
-            return String();
-        }
-        return String(findNullTerminated(buffer));
-    }
-}
-
-/**
- * $(D_PSYMBOL AddressFamily) specifies a communication domain; this selects
- * the protocol family which will be used for communication.
- */
-enum AddressFamily : int
-{
-    unspec    = 0,     /// Unspecified.
-    local     = 1,     /// Local to host (pipes and file-domain).
-    unix      = local, /// POSIX name for PF_LOCAL.
-    inet      = 2,     /// IP protocol family.
-    ax25      = 3,     /// Amateur Radio AX.25.
-    ipx       = 4,     /// Novell Internet Protocol.
-    appletalk = 5,     /// Appletalk DDP.
-    netrom    = 6,     /// Amateur radio NetROM.
-    bridge    = 7,     /// Multiprotocol bridge.
-    atmpvc    = 8,     /// ATM PVCs.
-    x25       = 9,     /// Reserved for X.25 project.
-    inet6     = 10,    /// IP version 6.
-}

source/tanya/net/inet.d

@@ -1,236 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-/**
- * Internet utilities.
- *
- * Copyright: Eugene Wissner 2016-2020.
- * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
- *                  Mozilla Public License, v. 2.0).
- * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
- * Source: $(LINK2 https://github.com/caraus-ecms/tanya/blob/master/source/tanya/net/inet.d,
- *                 tanya/net/inet.d)
- */
-module tanya.net.inet;
-
-import tanya.meta.trait;
-import tanya.meta.transform;
-import tanya.range;
-
-/**
- * Represents an unsigned integer as an $(D_KEYWORD ubyte) range.
- *
- * The range is bidirectional. The byte order is always big-endian.
- *
- * It can accept any unsigned integral type but the value should fit
- * in $(D_PARAM L) bytes.
- *
- * Params:
- *  L = Desired range length.
- */
-struct NetworkOrder(uint L)
-if (L > ubyte.sizeof && L <= ulong.sizeof)
-{
-    static if (L > uint.sizeof)
-    {
-        private alias StorageType = ulong;
-    }
-    else static if (L > ushort.sizeof)
-    {
-        private alias StorageType = uint;
-    }
-    else static if (L > ubyte.sizeof)
-    {
-        private alias StorageType = ushort;
-    }
-    else
-    {
-        private alias StorageType = ubyte;
-    }
-
-    private StorageType value;
-    private size_t size = L;
-
-    invariant
-    {
-        assert(this.size <= L);
-    }
-
-    /**
-     * Constructs a new range.
-     *
-     * $(D_PARAM T) can be any unsigned type but $(D_PARAM value) cannot be
-     * larger than the maximum can be stored in $(D_PARAM L) bytes. Otherwise
-     * an assertion failure will be caused.
-     *
-     * Params:
-     *  T      = Value type.
-     *  value  = The value should be represented by this range.
-     *
-     * Precondition: $(D_INLINECODE value <= (2 ^^ (L * 8)) - 1).
-     */
-    this(T)(T value)
-    if (isUnsigned!T)
-    in
-    {
-        assert(value <= (2 ^^ (L * 8)) - 1);
-    }
-    do
-    {
-        this.value = value & StorageType.max;
-    }
-
-    /**
-     * Returns: LSB.
-     *
-     * Precondition: $(D_INLINECODE length > 0).
-     */
-    @property ubyte back() const
-    in
-    {
-        assert(this.length > 0);
-    }
-    do
-    {
-        return this.value & 0xff;
-    }
-
-    /**
-     * Returns: MSB.
-     *
-     * Precondition: $(D_INLINECODE length > 0).
-     */
-    @property ubyte front() const
-    in
-    {
-        assert(this.length > 0);
-    }
-    do
-    {
-        return (this.value >> ((this.length - 1) * 8)) & 0xff;
-    }
-
-    /**
-     * Eliminates the LSB.
-     *
-     * Precondition: $(D_INLINECODE length > 0).
-     */
-    void popBack()
-    in
-    {
-        assert(this.length > 0);
-    }
-    do
-    {
-        this.value >>= 8;
-        --this.size;
-    }
-
-    /**
-     * Eliminates the MSB.
-     *
-     * Precondition: $(D_INLINECODE length > 0).
-     */
-    void popFront()
-    in
-    {
-        assert(this.length > 0);
-    }
-    do
-    {
-        this.value &= StorageType.max >> ((StorageType.sizeof - this.length) * 8);
-        --this.size;
-    }
-
-    /**
-     * Returns: Copy of this range.
-     */
-    typeof(this) save() const
-    {
-        return this;
-    }
-
-    /**
-     * Returns: Whether the range is empty.
-     */
-    @property bool empty() const
-    {
-        return this.length == 0;
-    }
-
-    /**
-     * Returns: Byte length.
-     */
-    @property size_t length() const
-    {
-        return this.size;
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    auto networkOrder = NetworkOrder!3(0xae34e2u);
-    assert(!networkOrder.empty);
-    assert(networkOrder.front == 0xae);
-
-    networkOrder.popFront();
-    assert(networkOrder.length == 2);
-    assert(networkOrder.front == 0x34);
-    assert(networkOrder.back == 0xe2);
-
-    networkOrder.popBack();
-    assert(networkOrder.length == 1);
-    assert(networkOrder.front == 0x34);
-    assert(networkOrder.front == 0x34);
-
-    networkOrder.popFront();
-    assert(networkOrder.empty);
-}
-
-/**
- * Converts the $(D_KEYWORD ubyte) input range $(D_PARAM range) to
- * $(D_PARAM T).
- *
- * The byte order of $(D_PARAM r) is assumed to be big-endian. The length
- * cannot be larger than $(D_INLINECODE T.sizeof). Otherwise an assertion
- * failure will be caused.
- *
- * Params:
- *  T     = Desired return type.
- *  R     = Range type.
- *  range = Input range.
- *
- * Returns: Integral representation of $(D_PARAM range) with the host byte
- *          order.
- */
-T toHostOrder(T = size_t, R)(R range)
-if (isInputRange!R
- && !isInfinite!R
- && is(Unqual!(ElementType!R) == ubyte)
- && isUnsigned!T)
-{
-    T ret;
-    ushort pos = T.sizeof * 8;
-
-    for (; !range.empty && range.front == 0; pos -= 8, range.popFront())
-    {
-    }
-    for (; !range.empty; range.popFront())
-    {
-        assert(pos != 0);
-        pos -= 8;
-        ret |= (cast(T) range.front) << pos;
-    }
-
-    return ret >> pos;
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    const value = 0xae34e2u;
-    auto networkOrder = NetworkOrder!4(value);
-    assert(networkOrder.toHostOrder() == value);
-}

source/tanya/net/package.d

@@ -1,20 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-/**
- * Network programming.
- *
- * Copyright: Eugene Wissner 2017-2022.
- * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
- *                  Mozilla Public License, v. 2.0).
- * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
- * Source: $(LINK2 https://github.com/caraus-ecms/tanya/blob/master/source/tanya/net/package.d,
- *                 tanya/net/package.d)
- */
-module tanya.net;
-
-public import tanya.net.iface;
-public import tanya.net.inet;
-public import tanya.net.ip;
-public import tanya.net.uri;

source/tanya/net/uri.d

@@ -1,411 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-/**
- * URL parser.
- *
- * Copyright: Eugene Wissner 2017-2020.
- * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
- *                  Mozilla Public License, v. 2.0).
- * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
- * Source: $(LINK2 https://github.com/caraus-ecms/tanya/blob/master/source/tanya/net/uri.d,
- *                 tanya/net/uri.d)
- */
-module tanya.net.uri;
-
-import std.ascii;
-import tanya.conv;
-import tanya.memory.allocator;
-
-/**
- * Thrown if an invalid URI was specified.
- */
-final class URIException : Exception
-{
-    /**
-     * Params:
-     *  msg  = The message for the exception.
-     *  file = The file where the exception occurred.
-     *  line = The line number where the exception occurred.
-     *  next = The previous exception in the chain of exceptions, if any.
-     */
-    this(string msg,
-         string file = __FILE__,
-         size_t line = __LINE__,
-         Throwable next = null) @nogc nothrow pure @safe
-    {
-        super(msg, file, line, next);
-    }
-}
-
-/**
- * A Unique Resource Locator.
- */
-struct URL
-{
-    /// The URL scheme.
-    const(char)[] scheme;
-
-    /// The username.
-    const(char)[] user;
-
-    /// The password.
-    const(char)[] pass;
-
-    /// The hostname.
-    const(char)[] host;
-
-    /// The port number.
-    ushort port;
-
-    /// The path.
-    const(char)[] path;
-
-    /// The query string.
-    const(char)[] query;
-
-    /// The anchor.
-    const(char)[] fragment;
-
-    /**
-     * Attempts to parse an URL from a string.
-     * Output string data (scheme, user, etc.) are just slices of input string
-     * (i.e., no memory allocation and copying).
-     *
-     * Params:
-     *  source = The string containing the URL.
-     *
-     * Throws: $(D_PSYMBOL URIException) if the URL is malformed.
-     */
-    this(const char[] source) @nogc pure
-    {
-        ptrdiff_t pos = -1, endPos = source.length, start;
-
-        foreach (i, ref c; source)
-        {
-            if (pos == -1 && c == ':')
-            {
-                pos = i;
-            }
-            if (endPos == source.length && (c == '?' || c == '#'))
-            {
-                endPos = i;
-            }
-        }
-
-        // Check if the colon is a part of the scheme or the port and parse
-        // the appropriate part.
-        if (source.length > 1 && source[0] == '/' && source[1] == '/')
-        {
-            // Relative scheme.
-            start = 2;
-        }
-        else if (pos > 0)
-        {
-            // Validate scheme:
-            // [ toLower(alpha) | digit | "+" | "-" | "." ]
-            foreach (ref c; source[0 .. pos])
-            {
-                if (!c.isAlphaNum && c != '+' && c != '-' && c != '.')
-                {
-                    goto ParsePath;
-                }
-            }
-
-            if (source.length == pos + 1) // only "scheme:" is available.
-            {
-                this.scheme = source[0 .. $ - 1];
-                return;
-            }
-            else if (source.length > pos + 1 && source[pos + 1] == '/')
-            {
-                this.scheme = source[0 .. pos];
-
-                if (source.length > pos + 2 && source[pos + 2] == '/')
-                {
-                    start = pos + 3;
-
-                    if (source.length <= start)
-                    {
-                        // Only "scheme://" is available.
-                        return;
-                    }
-                    if (this.scheme == "file" && source[start] == '/')
-                    {
-                        // Windows drive letters.
-                        if (source.length - start > 2
-                         && source[start + 2] == ':')
-                        {
-                            ++start;
-                        }
-                        goto ParsePath;
-                    }
-                }
-                else
-                {
-                    start = pos + 1;
-                    goto ParsePath;
-                }
-            }
-            else if (!parsePort(source[pos .. $]))
-            {
-                // Schemas like mailto: and zlib: may not have any slash after
-                // them.
-                this.scheme = source[0 .. pos];
-                start = pos + 1;
-                goto ParsePath;
-            }
-        }
-        else if (pos == 0 && parsePort(source[pos .. $]))
-        {
-            // An URL shouldn't begin with a port number.
-            throw defaultAllocator.make!URIException("URL begins with port");
-        }
-        else
-        {
-            goto ParsePath;
-        }
-
-        // Parse host.
-        pos = -1;
-        for (ptrdiff_t i = start; i < source.length; ++i)
-        {
-            if (source[i] == '@')
-            {
-                pos = i;
-            }
-            else if (source[i] == '/')
-            {
-                endPos = i;
-                break;
-            }
-        }
-
-        // Check for login and password.
-        if (pos != -1)
-        {
-            // *( unreserved / pct-encoded / sub-delims / ":" )
-            foreach (i, c; source[start .. pos])
-            {
-                if (c == ':')
-                {
-                    if (this.user is null)
-                    {
-                        this.user = source[start .. start + i];
-                        this.pass = source[start + i + 1 .. pos]; 
-                    }
-                }
-                else if (!c.isAlpha() &&
-                         !c.isDigit() &&
-                         c != '!' &&
-                         c != ';' &&
-                         c != '=' &&
-                         c != '_' &&
-                         c != '~' &&
-                         !(c >= '$' && c <= '.'))
-                {
-                    this.scheme = this.user = this.pass = null;
-                    throw make!URIException(defaultAllocator,
-                                            "Restricted characters in user information");
-                }
-            }
-            if (this.user is null)
-            {
-                this.user = source[start .. pos];
-            }
-
-            start = ++pos;
-        }
-
-        pos = endPos;
-        if (endPos <= 1 || source[start] != '[' || source[endPos - 1] != ']')
-        {
-            // Short circuit portscan.
-            // IPv6 embedded address.
-            for (ptrdiff_t i = endPos - 1; i >= start; --i)
-            {
-                if (source[i] == ':')
-                {
-                    pos = i;
-                    if  (this.port == 0 && !parsePort(source[i .. endPos]))
-                    {
-                        this.scheme = this.user = this.pass = null;
-                        throw defaultAllocator.make!URIException("Invalid port");
-                    }
-                    break;
-                }
-            }
-        }
-
-        // Check if we have a valid host, if we don't reject the string as URL.
-        if (pos <= start)
-        {
-            this.scheme = this.user = this.pass = null;
-            throw defaultAllocator.make!URIException("Invalid host");
-        }
-
-        this.host = source[start .. pos];
-
-        if (endPos == source.length)
-        {
-            return;
-        }
-
-        start = endPos;
-
-    ParsePath:
-        endPos = source.length;
-        pos = -1;
-        foreach (i, ref c; source[start .. $])
-        {
-            if (c == '?' && pos == -1)
-            {
-                pos = start + i;
-            }
-            else if (c == '#')
-            {
-                endPos = start + i;
-                break;
-            }
-        }
-        if (pos == -1)
-        {
-            pos = endPos;
-        }
-
-        if (pos > start)
-        {
-            this.path = source[start .. pos];
-        }
-        if (endPos >= ++pos)
-        {
-            this.query = source[pos .. endPos];
-        }
-        if (++endPos <= source.length)
-        {
-            this.fragment = source[endPos .. $];
-        }
-    }
-
-    /*
-     * Attempts to parse and set the port.
-     *
-     * Params:
-     *  port = String beginning with a colon followed by the port number and
-     *         an optional path (query string and/or fragment), like:
-     *         `:12345/some_path` or `:12345`.
-     *
-     * Returns: Whether the port could be found.
-     */
-    private bool parsePort(const(char)[] port) @nogc nothrow pure @safe
-    {
-        auto unparsed = port[1 .. $];
-        auto parsed = readIntegral!ushort(unparsed);
-        if (unparsed.length == 0 || unparsed[0] == '/')
-        {
-            this.port = parsed;
-            return true;
-        }
-        return false;
-    }
-}
-
-///
-@nogc pure @system unittest
-{
-    auto u = URL("example.org");
-    assert(u.path == "example.org"); 
-
-    u = URL("relative/path");
-    assert(u.path == "relative/path"); 
-
-    // Host and scheme
-    u = URL("https://example.org");
-    assert(u.scheme == "https");
-    assert(u.host == "example.org");
-    assert(u.path is null);
-    assert(u.port == 0);
-    assert(u.fragment is null);
-
-    // With user and port and path
-    u = URL("https://hilary:putnam@example.org:443/foo/bar");
-    assert(u.scheme == "https");
-    assert(u.host == "example.org");
-    assert(u.path == "/foo/bar");
-    assert(u.port == 443);
-    assert(u.user == "hilary");
-    assert(u.pass == "putnam");
-    assert(u.fragment is null);
-
-    // With query string
-    u = URL("https://example.org/?login=true");
-    assert(u.scheme == "https");
-    assert(u.host == "example.org");
-    assert(u.path == "/");
-    assert(u.query == "login=true");
-    assert(u.fragment is null);
-
-    // With query string and fragment
-    u = URL("https://example.org/?login=false#label");
-    assert(u.scheme == "https");
-    assert(u.host == "example.org");
-    assert(u.path == "/");
-    assert(u.query == "login=false");
-    assert(u.fragment == "label");
-
-    u = URL("redis://root:password@localhost:2201/path?query=value#fragment");
-    assert(u.scheme == "redis");
-    assert(u.user == "root");
-    assert(u.pass == "password");
-    assert(u.host == "localhost");
-    assert(u.port == 2201);
-    assert(u.path == "/path");
-    assert(u.query == "query=value");
-    assert(u.fragment == "fragment");
-}
-
-/**
- * Attempts to parse an URL from a string and returns the specified component
- * of the URL or $(D_PSYMBOL URL) if no component is specified.
- *
- * Params:
- *  T      = "scheme", "host", "port", "user", "pass", "path", "query",
- *           "fragment".
- *  source = The string containing the URL.
- *
- * Returns: Requested URL component.
- */
-auto parseURL(string T)(const char[] source)
-if (T == "scheme"
- || T == "host"
- || T == "user"
- || T == "pass"
- || T == "path"
- || T == "query"
- || T == "fragment"
- || T == "port")
-{
-    auto ret = URL(source);
-    return mixin("ret." ~ T);
-}
-
-/// ditto
-URL parseURL(const char[] source) @nogc pure
-{
-    return URL(source);
-}
-
-///
-@nogc pure @system unittest
-{
-    auto u = parseURL("http://example.org:5326");
-    assert(u.scheme == parseURL!"scheme"("http://example.org:5326"));
-    assert(u.host == parseURL!"host"("http://example.org:5326"));
-    assert(u.user == parseURL!"user"("http://example.org:5326"));
-    assert(u.pass == parseURL!"pass"("http://example.org:5326"));
-    assert(u.path == parseURL!"path"("http://example.org:5326"));
-    assert(u.query == parseURL!"query"("http://example.org:5326"));
-    assert(u.fragment == parseURL!"fragment"("http://example.org:5326"));
-    assert(u.port == parseURL!"port"("http://example.org:5326"));
-}

source/tanya/range/adapter.d

@@ -1,208 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-/**
- * Range adapters transform some data structures into ranges.
- *
- * Copyright: Eugene Wissner 2018-2020.
- * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
- *                  Mozilla Public License, v. 2.0).
- * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
- * Source: $(LINK2 https://github.com/caraus-ecms/tanya/blob/master/source/tanya/range/adapter.d,
- *                 tanya/range/adapter.d)
- */
-module tanya.range.adapter;
-
-import tanya.algorithm.mutation;
-import tanya.memory.lifetime;
-import tanya.meta.trait;
-import tanya.range;
-
-private mixin template InserterCtor()
-{
-    private Container* container;
-
-    private this(return scope ref Container container) @trusted
-    {
-        this.container = &container;
-    }
-}
-
-/**
- * If $(D_PARAM container) is a container with `insertBack`-support,
- * $(D_PSYMBOL backInserter) returns an output range that puts the elements
- * into the container with `insertBack`.
- *
- * The resulting output range supports all types `insertBack` supports.
- *
- * The range keeps a reference to the container passed to it, it doesn't use
- * any other storage. So there is no method to get the written data out of the
- * range - the container passed to $(D_PSYMBOL backInserter) contains that data
- * and can be used directly after all operations on the output range are
- * completed. It also means that the result range is not allowed to outlive its
- * container.
- *
- * Params:
- *  Container = Container type.
- *  container = Container used as an output range.
- *
- * Returns: `insertBack`-based output range.
- */
-auto backInserter(Container)(return scope ref Container container)
-if (hasMember!(Container, "insertBack"))
-{
-    static struct Inserter
-    {
-        void opCall(T)(auto ref T data)
-        {
-            this.container.insertBack(forward!data);
-        }
-
-        mixin InserterCtor;
-    }
-    return Inserter(container);
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static struct Container
-    {
-        int element;
-
-        void insertBack(int element)
-        {
-            this.element = element;
-        }
-    }
-    Container container;
-    backInserter(container)(5);
-
-    assert(container.element == 5);
-}
-
-/**
- * If $(D_PARAM container) is a container with `insertFront`-support,
- * $(D_PSYMBOL frontInserter) returns an output range that puts the elements
- * into the container with `insertFront`.
- *
- * The resulting output range supports all types `insertFront` supports.
- *
- * The range keeps a reference to the container passed to it, it doesn't use
- * any other storage. So there is no method to get the written data out of the
- * range - the container passed to $(D_PSYMBOL frontInserter) contains that data
- * and can be used directly after all operations on the output range are
- * completed. It also means that the result range is not allowed to outlive its
- * container.
- *
- * Params:
- *  Container = Container type.
- *  container = Container used as an output range.
- *
- * Returns: `insertFront`-based output range.
- */
-auto frontInserter(Container)(return scope ref Container container)
-if (hasMember!(Container, "insertFront"))
-{
-    static struct Inserter
-    {
-        void opCall(T)(auto ref T data)
-        {
-            this.container.insertFront(forward!data);
-        }
-
-        mixin InserterCtor;
-    }
-    return Inserter(container);
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static struct Container
-    {
-        int element;
-
-        void insertFront(int element)
-        {
-            this.element = element;
-        }
-    }
-    Container container;
-    frontInserter(container)(5);
-
-    assert(container.element == 5);
-}
-
-/**
- * $(D_PSYMBOL arrayInserter) makes an output range out of an array.
- *
- * The returned output range accepts single values as well as input ranges that
- * can be copied into the target array.
- *
- * Params:
- *  Array = Array type.
- *  array = Array.
- *
- * Returns: An output range writing into $(D_PARAM array).
- */
-auto arrayInserter(Array)(return scope ref Array array)
-if (isArray!Array)
-{
-    static if (is(Array ArrayT : ArrayT[size], size_t size))
-    {
-        alias E = ArrayT;
-    }
-    else
-    {
-        alias E = ElementType!Array;
-    }
-
-    static struct ArrayInserter
-    {
-        private E[] data;
-
-        private this(return scope ref Array data) @trusted
-        {
-            this.data = data[];
-        }
-
-        void opCall(T)(auto ref T data)
-        if (is(T : E))
-        in
-        {
-            assert(!this.data.empty);
-        }
-        do
-        {
-            put(this.data, data);
-        }
-
-        void opCall(R)(auto ref R data)
-        if (isInputRange!R && isOutputRange!(E[], ElementType!R))
-        {
-            this.data = copy(data, this.data);
-        }
-    }
-    return ArrayInserter(array);
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    int[1] array;
-
-    arrayInserter(array)(5);
-    assert(array[0] == 5);
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    char[1] array;
-    alias Actual = typeof(arrayInserter(array));
-
-    static assert(isOutputRange!(Actual, char));
-    static assert(isOutputRange!(Actual, char[]));
-}

source/tanya/range/array.d

@@ -1,220 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-/**
- * $(D_PSYMBOL tanya.range.array) implements range primitives for built-in arrays.
- *
- * This module is a submodule of
- * $(LINK2 https://github.com/caraus-ecms/tanya/blob/master/source/tanya/range/package.d, tanya.range).
- *
- * After importing of
- * $(LINK2 https://github.com/caraus-ecms/tanya/blob/master/source/tanya/range/array.d, tanya/range/array.d)
- * built-in arrays can act as bidirectional ranges. For that to work the module
- * defines a set of functions that accept a built-in array of any type as their
- * first argument, so thanks to UFCS (Uniform Function Call Syntax) they can be
- * called as if they were array member functions. For example the arrays the
- * `.length`-property, but no `.empty` property. So here can be find the
- * $(D_PSYMBOL empty) function. Since $(D_INLINECODE empty(array)) and
- * $(D_INLINECODE array.empty) are equal for the arrays, arrays get a faked
- * property `empty`.
- *
- * The functions in this module don't change array elements or its underlying
- * storage, but some functions alter the slice. Each array maintains a pointer
- * to its data and the length and there can be several pointers which point to
- * the same data. Array pointer can be advanced and the length can be reduced
- * without changing the underlying storage. So slices offer the possibility to
- * have multiple views into the same array, point to different positions inside
- * it.
- *
- * Strings ($(D_INLINECODE char[]), (D_INLINECODE wchar[]) and
- * (D_INLINECODE dchar[])) are treated as any other normal array, they aren't
- * auto-decoded.
- *
- * Copyright: Eugene Wissner 2017-2020.
- * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
- *                  Mozilla Public License, v. 2.0).
- * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
- * Source: $(LINK2 https://github.com/caraus-ecms/tanya/blob/master/source/tanya/range/array.d,
- *                 tanya/range/array.d)
- */
-module tanya.range.array;
-
-/**
- * Returns the first element of the $(D_PARAM array).
- *
- * The element is returned by reference, so $(D_PSYMBOL front) can be also used
- * to change the first element of $(D_PARAM array) if it is mutable.
- *
- * Params:
- *  T     = Element type of $(D_PARAM array).
- *  array = Built-in array.
- *
- * Returns: First element.
- *
- * Precondition: $(D_INLINECODE array.length > 0).
- */
-@property ref inout(T) front(T)(return scope inout(T)[] array)
-in
-{
-    assert(array.length > 0);
-}
-do
-{
-    return array[0];
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    string s = "Wenn die Wunde nicht mehr wehtut, schmerzt die Narbe";
-    static assert(is(typeof(s.front) == immutable char));
-    assert(s.front == 'W');
-
-    wstring w = "Волны несутся, гремя и сверкая";
-    static assert(is(typeof(w.front) == immutable wchar));
-    assert(w.front == 'В');
-
-    dstring d = "Для писателя память - это почти все";
-    static assert(is(typeof(d.front) == immutable dchar));
-    assert(d.front == 'Д');
-}
-
-/**
- * Returns the last element of the $(D_PARAM array).
- *
- * The element is returned by reference, so $(D_PSYMBOL back) can be also used
- * to change the last element of $(D_PARAM array) if it is mutable.
- *
- * Params:
- *  T     = Element type of $(D_PARAM array).
- *  array = Built-in array.
- *
- * Returns: Last element.
- *
- * Precondition: $(D_INLINECODE array.length > 0).
- */
-@property ref inout(T) back(T)(return scope inout(T)[] array)
-in
-{
-    assert(array.length > 0);
-}
-do
-{
-    return array[$ - 1];
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    string s = "Brecht";
-    static assert(is(typeof(s.back) == immutable char));
-    assert(s.back == 't');
-
-    wstring w = "Тютчев";
-    static assert(is(typeof(w.back) == immutable wchar));
-    assert(w.back == 'в');
-
-    dstring d = "Паустовский";
-    static assert(is(typeof(d.back) == immutable dchar));
-    assert(d.back == 'й');
-}
-
-/**
- * $(D_PSYMBOL popFront) and $(D_PSYMBOL popBack) advance the $(D_PARAM array)
- * and remove one element from its back, respectively.
- *
- * $(D_PSYMBOL popFront) and $(D_PSYMBOL popBack) don't alter the array
- * storage, they only narrow the view into the array.
- *
- * Params:
- *  T     = Element type of $(D_PARAM array).
- *  array = Built-in array.
- *
- * Precondition: $(D_INLINECODE array.length > 0).
- */
-void popFront(T)(ref inout(T)[] array)
-in
-{
-    assert(array.length > 0);
-}
-do
-{
-    array = array[1 .. $];
-}
-
-/// ditto
-void popBack(T)(ref inout(T)[] array)
-in
-{
-    assert(array.length > 0);
-}
-do
-{
-    array = array[0 .. $ - 1];
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    wstring array = "Der finstere Ozean der Metaphysik. Nietzsche";
-
-    array.popFront();
-    assert(array.length == 43);
-    assert(array.front == 'e');
-
-    array.popBack();
-    assert(array.length == 42);
-    assert(array.back == 'h');
-}
-
-/**
- * Tests whether $(D_PARAM array) is empty.
- *
- * Params:
- *  T     = Element type of $(D_PARAM array).
- *  array = Built-in array.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM array) has no elements,
- *          $(D_KEYWORD false) otherwise.
- */
-@property bool empty(T)(scope const T[] array)
-{
-    return array.length == 0;
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    int[1] array;
-    assert(!array.empty);
-    assert(array[1 .. 1].empty);
-}
-
-/**
- * Returns a copy of the slice $(D_PARAM array).
- *
- * $(D_PSYMBOL save) doesn't copy the array itself, but only the data pointer
- * and the length.
- *
- * Params:
- *  T     = Element type of $(D_PARAM array).
- *  array = Built-in array.
- *
- * Returns: A copy of the slice $(D_PARAM array).
- */
-@property inout(T)[] save(T)(return scope inout(T)[] array)
-{
-    return array;
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    ubyte[8] array;
-    auto slice = array.save;
-
-    assert(slice.length == array.length);
-    slice.popFront();
-    assert(slice.length < array.length);
-}

source/tanya/range/package.d

@@ -1,20 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-/**
- * This package contains generic functions and templates to be used with D
- * ranges.
- *
- * Copyright: Eugene Wissner 2017-2020.
- * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
- *                  Mozilla Public License, v. 2.0).
- * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
- * Source: $(LINK2 https://github.com/caraus-ecms/tanya/blob/master/source/tanya/range/package.d,
- *                 tanya/range/package.d)
- */
-module tanya.range;
-
-public import tanya.range.adapter;
-public import tanya.range.array;
-public import tanya.range.primitive;

test/dub.json

@@ -1,17 +0,0 @@
-{
-	"name": "test",
-	"description": "Test suite for unittest-blocks",
-	"targetType": "library",
-
-	"dependencies": {
-		"tanya:middle": "*"
-	},
-
-	"sourcePaths": [
-		"."
-	],
-	"importPaths": [
-		"."
-	],
-	"dflags-dmd": ["-dip1000"]
-}

test/tanya/test/assertion.d

@@ -1,105 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-/**
- * Additional assertions.
- *
- * This module provides functions that assert whether a given expression
- * satisfies some complex condition, that can't be tested with
- * $(D_KEYWORD assert) in a single line. Internally all the functions
- * just evaluate the expression and call $(D_KEYWORD assert).
- *
- * The functions can cause segmentation fault if the module is compiled
- * in production mode and the condition fails.
- *
- * Copyright: Eugene Wissner 2017-2020.
- * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
- *                  Mozilla Public License, v. 2.0).
- * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
- * Source: $(LINK2 https://github.com/caraus-ecms/tanya/blob/master/source/tanya/test/assertion.d,
- *                 tanya/test/assertion.d)
- */
-module tanya.test.assertion;
-
-import tanya.memory.allocator;
-import tanya.meta.trait;
-
-/**
- * Asserts whether the function $(D_PARAM expr) throws an exception of type
- * $(D_PARAM E). If it does, the exception is catched and properly destroyed.
- * If it doesn't, an assertion error is thrown. If the exception doesn't match
- * $(D_PARAM E) type, it isn't catched and escapes.
- *
- * Params:
- *  E    = Expected exception type.
- *  T    = Throwing function type.
- *  Args = Argument types of the throwing function.
- *  expr = Throwing function.
- *  args = Arguments for $(D_PARAM expr).
- */
-void assertThrown(E : Exception, T, Args...)(T expr, auto ref Args args)
-if (isSomeFunction!T)
-{
-    try
-    {
-        cast(void) expr(args);
-        assert(false, "Expected exception not thrown");
-    }
-    catch (E exception)
-    {
-        defaultAllocator.dispose(exception);
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    // If you want to test that an expression throws, you can wrap it into an
-    // arrow function.
-    static struct CtorThrows
-    {
-        this(int i) @nogc pure @safe
-        {
-            throw defaultAllocator.make!Exception();
-        }
-    }
-    assertThrown!Exception(() => CtorThrows(8));
-}
-
-/**
- * Asserts that the function $(D_PARAM expr) doesn't throw.
- *
- * If it does, the thrown exception is catched, properly destroyed and an
- * assertion error is thrown instead.
- *
- * Params:
- *  T    = Tested function type.
- *  Args = Argument types of $(D_PARAM expr).
- *  expr = Tested function.
- *  args = Arguments for $(D_PARAM expr).
- */
-void assertNotThrown(T, Args...)(T expr, auto ref Args args)
-if (isSomeFunction!T)
-{
-    try
-    {
-        cast(void) expr(args);
-    }
-    catch (Exception exception)
-    {
-        defaultAllocator.dispose(exception);
-        assert(false, "Unexpected exception thrown");
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    // If you want to test that an expression doesn't throw, you can wrap it
-    // into an arrow function.
-    static struct S
-    {
-    }
-    assertNotThrown(() => S());
-}

test/tanya/test/package.d

@@ -1,18 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-/**
- * Test suite for $(D_KEYWORD unittest)-blocks.
- *
- * Copyright: Eugene Wissner 2017-2020.
- * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
- *                  Mozilla Public License, v. 2.0).
- * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
- * Source: $(LINK2 https://github.com/caraus-ecms/tanya/blob/master/source/tanya/test/package.d,
- *                 tanya/test/package.d)
- */
-module tanya.test;
-
-public import tanya.test.assertion;
-public import tanya.test.stub;

test/tanya/test/stub.d

@@ -1,397 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-/**
- * Range and generic type generators.
- *
- * Copyright: Eugene Wissner 2018-2020.
- * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
- *                  Mozilla Public License, v. 2.0).
- * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
- * Source: $(LINK2 https://github.com/caraus-ecms/tanya/blob/master/source/tanya/test/stub.d,
- *                 tanya/test/stub.d)
- */
-module tanya.test.stub;
-
-/**
- * Attribute signalizing that the generated range should contain the given
- * number of elements.
- *
- * $(D_PSYMBOL Count) should be always specified with some value and not as a
- * type, so $(D_INLINECODE Count(1)) instead just $(D_INLINECODE Count),
- * otherwise you can just omit $(D_PSYMBOL Count) and it will default to 0.
- *
- * $(D_PSYMBOL Count) doesn't generate `.length` property - use
- * $(D_PSYMBOL Length) for that.
- *
- * If neither $(D_PSYMBOL Length) nor $(D_PSYMBOL Infinite) is given,
- * $(D_ILNINECODE Count(0)) is assumed.
- *
- * This attribute conflicts with $(D_PSYMBOL Infinite) and $(D_PSYMBOL Length).
- */
-struct Count
-{
-    /// Original range length.
-    size_t count = 0;
-
-    @disable this();
-
-    /**
-     * Constructs the attribute with the given length.
-     *
-     * Params:
-     *  count = Original range length.
-     */
-    this(size_t count) @nogc nothrow pure @safe
-    {
-        this.count = count;
-    }
-}
-
-/**
- * Attribute signalizing that the generated range should be infinite.
- *
- * This attribute conflicts with $(D_PSYMBOL Count) and $(D_PSYMBOL Length).
- */
-struct Infinite
-{
-}
-
-/**
- * Generates `.length` property for the range.
- *
- * The length of the range can be specified as a constructor argument,
- * otherwise it is 0.
- *
- * This attribute conflicts with $(D_PSYMBOL Count) and $(D_PSYMBOL Infinite).
- */
-struct Length
-{
-    /// Original range length.
-    size_t length = 0;
-}
-
-/**
- * Attribute signalizing that the generated range should return values by
- * reference.
- *
- * This atribute affects the return values of `.front`, `.back` and `[]`.
- */
-struct WithLvalueElements
-{
-}
-
-/**
- * Generates an input range.
- *
- * Params:
- *  E = Element type.
- */
-mixin template InputRangeStub(E = int)
-{
-    import tanya.meta.metafunction : Alias;
-    import tanya.meta.trait : evalUDA, getUDAs, hasUDA;
-
-    /*
-     * Aliases for the attribute lookups to access them faster
-     */
-    private enum bool infinite = hasUDA!(typeof(this), Infinite);
-    private enum bool withLvalueElements = hasUDA!(typeof(this),
-                                                   WithLvalueElements);
-    private alias Count = getUDAs!(typeof(this), .Count);
-    private alias Length = getUDAs!(typeof(this), .Length);
-
-    static if (Count.length != 0)
-    {
-        private enum size_t count = Count[0].count;
-
-        static assert (!infinite,
-                       "Range cannot have count and be infinite at the same time");
-        static assert (Length.length == 0,
-                       "Range cannot have count and length at the same time");
-    }
-    else static if (Length.length != 0)
-    {
-        private enum size_t count = evalUDA!(Length[0]).length;
-
-        static assert (!infinite,
-                       "Range cannot have length and be infinite at the same time");
-    }
-    else static if (!infinite)
-    {
-        private enum size_t count = 0;
-    }
-
-    /*
-     * Member generation
-     */
-    static if (infinite)
-    {
-        enum bool empty = false;
-    }
-    else
-    {
-        private size_t length_ = count;
-
-        @property bool empty() const @nogc nothrow pure @safe
-        {
-            return this.length_ == 0;
-        }
-    }
-
-    static if (withLvalueElements)
-    {
-        private E* element; // Pointer to enable range copying in save()
-    }
-
-    void popFront() @nogc nothrow pure @safe
-    in
-    {
-        assert(!empty);
-    }
-    do
-    {
-        static if (!infinite)
-        {
-            --this.length_;
-        }
-    }
-
-    static if (withLvalueElements)
-    {
-        ref E front() @nogc nothrow pure @safe
-        in
-        {
-            assert(!empty);
-        }
-        do
-        {
-            return *this.element;
-        }
-    }
-    else
-    {
-        E front() @nogc nothrow pure @safe
-        in
-        {
-            assert(!empty);
-        }
-        do
-        {
-            return E.init;
-        }
-    }
-
-    static if (Length.length != 0)
-    {
-        size_t length() const @nogc nothrow pure @safe
-        {
-            return this.length_;
-        }
-    }
-}
-
-/**
- * Generates a forward range.
- *
- * This mixin includes input range primitives as well, but can be combined with
- * $(D_PSYMBOL RandomAccessRangeStub).
- *
- * Params:
- *  E = Element type.
- */
-mixin template ForwardRangeStub(E = int)
-{
-    static if (!is(typeof(this.InputRangeMixin) == void))
-    {
-        mixin InputRangeStub!E InputRangeMixin;
-    }
-
-    auto save() @nogc nothrow pure @safe
-    {
-        return this;
-    }
-}
-
-/**
- * Generates a bidirectional range.
- *
- * This mixin includes forward range primitives as well, but can be combined with
- * $(D_PSYMBOL RandomAccessRangeStub).
- *
- * Params:
- *  E = Element type.
- */
-mixin template BidirectionalRangeStub(E = int)
-{
-    mixin ForwardRangeStub!E;
-
-    void popBack() @nogc nothrow pure @safe
-    in
-    {
-        assert(!empty);
-    }
-    do
-    {
-        static if (!infinite)
-        {
-            --this.length_;
-        }
-    }
-
-    static if (withLvalueElements)
-    {
-        ref E back() @nogc nothrow pure @safe
-        in
-        {
-            assert(!empty);
-        }
-        do
-        {
-            return *this.element;
-        }
-    }
-    else
-    {
-        E back() @nogc nothrow pure @safe
-        in
-        {
-            assert(!empty);
-        }
-        do
-        {
-            return E.init;
-        }
-    }
-}
-
-/**
- * Generates a random-access range.
- *
- * This mixin includes input range primitives as well, but can be combined with
- * $(D_PSYMBOL ForwardRangeStub) or $(D_PSYMBOL BidirectionalRangeStub).
- *
- * Note that a random-access range also requires $(D_PSYMBOL Length) or
- * $(D_PARAM Infinite) by definition.
- *
- * Params:
- *  E = Element type.
- */
-mixin template RandomAccessRangeStub(E = int)
-{
-    static if (!is(typeof(this.InputRangeMixin) == void))
-    {
-        mixin InputRangeStub!E InputRangeMixin;
-    }
-
-    static if (withLvalueElements)
-    {
-        ref E opIndex(size_t) @nogc nothrow pure @safe
-        {
-            return *this.element;
-        }
-    }
-    else
-    {
-        E opIndex(size_t) @nogc nothrow pure @safe
-        {
-            return E.init;
-        }
-    }
-}
-
-/**
- * Struct with a disabled postblit constructor.
- *
- * $(D_PSYMBOL NonCopyable) can be used as an attribute for
- * $(D_PSYMBOL StructStub) or as a standalone type.
- */
-struct NonCopyable
-{
-    @disable this(this);
-}
-
-/**
- * Struct with an elaborate destructor.
- *
- * $(D_PSYMBOL WithDtor) can be used as an attribute for
- * $(D_PSYMBOL StructStub) or as a standalone type.
- *
- * When used as a standalone object the constructor of $(D_PSYMBOL WithDtor)
- * accepts an additional `counter` argument, which is incremented by the
- * destructor. $(D_PSYMBOL WithDtor) stores a pointer to the passed variable,
- * so the variable can be investigated after the struct isn't available
- * anymore.
- */
-struct WithDtor
-{
-    size_t* counter;
-
-    this(ref size_t counter) @nogc nothrow pure @trusted
-    {
-        this.counter = &counter;
-    }
-
-    ~this() @nogc nothrow pure @safe
-    {
-        if (this.counter !is null)
-        {
-            ++*this.counter;
-        }
-    }
-}
-
-/**
- * Struct supporting hashing.
- *
- * $(D_PSYMBOL Hashable) can be used as an attribute for
- * $(D_PSYMBOL StructStub) or as a standalone type.
- *
- * The constructor accepts an additional parameter, which is returned by the
- * `toHash()`-function. `0U` is returned if no hash value is given.
- */
-struct Hashable
-{
-    size_t hash;
-
-    size_t toHash() const @nogc nothrow pure @safe
-    {
-        return this.hash;
-    }
-}
-
-/**
- * Generates a $(D_KEYWORD struct) with common functionality.
- *
- * To specify the needed functionality use user-defined attributes on the
- * $(D_KEYWORD struct) $(D_PSYMBOL StructStub) is mixed in.
- *
- * Supported attributes are: $(D_PSYMBOL NonCopyable), $(D_PSYMBOL Hashable),
- * $(D_PSYMBOL WithDtor).
- */
-mixin template StructStub()
-{
-    import tanya.meta.trait : evalUDA, getUDAs, hasUDA;
-
-    static if (hasUDA!(typeof(this), NonCopyable))
-    {
-        @disable this(this);
-    }
-
-    private alias Hashable = getUDAs!(typeof(this), .Hashable);
-    static if (Hashable.length > 0)
-    {
-        size_t toHash() const @nogc nothrow pure @safe
-        {
-            return evalUDA!(Hashable[0]).hash;
-        }
-    }
-
-    static if (hasUDA!(typeof(this), WithDtor))
-    {
-        ~this() @nogc nothrow pure @safe
-        {
-        }
-    }
-}

tests/tanya/algorithm/tests/iteration.d

@@ -1,55 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-module tanya.algorithm.tests.iteration;
-
-import tanya.algorithm.iteration;
-import tanya.range;
-import tanya.test.stub;
-
-// Singleton range is bidirectional and random-access
-@nogc nothrow pure @safe unittest
-{
-    static assert(isBidirectionalRange!(typeof(singleton('a'))));
-    static assert(isRandomAccessRange!(typeof(singleton('a'))));
-
-    assert({ char a; return isBidirectionalRange!(typeof(singleton(a))); });
-    assert({ char a; return isRandomAccessRange!(typeof(singleton(a))); });
-}
-
-@nogc nothrow pure @safe unittest
-{
-    char a = 'a';
-    auto single = singleton(a);
-
-    assert(single.front == 'a');
-    assert(single.back == 'a');
-    assert(single[0] == 'a');
-    assert(single.length == 1);
-    assert(!single.empty);
-}
-
-// popFront makes SingletonByRef empty
-@nogc nothrow pure @safe unittest
-{
-    char a = 'a';
-    auto single = singleton(a);
-
-    single.popFront();
-    assert(single.empty);
-    assert(single.length == 0);
-    assert(single.empty);
-}
-
-// popBack makes SingletonByRef empty
-@nogc nothrow pure @safe unittest
-{
-    char a = 'b';
-    auto single = singleton(a);
-
-    single.popBack();
-    assert(single.empty);
-    assert(single.length == 0);
-    assert(single.empty);
-}

tests/tanya/algorithm/tests/mutation.d

@@ -1,97 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-module tanya.algorithm.tests.mutation;
-
-import tanya.algorithm.mutation;
-import tanya.range;
-import tanya.test.stub;
-
-// Returns advanced target
-@nogc nothrow pure @safe unittest
-{
-    int[5] input = [1, 2, 3, 4, 5];
-    assert(copy(input[3 .. 5], input[]).front == 3);
-}
-
-// Copies overlapping arrays
-@nogc nothrow pure @safe unittest
-{
-    import std.algorithm.comparison : equal;
-
-    int[6] actual = [1, 2, 3, 4, 5, 6];
-    const int[6] expected = [1, 2, 1, 2, 3, 4];
-
-    copy(actual[0 .. 4], actual[2 .. 6]);
-    assert(equal(actual[], expected[]));
-}
-
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(typeof(copy((ubyte[]).init, (ushort[]).init))));
-    static assert(!is(typeof(copy((ushort[]).init, (ubyte[]).init))));
-}
-
-@nogc nothrow pure @safe unittest
-{
-    static struct OutPutRange
-    {
-        int value;
-
-        void opCall(int value) @nogc nothrow pure @safe
-        in
-        {
-            assert(this.value == 0);
-        }
-        do
-        {
-            this.value = value;
-        }
-    }
-    int[1] source = [5];
-    OutPutRange target;
-
-    assert(copy(source[], target).value == 5);
-}
-
-// [] is called where possible
-@nogc nothrow pure @system unittest
-{
-    static struct Slice
-    {
-        bool* slicingCalled;
-
-        int front() @nogc nothrow pure @safe
-        {
-            return 0;
-        }
-
-        void front(int) @nogc nothrow pure @safe
-        {
-        }
-
-        void popFront() @nogc nothrow pure @safe
-        {
-        }
-
-        bool empty() @nogc nothrow pure @safe
-        {
-            return true;
-        }
-
-        void opIndexAssign(int) @nogc nothrow pure @safe
-        {
-            *this.slicingCalled = true;
-        }
-    }
-    bool slicingCalled;
-    auto range = Slice(&slicingCalled);
-    fill(range, 0);
-    assert(slicingCalled);
-}
-
-@nogc nothrow pure @safe unittest
-{
-    NonCopyable[] nonCopyable;
-    initializeAll(nonCopyable);
-}

tests/tanya/container/tests/array.d

@@ -1,189 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-module tanya.container.tests.array;
-
-import std.algorithm.comparison;
-import tanya.container.array;
-import tanya.memory.allocator;
-import tanya.test.stub;
-
-// const arrays return usable ranges
-@nogc nothrow pure @safe unittest
-{
-    auto v = const Array!int([1, 2, 4]);
-    auto r1 = v[];
-
-    assert(r1.back == 4);
-    r1.popBack();
-    assert(r1.back == 2);
-    r1.popBack();
-    assert(r1.back == 1);
-    r1.popBack();
-    assert(r1.length == 0);
-
-    static assert(!is(typeof(r1[0] = 5)));
-    static assert(!is(typeof(v[0] = 5)));
-
-    const r2 = r1[];
-    static assert(is(typeof(r2[])));
-}
-
-@nogc nothrow pure @safe unittest
-{
-    Array!int v1;
-    const Array!int v2;
-
-    auto r1 = v1[];
-    auto r2 = v1[];
-
-    assert(r1.length == 0);
-    assert(r2.empty);
-    assert(r1 == r2);
-
-    v1.insertBack([1, 2, 4]);
-    assert(v1[] == v1);
-    assert(v2[] == v2);
-    assert(v2[] != v1);
-    assert(v1[] != v2);
-    assert(v1[].equal(v1[]));
-    assert(v2[].equal(v2[]));
-    assert(!v1[].equal(v2[]));
-}
-
-@nogc nothrow pure @safe unittest
-{
-    struct MutableEqualsStruct
-    {
-        bool opEquals(typeof(this) that) @nogc nothrow pure @safe
-        {
-            return true;
-        }
-    }
-    struct ConstEqualsStruct
-    {
-        bool opEquals(const typeof(this) that) const @nogc nothrow pure @safe
-        {
-            return true;
-        }
-    }
-    auto v1 = Array!ConstEqualsStruct();
-    auto v2 = Array!ConstEqualsStruct();
-    assert(v1 == v2);
-    assert(v1[] == v2);
-    assert(v1 == v2[]);
-    assert(v1[].equal(v2[]));
-
-    auto v3 = const Array!ConstEqualsStruct();
-    auto v4 = const Array!ConstEqualsStruct();
-    assert(v3 == v4);
-    assert(v3[] == v4);
-    assert(v3 == v4[]);
-    assert(v3[].equal(v4[]));
-
-    auto v7 = Array!MutableEqualsStruct(1, MutableEqualsStruct());
-    auto v8 = Array!MutableEqualsStruct(1, MutableEqualsStruct());
-    assert(v7 == v8);
-    assert(v7[] == v8);
-    assert(v7 == v8[]);
-    assert(v7[].equal(v8[]));
-}
-
-// Destructor can destroy empty arrays
-@nogc nothrow pure @safe unittest
-{
-    auto v = Array!WithDtor();
-}
-
-@nogc nothrow pure @safe unittest
-{
-    class A
-    {
-    }
-    A a1, a2;
-    auto v1 = Array!A([a1, a2]);
-
-    static assert(is(Array!(A*)));
-}
-
-@nogc nothrow pure @safe unittest
-{
-    auto v = Array!int([5, 15, 8]);
-    {
-        size_t i;
-
-        foreach (e; v)
-        {
-            assert(i != 0 || e == 5);
-            assert(i != 1 || e == 15);
-            assert(i != 2 || e == 8);
-            ++i;
-        }
-        assert(i == 3);
-    }
-    {
-        size_t i = 3;
-
-        foreach_reverse (e; v)
-        {
-            --i;
-            assert(i != 2 || e == 8);
-            assert(i != 1 || e == 15);
-            assert(i != 0 || e == 5);
-        }
-        assert(i == 0);
-    }
-}
-
-// const constructor tests
-@nogc nothrow pure @system unittest
-{
-    auto v1 = const Array!int([1, 2, 3]);
-    auto v2 = Array!int(v1);
-    assert(v1.get !is v2.get);
-    assert(v1 == v2);
-
-    auto v3 = const Array!int(Array!int([1, 2, 3]));
-    assert(v1 == v3);
-    assert(v3.length == 3);
-    assert(v3.capacity == 3);
-}
-
-@nogc nothrow pure @safe unittest
-{
-    auto v1 = Array!int(defaultAllocator);
-}
-
-@nogc nothrow pure @safe unittest
-{
-    Array!int v;
-    auto r = v[];
-    assert(r.length == 0);
-    assert(r.empty);
-}
-
-@nogc nothrow pure @safe unittest
-{
-    auto v1 = const Array!int([5, 15, 8]);
-    Array!int v2;
-    v2 = v1[0 .. 2];
-    assert(equal(v1[0 .. 2], v2[]));
-}
-
-// Move assignment
-@nogc nothrow pure @safe unittest
-{
-    Array!int v1;
-    v1 = Array!int([5, 15, 8]);
-}
-
-// Postblit is safe
-@nogc nothrow pure @safe unittest
-{
-    auto array = Array!int(3);
-    void func(Array!int arg)
-    {
-        assert(arg.capacity == 3);
-    }
-    func(array);
-}

tests/tanya/container/tests/buffer.d

@@ -1,17 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-module tanya.container.tests.buffer;
-
-import tanya.container.buffer;
-
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(ReadBuffer!int));
-}
-
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(typeof(WriteBuffer!int(5))));
-}
-

tests/tanya/container/tests/entry.d

@@ -1,17 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-module tanya.container.tests.entry;
-
-import tanya.container.entry;
-import tanya.test.stub;
-
-// Can be constructed with non-copyable key/values
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(Bucket!NonCopyable));
-    static assert(is(Bucket!(NonCopyable, NonCopyable)));
-
-    static assert(is(HashArray!((ref NonCopyable) => 0U, NonCopyable)));
-    static assert(is(HashArray!((ref NonCopyable) => 0U, NonCopyable, NonCopyable)));
-}

tests/tanya/container/tests/hashtable.d

@@ -1,133 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-module tanya.container.tests.hashtable;
-
-import tanya.container.hashtable;
-import tanya.test.stub;
-
-@nogc nothrow pure @safe unittest
-{
-    import tanya.range.primitive : isForwardRange;
-    static assert(is(HashTable!(string, int) a));
-    static assert(is(const HashTable!(string, int)));
-    static assert(isForwardRange!(HashTable!(string, int).Range));
-
-    static assert(is(HashTable!(int, int, (ref const int) => size_t.init)));
-    static assert(is(HashTable!(int, int, (int) => size_t.init)));
-}
-
-// Constructs by reference
-@nogc nothrow pure @safe unittest
-{
-    auto hashTable1 = HashTable!(string, int)(7);
-    auto hashTable2 = HashTable!(string, int)(hashTable1);
-    assert(hashTable1.length == hashTable2.length);
-    assert(hashTable1.capacity == hashTable2.capacity);
-}
-
-// Constructs by value
-@nogc nothrow pure @safe unittest
-{
-    auto hashTable = HashTable!(string, int)(HashTable!(string, int)(7));
-    assert(hashTable.capacity == 7);
-}
-
-// Assigns by reference
-@nogc nothrow pure @safe unittest
-{
-    auto hashTable1 = HashTable!(string, int)(7);
-    HashTable!(string, int) hashTable2;
-    hashTable1 = hashTable2;
-    assert(hashTable1.length == hashTable2.length);
-    assert(hashTable1.capacity == hashTable2.capacity);
-}
-
-// Assigns by value
-@nogc nothrow pure @safe unittest
-{
-    HashTable!(string, int) hashTable;
-    hashTable = HashTable!(string, int)(7);
-    assert(hashTable.capacity == 7);
-}
-
-// Postblit copies
-@nogc nothrow pure @safe unittest
-{
-    auto hashTable = HashTable!(string, int)(7);
-    void testFunc(HashTable!(string, int) hashTable)
-    {
-        assert(hashTable.capacity == 7);
-    }
-    testFunc(hashTable);
-}
-
-// Issue 53: https://github.com/caraus-ecms/tanya/issues/53
-@nogc nothrow pure @safe unittest
-{
-    {
-        HashTable!(uint, uint) hashTable;
-        foreach (uint i; 0 .. 14)
-        {
-            hashTable[i + 1] = i;
-        }
-        assert(hashTable.length == 14);
-    }
-    {
-        HashTable!(int, int) hashtable;
-
-        hashtable[1194250162] = 3;
-        hashtable[-1131293824] = 6;
-        hashtable[838100082] = 9;
-
-        hashtable.rehash(11);
-
-        assert(hashtable[-1131293824] == 6);
-    }
-}
-
-@nogc nothrow pure @safe unittest
-{
-    static struct String
-    {
-        bool opEquals(string) const @nogc nothrow pure @safe
-        {
-            return true;
-        }
-
-        bool opEquals(ref const string) const @nogc nothrow pure @safe
-        {
-            return true;
-        }
-
-        bool opEquals(String) const @nogc nothrow pure @safe
-        {
-            return true;
-        }
-
-        bool opEquals(ref const String) const @nogc nothrow pure @safe
-        {
-            return true;
-        }
-
-        size_t toHash() const @nogc nothrow pure @safe
-        {
-            return 0;
-        }
-    }
-    static assert(is(typeof("asdf" in HashTable!(String, int)())));
-    static assert(is(typeof(HashTable!(String, int)()["asdf"])));
-}
-
-// Can have non-copyable keys and elements
-@nogc nothrow pure @safe unittest
-{
-    @NonCopyable @Hashable
-    static struct S
-    {
-        mixin StructStub;
-    }
-    static assert(is(HashTable!(S, int)));
-    static assert(is(HashTable!(int, S)));
-    static assert(is(HashTable!(S, S)));
-}

tests/tanya/container/tests/list.d

@@ -1,120 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-module tanya.container.tests.list;
-
-import tanya.container.list;
-import tanya.test.stub;
-
-@nogc nothrow pure @safe unittest
-{
-    interface Stuff
-    {
-    }
-    static assert(is(SList!Stuff));
-}
-
-@nogc nothrow pure @safe unittest
-{
-    auto l = SList!int(0, 0);
-    assert(l.empty);
-}
-
-// foreach called using opIndex().
-@nogc nothrow pure @safe unittest
-{
-    SList!int l;
-    size_t i;
-
-    l.insertFront(5);
-    l.insertFront(4);
-    l.insertFront(9);
-    foreach (e; l)
-    {
-        assert(i != 0 || e == 9);
-        assert(i != 1 || e == 4);
-        assert(i != 2 || e == 5);
-        ++i;
-    }
-}
-
-@nogc nothrow pure @safe unittest
-{
-    auto l1 = SList!int();
-    auto l2 = SList!int([9, 4]);
-    l1 = l2[];
-    assert(l1 == l2);
-}
-
-@nogc nothrow pure @safe unittest
-{
-    class A
-    {
-    }
-    static assert(is(SList!(A*)));
-    static assert(is(DList!(A*)));
-}
-
-// Removes all elements
-@nogc nothrow pure @safe unittest
-{
-    auto l = DList!int([5]);
-    assert(l.remove(l[]).empty);
-}
-
-@nogc nothrow pure @safe unittest
-{
-    auto l1 = DList!int([5, 234, 30, 1]);
-    auto l2 = DList!int([5, 1]);
-    auto r = l1[];
-
-    r.popFront();
-    r.popBack();
-    assert(r.front == 234);
-    assert(r.back == 30);
-
-    assert(!l1.remove(r).empty);
-    assert(l1 == l2);
-}
-
-@nogc nothrow pure @safe unittest
-{
-    auto l = DList!int(0, 0);
-    assert(l.empty);
-}
-
-@nogc nothrow pure @safe unittest
-{
-    DList!int l;
-    l.insertAfter(l[], 234);
-    assert(l.front == 234);
-    assert(l.back == 234);
-}
-
-@nogc nothrow pure @safe unittest
-{
-    auto l1 = DList!int();
-    auto l2 = DList!int([9, 4]);
-    l1 = l2[];
-    assert(l1 == l2);
-}
-
-// Sets the new head
-@nogc nothrow pure @safe unittest
-{
-    auto l1 = DList!int([5, 234, 30, 1]);
-    auto l2 = DList!int([1]);
-    auto r = l1[];
-
-    r.popBack();
-
-    assert(!l1.remove(r).empty);
-    assert(l1 == l2);
-}
-
-// Can have non-copyable elements
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(SList!NonCopyable));
-    static assert(is(DList!NonCopyable));
-}

tests/tanya/container/tests/set.d

@@ -1,155 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-module tanya.container.tests.set;
-
-import tanya.container.set;
-import tanya.memory.allocator;
-import tanya.test.stub;
-
-// Basic insertion logic.
-@nogc nothrow pure @safe unittest
-{
-    Set!int set;
-
-    assert(set.insert(5) == 1);
-    assert(5 in set);
-    assert(set.capacity == 3);
-
-    assert(set.insert(5) == 0);
-    assert(5 in set);
-    assert(set.capacity == 3);
-
-    assert(set.insert(9) == 1);
-    assert(9 in set);
-    assert(5 in set);
-    assert(set.capacity == 3);
-
-    assert(set.insert(7) == 1);
-    assert(set.insert(8) == 1);
-    assert(8 in set);
-    assert(5 in set);
-    assert(9 in set);
-    assert(7 in set);
-    assert(set.capacity == 7);
-
-    assert(set.insert(16) == 1);
-    assert(16 in set);
-    assert(set.capacity == 7);
-}
-
-// Static checks.
-@nogc nothrow pure @safe unittest
-{
-    import tanya.range.primitive;
-
-    static assert(isBidirectionalRange!(Set!int.ConstRange));
-    static assert(isBidirectionalRange!(Set!int.Range));
-
-    static assert(!isInfinite!(Set!int.Range));
-    static assert(!hasLength!(Set!int.Range));
-
-    static assert(is(Set!uint));
-    static assert(is(Set!long));
-    static assert(is(Set!ulong));
-    static assert(is(Set!short));
-    static assert(is(Set!ushort));
-    static assert(is(Set!bool));
-}
-
-@nogc nothrow pure @safe unittest
-{
-    const Set!int set;
-    assert(set[].empty);
-}
-
-@nogc nothrow pure @safe unittest
-{
-    Set!int set;
-    set.insert(8);
-
-    auto r1 = set[];
-    auto r2 = r1.save();
-
-    r1.popFront();
-    assert(r1.empty);
-
-    r2.popBack();
-    assert(r2.empty);
-}
-
-// Initial capacity is 0.
-@nogc nothrow pure @safe unittest
-{
-    auto set = Set!int(defaultAllocator);
-    assert(set.capacity == 0);
-}
-
-// Capacity is set to a prime.
-@nogc nothrow pure @safe unittest
-{
-    auto set = Set!int(8);
-    assert(set.capacity == 13);
-}
-
-// Constructs by reference
-@nogc nothrow pure @safe unittest
-{
-    auto set1 = Set!int(7);
-    auto set2 = Set!int(set1);
-    assert(set1.length == set2.length);
-    assert(set1.capacity == set2.capacity);
-}
-
-// Constructs by value
-@nogc nothrow pure @safe unittest
-{
-    auto set = Set!int(Set!int(7));
-    assert(set.capacity == 7);
-}
-
-// Assigns by reference
-@nogc nothrow pure @safe unittest
-{
-    auto set1 = Set!int(7);
-    Set!int set2;
-    set1 = set2;
-    assert(set1.length == set2.length);
-    assert(set1.capacity == set2.capacity);
-}
-
-// Assigns by value
-@nogc nothrow pure @safe unittest
-{
-    Set!int set;
-    set = Set!int(7);
-    assert(set.capacity == 7);
-}
-
-// Postblit copies
-@nogc nothrow pure @safe unittest
-{
-    auto set = Set!int(7);
-    void testFunc(Set!int set)
-    {
-        assert(set.capacity == 7);
-    }
-    testFunc(set);
-}
-
-// Hasher can take argument by ref
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(Set!(int, (const ref x) => cast(size_t) x)));
-}
-
-// Can have non-copyable elements
-@nogc nothrow pure @safe unittest
-{
-    @NonCopyable @Hashable
-    static struct S
-    {
-        mixin StructStub;
-    }
-    static assert(is(Set!S));
-}

tests/tanya/container/tests/string.d

@@ -1,121 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-module tanya.container.tests.string;
-
-import tanya.container.string;
-import tanya.test.assertion;
-
-@nogc nothrow pure @safe unittest
-{
-    auto s = String(0, 'K');
-    assert(s.length == 0);
-}
-
-// Allocates enough space for 3-byte character.
-@nogc pure @safe unittest
-{
-    String s;
-    s.insertBack('\u8100');
-}
-
-@nogc pure @safe unittest
-{
-    assertThrown!UTFException(() => String(1, cast(dchar) 0xd900));
-    assertThrown!UTFException(() => String(1, cast(wchar) 0xd900));
-}
-
-@nogc nothrow pure @safe unittest
-{
-    auto s1 = String("Buttercup");
-    auto s2 = String("Cap");
-    s2[] = s1[6 .. $];
-    assert(s2 == "cup");
-}
-
-@nogc nothrow pure @safe unittest
-{
-    auto s1 = String("Wow");
-    s1[] = 'a';
-    assert(s1 == "aaa");
-}
-
-@nogc nothrow pure @safe unittest
-{
-    auto s1 = String("ö");
-    s1[] = "oe";
-    assert(s1 == "oe");
-}
-
-// Postblit works
-@nogc nothrow pure @safe unittest
-{
-    void internFunc(String arg)
-    {
-    }
-    void middleFunc(S...)(S args)
-    {
-        foreach (arg; args)
-        {
-            internFunc(arg);
-        }
-    }
-    void topFunc(String args)
-    {
-        middleFunc(args);
-    }
-    topFunc(String("asdf"));
-}
-
-// Const range produces mutable ranges
-@nogc pure @safe unittest
-{
-    auto s = const String("И снизу лед, и сверху - маюсь между.");
-    {
-        const constRange = s[];
-
-        auto fromConstRange = constRange[];
-        fromConstRange.popFront();
-        assert(fromConstRange.front == s[1]);
-
-        fromConstRange = constRange[0 .. $];
-        fromConstRange.popFront();
-        assert(fromConstRange.front == s[1]);
-
-        assert(constRange.get() is s.get());
-    }
-    {
-        const constRange = s.byCodePoint();
-
-        auto fromConstRange = constRange[];
-        fromConstRange.popFront();
-        assert(fromConstRange.front == ' ');
-    }
-}
-
-// Can pop multibyte characters
-@nogc pure @safe unittest
-{
-    auto s = String("\U00024B62\U00002260");
-    auto range = s.byCodePoint();
-
-    range.popFront();
-    assert(!range.empty);
-
-    range.popFront();
-    assert(range.empty);
-
-    range = s.byCodePoint();
-    range.popFront();
-    s[$ - 3] = 0xf0;
-    assertThrown!UTFException(&(range.popFront));
-}
-
-// Inserts own char range correctly
-@nogc nothrow pure @safe unittest
-{
-    auto s1 = String(`ü`);
-    String s2;
-    s2.insertBack(s1[]);
-    assert(s1 == s2);
-}

tests/tanya/hash/tests/lookup.d

@@ -1,501 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-module tanya.hash.tests.lookup;
-
-import tanya.hash.lookup;
-import tanya.test.stub;
-
-// Tests that work for any hash size
-@nogc nothrow pure @safe unittest
-{
-    assert(hash(null) == 0);
-    assert(hash(Hashable()) == 0U);
-    assert(hash('a') == 'a');
-}
-
-static if (size_t.sizeof == 4) @nogc nothrow pure @safe unittest
-{
-    assert(hash(HashRange()) == 0x6222e842U);
-    assert(hash(ToHashRange()) == 3371162643U);
-}
-
-static if (size_t.sizeof == 8) @nogc nothrow pure @safe unittest
-{
-    assert(hash(HashRange()) == 0x08985907b541d342UL);
-    assert(hash(ToHashRange()) == 2072958611659694473);
-}
-
-static if (size_t.sizeof == 4) @nogc nothrow pure @system unittest
-{
-    assert(hash(cast(void*) 0x6e6f6863) == 0x6e6f6863);
-}
-
-static if (size_t.sizeof == 8) @nogc nothrow pure @system unittest
-{
-    assert(hash(cast(void*) 0x77206f676e6f6863) == 0x77206f676e6f6863);
-}
-
-/*
- * These are official FNV-1a test vectors and they are in the public domain.
- */
-// FNV-1a 32 bit test vectors
-static if (size_t.sizeof == 4) @nogc nothrow pure @safe unittest
-{
-    assert(hash("") == 0x811c9dc5U);
-    assert(hash("a") == 0xe40c292cU);
-    assert(hash("b") == 0xe70c2de5U);
-    assert(hash("c") == 0xe60c2c52U);
-    assert(hash("d") == 0xe10c2473U);
-    assert(hash("e") == 0xe00c22e0U);
-    assert(hash("f") == 0xe30c2799U);
-    assert(hash("fo") == 0x6222e842U);
-    assert(hash("foo") == 0xa9f37ed7U);
-    assert(hash("foob") == 0x3f5076efU);
-    assert(hash("fooba") == 0x39aaa18aU);
-    assert(hash("foobar") == 0xbf9cf968U);
-    assert(hash("\0") == 0x050c5d1fU);
-    assert(hash("a\0") == 0x2b24d044U);
-    assert(hash("b\0") == 0x9d2c3f7fU);
-    assert(hash("c\0") == 0x7729c516U);
-    assert(hash("d\0") == 0xb91d6109U);
-    assert(hash("e\0") == 0x931ae6a0U);
-    assert(hash("f\0") == 0x052255dbU);
-    assert(hash("fo\0") == 0xbef39fe6U);
-    assert(hash("foo\0") == 0x6150ac75U);
-    assert(hash("foob\0") == 0x9aab3a3dU);
-    assert(hash("fooba\0") == 0x519c4c3eU);
-    assert(hash("foobar\0") == 0x0c1c9eb8U);
-    assert(hash("ch") == 0x5f299f4eU);
-    assert(hash("cho") == 0xef8580f3U);
-    assert(hash("chon") == 0xac297727U);
-    assert(hash("chong") == 0x4546b9c0U);
-    assert(hash("chongo") == 0xbd564e7dU);
-    assert(hash("chongo ") == 0x6bdd5c67U);
-    assert(hash("chongo w") == 0xdd77ed30U);
-    assert(hash("chongo wa") == 0xf4ca9683U);
-    assert(hash("chongo was") == 0x4aeb9bd0U);
-    assert(hash("chongo was ") == 0xe0e67ad0U);
-    assert(hash("chongo was h") == 0xc2d32fa8U);
-    assert(hash("chongo was he") == 0x7f743fb7U);
-    assert(hash("chongo was her") == 0x6900631fU);
-    assert(hash("chongo was here") == 0xc59c990eU);
-    assert(hash("chongo was here!") == 0x448524fdU);
-    assert(hash("chongo was here!\n") == 0xd49930d5U);
-    assert(hash("ch\0") == 0x1c85c7caU);
-    assert(hash("cho\0") == 0x0229fe89U);
-    assert(hash("chon\0") == 0x2c469265U);
-    assert(hash("chong\0") == 0xce566940U);
-    assert(hash("chongo\0") == 0x8bdd8ec7U);
-    assert(hash("chongo \0") == 0x34787625U);
-    assert(hash("chongo w\0") == 0xd3ca6290U);
-    assert(hash("chongo wa\0") == 0xddeaf039U);
-    assert(hash("chongo was\0") == 0xc0e64870U);
-    assert(hash("chongo was \0") == 0xdad35570U);
-    assert(hash("chongo was h\0") == 0x5a740578U);
-    assert(hash("chongo was he\0") == 0x5b004d15U);
-    assert(hash("chongo was her\0") == 0x6a9c09cdU);
-    assert(hash("chongo was here\0") == 0x2384f10aU);
-    assert(hash("chongo was here!\0") == 0xda993a47U);
-    assert(hash("chongo was here!\n\0") == 0x8227df4fU);
-    assert(hash("cu") == 0x4c298165U);
-    assert(hash("cur") == 0xfc563735U);
-    assert(hash("curd") == 0x8cb91483U);
-    assert(hash("curds") == 0x775bf5d0U);
-    assert(hash("curds ") == 0xd5c428d0U);
-    assert(hash("curds a") == 0x34cc0ea3U);
-    assert(hash("curds an") == 0xea3b4cb7U);
-    assert(hash("curds and") == 0x8e59f029U);
-    assert(hash("curds and ") == 0x2094de2bU);
-    assert(hash("curds and w") == 0xa65a0ad4U);
-    assert(hash("curds and wh") == 0x9bbee5f4U);
-    assert(hash("curds and whe") == 0xbe836343U);
-    assert(hash("curds and whey") == 0x22d5344eU);
-    assert(hash("curds and whey\n") == 0x19a1470cU);
-    assert(hash("cu\0") == 0x4a56b1ffU);
-    assert(hash("cur\0") == 0x70b8e86fU);
-    assert(hash("curd\0") == 0x0a5b4a39U);
-    assert(hash("curds\0") == 0xb5c3f670U);
-    assert(hash("curds \0") == 0x53cc3f70U);
-    assert(hash("curds a\0") == 0xc03b0a99U);
-    assert(hash("curds an\0") == 0x7259c415U);
-    assert(hash("curds and\0") == 0x4095108bU);
-    assert(hash("curds and \0") == 0x7559bdb1U);
-    assert(hash("curds and w\0") == 0xb3bf0bbcU);
-    assert(hash("curds and wh\0") == 0x2183ff1cU);
-    assert(hash("curds and whe\0") == 0x2bd54279U);
-    assert(hash("curds and whey\0") == 0x23a156caU);
-    assert(hash("curds and whey\n\0") == 0x64e2d7e4U);
-    assert(hash("hi") == 0x683af69aU);
-    assert(hash("hi\0") == 0xaed2346eU);
-    assert(hash("hello") == 0x4f9f2cabU);
-    assert(hash("hello\0") == 0x02935131U);
-    assert(hash("\xff\x00\x00\x01") == 0xc48fb86dU);
-    assert(hash("\x01\x00\x00\xff") == 0x2269f369U);
-    assert(hash("\xff\x00\x00\x02") == 0xc18fb3b4U);
-    assert(hash("\x02\x00\x00\xff") == 0x50ef1236U);
-    assert(hash("\xff\x00\x00\x03") == 0xc28fb547U);
-    assert(hash("\x03\x00\x00\xff") == 0x96c3bf47U);
-    assert(hash("\xff\x00\x00\x04") == 0xbf8fb08eU);
-    assert(hash("\x04\x00\x00\xff") == 0xf3e4d49cU);
-    assert(hash("\x40\x51\x4e\x44") == 0x32179058U);
-    assert(hash("\x44\x4e\x51\x40") == 0x280bfee6U);
-    assert(hash("\x40\x51\x4e\x4a") == 0x30178d32U);
-    assert(hash("\x4a\x4e\x51\x40") == 0x21addaf8U);
-    assert(hash("\x40\x51\x4e\x54") == 0x4217a988U);
-    assert(hash("\x54\x4e\x51\x40") == 0x772633d6U);
-    assert(hash("127.0.0.1") == 0x08a3d11eU);
-    assert(hash("127.0.0.1\0") == 0xb7e2323aU);
-    assert(hash("127.0.0.2") == 0x07a3cf8bU);
-    assert(hash("127.0.0.2\0") == 0x91dfb7d1U);
-    assert(hash("127.0.0.3") == 0x06a3cdf8U);
-    assert(hash("127.0.0.3\0") == 0x6bdd3d68U);
-    assert(hash("64.81.78.68") == 0x1d5636a7U);
-    assert(hash("64.81.78.68\0") == 0xd5b808e5U);
-    assert(hash("64.81.78.74") == 0x1353e852U);
-    assert(hash("64.81.78.74\0") == 0xbf16b916U);
-    assert(hash("64.81.78.84") == 0xa55b89edU);
-    assert(hash("64.81.78.84\0") == 0x3c1a2017U);
-    assert(hash("feedface") == 0x0588b13cU);
-    assert(hash("feedface\0") == 0xf22f0174U);
-    assert(hash("feedfacedaffdeed") == 0xe83641e1U);
-    assert(hash("feedfacedaffdeed\0") == 0x6e69b533U);
-    assert(hash("feedfacedeadbeef") == 0xf1760448U);
-    assert(hash("feedfacedeadbeef\0") == 0x64c8bd58U);
-    assert(hash("line 1\nline 2\nline 3") == 0x97b4ea23U);
-    assert(hash("chongo <Landon Curt Noll> /\\../\\") == 0x9a4e92e6U);
-    assert(hash("chongo <Landon Curt Noll> /\\../\\\0") == 0xcfb14012U);
-    assert(hash("chongo (Landon Curt Noll) /\\../\\") == 0xf01b2511U);
-    assert(hash("chongo (Landon Curt Noll) /\\../\\\0") == 0x0bbb59c3U);
-    assert(hash("http://antwrp.gsfc.nasa.gov/apod/astropix.html") == 0xce524afaU);
-    assert(hash("http://en.wikipedia.org/wiki/Fowler_Noll_Vo_hash") == 0xdd16ef45U);
-    assert(hash("http://epod.usra.edu/") == 0x60648bb3U);
-    assert(hash("http://exoplanet.eu/") == 0x7fa4bcfcU);
-    assert(hash("http://hvo.wr.usgs.gov/cam3/") == 0x5053ae17U);
-    assert(hash("http://hvo.wr.usgs.gov/cams/HMcam/") == 0xc9302890U);
-    assert(hash("http://hvo.wr.usgs.gov/kilauea/update/deformation.html") == 0x956ded32U);
-    assert(hash("http://hvo.wr.usgs.gov/kilauea/update/images.html") == 0x9136db84U);
-    assert(hash("http://hvo.wr.usgs.gov/kilauea/update/maps.html") == 0xdf9d3323U);
-    assert(hash("http://hvo.wr.usgs.gov/volcanowatch/current_issue.html") == 0x32bb6cd0U);
-    assert(hash("http://neo.jpl.nasa.gov/risk/") == 0xc8f8385bU);
-    assert(hash("http://norvig.com/21-days.html") == 0xeb08bfbaU);
-    assert(hash("http://primes.utm.edu/curios/home.php") == 0x62cc8e3dU);
-    assert(hash("http://slashdot.org/") == 0xc3e20f5cU);
-    assert(hash("http://tux.wr.usgs.gov/Maps/155.25-19.5.html") == 0x39e97f17U);
-    assert(hash("http://volcano.wr.usgs.gov/kilaueastatus.php") == 0x7837b203U);
-    assert(hash("http://www.avo.alaska.edu/activity/Redoubt.php") == 0x319e877bU);
-    assert(hash("http://www.dilbert.com/fast/") == 0xd3e63f89U);
-    assert(hash("http://www.fourmilab.ch/gravitation/orbits/") == 0x29b50b38U);
-    assert(hash("http://www.fpoa.net/") == 0x5ed678b8U);
-    assert(hash("http://www.ioccc.org/index.html") == 0xb0d5b793U);
-    assert(hash("http://www.isthe.com/cgi-bin/number.cgi") == 0x52450be5U);
-    assert(hash("http://www.isthe.com/chongo/bio.html") == 0xfa72d767U);
-    assert(hash("http://www.isthe.com/chongo/index.html") == 0x95066709U);
-    assert(hash("http://www.isthe.com/chongo/src/calc/lucas-calc") == 0x7f52e123U);
-    assert(hash("http://www.isthe.com/chongo/tech/astro/venus2004.html") == 0x76966481U);
-    assert(hash("http://www.isthe.com/chongo/tech/astro/vita.html") == 0x063258b0U);
-    assert(hash("http://www.isthe.com/chongo/tech/comp/c/expert.html") == 0x2ded6e8aU);
-    assert(hash("http://www.isthe.com/chongo/tech/comp/calc/index.html") == 0xb07d7c52U);
-    assert(hash("http://www.isthe.com/chongo/tech/comp/fnv/index.html") == 0xd0c71b71U);
-    assert(hash("http://www.isthe.com/chongo/tech/math/number/howhigh.html") == 0xf684f1bdU);
-    assert(hash("http://www.isthe.com/chongo/tech/math/number/number.html") == 0x868ecfa8U);
-    assert(hash("http://www.isthe.com/chongo/tech/math/prime/mersenne.html") == 0xf794f684U);
-    assert(hash("http://www.isthe.com/chongo/tech/math/prime/mersenne.html#largest") == 0xd19701c3U);
-    assert(hash("http://www.lavarnd.org/cgi-bin/corpspeak.cgi") == 0x346e171eU);
-    assert(hash("http://www.lavarnd.org/cgi-bin/haiku.cgi") == 0x91f8f676U);
-    assert(hash("http://www.lavarnd.org/cgi-bin/rand-none.cgi") == 0x0bf58848U);
-    assert(hash("http://www.lavarnd.org/cgi-bin/randdist.cgi") == 0x6317b6d1U);
-    assert(hash("http://www.lavarnd.org/index.html") == 0xafad4c54U);
-    assert(hash("http://www.lavarnd.org/what/nist-test.html") == 0x0f25681eU);
-    assert(hash("http://www.macosxhints.com/") == 0x91b18d49U);
-    assert(hash("http://www.mellis.com/") == 0x7d61c12eU);
-    assert(hash("http://www.nature.nps.gov/air/webcams/parks/havoso2alert/havoalert.cfm") == 0x5147d25cU);
-    assert(hash("http://www.nature.nps.gov/air/webcams/parks/havoso2alert/timelines_24.cfm") == 0x9a8b6805U);
-    assert(hash("http://www.paulnoll.com/") == 0x4cd2a447U);
-    assert(hash("http://www.pepysdiary.com/") == 0x1e549b14U);
-    assert(hash("http://www.sciencenews.org/index/home/activity/view") == 0x2fe1b574U);
-    assert(hash("http://www.skyandtelescope.com/") == 0xcf0cd31eU);
-    assert(hash("http://www.sput.nl/~rob/sirius.html") == 0x6c471669U);
-    assert(hash("http://www.systemexperts.com/") == 0x0e5eef1eU);
-    assert(hash("http://www.tq-international.com/phpBB3/index.php") == 0x2bed3602U);
-    assert(hash("http://www.travelquesttours.com/index.htm") == 0xb26249e0U);
-    assert(hash("http://www.wunderground.com/global/stations/89606.html") == 0x2c9b86a4U);
-    assert(hash(r10!"21701") == 0xe415e2bbU);
-    assert(hash(r10!"M21701") == 0x18a98d1dU);
-    assert(hash(r10!"2^21701-1") == 0xb7df8b7bU);
-    assert(hash(r10!"\x54\xc5") == 0x241e9075U);
-    assert(hash(r10!"\xc5\x54") == 0x063f70ddU);
-    assert(hash(r10!"23209") == 0x0295aed9U);
-    assert(hash(r10!"M23209") == 0x56a7f781U);
-    assert(hash(r10!"2^23209-1") == 0x253bc645U);
-    assert(hash(r10!"\x5a\xa9") == 0x46610921U);
-    assert(hash(r10!"\xa9\x5a") == 0x7c1577f9U);
-    assert(hash(r10!"391581216093") == 0x512b2851U);
-    assert(hash(r10!"391581*2^216093-1") == 0x76823999U);
-    assert(hash(r10!"\x05\xf9\x9d\x03\x4c\x81") == 0xc0586935U);
-    assert(hash(r10!"FEDCBA9876543210") == 0xf3415c85U);
-    assert(hash(r10!"\xfe\xdc\xba\x98\x76\x54\x32\x10") == 0x0ae4ff65U);
-    assert(hash(r10!"EFCDAB8967452301") == 0x58b79725U);
-    assert(hash(r10!"\xef\xcd\xab\x89\x67\x45\x23\x01") == 0xdea43aa5U);
-    assert(hash(r10!"0123456789ABCDEF") == 0x2bb3be35U);
-    assert(hash(r10!"\x01\x23\x45\x67\x89\xab\xcd\xef") == 0xea777a45U);
-    assert(hash(r10!"1032547698BADCFE") == 0x8f21c305U);
-    assert(hash(r10!"\x10\x32\x54\x76\x98\xba\xdc\xfe") == 0x5c9d0865U);
-    assert(hash(r500!"\x00") == 0xfa823dd5U);
-    assert(hash(r500!"\x07") == 0x21a27271U);
-    assert(hash(r500!"~") == 0x83c5c6d5U);
-    assert(hash(r500!"\x7f") == 0x813b0881U);
-}
-
-// FNV-1a 64 bit test vectors
-static if (size_t.sizeof == 8) @nogc nothrow pure @safe unittest
-{
-    assert(hash("") == 0xcbf29ce484222325UL);
-    assert(hash("a") == 0xaf63dc4c8601ec8cUL);
-    assert(hash("b") == 0xaf63df4c8601f1a5UL);
-    assert(hash("c") == 0xaf63de4c8601eff2UL);
-    assert(hash("d") == 0xaf63d94c8601e773UL);
-    assert(hash("e") == 0xaf63d84c8601e5c0UL);
-    assert(hash("f") == 0xaf63db4c8601ead9UL);
-    assert(hash("fo") == 0x08985907b541d342UL);
-    assert(hash("foo") == 0xdcb27518fed9d577UL);
-    assert(hash("foob") == 0xdd120e790c2512afUL);
-    assert(hash("fooba") == 0xcac165afa2fef40aUL);
-    assert(hash("foobar") == 0x85944171f73967e8UL);
-    assert(hash("\0") == 0xaf63bd4c8601b7dfUL);
-    assert(hash("a\0") == 0x089be207b544f1e4UL);
-    assert(hash("b\0") == 0x08a61407b54d9b5fUL);
-    assert(hash("c\0") == 0x08a2ae07b54ab836UL);
-    assert(hash("d\0") == 0x0891b007b53c4869UL);
-    assert(hash("e\0") == 0x088e4a07b5396540UL);
-    assert(hash("f\0") == 0x08987c07b5420ebbUL);
-    assert(hash("fo\0") == 0xdcb28a18fed9f926UL);
-    assert(hash("foo\0") == 0xdd1270790c25b935UL);
-    assert(hash("foob\0") == 0xcac146afa2febf5dUL);
-    assert(hash("fooba\0") == 0x8593d371f738acfeUL);
-    assert(hash("foobar\0") == 0x34531ca7168b8f38UL);
-    assert(hash("ch") == 0x08a25607b54a22aeUL);
-    assert(hash("cho") == 0xf5faf0190cf90df3UL);
-    assert(hash("chon") == 0xf27397910b3221c7UL);
-    assert(hash("chong") == 0x2c8c2b76062f22e0UL);
-    assert(hash("chongo") == 0xe150688c8217b8fdUL);
-    assert(hash("chongo ") == 0xf35a83c10e4f1f87UL);
-    assert(hash("chongo w") == 0xd1edd10b507344d0UL);
-    assert(hash("chongo wa") == 0x2a5ee739b3ddb8c3UL);
-    assert(hash("chongo was") == 0xdcfb970ca1c0d310UL);
-    assert(hash("chongo was ") == 0x4054da76daa6da90UL);
-    assert(hash("chongo was h") == 0xf70a2ff589861368UL);
-    assert(hash("chongo was he") == 0x4c628b38aed25f17UL);
-    assert(hash("chongo was her") == 0x9dd1f6510f78189fUL);
-    assert(hash("chongo was here") == 0xa3de85bd491270ceUL);
-    assert(hash("chongo was here!") == 0x858e2fa32a55e61dUL);
-    assert(hash("chongo was here!\n") == 0x46810940eff5f915UL);
-    assert(hash("ch\0") == 0xf5fadd190cf8edaaUL);
-    assert(hash("cho\0") == 0xf273ed910b32b3e9UL);
-    assert(hash("chon\0") == 0x2c8c5276062f6525UL);
-    assert(hash("chong\0") == 0xe150b98c821842a0UL);
-    assert(hash("chongo\0") == 0xf35aa3c10e4f55e7UL);
-    assert(hash("chongo \0") == 0xd1ed680b50729265UL);
-    assert(hash("chongo w\0") == 0x2a5f0639b3dded70UL);
-    assert(hash("chongo wa\0") == 0xdcfbaa0ca1c0f359UL);
-    assert(hash("chongo was\0") == 0x4054ba76daa6a430UL);
-    assert(hash("chongo was \0") == 0xf709c7f5898562b0UL);
-    assert(hash("chongo was h\0") == 0x4c62e638aed2f9b8UL);
-    assert(hash("chongo was he\0") == 0x9dd1a8510f779415UL);
-    assert(hash("chongo was her\0") == 0xa3de2abd4911d62dUL);
-    assert(hash("chongo was here\0") == 0x858e0ea32a55ae0aUL);
-    assert(hash("chongo was here!\0") == 0x46810f40eff60347UL);
-    assert(hash("chongo was here!\n\0") == 0xc33bce57bef63eafUL);
-    assert(hash("cu") == 0x08a24307b54a0265UL);
-    assert(hash("cur") == 0xf5b9fd190cc18d15UL);
-    assert(hash("curd") == 0x4c968290ace35703UL);
-    assert(hash("curds") == 0x07174bd5c64d9350UL);
-    assert(hash("curds ") == 0x5a294c3ff5d18750UL);
-    assert(hash("curds a") == 0x05b3c1aeb308b843UL);
-    assert(hash("curds an") == 0xb92a48da37d0f477UL);
-    assert(hash("curds and") == 0x73cdddccd80ebc49UL);
-    assert(hash("curds and ") == 0xd58c4c13210a266bUL);
-    assert(hash("curds and w") == 0xe78b6081243ec194UL);
-    assert(hash("curds and wh") == 0xb096f77096a39f34UL);
-    assert(hash("curds and whe") == 0xb425c54ff807b6a3UL);
-    assert(hash("curds and whey") == 0x23e520e2751bb46eUL);
-    assert(hash("curds and whey\n") == 0x1a0b44ccfe1385ecUL);
-    assert(hash("cu\0") == 0xf5ba4b190cc2119fUL);
-    assert(hash("cur\0") == 0x4c962690ace2baafUL);
-    assert(hash("curd\0") == 0x0716ded5c64cda19UL);
-    assert(hash("curds\0") == 0x5a292c3ff5d150f0UL);
-    assert(hash("curds \0") == 0x05b3e0aeb308ecf0UL);
-    assert(hash("curds a\0") == 0xb92a5eda37d119d9UL);
-    assert(hash("curds an\0") == 0x73ce41ccd80f6635UL);
-    assert(hash("curds and\0") == 0xd58c2c132109f00bUL);
-    assert(hash("curds and \0") == 0xe78baf81243f47d1UL);
-    assert(hash("curds and w\0") == 0xb0968f7096a2ee7cUL);
-    assert(hash("curds and wh\0") == 0xb425a84ff807855cUL);
-    assert(hash("curds and whe\0") == 0x23e4e9e2751b56f9UL);
-    assert(hash("curds and whey\0") == 0x1a0b4eccfe1396eaUL);
-    assert(hash("curds and whey\n\0") == 0x54abd453bb2c9004UL);
-    assert(hash("hi") == 0x08ba5f07b55ec3daUL);
-    assert(hash("hi\0") == 0x337354193006cb6eUL);
-    assert(hash("hello") == 0xa430d84680aabd0bUL);
-    assert(hash("hello\0") == 0xa9bc8acca21f39b1UL);
-    assert(hash("\xff\x00\x00\x01") == 0x6961196491cc682dUL);
-    assert(hash("\x01\x00\x00\xff") == 0xad2bb1774799dfe9UL);
-    assert(hash("\xff\x00\x00\x02") == 0x6961166491cc6314UL);
-    assert(hash("\x02\x00\x00\xff") == 0x8d1bb3904a3b1236UL);
-    assert(hash("\xff\x00\x00\x03") == 0x6961176491cc64c7UL);
-    assert(hash("\x03\x00\x00\xff") == 0xed205d87f40434c7UL);
-    assert(hash("\xff\x00\x00\x04") == 0x6961146491cc5faeUL);
-    assert(hash("\x04\x00\x00\xff") == 0xcd3baf5e44f8ad9cUL);
-    assert(hash("\x40\x51\x4e\x44") == 0xe3b36596127cd6d8UL);
-    assert(hash("\x44\x4e\x51\x40") == 0xf77f1072c8e8a646UL);
-    assert(hash("\x40\x51\x4e\x4a") == 0xe3b36396127cd372UL);
-    assert(hash("\x4a\x4e\x51\x40") == 0x6067dce9932ad458UL);
-    assert(hash("\x40\x51\x4e\x54") == 0xe3b37596127cf208UL);
-    assert(hash("\x54\x4e\x51\x40") == 0x4b7b10fa9fe83936UL);
-    assert(hash("127.0.0.1") == 0xaabafe7104d914beUL);
-    assert(hash("127.0.0.1\0") == 0xf4d3180b3cde3edaUL);
-    assert(hash("127.0.0.2") == 0xaabafd7104d9130bUL);
-    assert(hash("127.0.0.2\0") == 0xf4cfb20b3cdb5bb1UL);
-    assert(hash("127.0.0.3") == 0xaabafc7104d91158UL);
-    assert(hash("127.0.0.3\0") == 0xf4cc4c0b3cd87888UL);
-    assert(hash("64.81.78.68") == 0xe729bac5d2a8d3a7UL);
-    assert(hash("64.81.78.68\0") == 0x74bc0524f4dfa4c5UL);
-    assert(hash("64.81.78.74") == 0xe72630c5d2a5b352UL);
-    assert(hash("64.81.78.74\0") == 0x6b983224ef8fb456UL);
-    assert(hash("64.81.78.84") == 0xe73042c5d2ae266dUL);
-    assert(hash("64.81.78.84\0") == 0x8527e324fdeb4b37UL);
-    assert(hash("feedface") == 0x0a83c86fee952abcUL);
-    assert(hash("feedface\0") == 0x7318523267779d74UL);
-    assert(hash("feedfacedaffdeed") == 0x3e66d3d56b8caca1UL);
-    assert(hash("feedfacedaffdeed\0") == 0x956694a5c0095593UL);
-    assert(hash("feedfacedeadbeef") == 0xcac54572bb1a6fc8UL);
-    assert(hash("feedfacedeadbeef\0") == 0xa7a4c9f3edebf0d8UL);
-    assert(hash("line 1\nline 2\nline 3") == 0x7829851fac17b143UL);
-    assert(hash("chongo <Landon Curt Noll> /\\../\\") == 0x2c8f4c9af81bcf06UL);
-    assert(hash("chongo <Landon Curt Noll> /\\../\\\0") == 0xd34e31539740c732UL);
-    assert(hash("chongo (Landon Curt Noll) /\\../\\") == 0x3605a2ac253d2db1UL);
-    assert(hash("chongo (Landon Curt Noll) /\\../\\\0") == 0x08c11b8346f4a3c3UL);
-    assert(hash("http://antwrp.gsfc.nasa.gov/apod/astropix.html") == 0x6be396289ce8a6daUL);
-    assert(hash("http://en.wikipedia.org/wiki/Fowler_Noll_Vo_hash") == 0xd9b957fb7fe794c5UL);
-    assert(hash("http://epod.usra.edu/") == 0x05be33da04560a93UL);
-    assert(hash("http://exoplanet.eu/") == 0x0957f1577ba9747cUL);
-    assert(hash("http://hvo.wr.usgs.gov/cam3/") == 0xda2cc3acc24fba57UL);
-    assert(hash("http://hvo.wr.usgs.gov/cams/HMcam/") == 0x74136f185b29e7f0UL);
-    assert(hash("http://hvo.wr.usgs.gov/kilauea/update/deformation.html") == 0xb2f2b4590edb93b2UL);
-    assert(hash("http://hvo.wr.usgs.gov/kilauea/update/images.html") == 0xb3608fce8b86ae04UL);
-    assert(hash("http://hvo.wr.usgs.gov/kilauea/update/maps.html") == 0x4a3a865079359063UL);
-    assert(hash("http://hvo.wr.usgs.gov/volcanowatch/current_issue.html") == 0x5b3a7ef496880a50UL);
-    assert(hash("http://neo.jpl.nasa.gov/risk/") == 0x48fae3163854c23bUL);
-    assert(hash("http://norvig.com/21-days.html") == 0x07aaa640476e0b9aUL);
-    assert(hash("http://primes.utm.edu/curios/home.php") == 0x2f653656383a687dUL);
-    assert(hash("http://slashdot.org/") == 0xa1031f8e7599d79cUL);
-    assert(hash("http://tux.wr.usgs.gov/Maps/155.25-19.5.html") == 0xa31908178ff92477UL);
-    assert(hash("http://volcano.wr.usgs.gov/kilaueastatus.php") == 0x097edf3c14c3fb83UL);
-    assert(hash("http://www.avo.alaska.edu/activity/Redoubt.php") == 0xb51ca83feaa0971bUL);
-    assert(hash("http://www.dilbert.com/fast/") == 0xdd3c0d96d784f2e9UL);
-    assert(hash("http://www.fourmilab.ch/gravitation/orbits/") == 0x86cd26a9ea767d78UL);
-    assert(hash("http://www.fpoa.net/") == 0xe6b215ff54a30c18UL);
-    assert(hash("http://www.ioccc.org/index.html") == 0xec5b06a1c5531093UL);
-    assert(hash("http://www.isthe.com/cgi-bin/number.cgi") == 0x45665a929f9ec5e5UL);
-    assert(hash("http://www.isthe.com/chongo/bio.html") == 0x8c7609b4a9f10907UL);
-    assert(hash("http://www.isthe.com/chongo/index.html") == 0x89aac3a491f0d729UL);
-    assert(hash("http://www.isthe.com/chongo/src/calc/lucas-calc") == 0x32ce6b26e0f4a403UL);
-    assert(hash("http://www.isthe.com/chongo/tech/astro/venus2004.html") == 0x614ab44e02b53e01UL);
-    assert(hash("http://www.isthe.com/chongo/tech/astro/vita.html") == 0xfa6472eb6eef3290UL);
-    assert(hash("http://www.isthe.com/chongo/tech/comp/c/expert.html") == 0x9e5d75eb1948eb6aUL);
-    assert(hash("http://www.isthe.com/chongo/tech/comp/calc/index.html") == 0xb6d12ad4a8671852UL);
-    assert(hash("http://www.isthe.com/chongo/tech/comp/fnv/index.html") == 0x88826f56eba07af1UL);
-    assert(hash("http://www.isthe.com/chongo/tech/math/number/howhigh.html") == 0x44535bf2645bc0fdUL);
-    assert(hash("http://www.isthe.com/chongo/tech/math/number/number.html") == 0x169388ffc21e3728UL);
-    assert(hash("http://www.isthe.com/chongo/tech/math/prime/mersenne.html") == 0xf68aac9e396d8224UL);
-    assert(hash("http://www.isthe.com/chongo/tech/math/prime/mersenne.html#largest") == 0x8e87d7e7472b3883UL);
-    assert(hash("http://www.lavarnd.org/cgi-bin/corpspeak.cgi") == 0x295c26caa8b423deUL);
-    assert(hash("http://www.lavarnd.org/cgi-bin/haiku.cgi") == 0x322c814292e72176UL);
-    assert(hash("http://www.lavarnd.org/cgi-bin/rand-none.cgi") == 0x8a06550eb8af7268UL);
-    assert(hash("http://www.lavarnd.org/cgi-bin/randdist.cgi") == 0xef86d60e661bcf71UL);
-    assert(hash("http://www.lavarnd.org/index.html") == 0x9e5426c87f30ee54UL);
-    assert(hash("http://www.lavarnd.org/what/nist-test.html") == 0xf1ea8aa826fd047eUL);
-    assert(hash("http://www.macosxhints.com/") == 0x0babaf9a642cb769UL);
-    assert(hash("http://www.mellis.com/") == 0x4b3341d4068d012eUL);
-    assert(hash("http://www.nature.nps.gov/air/webcams/parks/havoso2alert/havoalert.cfm") == 0xd15605cbc30a335cUL);
-    assert(hash("http://www.nature.nps.gov/air/webcams/parks/havoso2alert/timelines_24.cfm") == 0x5b21060aed8412e5UL);
-    assert(hash("http://www.paulnoll.com/") == 0x45e2cda1ce6f4227UL);
-    assert(hash("http://www.pepysdiary.com/") == 0x50ae3745033ad7d4UL);
-    assert(hash("http://www.sciencenews.org/index/home/activity/view") == 0xaa4588ced46bf414UL);
-    assert(hash("http://www.skyandtelescope.com/") == 0xc1b0056c4a95467eUL);
-    assert(hash("http://www.sput.nl/~rob/sirius.html") == 0x56576a71de8b4089UL);
-    assert(hash("http://www.systemexperts.com/") == 0xbf20965fa6dc927eUL);
-    assert(hash("http://www.tq-international.com/phpBB3/index.php") == 0x569f8383c2040882UL);
-    assert(hash("http://www.travelquesttours.com/index.htm") == 0xe1e772fba08feca0UL);
-    assert(hash("http://www.wunderground.com/global/stations/89606.html") == 0x4ced94af97138ac4UL);
-    assert(hash(r10!"21701") == 0xc4112ffb337a82fbUL);
-    assert(hash(r10!"M21701") == 0xd64a4fd41de38b7dUL);
-    assert(hash(r10!"2^21701-1") == 0x4cfc32329edebcbbUL);
-    assert(hash(r10!"\x54\xc5") == 0x0803564445050395UL);
-    assert(hash(r10!"\xc5\x54") == 0xaa1574ecf4642ffdUL);
-    assert(hash(r10!"23209") == 0x694bc4e54cc315f9UL);
-    assert(hash(r10!"M23209") == 0xa3d7cb273b011721UL);
-    assert(hash(r10!"2^23209-1") == 0x577c2f8b6115bfa5UL);
-    assert(hash(r10!"\x5a\xa9") == 0xb7ec8c1a769fb4c1UL);
-    assert(hash(r10!"\xa9\x5a") == 0x5d5cfce63359ab19UL);
-    assert(hash(r10!"391581216093") == 0x33b96c3cd65b5f71UL);
-    assert(hash(r10!"391581*2^216093-1") == 0xd845097780602bb9UL);
-    assert(hash(r10!"\x05\xf9\x9d\x03\x4c\x81") == 0x84d47645d02da3d5UL);
-    assert(hash(r10!"FEDCBA9876543210") == 0x83544f33b58773a5UL);
-    assert(hash(r10!"\xfe\xdc\xba\x98\x76\x54\x32\x10") == 0x9175cbb2160836c5UL);
-    assert(hash(r10!"EFCDAB8967452301") == 0xc71b3bc175e72bc5UL);
-    assert(hash(r10!"\xef\xcd\xab\x89\x67\x45\x23\x01") == 0x636806ac222ec985UL);
-    assert(hash(r10!"0123456789ABCDEF") == 0xb6ef0e6950f52ed5UL);
-    assert(hash(r10!"\x01\x23\x45\x67\x89\xab\xcd\xef") == 0xead3d8a0f3dfdaa5UL);
-    assert(hash(r10!"1032547698BADCFE") == 0x922908fe9a861ba5UL);
-    assert(hash(r10!"\x10\x32\x54\x76\x98\xba\xdc\xfe") == 0x6d4821de275fd5c5UL);
-    assert(hash(r500!"\x00") == 0x1fe3fce62bd816b5UL);
-    assert(hash(r500!"\x07") == 0xc23e9fccd6f70591UL);
-    assert(hash(r500!"~") == 0xc1af12bdfe16b5b5UL);
-    assert(hash(r500!"\x7f") == 0x39e9f18f2f85e221UL);
-}
-
-private enum string r10(string x) = x ~ x ~ x ~ x ~ x ~ x ~ x ~ x ~ x ~ x;
-private enum string r100(string x) = r10!x ~ r10!x ~ r10!x ~ r10!x ~ r10!x
-                               ~ r10!x ~ r10!x ~ r10!x ~ r10!x ~ r10!x;
-private enum string r500(string x) = r100!x ~ r100!x ~ r100!x ~ r100!x ~ r100!x;
-
-private struct HashRange
-{
-    string fo = "fo";
-
-    @property ubyte front() const @nogc nothrow pure @safe
-    {
-        return this.fo[0];
-    }
-
-    void popFront() @nogc nothrow pure @safe
-    {
-        this.fo = this.fo[1 .. $];
-    }
-
-    @property bool empty() const @nogc nothrow pure @safe
-    {
-        return this.fo.length == 0;
-    }
-}
-
-private struct ToHashRange
-{
-    bool empty_;
-
-    @property Hashable front() const @nogc nothrow pure @safe
-    {
-        return Hashable();
-    }
-
-    void popFront() @nogc nothrow pure @safe
-    {
-        this.empty_ = true;
-    }
-
-     @property bool empty() const @nogc nothrow pure @safe
-     {
-         return this.empty_;
-     }
-}

tests/tanya/math/tests/package.d

@@ -1,19 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-module tanya.math.tests;
-
-import tanya.math;
-
-static if (ieeePrecision!float == IEEEPrecision.doubleExtended)
-@nogc nothrow pure @safe unittest
-{
-    assert(classify(1.68105e-10) == FloatingPointClass.normal);
-    assert(classify(1.68105e-4932L) == FloatingPointClass.subnormal);
-
-    // Emulate unnormals, because they aren't generated anymore since i386
-    FloatBits!real unnormal;
-    unnormal.exp = 0x123;
-    unnormal.mantissa = 0x1;
-    assert(classify(unnormal) == FloatingPointClass.subnormal);
-}

tests/tanya/math/tests/random.d

@@ -1,17 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-module tanya.math.tests.random;
-
-import tanya.math.random;
-import tanya.memory.allocator;
-
-static if (is(PlatformEntropySource)) @nogc @system unittest
-{
-    import tanya.memory.smartref : unique;
-
-    auto source = defaultAllocator.unique!PlatformEntropySource();
-
-    assert(source.threshold == 32);
-    assert(source.strong);
-}

tests/tanya/memory/tests/lifetime.d

@@ -1,177 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-module tanya.memory.tests.lifetime;
-
-import tanya.memory.allocator;
-import tanya.memory.lifetime;
-import tanya.test.stub;
-
-@nogc nothrow pure @safe unittest
-{
-    int[] p;
-
-    p = defaultAllocator.resize(p, 20);
-    assert(p.length == 20);
-
-    p = defaultAllocator.resize(p, 30);
-    assert(p.length == 30);
-
-    p = defaultAllocator.resize(p, 10);
-    assert(p.length == 10);
-
-    p = defaultAllocator.resize(p, 0);
-    assert(p is null);
-}
-
-@nogc nothrow pure @system unittest
-{
-    static struct S
-    {
-        ~this() @nogc nothrow pure @safe
-        {
-        }
-    }
-    auto p = cast(S[]) defaultAllocator.allocate(S.sizeof);
-
-    defaultAllocator.dispose(p);
-}
-
-// Works with interfaces.
-@nogc nothrow pure @safe unittest
-{
-    interface I
-    {
-    }
-    class C : I
-    {
-    }
-    auto c = defaultAllocator.make!C();
-    I i = c;
-
-    defaultAllocator.dispose(i);
-    defaultAllocator.dispose(i);
-}
-
-// Handles "Cannot access frame pointer" error.
-@nogc nothrow pure @safe unittest
-{
-    struct F
-    {
-        ~this() @nogc nothrow pure @safe
-        {
-        }
-    }
-    static assert(is(typeof(emplace!F((void[]).init))));
-}
-
-// Can emplace structs without a constructor
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(typeof(emplace!WithDtor(null, WithDtor()))));
-    static assert(is(typeof(emplace!WithDtor(null))));
-}
-
-// Doesn't call a destructor on uninitialized elements
-@nogc nothrow pure @system unittest
-{
-    static struct SWithDtor
-    {
-        private bool canBeInvoked = false;
-        ~this() @nogc nothrow pure @safe
-        {
-            assert(this.canBeInvoked);
-        }
-    }
-    void[SWithDtor.sizeof] memory = void;
-    auto actual = emplace!SWithDtor(memory[], SWithDtor(true));
-    assert(actual.canBeInvoked);
-}
-
-// Initializes structs if no arguments are given
-@nogc nothrow pure @safe unittest
-{
-    static struct SEntry
-    {
-        byte content;
-    }
-    ubyte[1] mem = [3];
-
-    assert(emplace!SEntry(cast(void[]) mem[0 .. 1]).content == 0);
-}
-
-// Postblit is called when emplacing a struct
-@nogc nothrow pure @system unittest
-{
-    static struct S
-    {
-        bool called = false;
-        this(this) @nogc nothrow pure @safe
-        {
-            this.called = true;
-        }
-    }
-    S target;
-    S* sp = ⌖
-
-    emplace!S(sp[0 .. 1], S());
-    assert(target.called);
-}
-
-// Is pure.
-@nogc nothrow pure @system unittest
-{
-    struct S
-    {
-        this(this)
-        {
-        }
-    }
-    S source, target = void;
-    static assert(is(typeof({ moveEmplace(source, target); })));
-}
-
-// Moves nested.
-@nogc nothrow pure @system unittest
-{
-    struct Nested
-    {
-        void method() @nogc nothrow pure @safe
-        {
-        }
-    }
-    Nested source, target = void;
-    moveEmplace(source, target);
-    assert(source == target);
-}
-
-// Emplaces static arrays.
-@nogc nothrow pure @system unittest
-{
-    static struct S
-    {
-        size_t member;
-        this(size_t i) @nogc nothrow pure @safe
-        {
-            this.member = i;
-        }
-        ~this() @nogc nothrow pure @safe
-        {
-        }
-    }
-    S[2] source = [ S(5), S(5) ], target = void;
-    moveEmplace(source, target);
-    assert(source[0].member == 0);
-    assert(target[0].member == 5);
-    assert(source[1].member == 0);
-    assert(target[1].member == 5);
-}
-
-// Moves if source is target.
-@nogc nothrow pure @safe unittest
-{
-    int x = 5;
-    move(x, x);
-    assert(x == 5);
-}
-

tests/tanya/memory/tests/mallocator.d

@@ -1,21 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-module tanya.memory.tests.mallocator;
-
-import tanya.memory.mallocator;
-
-// Fails with false
-@nogc nothrow pure @system unittest
-{
-    void[] p = Mallocator.instance.allocate(20);
-    void[] oldP = p;
-    assert(!Mallocator.instance.reallocate(p, size_t.max - 16));
-    assert(oldP is p);
-    Mallocator.instance.deallocate(p);
-}
-
-@nogc nothrow pure unittest
-{
-    assert(Mallocator.instance.alignment == (void*).alignof);
-}

tests/tanya/memory/tests/mmappool.d

@@ -1,133 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-module tanya.memory.tests.mmappool;
-
-import tanya.memory.mmappool;
-
-@nogc nothrow pure @system unittest
-{
-    auto p = MmapPool.instance.allocate(20);
-    assert(p);
-    MmapPool.instance.deallocate(p);
-
-    p = MmapPool.instance.allocate(0);
-    assert(p.length == 0);
-}
-
-@nogc nothrow pure @system unittest
-{
-    auto p = MmapPool.instance.allocate(20);
-
-    assert(MmapPool.instance.deallocate(p));
-}
-
-@nogc nothrow pure @system unittest
-{
-    void[] p;
-    assert(!MmapPool.instance.reallocateInPlace(p, 5));
-    assert(p is null);
-
-    p = MmapPool.instance.allocate(1);
-    auto orig = p.ptr;
-
-    assert(MmapPool.instance.reallocateInPlace(p, 2));
-    assert(p.length == 2);
-    assert(p.ptr == orig);
-
-    assert(MmapPool.instance.reallocateInPlace(p, 4));
-    assert(p.length == 4);
-    assert(p.ptr == orig);
-
-    assert(MmapPool.instance.reallocateInPlace(p, 2));
-    assert(p.length == 2);
-    assert(p.ptr == orig);
-
-    MmapPool.instance.deallocate(p);
-}
-
-@nogc nothrow pure @system unittest
-{
-    void[] p;
-    MmapPool.instance.reallocate(p, 10 * int.sizeof);
-    (cast(int[]) p)[7] = 123;
-
-    assert(p.length == 40);
-
-    MmapPool.instance.reallocate(p, 8 * int.sizeof);
-
-    assert(p.length == 32);
-    assert((cast(int[]) p)[7] == 123);
-
-    MmapPool.instance.reallocate(p, 20 * int.sizeof);
-    (cast(int[]) p)[15] = 8;
-
-    assert(p.length == 80);
-    assert((cast(int[]) p)[15] == 8);
-    assert((cast(int[]) p)[7] == 123);
-
-    MmapPool.instance.reallocate(p, 8 * int.sizeof);
-
-    assert(p.length == 32);
-    assert((cast(int[]) p)[7] == 123);
-
-    MmapPool.instance.deallocate(p);
-}
-
-// A lot of allocations/deallocations, but it is the minimum caused a
-// segmentation fault because MmapPool reallocateInPlace moves a block wrong.
-@nogc nothrow pure @system unittest
-{
-    auto a = MmapPool.instance.allocate(16);
-    auto d = MmapPool.instance.allocate(16);
-    auto b = MmapPool.instance.allocate(16);
-    auto e = MmapPool.instance.allocate(16);
-    auto c = MmapPool.instance.allocate(16);
-    auto f = MmapPool.instance.allocate(16);
-
-    MmapPool.instance.deallocate(a);
-    MmapPool.instance.deallocate(b);
-    MmapPool.instance.deallocate(c);
-
-    a = MmapPool.instance.allocate(50);
-    MmapPool.instance.reallocateInPlace(a, 64);
-    MmapPool.instance.deallocate(a);
-
-    a = MmapPool.instance.allocate(1);
-    auto tmp1 = MmapPool.instance.allocate(1);
-    auto h1 = MmapPool.instance.allocate(1);
-    auto tmp2 = cast(ubyte[]) MmapPool.instance.allocate(1);
-
-    auto h2 = MmapPool.instance.allocate(2);
-    tmp1 = MmapPool.instance.allocate(1);
-    MmapPool.instance.deallocate(h2);
-    MmapPool.instance.deallocate(h1);
-
-    h2 = MmapPool.instance.allocate(2);
-    h1 = MmapPool.instance.allocate(1);
-    MmapPool.instance.deallocate(h2);
-
-    auto rep = cast(void[]) tmp2;
-    MmapPool.instance.reallocate(rep, tmp1.length);
-    tmp2 = cast(ubyte[]) rep;
-
-    MmapPool.instance.reallocate(tmp1, 9);
-
-    rep = cast(void[]) tmp2;
-    MmapPool.instance.reallocate(rep, tmp1.length);
-    tmp2 = cast(ubyte[]) rep;
-    MmapPool.instance.reallocate(tmp1, 17);
-
-    tmp2[$ - 1] = 0;
-
-    MmapPool.instance.deallocate(tmp1);
-
-    b = MmapPool.instance.allocate(16);
-
-    MmapPool.instance.deallocate(h1);
-    MmapPool.instance.deallocate(a);
-    MmapPool.instance.deallocate(b);
-    MmapPool.instance.deallocate(d);
-    MmapPool.instance.deallocate(e);
-    MmapPool.instance.deallocate(f);
-}

tests/tanya/memory/tests/op.d

@@ -1,67 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-module tanya.memory.tests.op;
-
-import tanya.memory.op;
-
-@nogc nothrow pure @system unittest
-{
-    ubyte[2] buffer = 1;
-    fill!0(buffer[1 .. $]);
-    assert(buffer[0] == 1 && buffer[1] == 0);
-}
-
-@nogc nothrow pure @safe unittest
-{
-    assert(equal(null, null));
-}
-
-@nogc nothrow pure @safe unittest
-{
-    ubyte[0] source, target;
-    source.copy(target);
-}
-
-@nogc nothrow pure @safe unittest
-{
-    ubyte[1] source = [1];
-    ubyte[1] target;
-    source.copy(target);
-    assert(target[0] == 1);
-}
-
-@nogc nothrow pure @safe unittest
-{
-    ubyte[8] source = [1, 2, 3, 4, 5, 6, 7, 8];
-    ubyte[8] target;
-    source.copy(target);
-    assert(equal(source, target));
-}
-
-@nogc nothrow pure @safe unittest
-{
-    ubyte[9] r1 = [ 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i' ];
-    ubyte[9] r2;
-
-    copyBackward(r1, r2);
-    assert(equal(r1, r2));
-}
-
-// Compares unanligned memory
-@nogc nothrow pure @safe unittest
-{
-    ubyte[16] r1 = [
-        'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
-        'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p',
-    ];
-    ubyte[16] r2 = [
-        'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
-        'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p',
-    ];
-
-    assert(equal(r1, r2));
-    assert(equal(r1[1 .. $], r2[1 .. $]));
-    assert(equal(r1[0 .. $ - 1], r2[0 .. $ - 1]));
-    assert(equal(r1[0 .. 8], r2[0 .. 8]));
-}

tests/tanya/memory/tests/smartref.d

@@ -1,253 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-module tanya.memory.tests.smartref;
-
-import tanya.memory.allocator;
-import tanya.memory.smartref;
-import tanya.meta.trait;
-import tanya.test.stub;
-
-@nogc @system unittest
-{
-    auto rc = defaultAllocator.refCounted!int(5);
-    rc = defaultAllocator.make!int(7);
-    assert(*rc == 7);
-}
-
-@nogc @system unittest
-{
-    RefCounted!int rc;
-    assert(!rc.isInitialized);
-    rc = null;
-    assert(!rc.isInitialized);
-}
-
-@nogc @system unittest
-{
-    auto rc = defaultAllocator.refCounted!int(5);
-
-    void func(RefCounted!int param) @nogc
-    {
-        assert(param.count == 2);
-        param = defaultAllocator.make!int(7);
-        assert(param.count == 1);
-        assert(*param == 7);
-    }
-    func(rc);
-    assert(rc.count == 1);
-    assert(*rc == 5);
-}
-
-@nogc @system unittest
-{
-    RefCounted!int rc;
-
-    void func(RefCounted!int param) @nogc
-    {
-        assert(param.count == 0);
-        param = defaultAllocator.make!int(7);
-        assert(param.count == 1);
-        assert(*param == 7);
-    }
-    func(rc);
-    assert(rc.count == 0);
-}
-
-@nogc @system unittest
-{
-    RefCounted!int rc1, rc2;
-    static assert(is(typeof(rc1 = rc2)));
-}
-
-@nogc @system unittest
-{
-    auto rc = RefCounted!int(defaultAllocator);
-    assert(!rc.isInitialized);
-    assert(rc.allocator is defaultAllocator);
-}
-
-@nogc @system unittest
-{
-    auto rc = defaultAllocator.refCounted!int(5);
-    assert(rc.count == 1);
-
-    void func(RefCounted!int rc) @nogc
-    {
-        assert(rc.count == 2);
-        rc = null;
-        assert(!rc.isInitialized);
-        assert(rc.count == 0);
-    }
-
-    assert(rc.count == 1);
-    func(rc);
-    assert(rc.count == 1);
-
-    rc = null;
-    assert(!rc.isInitialized);
-    assert(rc.count == 0);
-}
-
-@nogc @system unittest
-{
-    auto rc = defaultAllocator.refCounted!int(5);
-    assert(*rc == 5);
-
-    void func(RefCounted!int rc) @nogc
-    {
-        assert(rc.count == 2);
-        rc = defaultAllocator.refCounted!int(4);
-        assert(*rc == 4);
-        assert(rc.count == 1);
-    }
-    func(rc);
-    assert(*rc == 5);
-}
-
-@nogc @system unittest
-{
-    auto rc = defaultAllocator.refCounted!(int[])(5);
-    assert(rc.length == 5);
-}
-
-@nogc @system unittest
-{
-    auto p1 = defaultAllocator.make!int(5);
-    auto p2 = p1;
-    auto rc = RefCounted!int(p1, defaultAllocator);
-    assert(rc.get() is p2);
-}
-
-@nogc @system unittest
-{
-    size_t destroyed;
-    {
-        auto rc = defaultAllocator.refCounted!WithDtor(destroyed);
-    }
-    assert(destroyed == 1);
-}
-
-@nogc nothrow pure @system unittest
-{
-    auto s = defaultAllocator.unique!int(5);
-    assert(*s == 5);
-
-    s = null;
-    assert(s is null);
-}
-
-@nogc nothrow pure @system unittest
-{
-    auto s = defaultAllocator.unique!int(5);
-    assert(*s == 5);
-
-    s = defaultAllocator.unique!int(4);
-    assert(*s == 4);
-}
-
-@nogc nothrow pure @system unittest
-{
-    auto p1 = defaultAllocator.make!int(5);
-    auto p2 = p1;
-
-    auto rc = Unique!int(p1, defaultAllocator);
-    assert(rc.get() is p2);
-}
-
-@nogc nothrow pure @system unittest
-{
-    auto rc = Unique!int(defaultAllocator);
-    assert(rc.allocator is defaultAllocator);
-}
-
-@nogc @system unittest
-{
-    uint destroyed;
-    auto a = defaultAllocator.make!A(destroyed);
-
-    assert(destroyed == 0);
-    {
-        auto rc = RefCounted!A(a, defaultAllocator);
-        assert(rc.count == 1);
-
-        void func(RefCounted!A rc) @nogc @system
-        {
-            assert(rc.count == 2);
-        }
-        func(rc);
-
-        assert(rc.count == 1);
-    }
-    assert(destroyed == 1);
-
-    RefCounted!int rc;
-    assert(rc.count == 0);
-    rc = defaultAllocator.make!int(8);
-    assert(rc.count == 1);
-}
-
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(ReturnType!(RefCounted!int.get) == inout int*));
-    static assert(is(ReturnType!(RefCounted!A.get) == inout A));
-    static assert(is(ReturnType!(RefCounted!B.get) == inout B*));
-}
-
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(RefCounted!B));
-    static assert(is(RefCounted!A));
-}
-
-@nogc @system unittest
-{
-    struct E
-    {
-    }
-    auto b = defaultAllocator.refCounted!B(15);
-    static assert(is(typeof(b.prop) == int));
-    static assert(!is(typeof(defaultAllocator.refCounted!B())));
-
-    static assert(is(typeof(defaultAllocator.refCounted!E())));
-    static assert(!is(typeof(defaultAllocator.refCounted!E(5))));
-    {
-        auto rc = defaultAllocator.refCounted!B(3);
-        assert(rc.get().prop == 3);
-    }
-    {
-        auto rc = defaultAllocator.refCounted!E();
-        assert(rc.count);
-    }
-}
-
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(typeof(defaultAllocator.unique!B(5))));
-    static assert(is(typeof(defaultAllocator.unique!(int[])(5))));
-}
-
-private class A
-{
-    uint *destroyed;
-
-    this(ref uint destroyed) @nogc
-    {
-        this.destroyed = &destroyed;
-    }
-
-    ~this() @nogc
-    {
-        ++(*destroyed);
-    }
-}
-
-private struct B
-{
-    int prop;
-    @disable this();
-    this(int param1) @nogc
-    {
-        prop = param1;
-    }
-}

tests/tanya/meta/tests/metafunction.d

@@ -1,30 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-module tanya.meta.tests.metafunction;
-
-import tanya.meta.metafunction;
-
-@nogc nothrow pure @safe unittest
-{
-    enum cmp(int x, int y) = x - y;
-    static assert(isSorted!(cmp));
-    static assert(isSorted!(cmp, 1));
-    static assert(isSorted!(cmp, 1, 2, 2));
-    static assert(isSorted!(cmp, 1, 2, 2, 4));
-    static assert(isSorted!(cmp, 1, 2, 2, 4, 8));
-    static assert(!isSorted!(cmp, 32, 2, 2, 4, 8));
-    static assert(isSorted!(cmp, 32, 32));
-}
-
-@nogc nothrow pure @safe unittest
-{
-    enum cmp(int x, int y) = x < y;
-    static assert(isSorted!(cmp));
-    static assert(isSorted!(cmp, 1));
-    static assert(isSorted!(cmp, 1, 2, 2));
-    static assert(isSorted!(cmp, 1, 2, 2, 4));
-    static assert(isSorted!(cmp, 1, 2, 2, 4, 8));
-    static assert(!isSorted!(cmp, 32, 2, 2, 4, 8));
-    static assert(isSorted!(cmp, 32, 32));
-}

tests/tanya/meta/tests/trait.d

@@ -1,172 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-module tanya.meta.tests.trait;
-
-import tanya.meta.metafunction;
-import tanya.meta.trait;
-
-// typeof(null) is not a pointer.
-@nogc nothrow pure @safe unittest
-{
-    static assert(!isPointer!(typeof(null)));
-    static assert(!isPointer!(const shared typeof(null)));
-
-    enum typeOfNull : typeof(null)
-    {
-        null_ = null,
-    }
-    static assert(!isPointer!typeOfNull);
-}
-
-@nogc nothrow pure @safe unittest
-{
-    static struct S
-    {
-        @property int opCall()
-        {
-            return 0;
-        }
-    }
-    S s;
-    static assert(isCallable!S);
-    static assert(isCallable!s);
-}
-
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(FunctionTypeOf!(void delegate()) == function));
-
-    static void staticFunc()
-    {
-    }
-    auto functionPointer = &staticFunc;
-    static assert(is(FunctionTypeOf!staticFunc == function));
-    static assert(is(FunctionTypeOf!functionPointer == function));
-
-    void func()
-    {
-    }
-    auto dg = &func;
-    static assert(is(FunctionTypeOf!func == function));
-    static assert(is(FunctionTypeOf!dg == function));
-
-    interface I
-    {
-        @property int prop();
-    }
-    static assert(is(FunctionTypeOf!(I.prop) == function));
-
-    static struct S
-    {
-        void opCall()
-        {
-        }
-    }
-    class C
-    {
-        static void opCall()
-        {
-        }
-    }
-    S s;
-
-    static assert(is(FunctionTypeOf!s == function));
-    static assert(is(FunctionTypeOf!C == function));
-    static assert(is(FunctionTypeOf!S == function));
-}
-
-@nogc nothrow pure @safe unittest
-{
-    static struct S2
-    {
-        @property int opCall()
-        {
-            return 0;
-        }
-    }
-    S2 s2;
-    static assert(is(FunctionTypeOf!S2 == function));
-    static assert(is(FunctionTypeOf!s2 == function));
-}
-
-@nogc nothrow pure @safe unittest
-{
-    static assert(!hasElaborateAssign!int);
-
-    static struct S1
-    {
-        void opAssign(S1)
-        {
-        }
-    }
-    static struct S2
-    {
-        void opAssign(int)
-        {
-        }
-    }
-    static struct S3
-    {
-        S1 s;
-        alias s this;
-    }
-    static assert(hasElaborateAssign!S1);
-    static assert(!hasElaborateAssign!(const S1));
-    static assert(hasElaborateAssign!(S1[1]));
-    static assert(!hasElaborateAssign!(S1[0]));
-    static assert(!hasElaborateAssign!S2);
-    static assert(hasElaborateAssign!S3);
-
-    static struct S4
-    {
-        void opAssign(S4)
-        {
-        }
-        @disable this(this);
-    }
-    static assert(hasElaborateAssign!S4);
-}
-
-// Produces a tuple for an enum with only one member
-@nogc nothrow pure @safe unittest
-{
-    enum E : int
-    {
-        one = 0,
-    }
-    static assert(EnumMembers!E == AliasSeq!0);
-}
-
-@nogc nothrow pure @safe unittest
-{
-    class RefCountedStore(T)
-    {
-    }
-    static assert(!isInnerClass!(RefCountedStore!int));
-}
-
-@nogc nothrow pure @safe unittest
-{
-    static struct DisabledOpEquals
-    {
-        @disable bool opEquals(typeof(this)) @nogc nothrow pure @safe;
-
-        int opCmp(typeof(this)) @nogc nothrow pure @safe
-        {
-            return 0;
-        }
-    }
-    static assert(!isEqualityComparable!DisabledOpEquals);
-    static assert(isOrderingComparable!DisabledOpEquals);
-
-    static struct OpEquals
-    {
-        bool opEquals(typeof(this)) @nogc nothrow pure @safe
-        {
-            return true;
-        }
-    }
-    static assert(isEqualityComparable!OpEquals);
-    static assert(!isOrderingComparable!OpEquals);
-}

tests/tanya/net/tests/iface.d

@@ -1,25 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-module tanya.net.tests.iface;
-
-import std.algorithm.comparison;
-import std.utf;
-import tanya.net.iface;
-
-@nogc nothrow @safe unittest
-{
-    version (linux)
-    {
-        assert(equal(indexToName(1)[], "lo".byChar));
-    }
-    else version (Windows)
-    {
-        assert(equal(indexToName(1)[], "loopback_0"));
-    }
-    else
-    {
-        assert(equal(indexToName(1)[], "lo0"));
-    }
-    assert(indexToName(uint.max).empty);
-}

tests/tanya/net/tests/inet.d

@@ -1,16 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-module tanya.net.tests.inet;
-
-import tanya.net.inet;
-import tanya.range;
-
-// Static tests
-@nogc nothrow pure @safe unittest
-{
-    static assert(isBidirectionalRange!(NetworkOrder!4));
-    static assert(isBidirectionalRange!(NetworkOrder!8));
-    static assert(!is(NetworkOrder!9));
-    static assert(!is(NetworkOrder!1));
-}

tests/tanya/net/tests/ip.d

@@ -1,154 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-module tanya.net.tests.ip;
-
-import tanya.net.ip;
-import tanya.range;
-
-// Rejects malformed addresses
-@nogc nothrow pure @safe unittest
-{
-    assert(address4("256.0.0.1").isNull);
-    assert(address4(".0.0.1").isNull);
-    assert(address4("0..0.1").isNull);
-    assert(address4("0.0.0.").isNull);
-    assert(address4("0.0.").isNull);
-    assert(address4("").isNull);
-}
-
-@nogc nothrow pure @safe unittest
-{
-    assert(address4(cast(ubyte[]) []).isNull);
-}
-
-// Assignment and comparison works
-@nogc nothrow pure @safe unittest
-{
-    auto address1 = Address4.loopback();
-    auto address2 = Address4.any();
-    address1 = address2;
-    assert(address1 == address2);
-}
-
-@nogc nothrow @safe unittest
-{
-    char[18] actual;
-
-    address6("ff00:2:3:4:5:6:7:8").get.toString(arrayInserter(actual));
-    assert(actual[] == "ff00:2:3:4:5:6:7:8");
-}
-
-// Skips zero group in the middle
-@nogc nothrow @safe unittest
-{
-    char[12] actual;
-
-    address6("1::4:5:6:7:8").get.toString(arrayInserter(actual));
-    assert(actual[] == "1::4:5:6:7:8");
-}
-
-// Doesn't replace lonely zeroes
-@nogc nothrow @safe unittest
-{
-    char[15] actual;
-
-    address6("0:1:0:2:3:0:4:0").get.toString(arrayInserter(actual));
-    assert(actual[] == "0:1:0:2:3:0:4:0");
-}
-
-// Skips zero group at the beginning
-@nogc nothrow @safe unittest
-{
-    char[13] actual;
-
-    address6("::3:4:5:6:7:8").get.toString(arrayInserter(actual));
-    assert(actual[] == "::3:4:5:6:7:8");
-}
-
-// Skips zero group at the end
-@nogc nothrow @safe unittest
-{
-    char[13] actual;
-
-    address6("1:2:3:4:5:6::").get.toString(arrayInserter(actual));
-    assert(actual[] == "1:2:3:4:5:6::");
-}
-
-@nogc nothrow @safe unittest
-{
-    ubyte[16] expected = [0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7, 0, 8];
-    auto actual = address6("1:2:3:4:5:6:7:8");
-    assert(actual.get.toBytes() == expected);
-}
-
-@nogc nothrow @safe unittest
-{
-    ubyte[16] expected;
-    auto actual = address6("::");
-    assert(actual.get.toBytes() == expected);
-}
-
-@nogc nothrow @safe unittest
-{
-    ubyte[16] expected = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1];
-    auto actual = address6("::1");
-    assert(actual.get.toBytes() == expected);
-}
-
-@nogc nothrow @safe unittest
-{
-    ubyte[16] expected = [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
-    auto actual = address6("1::");
-    assert(actual.get.toBytes() == expected);
-}
-
-// Rejects malformed addresses
-@nogc nothrow @safe unittest
-{
-    assert(address6("").isNull);
-    assert(address6(":").isNull);
-    assert(address6(":a").isNull);
-    assert(address6("a:").isNull);
-    assert(address6("1:2:3:4::6:").isNull);
-    assert(address6("fe80:2:3:4::6:7:8%").isNull);
-}
-
-// Parses embedded IPv4 address
-@nogc nothrow @safe unittest
-{
-    ubyte[16] expected = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4];
-    auto actual = address6("0:0:0:0:0:0:1.2.3.4");
-    assert(actual.get.toBytes() == expected);
-}
-
-@nogc nothrow @safe unittest
-{
-    ubyte[16] expected = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4];
-    auto actual = address6("::1.2.3.4");
-    assert(actual.get.toBytes() == expected);
-}
-
-@nogc nothrow @safe unittest
-{
-    ubyte[16] expected = [0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 6, 1, 2, 3, 4];
-    auto actual = address6("::5:6:1.2.3.4");
-    assert(actual.get.toBytes() == expected);
-}
-
-@nogc nothrow @safe unittest
-{
-    assert(address6("0:0:0:0:0:0:1.2.3.").isNull);
-    assert(address6("0:0:0:0:0:0:1.2:3.4").isNull);
-    assert(address6("0:0:0:0:0:0:1.2.3.4.").isNull);
-    assert(address6("fe80:0:0:0:0:0:1.2.3.4%1").get.scopeID == 1);
-}
-
-// Can assign another address
-@nogc nothrow pure @safe unittest
-{
-    Address actual = Address4.loopback;
-    Address expected = Address6.loopback;
-    actual = expected;
-    assert(actual == expected);
-}