Refactor allSatisfy, anySatisfy, staticIndexOf

In tanya.algorithm.iteration.take & retro preserve const/inout for `empty`/`front`/etc.

.gitignore

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

.travis.yml

@@ -1,23 +1,69 @@
 sudo: false
 
 os:
- - linux
+- linux
- - osx
+- osx
 
 language: d
 
 d:
- - dmd-2.074.0
+- dmd-2.085.0
- - dmd-2.073.2
+- dmd-2.081.2
- - dmd-2.072.2
- - dmd-2.071.2
 
-env: 
+env:
- matrix:
+  global:
+  - LATEST=2.085.0
+
+  matrix:
   - ARCH=x86_64
+  - ARCH=x86
+
+matrix:
+  include:
+  - name: D-Scanner
+    d: dmd-$LATEST
+    env: DSCANNER=0.7.0
+    os: linux
+  - name: DDoc
+    d: dmd-$LATEST
+    env: DDOC=true
+    os: linux
+
+addons:
+  apt:
+    packages:
+    - gcc-multilib
+
+before_script:
+- if [ "`$DC --version | head -n 1 | grep v$LATEST`" ] &&
+     [ -z "$DSCANNER$DDOC" ]; then
+    export UNITTEST="unittest-cov";
+  fi
 
 script:
- - dub test -b unittest-cov --arch=$ARCH
+- set -e;
+  if [ -n "$DDOC" ]; then
+    dub build :meta -b ddox --compiler=$DC;
+    dub build :sys -b ddox --compiler=$DC;
+    dub build :os -b ddox --compiler=$DC;
+    dub build :encoding -b ddox --compiler=$DC;
+    dub build :middle -b ddox --compiler=$DC;
+    dub build :test -b ddox --compiler=$DC;
+    dub build -b ddox --compiler=$DC;
+  elif [ -z "$DSCANNER" ]; then
+    dub test :meta -b ${UNITTEST:-unittest} --arch=$ARCH --compiler=$DC;
+    dub test :sys -b ${UNITTEST:-unittest} --arch=$ARCH --compiler=$DC;
+    dub test :os -b ${UNITTEST:-unittest} --arch=$ARCH --compiler=$DC;
+    dub test :encoding -b ${UNITTEST:-unittest} --arch=$ARCH --compiler=$DC;
+    dub test :middle -b ${UNITTEST:-unittest} --arch=$ARCH --compiler=$DC;
+    dub test :test -b ${UNITTEST:-unittest} --arch=$ARCH --compiler=$DC;
+    dub test -b ${UNITTEST:-unittest} --arch=$ARCH --compiler=$DC;
+  else
+    dub fetch dscanner --version=$DSCANNER;
+
+    FILES=$(find */tanya -type f);
+    dub run dscanner -- --styleCheck $FILES;
+  fi
 
 after_success:
- - bash <(curl -s https://codecov.io/bash)
+- test "$UNITTEST" && bash <(curl -s https://codecov.io/bash) || true

CODE_OF_CONDUCT.md

@@ -0,0 +1,5 @@
+# Contributor Code of Conduct
+
+This project adheres to No Code of Conduct.  We are all adults.  We accept anyone's contributions.  Nothing else matters.
+
+For more information please visit the [No Code of Conduct](https://github.com/domgetter/NCoC) homepage.

CONTRIBUTING.md

@@ -0,0 +1,107 @@
+
+# Contributing
+
+Tanya is a project in active development, therefore any help is appreciated. Thank you for considering contributing
+to it, feel welcome.
+These guidelines describe ways to get started.
+
+
+## Ways to get involved
+
+* **Reporting a problem**: [Report](https://github.com/caraus-ecms/tanya/issues) bugs and usage problems you
+encounter.
+* **Fixing issues**: [The bug tracker](https://github.com/caraus-ecms/tanya/issues) contains a list of issues you
+can work on.
+* **Documentation**: You can improve API documentation by correcting grammar errors, completing existing texts and
+writing new ones, or providing usage examples.
+* **Testing**: Test coverage is important for a library. Writing tests is not only helpful, but is also a great way
+to get a feel for how tanya works.
+* **Adding new features**: Tanya is a growing library. If you think some feature is missing, you can suggest
+and implement this.
+
+
+## Opening an issue
+
+If you have found a bug, an error, have some question, or suggestion,
+[Open an issue](https://github.com/caraus-ecms/tanya/issues). I'll try to answer as soon as I can. There is also a
+list of open issues that mirror the current development process and progress. If you're looking for a challenge, just
+pick an issue you are interested in and start working on it. Fill free to comment on the issue to get more
+information.
+
+You can also look at the [milestones](https://github.com/Dlackware/gnome/milestones) to see what is planned for a
+specific release.
+
+
+## Contribution process
+
+### Creating a pull request
+
+I accept GitHub pull requests. Creating a pull request is like sending a patch with the suggested change.
+First you have to [fork](https://guides.github.com/activities/forking/) the repository. Clone your fork locally
+with `git clone` and create a new branch where you want to work. For example:
+
+```shell
+git checkout -b bugfix-x
+```
+Commit your changes to your fork:
+
+```shell
+git commit -m "Fix X"
+git push -u origin bugfix-x
+```
+
+After that if you visit your fork on GitHub, GitHub will suggest to create pull request. Just follow the steps
+described on GitHub to finish the process. See
+[Using Pull Requests](https://help.github.com/articles/about-pull-requests/) for more information.
+
+Please ensure that your fork is even with the upstream (original) repository. If not, you have to rebase your branch
+on upstream/master before submitting the pull request. See [Syncing a fork](https://help.github.com/articles/syncing-a-fork/) for a
+step-by-step guide.
+
+### Fixing a bug
+
+Add a unit test that demonstrates the bug along with a short description or link to the original bug.
+
+### Adding new features
+
+* Use Ddoc to document the feature.
+* Add some unit tests to prevent bugs.
+* [Documented D unit tests](https://dlang.org/spec/ddoc.html#using_ddoc_to_generate_examples) go into the documentation and can be used as an usage
+example. These tests should be readable and not complicated since they demonstrate how the feature is supposed to work.
+* More advanced tests should be put into a separate not documented unittest block.
+
+### Writing unit tests
+
+```d
+///
+unittest
+{
+    // A documented unit test has three slashes in front of it.
+}
+
+// Issue ##: https://github.com/caraus-ecms/tanya/issues/##.
+unittest
+{
+    // Not documented unit test may still have a description.
+}
+```
+
+### Style guide
+
+Make sure your changes follow [The D Style](https://dlang.org/dstyle.html) (including
+[Additional Requirements for Phobos](https://dlang.org/dstyle.html#phobos)).
+
+You can also use [dscanner](https://github.com/dlang-community/D-Scanner) to test the new code against the
+most guidlines. The root of this repository contains
+[dscanner.ini](https://github.com/caraus-ecms/tanya/blob/master/dscanner.ini), configuration file with settings for an
+automatic style check. Just go to the top-level directory and issue (this assumes `dscanner` is installed in your
+system):
+
+```shell
+dscanner --styleCheck source
+```
+
+## Questions and suggestions
+
+* [Open an issue](https://github.com/caraus-ecms/tanya/issues)
+* [Send an email](mailto:info@caraus.de)

README.md

@@ -1,6 +1,6 @@
 # Tanya
 
-[![Build status](https://travis-ci.org/caraus-ecms/tanya.svg?branch=master)](https://travis-ci.org/caraus-ecms/tanya)
+[![Build Status](https://travis-ci.com/caraus-ecms/tanya.svg?branch=master)](https://travis-ci.com/caraus-ecms/tanya)
 [![Build status](https://ci.appveyor.com/api/projects/status/djkmverdfsylc7ti/branch/master?svg=true)](https://ci.appveyor.com/project/belka-ew/tanya/branch/master)
 [![codecov](https://codecov.io/gh/caraus-ecms/tanya/branch/master/graph/badge.svg)](https://codecov.io/gh/caraus-ecms/tanya)
 [![Dub version](https://img.shields.io/dub/v/tanya.svg)](https://code.dlang.org/packages/tanya)
@@ -12,61 +12,205 @@ 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 extends Phobos functionality and provides alternative implementations for
+Tanya provides data structures and utilities to facilitate painless systems
-data structures and utilities that depend on the Garbage Collector in Phobos.
+programming in D.
+
+* [API Documentation](https://docs.caraus.io/tanya)
+* [Contribution guidelines](CONTRIBUTING.md)
 
-* [Bug tracker](https://issues.caraus.io/projects/tanya)
-* [Documentation](https://docs.caraus.io/tanya)
 
 ## Overview
 
-Tanya consists of the following packages:
+Tanya consists of the following packages and (top-level) modules:
 
+* `algorithm`: Collection of generic algorithms.
 * `async`: Event loop (epoll, kqueue and IOCP).
+* `bitmanip`: Bit manipulation.
 * `container`: Queue, Array, Singly and doubly linked lists, Buffers, UTF-8
-string.
+string, Set, Hash table.
+* `conv`: This module provides functions for converting between different
+types.
+* `encoding`: This package provides tools to work with text encodings.
+* `format`: Formatting and conversion functions.
+* `functional`: Functions that manipulate other functions and their argument
+lists.
+* `hash`: Hash algorithms.
 * `math`: Arbitrary precision integer and a set of functions.
-* `memory`: Tools for manual memory management (allocator, reference counting,
+* `memory`: Tools for manual memory management (allocators, smart pointers).
-helper functions).
+* `meta`: Template metaprogramming. This package contains utilities to acquire
-* `network`: URL-Parsing, sockets, utilities.
+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.
+* `network`: Socket implementation. `network` is currently under rework.
+After finishing the new socket implementation will land in the `net` package and
+`network` will be deprecated.
+* `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
 
 ### Supported compilers
 
-| dmd     |
+| DMD               | GCC             |
-|:-------:|
+|:-----------------:|:---------------:|
-| 2.074.0 |
+| 2.081.2 — 2.085.0 | gdc-8 (2.081.2) |
-| 2.073.2 |
+|                   | gdc-7 (2.081.2) |
-| 2.072.2 |
-| 2.071.2 |
 
-### Current status
+### Release management
 
-Following modules are under development:
+Tanya is still under active development and it isn't possible to provide great
+backwards-compatibility at this stage. This won't change until 1.0.0. Almost
+every release contains new features or API changes alongside bug fixes. Thus:
 
-| Feature      | Branch       | Build status                                                                                                                                                                                                                                                                                                 |
+- Patch releases add new functionality and bug fixes in a backwards-compatible
-|--------------|:------------:|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+manner
-| BitVector    | bitvector    | [![bitvector](https://travis-ci.org/caraus-ecms/tanya.svg?branch=bitvector)](https://travis-ci.org/caraus-ecms/tanya) [![bitvector](https://ci.appveyor.com/api/projects/status/djkmverdfsylc7ti/branch/bitvector?svg=true)](https://ci.appveyor.com/project/belka-ew/tanya/branch/bitvector)                |
-| TLS          | crypto       | [![crypto](https://travis-ci.org/caraus-ecms/tanya.svg?branch=crypto)](https://travis-ci.org/caraus-ecms/tanya) [![crypto](https://ci.appveyor.com/api/projects/status/djkmverdfsylc7ti/branch/crypto?svg=true)](https://ci.appveyor.com/project/belka-ew/tanya/branch/crypto)                               |
-| File IO      | io           | [![io](https://travis-ci.org/caraus-ecms/tanya.svg?branch=io)](https://travis-ci.org/caraus-ecms/tanya) [![io](https://ci.appveyor.com/api/projects/status/djkmverdfsylc7ti/branch/io?svg=true)](https://ci.appveyor.com/project/belka-ew/tanya/branch/io)                                                   |
-| Hash table   | horton-table | [![horton-table](https://travis-ci.org/caraus-ecms/tanya.svg?branch=horton-table)](https://travis-ci.org/caraus-ecms/tanya) [![horton-table](https://ci.appveyor.com/api/projects/status/djkmverdfsylc7ti/branch/horton-table?svg=true)](https://ci.appveyor.com/project/belka-ew/tanya/branch/horton-table) |
 
-### Further characteristics
+- Minor releases contain API breakages
 
-* Tanya is a native D library.
+- Major release number is always the same: `0.x.x`
 
-* Tanya is cross-platform. The development happens on a 64-bit Linux, but it
+Deprecated functionality is where possible marked as such before getting
-is being tested on Windows and FreeBSD as well.
+removed. It is left in the library for one release: If 0.8.1 deprecates some
+feature, it is removed in the next release: 0.9.0.
 
-* The library isn't thread-safe. Thread-safity should be added later.
+## Further characteristics
 
-## Release management
+- Tanya is a native D library
 
-3-week release cycle.
+- Tanya is cross-platform. The development happens on a 64-bit Linux, but it
+is being tested on Windows and FreeBSD as well
 
-## Contributing
+- Tanya favours generic algorithms therefore there is no auto-decoding. Char
+arrays are handled as any other array type
 
-Since I'm mostly busy writing new code and implementing new features I would
+- The library isn't thread-safe yet
-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: info@caraus.de.
+- Complex numbers (`cfloat`, `cdouble`, `creal`, `ifloat`, `idouble`, `ireal`)
+aren't supported
+
+
+## Feedback
+
+Any feedback about your experience with tanya would be greatly appreciated. Feel free to
+[contact me](mailto:info@caraus.de).

appveyor.yml

@@ -1,52 +1,60 @@
 platform: x64
-os: Visual Studio 2017
+os: Visual Studio 2015
 
 environment:
- matrix:
+  matrix:
-  - DC: dmd
+    - DC: dmd
-    DVersion: 2.074.0
+      DVersion: 2.085.0
-    arch: x86
+      arch: x64
-  - DC: dmd
+    - DC: dmd
-    DVersion: 2.073.2
+      DVersion: 2.085.0
-    arch: x86
+      arch: x86
-  - DC: dmd
+    - DC: dmd
-    DVersion: 2.072.2
+      DVersion: 2.081.2
-    arch: x86
+      arch: x64
-  - DC: dmd
+    - DC: dmd
-    DVersion: 2.071.2
+      DVersion: 2.081.2
-    arch: x86
+      arch: x86
 
 skip_tags: true
 
 install:
   - ps: function SetUpDCompiler
         {
-            $env:toolchain = "msvc";
+          $env:toolchain = "msvc";
-            $version = $env:DVersion;
+          $version = $env:DVersion;
-            Invoke-WebRequest "http://downloads.dlang.org/releases/2.x/$($version)/dmd.$($version).windows.7z" -OutFile "c:\dmd.7z";
+          Invoke-WebRequest "http://downloads.dlang.org/releases/2.x/$($version)/dmd.$($version).windows.7z" -OutFile "c:\dmd.7z";
-            echo "finished.";
+          echo "finished.";
-            pushd c:\\;
+          pushd c:\\;
-            7z x dmd.7z > $null;
+          7z x dmd.7z > $null;
-            popd;
+          popd;
         }
   - ps: SetUpDCompiler
 
-  - ps: if($env:DVersion -eq "2.071.2"){
-            Invoke-WebRequest "http://code.dlang.org/files/dub-1.2.1-windows-x86.zip" -OutFile "dub.zip";
-            7z x dub.zip -odub > $null;
-            Move-Item "dub/dub.exe" "C:\dmd2\windows\bin"
-          }
-
 before_build:
+  - ps: if($env:arch -eq "x86"){
+          $env:compilersetupargs = "x86";
+          $env:Darch = "x86_mscoff";
+        }
+        elseif($env:arch -eq "x64"){
+          $env:compilersetupargs = "amd64";
+          $env:Darch = "x86_64";
+        }
   - ps: $env:PATH += ";C:\dmd2\windows\bin;";
-  - call "C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\Common7\Tools\VsDevCmd.bat" -arch=%arch%
+  - call "C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall" %compilersetupargs%
 
 build_script:
- - echo dummy build script - dont remove me
+  - echo dummy build script - dont remove me
 
 test_script:
- - echo %DC%
+  - echo %Darch%
- - echo %PATH%
+  - echo %PATH%
- - 'dub --version'
+  - 'dub --version'
- - '%DC% --version'
+  - '%DC% --version'
- - dub test --arch=x86 --compiler=%DC%
+  - dub test :meta -b unittest --arch=%Darch% --compiler=%DC%
+  - dub test :sys -b unittest --arch=%Darch% --compiler=%DC%
+  - dub test :os -b unittest --arch=%Darch% --compiler=%DC%
+  - dub test :encoding -b unittest --arch=%Darch% --compiler=%DC%
+  - dub test :middle -b unittest --arch=%Darch% --compiler=%DC%
+  - dub test :test -b unittest --arch=%Darch% --compiler=%DC%
+  - dub test -b unittest --arch=%Darch% --compiler=%DC%

arch/build.ninja

@@ -0,0 +1,14 @@
+rule gas
+  command = gcc -c $in -o $out
+
+rule archive
+  command = ar rcs $out $in
+
+build abs.o: gas x64/linux/math/abs.S
+build log.o: gas x64/linux/math/log.S
+build equal.o: gas x64/linux/memory/equal.S
+build fill.o: gas x64/linux/memory/fill.S
+build copy.o: gas x64/linux/memory/copy.S
+build syscall.o: gas x64/linux/syscall.S
+
+build tanya.a: archive syscall.o copy.o fill.o equal.o log.o abs.o

arch/x64/linux/concurrency/thread.S

@@ -0,0 +1,8 @@
+	.text
+
+	.globl thrd_current
+	.type thrd_current, @function
+
+thrd_current:
+	mov %fs:0, %rax
+	ret

arch/x64/linux/math/abs.S

@@ -0,0 +1,35 @@
+	.text
+
+
+// fabsf.
+	.globl _D5tanya4math8nbtheory4fabsFNaNbNiNffZf
+	.type _D5tanya4math8nbtheory4fabsFNaNbNiNffZf, @function
+
+_D5tanya4math8nbtheory4fabsFNaNbNiNffZf:
+	mov $0x7fffffff, %eax
+	movq %rax, %xmm1
+	andpd %xmm1, %xmm0
+	ret
+
+
+// fabs.
+	.globl _D5tanya4math8nbtheory4fabsFNaNbNiNfdZd
+	.type _D5tanya4math8nbtheory4fabsFNaNbNiNfdZd, @function
+
+_D5tanya4math8nbtheory4fabsFNaNbNiNfdZd:
+	mov $0x7fffffffffffffff, %rax
+	movq %rax, %xmm1
+	andpd %xmm1, %xmm0
+	ret
+
+
+// fabsl.
+	.globl _D5tanya4math8nbtheory4fabsFNaNbNiNfeZe
+	.type _D5tanya4math8nbtheory4fabsFNaNbNiNfeZe, @function
+
+// Load the parameter from the stack onto FP stack, execute 'fabs' instruction
+// The result is returned in ST0.
+_D5tanya4math8nbtheory4fabsFNaNbNiNfeZe:
+	fldt 0x8(%rsp)
+	fabs
+	ret

arch/x64/linux/math/log.S

@@ -0,0 +1,48 @@
+	.text
+
+
+// logf.
+	.globl _D5tanya4math8nbtheory4logfFNaNbNiNffZf
+	.type _D5tanya4math8nbtheory4logfFNaNbNiNffZf, @function
+
+_D5tanya4math8nbtheory4logfFNaNbNiNffZf:
+	movss %xmm0, -4(%rsp) // Put the argument onto the stack
+
+	fldln2 // Put lb(e) onto the FPU stack
+	flds -4(%rsp) // Put a float onto the FPU stack
+	fyl2x // %st1 * lb(%st0)
+
+	 // The result is on the FPU stack, but returned in %xmm0
+	fstps -4(%rsp)
+	movss -4(%rsp), %xmm0
+
+	ret
+
+
+// log.
+	.globl _D5tanya4math8nbtheory3logFNaNbNiNfdZd
+	.type _D5tanya4math8nbtheory3logFNaNbNiNfdZd, @function
+
+_D5tanya4math8nbtheory3logFNaNbNiNfdZd:
+	movsd %xmm0, -8(%rsp) // Put the argument onto the stack
+
+	fldln2 // Put lb(e) onto the FPU stack
+	fldl -8(%rsp) // Put a double onto the FPU stack
+	fyl2x // %st1 * lb(%st0)
+
+	 // The result is on the FPU stack, but returned in %xmm0
+	fstpl -8(%rsp)
+	movsd -8(%rsp), %xmm0
+
+	ret
+
+
+// logl.
+	.globl _D5tanya4math8nbtheory4loglFNaNbNiNfeZe
+	.type _D5tanya4math8nbtheory4loglFNaNbNiNfeZe, @function
+
+_D5tanya4math8nbtheory4loglFNaNbNiNfeZe:
+	fldln2 // Put lb(e) onto the FPU stack
+	fldt 8(%rsp) // Put the argument onto the FPU stack
+	fyl2x // %st1 * lb(%st0)
+	ret

arch/x64/linux/memory/copy.S

@@ -0,0 +1,67 @@
+	.text
+
+/*
+ * copyMemory.
+ *
+ * rdi - source length
+ * rsi - source data.
+ * rdx - target length.
+ * rcx - target data.
+ */
+	.globl _D5tanya6memory2op10copyMemoryFNaNbNixAvAvZv
+	.type _D5tanya6memory2op10copyMemoryFNaNbNixAvAvZv, @function
+
+_D5tanya6memory2op10copyMemoryFNaNbNixAvAvZv:
+		mov %rdi, %rdx
+		mov %rcx, %rdi
+
+		cmp  $0x08, %rdx
+		jc aligned_1
+		test $0x07, %edi
+		jz aligned_8
+
+	naligned:
+		movsb
+		dec  %rdx
+		test $0x07, %edi
+		jnz naligned
+
+	aligned_8:
+		mov %rdx,  %rcx
+		shr $0x03, %rcx
+		rep movsq
+		and $0x07, %edx
+		jz end
+
+	aligned_1:
+		// Write the remaining bytes
+		mov %rdx, %rcx
+		rep movsb
+
+	end:
+		ret
+
+/*
+ * moveMemory.
+ *
+ * rdi - source length
+ * rsi - source data.
+ * rdx - target length.
+ * rcx - target data.
+ */
+	.globl _D5tanya6memory2op10moveMemoryFNaNbNixAvAvZv
+	.type _D5tanya6memory2op10moveMemoryFNaNbNixAvAvZv, @function
+
+_D5tanya6memory2op10moveMemoryFNaNbNixAvAvZv:
+		mov %rdi, %rdx
+
+		lea -1(%rdx, %rsi), %rsi
+		lea -1(%rdx, %rcx), %rdi
+		mov %rdx, %rcx
+
+		std // Set the direction flag
+
+		rep movsb
+
+		cld // Clear the direction flag
+		ret

arch/x64/linux/memory/equal.S

@@ -0,0 +1,59 @@
+	.text
+
+/*
+ * equalMemory.
+ *
+ * rdi - r1 length
+ * rsi - r1 data.
+ * rdx - r2 length.
+ * rcx - r2 data.
+ */
+	.globl _D5tanya6memory2op11equalMemoryFNaNbNixAvxQdZb
+	.type _D5tanya6memory2op11equalMemoryFNaNbNixAvxQdZb, @function
+_D5tanya6memory2op11equalMemoryFNaNbNixAvxQdZb:
+		// Compare the lengths
+		cmp %rdx, %rdi
+		jne not_equal
+
+		mov %rcx, %rdi
+
+		// Check if we're aligned
+		cmp $0x08, %rdx
+		jc aligned_1
+		test $0x07, %edi
+		jz aligned_8
+
+	naligned:
+		cmpsb
+		jne not_equal
+
+		dec %rdx
+		test $0x07, %edi
+		jnz naligned
+
+	aligned_8:
+		mov %rdx,  %rcx
+		shr $0x03, %rcx
+
+		repe cmpsq
+		jne not_equal
+
+		and $0x07, %edx
+		jz equal
+
+	aligned_1: // Compare the remaining bytes
+		mov %rdx, %rcx
+		cmp $0x0, %rcx
+
+		repe cmpsb
+		jne not_equal
+
+	equal:
+		mov $0x01, %rax // Return 1
+		jmp end
+
+	not_equal:
+		xor %rax, %rax // Return 0
+
+	end:
+		ret

arch/x64/linux/memory/fill.S

@@ -0,0 +1,160 @@
+	.text
+
+/*
+ * fillMemory.
+ *
+ * rdi - length.
+ * rsi - pointer.
+ * rdx - value filled with a byte.
+ */
+	.globl _D5tanya6memory2op10fillMemoryFNaNbNiAvmZv
+	.type _D5tanya6memory2op10fillMemoryFNaNbNiAvmZv, @function
+
+_D5tanya6memory2op10fillMemoryFNaNbNiAvmZv:
+		// Check for zero length
+		test    %rdi, %rdi
+		jz end
+
+		mov     %rdi, %rax
+		mov     %rsi, %r8
+
+		movq    %rdx,  %xmm0
+		movlhps %xmm0, %xmm0
+
+		// Check if the pointer is aligned to a 16-byte boundary
+		and     $-0x10, %r8
+
+		// Compute the number of misaligned bytes
+		mov  %rsi, %r9
+		sub  %r8,  %r9
+
+		test %r9,  %r9
+		jz aligned
+
+		// Get the number of bytes to be written until we are aligned
+		mov $0x10, %rcx
+		sub %r9,   %rcx
+
+		mov %rsi,  %r8
+
+		// If the length is less than the number of misaligned bytes,
+		// write one byte at a time and exit
+		cmp %rax, %rcx
+		jg aligned_1
+
+	naligned:
+		mov %dl, (%r8) // Write a byte
+
+		// Advance the pointer. Decrease the total number of bytes
+		// and the misaligned ones
+		inc %r8
+		dec %rcx
+		dec %rax
+
+		// Checks if we are aligned
+		test %rcx, %rcx
+		jnz naligned
+
+	aligned:
+		// Checks if we're done writing bytes
+		test %rax, %rax
+		jz end
+
+		// Write 1 byte at a time
+		cmp $8, %rax
+		jl aligned_1
+
+		// Write 8 bytes at a time
+		cmp $16, %rax
+		jl aligned_8
+
+		// Write 16 bytes at a time
+		cmp $32, %rax
+		jl aligned_16
+
+		// Write 32 bytes at a time
+		cmp $64, %rax
+		jl aligned_32
+
+	aligned_64:
+		movdqa %xmm0, (%r8)
+		movdqa %xmm0, 16(%r8)
+		movdqa %xmm0, 32(%r8)
+		movdqa %xmm0, 48(%r8)
+
+		add $64, %r8
+		sub $64, %rax
+
+		cmp $64, %rax
+		jge aligned_64
+
+		// Checks if we're done writing bytes
+		test %rax, %rax
+		jz end
+
+		// Write 1 byte at a time
+		cmp $8, %rax
+		jl aligned_1
+
+		// Write 8 bytes at a time
+		cmp $16, %rax
+		jl aligned_8
+
+		// Write 16 bytes at a time
+		cmp $32, %rax
+		jl aligned_16
+
+	aligned_32:
+		movdqa %xmm0, (%r8)
+		movdqa %xmm0, 16(%r8)
+
+		add $32, %r8
+		sub $32, %rax
+
+		// Checks if we're done writing bytes
+		test %rax, %rax
+		jz end
+
+		// Write 1 byte at a time
+		cmp $8, %rax
+		jl aligned_1
+
+		// Write 8 bytes at a time
+		cmp $16, %rax
+		jl aligned_8
+
+	aligned_16:
+		movdqa %xmm0, (%r8)
+
+		add $16, %r8
+		sub $16, %rax
+
+		// Checks if we're done writing bytes
+		test %rax, %rax
+		jz end
+
+		// Write 1 byte at a time
+		cmp $8, %rax
+		jl aligned_1
+
+	aligned_8:
+		mov %rdx, (%r8)
+
+		add $8, %r8
+		sub $8, %rax
+
+		// Checks if we're done writing bytes
+		test %rax, %rax
+		jz end
+
+	aligned_1:
+		mov %dl, (%r8)
+
+		inc %r8
+		dec %rax
+
+		test %rax, %rax
+		jnz aligned_1
+
+	end:
+		ret

arch/x64/linux/syscall.S

@@ -0,0 +1,65 @@
+/*
+The kernel uses the following registers:
+%rdi, %rsi, %rdx, %r8, %r9, %r10
+
+The number of the syscall is passed in %rax.
+
+A syscall clobbers:
+%rax, %rcx, %r11
+
+The returned value is placed in %rax.
+*/
+	.text
+
+// 1 parameter.
+	.globl _D5tanya3sys5linux7syscallQiFNbNillZl
+	.type _D5tanya3sys5linux7syscallQiFNbNillZl, @function
+
+_D5tanya3sys5linux7syscallQiFNbNillZl:
+	movq %rsi, %rax // Syscall number.
+
+	syscall
+
+	ret
+
+
+// 2 parameters.
+	.globl _D5tanya3sys5linux7syscallQiFNbNilllZl
+	.type _D5tanya3sys5linux7syscallQiFNbNilllZl, @function
+
+_D5tanya3sys5linux7syscallQiFNbNilllZl:
+	movq %rdx, %rax
+
+	syscall
+
+	ret
+
+
+// 3 parameters.
+	.globl _D5tanya3sys5linux7syscallQiFNbNillllZl
+	.type _D5tanya3sys5linux7syscallQiFNbNillllZl, @function
+
+_D5tanya3sys5linux7syscallQiFNbNillllZl:
+	movq %rcx, %rax
+
+	syscall
+
+	ret
+
+
+// 6 parameters.
+	.globl _D5tanya3sys5linux7syscallQiFNbNilllllllZl
+	.type _D5tanya3sys5linux7syscallQiFNbNilllllllZl, @function
+
+_D5tanya3sys5linux7syscallQiFNbNilllllllZl:
+	pushq %rbp
+	movq %rsp, %rbp
+
+	movq 16(%rbp), %rax
+
+	mov %rcx, %r10
+
+	syscall
+
+	leave
+	ret

codecov.yml

@@ -0,0 +1,3 @@
+ignore:
+  - "source/tanya/async/event/iocp.d"
+  - "source/tanya/async/iocp.d"

dscanner.ini

@@ -0,0 +1,81 @@
+; 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,17 +1,86 @@
 {
 	"name": "tanya",
-	"description": "General purpose, @nogc library",
+	"description": "@nogc library. Containers, networking, metaprogramming, memory management, utilities",
 	"license": "MPL-2.0",
-	"copyright": "(c) Eugene Wissner <info@caraus.de>",
+	"copyright": "© Eugene Wissner <info@caraus.de>",
 	"authors": [
 		"Eugene Wissner"
 	],
 
 	"targetType": "library",
 
+	"dependencies": {
+		"tanya:meta": "*",
+		"tanya:sys": "*",
+		"tanya:os": "*",
+		"tanya:encoding": "*",
+		"tanya:middle": "*",
+		"tanya:test": "*"
+	},
+
+	"dependencies-linux": {
+		"mir-linux-kernel": "~>1.0.0"
+	},
+
+	"subPackages": [
+		"./meta",
+		"./sys",
+		"./os",
+		"./encoding",
+		"./middle",
+		"./test"
+	],
+
 	"configurations": [
 		{
-			"name": "library"
+			"name": "library",
+			"targetType": "staticLibrary",
+			"versions": ["TanyaPhobos"]
+		},
+		{
+			"name": "dynamic",
+			"targetType": "dynamicLibrary",
+			"versions": ["TanyaPhobos"]
+		},
+		{
+			"name": "native",
+			"targetType": "library",
+			"platforms": ["linux-x86_64-gdc"],
+			"preBuildCommands": ["ninja -C arch"],
+			"lflags": ["arch/tanya.a"],
+			"versions": ["TanyaNative"]
+		},
+		{
+			"name": "unittest",
+			"versions": ["TanyaPhobos"],
+			"dflags": ["-dip25"],
+			"importPaths": [
+				"./source",
+				"./tests"
+			],
+			"sourcePaths": [
+				"./source",
+				"./tests"
+			]
+		},
+		{
+			"name": "unittest-native",
+			"platforms": ["linux-x86_64-gdc"],
+			"preBuildCommands": ["ninja -C arch"],
+			"lflags": ["arch/tanya.a"],
+			"versions": ["TanyaNative"],
+			"importPaths": [
+				"./source",
+				"./tests"
+			],
+			"sourcePaths": [
+				"./source",
+				"./tests"
+			]
 		}
-	]
+	],
+
+	"libs-windows": ["advapi32"],
+	"libs-windows-x86_mscoff": ["iphlpapi"],
+	"libs-windows-x86_64": ["iphlpapi"]
 }

encoding/dub.json

@@ -0,0 +1,16 @@
+{
+	"name": "encoding",
+	"description": "This package provides tools to work with text encodings",
+	"targetType": "library",
+
+	"dependencies": {
+		"tanya:meta": "*"
+	},
+
+	"sourcePaths": [
+		"."
+	],
+	"importPaths": [
+		"."
+	]
+}

encoding/tanya/encoding/ascii.d

@@ -0,0 +1,501 @@
+/* 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/. */
+
+/**
+ * Functions operating on ASCII characters.
+ *
+ * ASCII is $(B A)merican $(B S)tandard $(B C)ode for $(B I)nformation
+ * $(B I)nterchange.
+ *
+ * Copyright: Eugene Wissner 2017-2019.
+ * 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/encoding/tanya/encoding/ascii.d,
+ *                 tanya/encoding/ascii.d)
+ */
+module tanya.encoding.ascii;
+
+import tanya.meta.trait;
+
+immutable string fullHexDigits = "0123456789ABCDEFabcdef"; /// 0..9A..Fa..f.
+immutable string hexDigits = "0123456789ABCDEF"; /// 0..9A..F.
+immutable string lowerHexDigits = "0123456789abcdef"; /// 0..9a..f.
+immutable string digits = "0123456789"; /// 0..9.
+immutable string octalDigits = "01234567"; /// 0..7.
+
+/// A..Za..z.
+immutable string letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+
+immutable string uppercase = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; /// A..Z.
+immutable string lowercase = "abcdefghijklmnopqrstuvwxyz"; /// a..z.
+
+/**
+ * Whitespace, Horizontal Tab (HT), Line Feed (LF), Carriage Return (CR),
+ * Vertical Tab (VT) or Form Feed (FF).
+ */
+immutable string whitespace = "\t\n\v\f\r ";
+
+/// Letter case specifier.
+enum LetterCase : bool
+{
+    upper, /// Uppercase.
+    lower, /// Lowercase.
+}
+
+/**
+ * Checks for an uppecase alphabetic character.
+ *
+ * Params:
+ *  C = Some character type.
+ *  c = Some character.
+ *
+ * Returns: $(D_KEYWORD true) if $(D_PARAM c) is an uppercase alphabetic
+ *          character, $(D_KEYWORD false) otherwise.
+ */
+bool isUpper(C)(C c)
+if (isSomeChar!C)
+{
+    return (c >= 'A') && (c <= 'Z');
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    assert(isUpper('A'));
+    assert(isUpper('Z'));
+    assert(isUpper('L'));
+    assert(!isUpper('a'));
+    assert(!isUpper('!'));
+}
+
+/**
+ * Checks for a lowercase alphabetic character.
+ *
+ * Params:
+ *  C = Some character type.
+ *  c = Some character.
+ *
+ * Returns: $(D_KEYWORD true) if $(D_PARAM c) is a lowercase alphabetic
+ *          character, $(D_KEYWORD false) otherwise.
+ */
+bool isLower(C)(C c)
+if (isSomeChar!C)
+{
+    return (c >= 'a') && (c <= 'z');
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    assert(isLower('a'));
+    assert(isLower('z'));
+    assert(isLower('l'));
+    assert(!isLower('A'));
+    assert(!isLower('!'));
+}
+
+/**
+ * Checks for an alphabetic character (upper- or lowercase).
+ *
+ * Params:
+ *  C = Some character type.
+ *  c = Some character.
+ *
+ * Returns: $(D_KEYWORD true) if $(D_PARAM c) is an alphabetic character,
+ *          $(D_KEYWORD false) otherwise.
+ */
+bool isAlpha(C)(C c)
+if (isSomeChar!C)
+{
+    return isUpper(c) || isLower(c);
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    assert(isAlpha('A'));
+    assert(isAlpha('Z'));
+    assert(isAlpha('L'));
+    assert(isAlpha('a'));
+    assert(isAlpha('z'));
+    assert(isAlpha('l'));
+    assert(!isAlpha('!'));
+}
+
+/**
+ * Checks for a digit.
+ *
+ * Params:
+ *  C = Some character type.
+ *  c = Some character.
+ *
+ * Returns: $(D_KEYWORD true) if $(D_PARAM c) is a digit,
+ *          $(D_KEYWORD false) otherwise.
+ */
+bool isDigit(C)(C c)
+if (isSomeChar!C)
+{
+    return (c >= '0') && (c <= '9');
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    assert(isDigit('0'));
+    assert(isDigit('1'));
+    assert(isDigit('2'));
+    assert(isDigit('3'));
+    assert(isDigit('4'));
+    assert(isDigit('5'));
+    assert(isDigit('6'));
+    assert(isDigit('7'));
+    assert(isDigit('8'));
+    assert(isDigit('9'));
+    assert(!isDigit('a'));
+    assert(!isDigit('!'));
+}
+
+/**
+ * Checks for an alphabetic character (upper- or lowercase) or a digit.
+ *
+ * Params:
+ *  C = Some character type.
+ *  c = Some character.
+ *
+ * Returns: $(D_KEYWORD true) if $(D_PARAM c) is an alphabetic character or a
+ *          digit, $(D_KEYWORD false) otherwise.
+ */
+bool isAlphaNum(C)(C c)
+if (isSomeChar!C)
+{
+    return isAlpha(c) || isDigit(c);
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    assert(isAlphaNum('0'));
+    assert(isAlphaNum('1'));
+    assert(isAlphaNum('9'));
+    assert(isAlphaNum('A'));
+    assert(isAlphaNum('Z'));
+    assert(isAlphaNum('L'));
+    assert(isAlphaNum('a'));
+    assert(isAlphaNum('z'));
+    assert(isAlphaNum('l'));
+    assert(!isAlphaNum('!'));
+}
+
+/**
+ * Checks for a 7-bit ASCII character.
+ *
+ * Params:
+ *  C = Some character type.
+ *  c = Some character.
+ *
+ * Returns: $(D_KEYWORD true) if $(D_PARAM c) is an ASCII character,
+ *          $(D_KEYWORD false) otherwise.
+ */
+bool isASCII(C)(C c)
+if (isSomeChar!C)
+{
+    return c < 128;
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    assert(isASCII('0'));
+    assert(isASCII('L'));
+    assert(isASCII('l'));
+    assert(isASCII('!'));
+    assert(!isASCII('©'));
+    assert(!isASCII('§'));
+    assert(!isASCII(char.init)); // 0xFF
+    assert(!isASCII(wchar.init)); // 0xFFFF
+    assert(!isASCII(dchar.init)); // 0xFFFF
+}
+
+/**
+ * Checks for a control character.
+ *
+ * Control characters are non-printable characters. Their ASCII codes are those
+ * between 0x00 (NUL) and 0x1f (US), and 0x7f (DEL).
+ *
+ * Params:
+ *  C = Some character type.
+ *  c = Some character.
+ *
+ * Returns: $(D_KEYWORD true) if $(D_PARAM c) is a control character,
+ *          $(D_KEYWORD false) otherwise.
+ *
+ * See_Also: $(D_PSYMBOL isPrintable),  $(D_PSYMBOL isGraphical).
+ */
+bool isControl(C)(C c)
+if (isSomeChar!C)
+{
+    return (c <= 0x1f) || (c == 0x7f);
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    assert(isControl('\t'));
+    assert(isControl('\0'));
+    assert(isControl('\u007f'));
+    assert(!isControl(' '));
+    assert(!isControl('a'));
+    assert(!isControl(char.init)); // 0xFF
+    assert(!isControl(wchar.init)); // 0xFFFF
+}
+
+/**
+ * Checks for a whitespace character.
+ *
+ * Whitespace characters are:
+ *
+ * $(UL
+ *  $(LI Whitespace)
+ *  $(LI Horizontal Tab (HT))
+ *  $(LI Line Feed (LF))
+ *  $(LI Carriage Return (CR))
+ *  $(LI Vertical Tab (VT))
+ *  $(LI Form Feed (FF))
+ * )
+ *
+ * Params:
+ *  C = Some character type.
+ *  c = Some character.
+ *
+ * Returns: $(D_KEYWORD true) if $(D_PARAM c) is a whitespace character,
+ *          $(D_KEYWORD false) otherwise.
+ *
+ * See_Also: $(D_PSYMBOL whitespace).
+ */
+bool isWhite(C)(C c)
+if (isSomeChar!C)
+{
+    return ((c >= 0x09) && (c <= 0x0d)) || (c == 0x20);
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    assert(isWhite('\t'));
+    assert(isWhite('\n'));
+    assert(isWhite('\v'));
+    assert(isWhite('\f'));
+    assert(isWhite('\r'));
+    assert(isWhite(' '));
+}
+
+/**
+ * Checks for a graphical character.
+ *
+ * Graphical characters are printable characters but whitespace characters.
+ *
+ * Params:
+ *  C = Some character type.
+ *  c = Some character.
+ *
+ * Returns: $(D_KEYWORD true) if $(D_PARAM c) is a control character,
+ *          $(D_KEYWORD false) otherwise.
+ *
+ * See_Also: $(D_PSYMBOL isControl), $(D_PSYMBOL isWhite).
+ */
+bool isGraphical(C)(C c)
+if (isSomeChar!C)
+{
+    return (c > 0x20) && (c < 0x7f);
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    assert(isGraphical('a'));
+    assert(isGraphical('0'));
+    assert(!isGraphical('\u007f'));
+    assert(!isGraphical('§'));
+    assert(!isGraphical('\n'));
+    assert(!isGraphical(' '));
+}
+
+/**
+ * Checks for a printable character.
+ *
+ * This is the opposite of a control character.
+ *
+ * Params:
+ *  C = Some character type.
+ *  c = Some character.
+ *
+ * Returns: $(D_KEYWORD true) if $(D_PARAM c) is a control character,
+ *          $(D_KEYWORD false) otherwise.
+ *
+ * See_Also: $(D_PSYMBOL isControl).
+ */
+bool isPrintable(C)(C c)
+if (isSomeChar!C)
+{
+    return (c >= 0x20) && (c < 0x7f);
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    assert(isPrintable('a'));
+    assert(isPrintable('0'));
+    assert(!isPrintable('\u007f'));
+    assert(!isPrintable('§'));
+    assert(!isPrintable('\n'));
+    assert(isPrintable(' '));
+}
+
+/**
+ * Checks for a hexadecimal digit.
+ *
+ * Params:
+ *  C = Some character type.
+ *  c = Some character.
+ *
+ * Returns: $(D_KEYWORD true) if $(D_PARAM c) is a hexadecimal digit,
+ *          $(D_KEYWORD false) otherwise.
+ */
+bool isHexDigit(C)(C c)
+if (isSomeChar!C)
+{
+    return ((c >= '0') && (c <= '9'))
+        || ((c >= 'a') && (c <= 'f'))
+        || ((c >= 'A') && (c <= 'F'));
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    assert(isHexDigit('0'));
+    assert(isHexDigit('1'));
+    assert(isHexDigit('8'));
+    assert(isHexDigit('9'));
+    assert(isHexDigit('A'));
+    assert(isHexDigit('F'));
+    assert(!isHexDigit('G'));
+    assert(isHexDigit('a'));
+    assert(isHexDigit('f'));
+    assert(!isHexDigit('g'));
+}
+
+/**
+ * Checks for an octal character.
+ *
+ * Params:
+ *  C = Some character type.
+ *  c = Some character.
+ *
+ * Returns: $(D_KEYWORD true) if $(D_PARAM c) is an octal character,
+ *          $(D_KEYWORD false) otherwise.
+ */
+bool isOctalDigit(C)(C c)
+if (isSomeChar!C)
+{
+    return (c >= '0') && (c <= '7');
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    assert(isOctalDigit('0'));
+    assert(isOctalDigit('1'));
+    assert(isOctalDigit('2'));
+    assert(isOctalDigit('3'));
+    assert(isOctalDigit('4'));
+    assert(isOctalDigit('5'));
+    assert(isOctalDigit('6'));
+    assert(isOctalDigit('7'));
+    assert(!isOctalDigit('8'));
+}
+
+/**
+ * Checks for a octal character.
+ *
+ * Params:
+ *  C = Some character type.
+ *  c = Some character.
+ *
+ * Returns: $(D_KEYWORD true) if $(D_PARAM c) is a octal character,
+ *          $(D_KEYWORD false) otherwise.
+ */
+bool isPunctuation(C)(C c)
+if (isSomeChar!C)
+{
+    return ((c >= 0x21) && (c <= 0x2f))
+        || ((c >= 0x3a) && (c <= 0x40))
+        || ((c >= 0x5b) && (c <= 0x60))
+        || ((c >= 0x7b) && (c <= 0x7e));
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    assert(isPunctuation('!'));
+    assert(isPunctuation(':'));
+    assert(isPunctuation('\\'));
+    assert(isPunctuation('|'));
+    assert(!isPunctuation('0'));
+    assert(!isPunctuation(' '));
+}
+
+/**
+ * Converts $(D_PARAM c) to uppercase.
+ *
+ * If $(D_PARAM c) is not a lowercase character, $(D_PARAM c) is returned
+ * unchanged.
+ *
+ * Params:
+ *  C = Some character type.
+ *  c = Some character.
+ *
+ * Returns: The lowercase of $(D_PARAM c) if available, just $(D_PARAM c)
+ *          otherwise.
+ */
+C toUpper(C)(C c)
+if (isSomeChar!C)
+{
+    return isLower(c) ? (cast(C) (c - 32)) : c;
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    assert(toUpper('a') == 'A');
+    assert(toUpper('A') == 'A');
+    assert(toUpper('!') == '!');
+}
+
+/**
+ * Converts $(D_PARAM c) to lowercase.
+ *
+ * If $(D_PARAM c) is not an uppercase character, $(D_PARAM c) is returned
+ * unchanged.
+ *
+ * Params:
+ *  C = Some character type.
+ *  c = Some character.
+ *
+ * Returns: The uppercase of $(D_PARAM c) if available, just $(D_PARAM c)
+ *          otherwise.
+ */
+C toLower(C)(C c)
+if (isSomeChar!C)
+{
+    return isUpper(c) ? (cast(C) (c + 32)) : c;
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    assert(toLower('A') == 'a');
+    assert(toLower('a') == 'a');
+    assert(toLower('!') == '!');
+}

encoding/tanya/encoding/package.d

@@ -0,0 +1,17 @@
+/* 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 tools to work with text encodings.
+ *
+ * Copyright: Eugene Wissner 2017-2019.
+ * 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/encoding/tanya/encoding/package.d,
+ *                 tanya/encoding/package.d)
+ */
+module tanya.encoding;
+
+public import tanya.encoding.ascii;

meta/dub.json

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

meta/tanya/meta/package.d

@@ -0,0 +1,23 @@
+/* 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-2019.
+ * 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

@@ -0,0 +1,934 @@
+/* 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-2019.
+ * 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 == const U)
+            || is(T U == immutable U)
+            || is(T U == inout U)
+            || is(T U == inout const U)
+            || is(T U == shared U)
+            || is(T U == shared const U)
+            || is(T U == shared inout U)
+            || is(T U == shared inout const 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).
+ *
+ * See_Also: $(D_PSYMBOL CopyTypeQualifiers).
+ */
+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));
+}
+
+/**
+ * Copies type qualifiers of $(D_PARAM From) to $(D_PARAM To).
+ *
+ * Type qualifiers copied are:
+ * $(UL
+ *  $(LI const)
+ *  $(LI immutable)
+ *  $(LI inout)
+ *  $(LI shared)
+ * )
+ * and combinations of these.
+ *
+ * Params:
+ *  From = Source type.
+ *  To   = Target type.
+ *
+ * Returns: $(D_PARAM To) with the type qualifiers of $(D_PARAM From).
+ *
+ * See_Also: $(D_PSYMBOL CopyConstness).
+ */
+template CopyTypeQualifiers(From, To)
+{
+    static if (is(From T == immutable T))
+    {
+        alias CopyTypeQualifiers = immutable To;
+    }
+    else static if (is(From T == const T))
+    {
+        alias CopyTypeQualifiers = const To;
+    }
+    else static if (is(From T == shared T))
+    {
+        alias CopyTypeQualifiers = shared To;
+    }
+    else static if (is(From T == shared const T))
+    {
+        alias CopyTypeQualifiers = shared const To;
+    }
+    else static if (is(From T == inout T))
+    {
+        alias CopyTypeQualifiers = inout To;
+    }
+    else static if (is(From T == shared inout T))
+    {
+        alias CopyTypeQualifiers = shared inout To;
+    }
+    else static if (is(From T == inout const T))
+    {
+        alias CopyTypeQualifiers = inout const To;
+    }
+    else static if (is(From T == shared inout const T))
+    {
+        alias CopyTypeQualifiers = shared inout const To;
+    }
+    else
+    {
+        alias CopyTypeQualifiers = To;
+    }
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    static assert(is(CopyTypeQualifiers!(int, char) == char));
+    static assert(is(CopyTypeQualifiers!(const int, char) == const char));
+    static assert(is(CopyTypeQualifiers!(immutable int, char) == immutable char));
+    static assert(is(CopyTypeQualifiers!(inout int, char) == inout char));
+    static assert(is(CopyTypeQualifiers!(inout const int, char) == inout const char));
+
+    static assert(is(CopyTypeQualifiers!(shared int, char) == shared char));
+    static assert(is(CopyTypeQualifiers!(shared const int, char) == shared const char));
+    static assert(is(CopyTypeQualifiers!(shared inout int, char) == shared inout char));
+    static assert(is(CopyTypeQualifiers!(shared inout const int, char) == shared inout const char));
+}
+
+/**
+ * Evaluates to the unsigned counterpart of the integral type $(D_PARAM T) preserving all type qualifiers.
+ * If $(D_PARAM T) is already unsigned, $(D_INLINECODE Unsigned!T) aliases $(D_PARAM T).
+ *
+ * Params:
+ *  T = A type.
+ *
+ * Returns: Unsigned counterpart of $(D_PARAM T).
+ *
+ * See_Also: $(D_PSYMBOL isSigned).
+ */
+template Unsigned(T)
+if (isIntegral!T)
+{
+    alias UnqualedType = Unqual!(OriginalType!T);
+    static if (is(UnqualedType == byte))
+    {
+        alias Unsigned = CopyTypeQualifiers!(T, ubyte);
+    }
+    else static if (is(UnqualedType == short))
+    {
+        alias Unsigned = CopyTypeQualifiers!(T, ushort);
+    }
+    else static if (is(UnqualedType == int))
+    {
+        alias Unsigned = CopyTypeQualifiers!(T, uint);
+    }
+    else static if (is(UnqualedType == long))
+    {
+        alias Unsigned = CopyTypeQualifiers!(T, ulong);
+    }
+    else
+    {
+        alias Unsigned = T;
+    }
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    static assert(is(Unsigned!byte == ubyte));
+    static assert(is(Unsigned!short == ushort));
+    static assert(is(Unsigned!int == uint));
+    static assert(is(Unsigned!long == ulong));
+
+    static assert(is(Unsigned!(const byte) == const ubyte));
+    static assert(is(Unsigned!(shared byte) == shared ubyte));
+    static assert(is(Unsigned!(shared const byte) == shared const ubyte));
+
+    static assert(!is(Unsigned!float));
+    static assert(is(Unsigned!ubyte == ubyte));
+}
+
+/**
+ * Evaluates to the signed counterpart of the integral type $(D_PARAM T) preserving all type qualifiers.
+ * If $(D_PARAM T) is already signed, $(D_INLINECODE Signed!T) aliases $(D_PARAM T).
+ *
+ * Params:
+ *  T = A type.
+ *
+ * Returns: Signed counterpart of $(D_PARAM T).
+ *
+ * See_Also: $(D_PSYMBOL isUnsigned).
+ */
+template Signed(T)
+if (isIntegral!T)
+{
+    alias UnqualedType = Unqual!(OriginalType!T);
+    static if (is(UnqualedType == ubyte))
+    {
+        alias Signed = CopyTypeQualifiers!(T, byte);
+    }
+    else static if (is(UnqualedType == ushort))
+    {
+        alias Signed = CopyTypeQualifiers!(T, short);
+    }
+    else static if (is(UnqualedType == uint))
+    {
+        alias Signed = CopyTypeQualifiers!(T, int);
+    }
+    else static if (is(UnqualedType == ulong))
+    {
+        alias Signed = CopyTypeQualifiers!(T, long);
+    }
+    else
+    {
+        alias Signed = T;
+    }
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    static assert(is(Signed!ubyte == byte));
+    static assert(is(Signed!ushort == short));
+    static assert(is(Signed!uint == int));
+    static assert(is(Signed!ulong == long));
+
+    static assert(is(Signed!(const ubyte) == const byte));
+    static assert(is(Signed!(shared ubyte) == shared byte));
+    static assert(is(Signed!(shared const ubyte) == shared const byte));
+
+    static assert(!is(Signed!float));
+    static assert(is(Signed!byte == byte));
+}
+
+/**
+ * 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])));
+}
+
+/**
+ * Params:
+ *  T = Scalar type.
+ *
+ * Returns: The type $(D_PARAM T) will promote to.
+ *
+ * See_Also: $(LINK2 https://dlang.org/spec/type.html#integer-promotions,
+ *                   Integer Promotions).
+ */
+template Promoted(T)
+if (isScalarType!T)
+{
+    alias Promoted = CopyTypeQualifiers!(T, typeof(T.init + T.init));
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    static assert(is(Promoted!bool == int));
+    static assert(is(Promoted!byte == int));
+    static assert(is(Promoted!ubyte == int));
+    static assert(is(Promoted!short == int));
+    static assert(is(Promoted!ushort == int));
+    static assert(is(Promoted!char == int));
+    static assert(is(Promoted!wchar == int));
+    static assert(is(Promoted!dchar == uint));
+
+    static assert(is(Promoted!(const bool) == const int));
+    static assert(is(Promoted!(shared bool) == shared int));
+}
+
+/**
+ * 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));
+}
+
+/**
+ * Returns a template with one argument which applies all qualifiers of
+ * $(D_PARAM T) on its argument if instantiated.
+ *
+ * Params:
+ *  T = A type.
+ *
+ * Returns: $(D_INLINECODE shared(inout const T)).
+ */
+template QualifierOf(T)
+{
+    static if (is(T U == const U))
+    {
+        alias QualifierOf = ConstOf;
+    }
+    else static if (is(T U == immutable U))
+    {
+        alias QualifierOf = ImmutableOf;
+    }
+    else static if (is(T U == inout U))
+    {
+        alias QualifierOf = InoutOf;
+    }
+    else static if (is(T U == inout const U))
+    {
+        alias QualifierOf = InoutConstOf;
+    }
+    else static if (is(T U == shared U))
+    {
+        alias QualifierOf = SharedOf;
+    }
+    else static if (is(T U == shared const U))
+    {
+        alias QualifierOf = SharedConstOf;
+    }
+    else static if (is(T U == shared inout U))
+    {
+        alias QualifierOf = SharedInoutOf;
+    }
+    else static if (is(T U == shared inout const U))
+    {
+        alias QualifierOf = SharedInoutConstOf;
+    }
+    else
+    {
+        alias QualifierOf(T) = T;
+    }
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    alias MutableOf = QualifierOf!int;
+    static assert(is(MutableOf!uint == uint));
+
+    alias ConstOf = QualifierOf!(const int);
+    static assert(is(ConstOf!uint == const uint));
+
+    alias InoutOf = QualifierOf!(inout int);
+    static assert(is(InoutOf!uint == inout uint));
+
+    alias InoutConstOf = QualifierOf!(inout const int);
+    static assert(is(InoutConstOf!uint == inout const uint));
+
+    alias ImmutableOf = QualifierOf!(immutable int);
+    static assert(is(ImmutableOf!uint == immutable uint));
+
+    alias SharedOf = QualifierOf!(shared int);
+    static assert(is(SharedOf!uint == shared uint));
+
+    alias SharedConstOf = QualifierOf!(shared const int);
+    static assert(is(SharedConstOf!uint == shared const uint));
+
+    alias SharedInoutOf = QualifierOf!(shared inout int);
+    static assert(is(SharedInoutOf!uint == shared inout uint));
+
+    alias SharedInoutConstOf = QualifierOf!(shared inout const int);
+    static assert(is(SharedInoutConstOf!uint == shared inout const uint));
+}
+
+/**
+ * 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)));
+}
+
+// e.g. returns int for int**.
+private template FinalPointerTarget(T)
+{
+    static if (isPointer!T)
+    {
+        alias FinalPointerTarget = FinalPointerTarget!(PointerTarget!T);
+    }
+    else
+    {
+        alias FinalPointerTarget = T;
+    }
+}
+
+// Returns true if T1 is void* and T2 is some pointer.
+private template voidAndPointer(T1, T2)
+{
+    enum bool voidAndPointer = is(Unqual!(PointerTarget!T1) == void)
+                            && isPointer!T2;
+}
+
+// Type returned by the ternary operator.
+private alias TernaryType(T, U) = typeof(true ? T.init : U.init);
+
+/**
+ * Determines the type all $(D_PARAM Args) can be implicitly converted to.
+ *
+ * $(OL
+ *  $(LI If one of the arguments is $(D_KEYWORD void), the common type is
+ *       $(D_KEYWORD void).)
+ *  $(LI The common type of integers with the same sign is the type with a
+ *       larger size. Signed and unsigned integers don't have a common type.
+ *       Type qualifiers are only preserved if all arguments are the same
+ *       type.)
+ *  $(LI The common type of floating point numbers is the type with more
+ *       precision. Type qualifiers are only preserved if all arguments are
+ *       the same type.)
+ *  $(LI The common type of polymorphic objects is the next, more generic type
+ *       both objects inherit from, e.g. $(D_PSYMBOL Object).)
+ *  $(LI `void*` is concerned as a common type of pointers only if one of the
+ *       arguments is a void pointer.)
+ *  $(LI Other types have a common type only if their pointers have a common
+ *       type. It means that for example $(D_KEYWORD bool) and $(D_KEYWORD int)
+         don't have a common type. If the types fullfill this condition, the
+         common type is determined with the ternary operator, i.e.
+         `typeof(true ? T1.init : T2.init)` is evaluated.)
+ * )
+ *
+ * If $(D_PARAM Args) don't have a common type, $(D_PSYMBOL CommonType) is
+ * $(D_KEYWORD void).
+ *
+ * Params:
+ *  Args = Type list.
+ *
+ * Returns: Common type for $(D_PARAM Args) or $(D_KEYWORD void) if
+ *          $(D_PARAM Args) don't have a common type.
+ */
+template CommonType(Args...)
+if (allSatisfy!(isType, Args))
+{
+    static if (Args.length == 0
+            || is(Unqual!(Args[0]) == void)
+            || is(Unqual!(Args[1]) == void))
+    {
+        alias CommonType = void;
+    }
+    else static if (Args.length == 1)
+    {
+        alias CommonType = Args[0];
+    }
+    else
+    {
+        private alias Pair = Args[0 .. 2];
+        private enum bool sameSigned = allSatisfy!(isIntegral, Pair)
+                                    && isSigned!(Args[0]) == isSigned!(Args[1]);
+
+        static if (is(Args[0] == Args[1]))
+        {
+            alias CommonType = CommonType!(Args[0], Args[2 .. $]);
+        }
+        else static if (sameSigned || allSatisfy!(isFloatingPoint, Pair))
+        {
+            alias CommonType = CommonType!(Unqual!(Largest!Pair),
+                                           Args[2 .. $]);
+        }
+        else static if (voidAndPointer!Pair
+                     || voidAndPointer!(Args[1], Args[0]))
+        {
+            // Workaround for https://issues.dlang.org/show_bug.cgi?id=15557.
+            // Determine the qualifiers returned by the ternary operator as if
+            // both pointers were int*. Then copy the qualifiers to void*.
+            alias P1 = CopyTypeQualifiers!(FinalPointerTarget!(Args[0]), int)*;
+            alias P2 = CopyTypeQualifiers!(FinalPointerTarget!(Args[1]), int)*;
+            static if (is(TernaryType!(P1, P2) U))
+            {
+                alias CommonType = CopyTypeQualifiers!(PointerTarget!U, void)*;
+            }
+            else
+            {
+                alias CommonType = void;
+            }
+        }
+        else static if ((isPointer!(Args[0]) || isPolymorphicType!(Args[0]))
+                     && is(TernaryType!Pair U))
+        {
+            alias CommonType = CommonType!(U, Args[2 .. $]);
+        }
+        else static if (is(TernaryType!(Args[0]*, Args[1]*)))
+        {
+            alias CommonType = CommonType!(TernaryType!Pair, Args[2 .. $]);
+        }
+        else
+        {
+            alias CommonType = void;
+        }
+    }
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    static assert(is(CommonType!(int, int, int) == int));
+    static assert(is(CommonType!(ubyte, ushort, uint) == uint));
+    static assert(is(CommonType!(int, uint) == void));
+
+    static assert(is(CommonType!(int, const int) == int));
+    static assert(is(CommonType!(const int, const int) == const int));
+
+    static assert(is(CommonType!(int[], const(int)[]) == const(int)[]));
+    static assert(is(CommonType!(string, char[]) == const(char)[]));
+
+    class A
+    {
+    }
+    static assert(is(CommonType!(const A, Object) == const Object));
+}
+
+/**
+ * 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

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

middle/tanya/memory/allocator.d

@@ -0,0 +1,497 @@
+/* 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-2019.
+ * 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 (allocator !is null)
+    {
+        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; allocator !is null)
+    {
+        if (allocator_ is null)
+        {
+            allocator_ = defaultAllocator;
+        }
+        return allocator_;
+    }
+
+    /// ditto
+    @property shared(Allocator) allocator() const @nogc nothrow pure @trusted
+    out (allocator; allocator !is null)
+    {
+        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; allocator !is null)
+{
+    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 (allocator !is null)
+{
+    .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 (allocator !is null)
+{
+    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 (allocator !is null)
+{
+    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 (allocator !is null)
+in (n <= size_t.max / E.sizeof)
+{
+    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

@@ -0,0 +1,508 @@
+/* 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.
+ * 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 (memory.length >= stateSize!T)
+out (result; memory.ptr is (() @trusted => cast(void*) result)())
+{
+    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 (memory.length == stateSize!T)
+out (result; memory.ptr is (() @trusted => cast(void*) result)())
+{
+    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 (memory.length >= T.sizeof)
+out (result; memory.ptr is result)
+{
+    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 (memory.length >= T.sizeof)
+out (result; memory.ptr is result)
+{
+    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 (&source !is &target, "Source and target must be different")
+{
+    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

@@ -3,22 +3,39 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /**
- * Copyright: Eugene Wissner 2017.
+ * Allocator based on $(D_PSYMBOL malloc), $(D_PSYMBOL realloc) and
+ * $(D_PSYMBOL free).
+ *
+ * Copyright: Eugene Wissner 2017-2019.
  * 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;
 
+version (TanyaNative)
+{
+}
+else:
+
 import core.stdc.stdlib;
-import std.algorithm.comparison;
 import tanya.memory.allocator;
 
 /**
- * Wrapper for malloc/realloc/free from the C standard library.
+ * 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.
      *
@@ -27,25 +44,26 @@ final class Mallocator : Allocator
      *
      * Returns: The pointer to the new allocated memory.
      */
-    void[] allocate(in size_t size) shared nothrow @nogc
+    void[] allocate(size_t size) @nogc nothrow pure shared @system
     {
-        if (!size)
+        if (size == 0)
         {
             return null;
         }
-        auto p = malloc(size + psize);
+        auto p = (cast(MallocType) &malloc)(size + psize);
 
         return p is null ? null : p[psize .. psize + size];
     }
 
     ///
-    @nogc nothrow unittest
+    @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);
     }
 
     /**
@@ -56,17 +74,17 @@ final class Mallocator : Allocator
      *
      * Returns: Whether the deallocation was successful.
      */
-    bool deallocate(void[] p) shared nothrow @nogc
+    bool deallocate(void[] p) @nogc nothrow pure shared @system
     {
         if (p !is null)
         {
-            free(p.ptr - psize);
+            (cast(FreeType) &free)(p.ptr - psize);
         }
         return true;
     }
 
     ///
-    @nogc nothrow unittest
+    @nogc nothrow pure @system unittest
     {
         void[] p;
         assert(Mallocator.instance.deallocate(p));
@@ -84,11 +102,20 @@ final class Mallocator : Allocator
      *
      * Returns: $(D_KEYWORD false).
      */
-    bool reallocateInPlace(ref void[] p, const size_t size) shared nothrow @nogc
+    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.
      *
@@ -98,7 +125,8 @@ final class Mallocator : Allocator
      *
      * Returns: Whether the reallocation was successful.
      */
-    bool reallocate(ref void[] p, const size_t size) shared nothrow @nogc
+    bool reallocate(ref void[] p, size_t size)
+    @nogc nothrow pure shared @system
     {
         if (size == 0)
         {
@@ -115,7 +143,7 @@ final class Mallocator : Allocator
         }
         else
         {
-            auto r = realloc(p.ptr - psize, size + psize);
+            auto r = (cast(ReallocType) &realloc)(p.ptr - psize, size + psize);
 
             if (r !is null)
             {
@@ -127,7 +155,7 @@ final class Mallocator : Allocator
     }
 
     ///
-    @nogc nothrow unittest
+    @nogc nothrow pure @system unittest
     {
         void[] p;
 
@@ -147,21 +175,16 @@ final class Mallocator : Allocator
     /**
      * Returns: The alignment offered.
      */
-    @property uint alignment() shared const pure nothrow @safe @nogc
+    @property uint alignment() const @nogc nothrow pure @safe shared
     {
-        return cast(uint) max(double.alignof, real.alignof);
+        return (void*).alignof;
     }
 
-    /**
+    static private shared(Mallocator) instantiate() @nogc nothrow @system
-     * Static allocator instance and initializer.
-     *
-     * Returns: The global $(D_PSYMBOL Allocator) instance.
-     */
-    static @property ref shared(Mallocator) instance() @nogc nothrow
     {
         if (instance_ is null)
         {
-            immutable size = __traits(classInstanceSize, Mallocator) + psize;
+            const size = __traits(classInstanceSize, Mallocator) + psize;
             void* p = malloc(size);
 
             if (p !is null)
@@ -173,13 +196,23 @@ final class Mallocator : Allocator
         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 unittest
+    @nogc nothrow pure @system unittest
     {
         assert(instance is instance);
     }
 
-    private enum psize = 8;
+    private enum ushort psize = 8;
 
     private shared static Mallocator instance_;
 }

middle/tanya/memory/mmappool.d

@@ -2,31 +2,46 @@
  * 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-2017.
+ * Native allocator.
+ *
+ * Copyright: Eugene Wissner 2016-2019.
  * 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.stdc.string;
+version (TanyaNative):
-import std.algorithm.comparison;
+
+import mir.linux._asm.unistd;
 import tanya.memory.allocator;
+import tanya.memory.op;
+import tanya.os.error;
+import tanya.sys.linux.syscall;
+import tanya.sys.posix.mman;
 
-version (Posix)
+private void* mapMemory(const size_t length) @nogc nothrow pure @system
 {
-    import core.stdc.errno;
+    auto p = syscall_(0,
-    import core.sys.posix.sys.mman;
+                      length,
-    import core.sys.posix.unistd;
+                      PROT_READ | PROT_WRITE,
-}
+                      MAP_PRIVATE | MAP_ANONYMOUS,
-else version (Windows)
+                      -1,
-{
+                      0,
-    import core.sys.windows.winbase;
+                      NR_mmap);
-    import core.sys.windows.windows;
+    return p == -ErrorCode.noMemory ? null : cast(void*) p;
 }
 
-/**
+private bool unmapMemory(shared void* addr, const size_t length)
+@nogc nothrow pure @system
+{
+    return syscall_(cast(ptrdiff_t) addr, length, NR_munmap) == 0;
+}
+
+/*
  * 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
@@ -36,6 +51,7 @@ else version (Windows)
  * block as free and only if all blocks in the region are free, the complete
  * region is deallocated.
  *
+ * <pre>
  * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  * |      |     |         |     |            ||      |     |                  |
  * |      |prev <-----------    |            ||      |     |                  |
@@ -47,25 +63,29 @@ else version (Windows)
  * |  N   |    -----------> next|            ||   N  |     |                  |
  * |      |     |         |     |            ||      |     |                  |
  * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ * </pre>
  */
 final class MmapPool : Allocator
 {
-    invariant
+    version (none)
     {
-        for (auto r = &head; *r !is null; r = &((*r).next))
+        @nogc nothrow pure @system invariant
         {
-            auto block = cast(Block) (cast(void*) *r + RegionEntry.sizeof);
+            for (auto r = &head; *r !is null; r = &((*r).next))
-            do
             {
-                assert(block.prev is null || block.prev.next is block);
+                auto block = cast(Block) (cast(void*) *r + RegionEntry.sizeof);
-                assert(block.next is null || block.next.prev is block);
+                do
-                assert(block.region is *r);
+                {
+                    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);
             }
-            while ((block = block.next) !is null);
         }
     }
 
-    /**
+    /*
      * Allocates $(D_PARAM size) bytes of memory.
      *
      * Params:
@@ -73,13 +93,17 @@ final class MmapPool : Allocator
      *
      * Returns: Pointer to the new allocated memory.
      */
-    void[] allocate(in size_t size) shared nothrow @nogc
+    void[] allocate(size_t size) @nogc nothrow pure shared @system
     {
-        if (!size)
+        if (size == 0)
+        {
+            return null;
+        }
+        const dataSize = addAlignment(size);
+        if (dataSize < size)
         {
             return null;
         }
-        immutable dataSize = addAlignment(size);
 
         void* data = findBlock(dataSize);
         if (data is null)
@@ -90,17 +114,7 @@ final class MmapPool : Allocator
         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.
      *
@@ -109,7 +123,8 @@ final class MmapPool : Allocator
      *
      * Returns: Data the block points to or $(D_KEYWORD null).
      */
-    private void* findBlock(in ref size_t size) shared nothrow @nogc
+    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)
@@ -151,7 +166,7 @@ final class MmapPool : Allocator
     }
 
     // Merge block with the next one.
-    private void mergeNext(Block block) shared const pure nothrow @safe @nogc
+    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)
@@ -161,7 +176,7 @@ final class MmapPool : Allocator
         block.next = block.next.next;
     }
 
-    /**
+    /*
      * Deallocates a memory block.
      *
      * Params:
@@ -169,7 +184,7 @@ final class MmapPool : Allocator
      *
      * Returns: Whether the deallocation was successful.
      */
-    bool deallocate(void[] p) shared nothrow @nogc
+    bool deallocate(void[] p) @nogc nothrow pure shared @system
     {
         if (p.ptr is null)
         {
@@ -191,14 +206,7 @@ final class MmapPool : Allocator
             {
                 block.region.next.prev = block.region.prev;
             }
-            version (Posix)
+            return unmapMemory(block.region, block.region.size);
-            {
-                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)
@@ -222,15 +230,7 @@ final class MmapPool : Allocator
         return true;
     }
 
-    ///
+    /*
-    nothrow unittest
-    {
-        auto p = MmapPool.instance.allocate(20);
-
-        assert(MmapPool.instance.deallocate(p));
-    }
-
-    /**
      * 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
@@ -242,7 +242,8 @@ final class MmapPool : Allocator
      *
      * Returns: $(D_KEYWORD true) if successful, $(D_KEYWORD false) otherwise.
      */
-    bool reallocateInPlace(ref void[] p, in size_t size) shared nothrow @nogc
+    bool reallocateInPlace(ref void[] p, size_t size)
+    @nogc nothrow pure shared @system
     {
         if (p is null || size == 0)
         {
@@ -258,19 +259,25 @@ final class MmapPool : Allocator
 
         if (block1.size >= size)
         {
-            // Enough space in the current block. Can happen because of the alignment.
+            // Enough space in the current block.
             p = p.ptr[0 .. size];
             return true;
         }
-        immutable dataSize = addAlignment(size);
+        const dataSize = addAlignment(size);
-        immutable delta = dataSize - addAlignment(p.length);
+        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 or the next block is too small or not
+            /* - It is the last block in the region
-            // free.
+             * - 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_)
@@ -284,8 +291,8 @@ final class MmapPool : Allocator
             {
                 block1.next.next.prev = block2;
             }
-            // block1.next and block2 can overlap.
+            copyBackward((cast(void*) block1.next)[0 .. BlockEntry.sizeof],
-            memmove(cast(void*) block2, cast(void*) block1.next, BlockEntry.sizeof);
+                         (cast(void*) block2)[0 .. BlockEntry.sizeof]);
             block1.next = block2;
         }
         else
@@ -299,32 +306,7 @@ final class MmapPool : Allocator
         return true;
     }
 
-    ///
+    /*
-    nothrow 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);
-    }
-
-    /**
      * Increases or decreases the size of a memory block.
      *
      * Params:
@@ -333,7 +315,8 @@ final class MmapPool : Allocator
      *
      * Returns: Whether the reallocation was successful.
      */
-    bool reallocate(ref void[] p, in size_t size) shared nothrow @nogc
+    bool reallocate(ref void[] p, size_t size)
+    @nogc nothrow pure shared @system
     {
         if (size == 0)
         {
@@ -357,7 +340,7 @@ final class MmapPool : Allocator
         }
         if (p !is null)
         {
-            memcpy(reallocP.ptr, p.ptr, min(p.length, size));
+            copy(p[0 .. p.length < size ? p.length : size], reallocP);
             deallocate(p);
         }
         p = reallocP;
@@ -365,67 +348,18 @@ final class MmapPool : Allocator
         return true;
     }
 
-    ///
+    static private shared(MmapPool) instantiate() @nogc nothrow @system
-    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.
+            const instanceSize = addAlignment(__traits(classInstanceSize,
-            version (Posix)
+                                              MmapPool));
-            {
-                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);
+                copy(typeid(MmapPool).initializer, data[0 .. instanceSize]);
                 instance_ = cast(shared MmapPool) data;
                 instance_.head = head;
             }
@@ -433,10 +367,14 @@ final class MmapPool : Allocator
         return instance_;
     }
 
-    ///
+    /*
-    nothrow unittest
+     * Static allocator instance and initializer.
+     *
+     * Returns: Global $(D_PSYMBOL MmapPool) instance.
+     */
+    static @property shared(MmapPool) instance() @nogc nothrow pure @system
     {
-        assert(instance is instance);
+        return (cast(GetPureInstance!MmapPool) &instantiate)();
     }
 
     /*
@@ -448,34 +386,19 @@ final class MmapPool : Allocator
      *
      * Returns: A pointer to the data.
      */
-    private static void* initializeRegion(size_t size, ref Region head)
+    private static void* initializeRegion(const size_t size, ref Region head)
-    nothrow @nogc
+    @nogc nothrow pure @system
     {
-        immutable regionSize = calculateRegionSize(size);
+        const regionSize = calculateRegionSize(size);
-
+        if (regionSize < size)
-        version (Posix)
         {
-            void* p = mmap(null,
+            return null;
-                           regionSize,
-                           PROT_READ | PROT_WRITE,
-                           MAP_PRIVATE | MAP_ANON,
-                           -1,
-                           0);
-            if (p is MAP_FAILED)
-            {
-                return null;
-            }
         }
-        else version (Windows)
+
+        void* p = mapMemory(regionSize);
+        if (p is null)
         {
-            void* p = VirtualAlloc(null,
+            return null;
-                                   regionSize,
-                                   MEM_COMMIT,
-                                   PAGE_READWRITE);
-            if (p is null)
-            {
-                return null;
-            }
         }
 
         Region region = cast(Region) p;
@@ -513,9 +436,10 @@ final class MmapPool : Allocator
         return data;
     }
 
-    private void* initializeRegion(size_t size) shared nothrow @nogc
+    private void* initializeRegion(const size_t size)
+    @nogc nothrow pure shared @system
     {
-        return initializeRegion(size, head);
+        return initializeRegion(size, this.head);
     }
 
     /*
@@ -524,13 +448,7 @@ final class MmapPool : Allocator
      *
      * Returns: Aligned size of $(D_PARAM x).
      */
-    private static immutable(size_t) addAlignment(size_t x)
+    private static size_t addAlignment(const size_t x) @nogc nothrow pure @safe
-    pure nothrow @safe @nogc
-    out (result)
-    {
-        assert(result > 0);
-    }
-    body
     {
         return (x - 1) / alignment_ * alignment_ + alignment_;
     }
@@ -541,29 +459,27 @@ final class MmapPool : Allocator
      *
      * Returns: Minimum region size (a multiple of $(D_PSYMBOL pageSize)).
      */
-    private static immutable(size_t) calculateRegionSize(size_t x)
+    private static size_t calculateRegionSize(ref const size_t x)
-    nothrow @safe @nogc
+    @nogc nothrow pure @safe
-    out (result)
     {
-        assert(result > 0);
+        return (x + RegionEntry.sizeof + BlockEntry.sizeof * 2)
-    }
+             / pageSize * pageSize + pageSize;
-    body
-    {
-        x += RegionEntry.sizeof + BlockEntry.sizeof * 2;
-        return x / pageSize * pageSize + pageSize;
     }
 
-    /**
+    /*
      * Returns: Alignment offered.
      */
-    @property uint alignment() shared const pure nothrow @safe @nogc
+    @property uint alignment() const @nogc nothrow pure @safe shared
     {
         return alignment_;
     }
-    private enum alignment_ = 8;
+
+    private enum uint alignment_ = 8;
 
     private shared static MmapPool instance_;
-    private shared static size_t pageSize;
+
+    // Page size.
+    enum size_t pageSize = 65536;
 
     private shared struct RegionEntry
     {
@@ -586,60 +502,19 @@ final class MmapPool : Allocator
     private alias Block = shared BlockEntry*;
 }
 
-// A lot of allocations/deallocations, but it is the minimum caused a
+@nogc nothrow pure @system unittest
-// segmentation fault because MmapPool reallocateInPlace moves a block wrong.
-unittest
 {
-    auto a = MmapPool.instance.allocate(16);
+    // allocate() check.
-    auto d = MmapPool.instance.allocate(16);
+    size_t tooMuchMemory = size_t.max
-    auto b = MmapPool.instance.allocate(16);
+                         - MmapPool.alignment_
-    auto e = MmapPool.instance.allocate(16);
+                         - BlockEntry.sizeof * 2
-    auto c = MmapPool.instance.allocate(16);
+                         - RegionEntry.sizeof
-    auto f = MmapPool.instance.allocate(16);
+                         - pageSize;
+    assert(MmapPool.instance.allocate(tooMuchMemory) is null);
 
-    MmapPool.instance.deallocate(a);
+    assert(MmapPool.instance.allocate(size_t.max) is null);
-    MmapPool.instance.deallocate(b);
-    MmapPool.instance.deallocate(c);
 
-    a = MmapPool.instance.allocate(50);
+    // initializeRegion() check.
-    MmapPool.instance.reallocateInPlace(a, 64);
+    tooMuchMemory = size_t.max - MmapPool.alignment_;
-    MmapPool.instance.deallocate(a);
+    assert(MmapPool.instance.allocate(tooMuchMemory) is null);
-
-    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);
 }

middle/tanya/memory/op.d

@@ -0,0 +1,351 @@
+/* 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-2019.
+ * 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;
+
+version (TanyaNative)
+{
+    extern private void fillMemory(void[], size_t) pure nothrow @system @nogc;
+
+    extern private void copyMemory(const void[], void[])
+    pure nothrow @system @nogc;
+
+    extern private void moveMemory(const void[], void[])
+    pure nothrow @system @nogc;
+
+    extern private bool equalMemory(const void[], const void[])
+    pure nothrow @system @nogc;
+}
+else
+{
+    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 (source.length <= target.length)
+in (source.length == 0 || source.ptr !is null)
+in (target.length == 0 || target.ptr !is null)
+{
+    version (TanyaNative)
+    {
+        copyMemory(source, target);
+    }
+    else
+    {
+        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 (memory.length == 0 || memory.ptr !is null)
+{
+    version (TanyaNative)
+    {
+        fillMemory(memory, filledBytes!c);
+    }
+    else
+    {
+        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 (source.length <= target.length)
+in (source.length == 0 || source.ptr !is null)
+in (target.length == 0 || target.ptr !is null)
+{
+    version (TanyaNative)
+    {
+        moveMemory(source, target);
+    }
+    else
+    {
+        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 (haystack.length == 0 || haystack.ptr !is null)
+{
+    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 (haystack.length == 0 || haystack.ptr !is null)
+{
+    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 (r1.length == 0 || r1.ptr !is null)
+in (r2.length == 0 || r2.ptr !is null)
+{
+    version (TanyaNative)
+    {
+        return equalMemory(r1, r2);
+    }
+    else
+    {
+        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

@@ -0,0 +1,20 @@
+/* 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-2019.
+ * 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;
+deprecated("Use tanya.meta.trait.stateSize instead")
+public import tanya.meta.trait : stateSize;

middle/tanya/memory/smartref.d

@@ -3,24 +3,33 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /**
- * Copyright: Eugene Wissner 2016-2017.
+ * 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-2019.
  * 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.types;
+module tanya.memory.smartref;
 
-import core.exception;
+import tanya.memory.allocator;
-import std.algorithm.comparison;
+import tanya.memory.lifetime;
-import std.algorithm.mutation;
+import tanya.meta.trait;
-import std.conv;
-import std.range;
-import std.traits;
-import tanya.memory;
 
 private template Payload(T)
 {
-    static if (is(T == class) || is(T == interface) || isArray!T)
+    static if (isPolymorphicType!T || isDynamicArray!T)
     {
         alias Payload = T;
     }
@@ -30,18 +39,14 @@ private template Payload(T)
     }
 }
 
-final class RefCountedStore(T)
+private final class RefCountedStore(T)
 {
     T payload;
     size_t counter = 1;
 
     size_t opUnary(string op)()
-        if (op == "--" || op == "++")
+    if (op == "--" || op == "++")
-    in
+    in (this.counter > 0)
-    {
-        assert(counter > 0);
-    }
-    body
     {
         mixin("return " ~ op ~ "counter;");
     }
@@ -61,11 +66,6 @@ final class RefCountedStore(T)
             return 0;
         }
     }
-
-    int opEquals(const size_t counter)
-    {
-        return this.counter == counter;
-    }
 }
 
 private void separateDeleter(T)(RefCountedStore!T storage,
@@ -101,8 +101,8 @@ struct RefCounted(T)
 
     invariant
     {
-        assert(storage is null || allocator_ !is null);
+        assert(this.storage is null || this.allocator_ !is null);
-        assert(storage is null || deleter !is null);
+        assert(this.storage is null || this.deleter !is null);
     }
 
     /**
@@ -116,27 +116,18 @@ struct RefCounted(T)
      *
      * Precondition: $(D_INLINECODE allocator !is null)
      */
-    this()(auto ref Payload!T value,
+    this(Payload!T value, shared Allocator allocator = defaultAllocator)
-           shared Allocator allocator = defaultAllocator)
     {
         this(allocator);
         this.storage = allocator.make!Storage();
         this.deleter = &separateDeleter!(Payload!T);
 
-        move(value, this.storage.payload);
+        this.storage.payload = value;
-        static if (__traits(isRef, value))
-        {
-            value = null;
-        }
     }
 
-    /// Ditto.
+    /// ditto
     this(shared Allocator allocator)
-    in
+    in (allocator !is null)
-    {
-        assert(allocator !is null);
-    }
-    body
     {
         this.allocator_ = allocator;
     }
@@ -159,7 +150,7 @@ struct RefCounted(T)
      */
     ~this()
     {
-        if (this.storage !is null && !(this.storage.counter && --this.storage))
+        if (this.storage !is null && !(this.storage > 0 && --this.storage))
         {
             deleter(this.storage, allocator);
         }
@@ -183,7 +174,7 @@ struct RefCounted(T)
      *
      * Returns: $(D_KEYWORD this).
      */
-    ref typeof(this) opAssign()(auto ref Payload!T rhs)
+    ref typeof(this) opAssign(Payload!T rhs)
     {
         if (this.storage is null)
         {
@@ -201,11 +192,11 @@ struct RefCounted(T)
             finalize(this.storage.payload);
             this.storage.payload = Payload!T.init;
         }
-        move(rhs, this.storage.payload);
+        this.storage.payload = rhs;
         return this;
     }
 
-    /// Ditto.
+    /// ditto
     ref typeof(this) opAssign(typeof(null))
     {
         if (this.storage is null)
@@ -225,7 +216,7 @@ struct RefCounted(T)
         return this;
     }
 
-    /// Ditto.
+    /// ditto
     ref typeof(this) opAssign(typeof(this) rhs)
     {
         swap(this.allocator_, rhs.allocator_);
@@ -239,46 +230,42 @@ struct RefCounted(T)
      *
      * Precondition: $(D_INLINECODE cound > 0).
      */
-    Payload!T get() pure nothrow @safe @nogc
+    inout(Payload!T) get() inout
-    in
+    in (count > 0, "Attempted to access an uninitialized reference")
     {
-        assert(count > 0, "Attempted to access an uninitialized reference.");
+        return this.storage.payload;
-    }
-    body
-    {
-        return storage.payload;
     }
 
     version (D_Ddoc)
     {
         /**
-         * Params:
-         *  op = Operation. 
-         *
          * 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 T opUnary(string op)()
+        ref inout(T) opUnary(string op)() inout
-            if (op == "*");
+        if (op == "*");
     }
     else static if (isPointer!(Payload!T))
     {
-        ref T opUnary(string op)()
+        ref inout(T) opUnary(string op)() inout
-            if (op == "*")
+        if (op == "*")
         {
-            return *storage.payload;
+            return *this.storage.payload;
         }
     }
 
     /**
-     * Returns: Whether this $(D_PSYMBOL RefCounted) already has an internal 
+     * Returns: Whether this $(D_PSYMBOL RefCounted) already has an internal
      *          storage.
      */
     @property bool isInitialized() const
     {
-        return storage !is null;
+        return this.storage !is null;
     }
 
     /**
@@ -288,7 +275,7 @@ struct RefCounted(T)
      */
     @property size_t count() const
     {
-        return storage is null ? 0 : storage.counter;
+        return this.storage is null ? 0 : this.storage.counter;
     }
 
     mixin DefaultAllocator;
@@ -296,121 +283,20 @@ struct RefCounted(T)
 }
 
 ///
-unittest
+@nogc @system unittest
 {
     auto rc = RefCounted!int(defaultAllocator.make!int(5), defaultAllocator);
-    auto val = rc.get;
+    auto val = rc.get();
 
     *val = 8;
-    assert(*rc.storage.payload == 8);
+    assert(*rc.get == 8);
 
     val = null;
-    assert(rc.storage.payload !is null);
+    assert(rc.get !is null);
-    assert(*rc.storage.payload == 8);
+    assert(*rc.get == 8);
 
     *rc = 9;
-    assert(*rc.storage.payload == 9);
+    assert(*rc.get == 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
-{
-    auto rc = defaultAllocator.refCounted!int(5);
-    assert(rc.count == 1);
-
-    void func(RefCounted!int rc)
-    {
-        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);
-}
-
-private unittest
-{
-    auto rc = defaultAllocator.refCounted!int(5);
-    assert(*rc == 5);
-
-    void func(RefCounted!int rc)
-    {
-        assert(rc.count == 2);
-        rc = defaultAllocator.refCounted!int(4);
-        assert(*rc == 4);
-        assert(rc.count == 1);
-    }
-    func(rc);
-    assert(*rc == 5);
-}
-
-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));
 }
 
 /**
@@ -427,19 +313,15 @@ private unittest
  *  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
+if (!is(T == interface) && !isAbstractClass!T
-     && !isAssociativeArray!T && !isArray!T)
+ && !isAssociativeArray!T && !isArray!T)
-in
+in (allocator !is null)
-{
-    assert(allocator !is null);
-}
-body
 {
     auto rc = typeof(return)(allocator);
 
@@ -455,17 +337,9 @@ body
     {
         () @trusted { allocator.deallocate(mem); }();
     }
-    rc.storage = emplace!((RefCounted!T.Storage))(mem[0 .. storageSize]);
+    rc.storage = emplace!(RefCounted!T.Storage)(mem[0 .. storageSize]);
+    rc.storage.payload = emplace!T(mem[storageSize .. $], args);
 
-    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);
-    }
     rc.deleter = &unifiedDeleter!(Payload!T);
     return rc;
 }
@@ -476,35 +350,30 @@ body
  *
  * 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 / ElementType!T.sizeof)
+ *                           && size <= size_t.max / E.sizeof)
  */
-RefCounted!T refCounted(T)(shared Allocator allocator, const size_t size)
+RefCounted!T refCounted(T : E[], E)(shared Allocator allocator, size_t size)
 @trusted
-    if (isArray!T)
+in (allocator !is null)
-in
+in (size <= size_t.max / E.sizeof)
 {
-    assert(allocator !is null);
+    return RefCounted!T(allocator.make!T(size), allocator);
-    assert(size <= size_t.max / ElementType!T.sizeof);
-}
-body
-{
-    auto payload = allocator.resize!(ElementType!T)(null, size);
-    return RefCounted!T(payload, allocator);
 }
 
 ///
-unittest
+@nogc @system unittest
 {
     auto rc = defaultAllocator.refCounted!int(5);
     assert(rc.count == 1);
 
-    void func(RefCounted!int param)
+    void func(RefCounted!int param) @nogc
     {
         if (param.count == 2)
         {
@@ -520,58 +389,13 @@ unittest
     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);
-    }
-}
-
-private @nogc unittest
-{
-    auto rc = defaultAllocator.refCounted!(int[])(5);
-    assert(rc.length == 5);
-}
-
-private @nogc unittest
-{
-    static bool destroyed = false;
-
-    struct F
-    {
-        ~this() @nogc
-        {
-            destroyed = true;
-        }
-    }
-    {
-        auto rc = defaultAllocator.refCounted!F();
-    }
-    assert(destroyed);
-}
-
 /**
- * $(D_PSYMBOL Scoped) stores an object that gets destroyed at the end of its scope.
+ * $(D_PSYMBOL Unique) stores an object that gets destroyed at the end of its scope.
  *
  * Params:
  *  T = Value type.
  */
-struct Scoped(T)
+struct Unique(T)
 {
     private Payload!T payload;
 
@@ -591,31 +415,21 @@ struct Scoped(T)
      *
      * Precondition: $(D_INLINECODE allocator !is null)
      */
-    this()(auto ref Payload!T value,
+    this(Payload!T value, shared Allocator allocator = defaultAllocator)
-           shared Allocator allocator = defaultAllocator)
     {
         this(allocator);
-
+        this.payload = value;
-        move(value, this.payload);
-        static if (__traits(isRef, value))
-        {
-            value = null;
-        }
     }
 
-    /// Ditto.
+    /// ditto
     this(shared Allocator allocator)
-    in
+    in (allocator !is null)
-    {
-        assert(allocator !is null);
-    }
-    body
     {
         this.allocator_ = allocator;
     }
 
     /**
-     * $(D_PSYMBOL Scoped) is noncopyable.
+     * $(D_PSYMBOL Unique) is noncopyable.
      */
     @disable this(this);
 
@@ -624,43 +438,39 @@ struct Scoped(T)
      */
     ~this()
     {
-        if (this.payload !is null)
+        allocator.dispose(this.payload);
-        {
-            allocator.dispose(this.payload);
-        }
     }
 
     /**
-     * Initialized this $(D_PARAM Scoped) and takes ownership over
+     * Initialized this $(D_PARAM Unique) and takes ownership over
      * $(D_PARAM rhs).
      *
-     * To reset $(D_PSYMBOL Scoped) assign $(D_KEYWORD null).
+     * 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 Scoped) and assign it.
+     * $(D_PSYMBOL Unique) and assign it.
      *
      * Params:
      *  rhs = New object.
      *
      * Returns: $(D_KEYWORD this).
      */
-    ref typeof(this) opAssign()(auto ref Payload!T rhs)
+    ref typeof(this) opAssign(Payload!T rhs)
     {
         allocator.dispose(this.payload);
-        move(rhs, this.payload);
+        this.payload = rhs;
-
         return this;
     }
 
-    /// Ditto.
+    /// ditto
     ref typeof(this) opAssign(typeof(null))
     {
         allocator.dispose(this.payload);
         return this;
     }
 
-    /// Ditto.
+    /// ditto
     ref typeof(this) opAssign(typeof(this) rhs)
     {
         swap(this.allocator_, rhs.allocator_);
@@ -669,71 +479,116 @@ struct Scoped(T)
         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.
      */
-    Payload!T get() pure nothrow @safe @nogc
+    inout(Payload!T) get() inout
     {
-        return payload;
+        return this.payload;
     }
 
     version (D_Ddoc)
     {
         /**
-         * Params:
-         *  op = Operation. 
-         *
          * 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 T opUnary(string op)()
+        ref inout(T) opUnary(string op)() inout
-            if (op == "*");
+        if (op == "*");
     }
     else static if (isPointer!(Payload!T))
     {
-        ref T opUnary(string op)()
+        ref inout(T) opUnary(string op)() inout
-            if (op == "*")
+        if (op == "*")
         {
-            return *payload;
+            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 unittest
+@nogc nothrow pure @system unittest
 {
     auto p = defaultAllocator.make!int(5);
-    auto s = Scoped!int(p, defaultAllocator);
+    auto s = Unique!int(p, defaultAllocator);
-    assert(p is null);
     assert(*s == 5);
 }
 
 ///
-@nogc unittest
+@nogc nothrow @system unittest
 {
-    static bool destroyed = false;
+    static bool destroyed;
 
-    struct F
+    static struct F
     {
-        ~this() @nogc
+        ~this() @nogc nothrow @safe
         {
             destroyed = true;
         }
     }
     {
-        auto s = Scoped!F(defaultAllocator.make!F(), defaultAllocator);
+        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 Scoped) using $(D_PARAM args) as the parameter list for
+ * $(D_PSYMBOL Unique) using $(D_PARAM args) as the parameter list for
  * the constructor of $(D_PARAM T).
  *
  * Params:
@@ -741,72 +596,40 @@ struct Scoped(T)
  *  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 Scoped!T).
+ * Returns: Newly created $(D_PSYMBOL Unique!T).
  *
  * Precondition: $(D_INLINECODE allocator !is null)
  */
-Scoped!T scoped(T, A...)(shared Allocator allocator, auto ref A args)
+Unique!T unique(T, A...)(shared Allocator allocator, auto ref A args)
-    if (!is(T == interface) && !isAbstractClass!T
+if (!is(T == interface) && !isAbstractClass!T
-     && !isAssociativeArray!T && !isArray!T)
+ && !isAssociativeArray!T && !isArray!T)
-in
+in (allocator !is null)
 {
-    assert(allocator !is null);
+    auto payload = allocator.make!(T, A)(args);
-}
+    return Unique!T(payload, allocator);
-body
-{
-    auto payload = allocator.make!(T, shared Allocator, A)(args);
-    return Scoped!T(payload, allocator);
 }
 
 /**
  * Constructs a new array with $(D_PARAM size) elements and wraps it in a
- * $(D_PSYMBOL Scoped).
+ * $(D_PSYMBOL Unique).
  *
  * Params:
  *  T         = Array type.
+ *  E         = Array element type.
  *  size      = Array size.
  *  allocator = Allocator.
  *
- * Returns: Newly created $(D_PSYMBOL Scoped!T).
+ * Returns: Newly created $(D_PSYMBOL Unique!T).
  *
  * Precondition: $(D_INLINECODE allocator !is null
- *                           && size <= size_t.max / ElementType!T.sizeof)
+ *                           && size <= size_t.max / E.sizeof)
  */
-Scoped!T scoped(T)(shared Allocator allocator, const size_t size)
+Unique!T unique(T : E[], E)(shared Allocator allocator, size_t size)
 @trusted
-    if (isArray!T)
+in (allocator !is null)
-in
+in (size <= size_t.max / E.sizeof)
 {
-    assert(allocator !is null);
+    auto payload = allocator.resize!E(null, size);
-    assert(size <= size_t.max / ElementType!T.sizeof);
+    return Unique!T(payload, allocator);
-}
-body
-{
-    auto payload = allocator.resize!(ElementType!T)(null, size);
-    return Scoped!T(payload, allocator);
-}
-
-private unittest
-{
-    static assert(is(typeof(defaultAllocator.scoped!B(5))));
-    static assert(is(typeof(defaultAllocator.scoped!(int[])(5))));
-}
-
-private unittest
-{
-    auto s = defaultAllocator.scoped!int(5);
-    assert(*s == 5);
-
-    s = null;
-    assert(s is null);
-}
-
-private unittest
-{
-    auto s = defaultAllocator.scoped!int(5);
-    assert(*s == 5);
-
-    s = defaultAllocator.scoped!int(4);
-    assert(*s == 4);
 }

os/dub.json

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

os/tanya/os/error.d

@@ -0,0 +1,413 @@
+/* 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-2019.
+ * 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) @nogc nothrow pure @safe
+    {
+        this.value_ = that;
+        return this;
+    }
+
+    /// ditto
+    ref ErrorCode opAssign(const ErrorCode that) @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

@@ -0,0 +1,18 @@
+/* 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-2019.
+ * 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/comparison.d

@@ -0,0 +1,374 @@
+/* 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 for comparing values.
+ *
+ * Copyright: Eugene Wissner 2018-2019.
+ * 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/comparison.d,
+ *                 tanya/algorithm/comparison.d)
+ */
+module tanya.algorithm.comparison;
+
+import tanya.algorithm.mutation;
+import tanya.math;
+static import tanya.memory.op;
+import tanya.meta.metafunction;
+import tanya.meta.trait;
+import tanya.meta.transform;
+import tanya.range.array;
+import tanya.range.primitive;
+
+private ref inout(Args[0]) minMax(alias cmp, Args...)(ref inout Args args)
+{
+    auto actual = ((ref arg) @trusted => &arg)(args[0]);
+
+    foreach (i, arg; args[1 .. $])
+    {
+        static if (isFloatingPoint!(Args[0]))
+        {
+            if (isNaN(arg))
+            {
+                continue;
+            }
+            if (isNaN(*actual))
+            {
+                actual = ((ref arg) @trusted => &arg)(args[i + 1]);
+                continue;
+            }
+        }
+        if (cmp(arg, *actual))
+        {
+            actual = ((ref arg) @trusted => &arg)(args[i + 1]);
+        }
+    }
+
+    return *actual;
+}
+
+private T moveIf(T)(ref T arg)
+{
+    static if (hasElaborateCopyConstructor!T && isMutable!T)
+    {
+        return move(arg);
+    }
+    else
+    {
+        return arg;
+    }
+}
+
+/**
+ * Finds the smallest element in the argument list or a range.
+ *
+ * If a range is passed, $(D_PSYMBOL min) returns a range of the same type,
+ * whose front element is the smallest in the range. If more than one element
+ * fulfills this condition, the front of the returned range points to
+ * the first one found.
+ * If $(D_PARAM range) is empty, the original range is returned.
+ *
+ * If $(D_PARAM Args) are floating point numbers, $(B NaN) is not considered
+ * for comparison. $(B NaN) is returned only if all arguments are $(B NaN)s.
+ *
+ * Params:
+ *  Args  = Types of the arguments. All arguments should have the same type.
+ *  Range = Forward range type.
+ *  args  = Argument list.
+ *  range = Forward range.
+ *
+ * Returns: The smallest element.
+ */
+CommonType!Args min(Args...)(Args args)
+if (Args.length >= 2
+ && isOrderingComparable!(Args[0])
+ && allSameType!(Map!(Unqual, Args)))
+{
+    return moveIf(minMax!((ref a, ref b) => a < b)(args));
+}
+
+/// ditto
+ref inout(Unqual!(Args[0])) min(Args...)(ref inout Args args)
+if (Args.length >= 2
+ && isOrderingComparable!(Args[0])
+ && allSameType!(Map!(Unqual, Args)))
+{
+    return minMax!((ref a, ref b) => a < b)(args);
+}
+
+/// ditto
+Range min(Range)(Range range)
+if (isForwardRange!Range && isOrderingComparable!(ElementType!Range))
+{
+    if (range.empty)
+    {
+        return range;
+    }
+    auto actual = range.save;
+
+    range.popFront();
+    for (; !range.empty; range.popFront())
+    {
+        if (range.front < actual.front)
+        {
+            actual = range.save;
+        }
+    }
+
+    return actual;
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    assert(min(1, 2) == 1);
+    assert(min(3, 2) == 2);
+    assert(min(3, 1, 2) == 1);
+
+    int[4] range = [3, 1, 1, 2];
+    auto minElement = min(range[]);
+    assert(minElement.front == 1);
+    assert(minElement.length == 3);
+}
+
+/**
+ * Finds the largest element in the argument list or a range.
+ *
+ * If a range is passed, $(D_PSYMBOL max) returns a range of the same type,
+ * whose front element is the largest in the range. If more than one element
+ * fulfills this condition, the front of the returned range points to
+ * the first one found.
+ * If $(D_PARAM range) is empty, the original range is returned.
+ *
+ * If $(D_PARAM Args) are floating point numbers, $(B NaN) is not considered
+ * for comparison. $(B NaN) is returned only if all arguments are $(B NaN)s.
+ *
+ * Params:
+ *  Args  = Types of the arguments. All arguments should have the same type.
+ *  Range = Forward range type.
+ *  args  = Argument list.
+ *  range = Forward range.
+ *
+ * Returns: The largest element.
+ */
+CommonType!Args max(Args...)(Args args)
+if (Args.length >= 2
+ && isOrderingComparable!(Args[0])
+ && allSameType!(Map!(Unqual, Args)))
+{
+    return moveIf(minMax!((ref a, ref b) => a > b)(args));
+}
+
+/// ditto
+ref inout(Unqual!(Args[0])) max(Args...)(ref inout Args args)
+if (Args.length >= 2
+ && isOrderingComparable!(Args[0])
+ && allSameType!(Map!(Unqual, Args)))
+{
+    return minMax!((ref a, ref b) => a > b)(args);
+}
+
+/// ditto
+Range max(Range)(Range range)
+if (isForwardRange!Range && isOrderingComparable!(ElementType!Range))
+{
+    if (range.empty)
+    {
+        return range;
+    }
+    auto actual = range.save;
+
+    range.popFront();
+    for (; !range.empty; range.popFront())
+    {
+        if (range.front > actual.front)
+        {
+            actual = range.save;
+        }
+    }
+
+    return actual;
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    assert(max(1, 2) == 2);
+    assert(max(3, 2) == 3);
+    assert(max(1, 3, 2) == 3);
+
+    int[4] range = [1, 5, 5, 2];
+    auto maxElement = max(range[]);
+    assert(maxElement.front == 5);
+    assert(maxElement.length == 3);
+}
+
+/**
+ * Compares element-wise two ranges for equality.
+ *
+ * If the ranges have different lengths, they aren't equal.
+ *
+ * Params:
+ *  pred = Predicate used to compare individual element pairs.
+ *  R1   = First range type.
+ *  R2   = Second range type.
+ *  r1   = First range.
+ *  r2   = Second range.
+ *
+ * Returns: $(D_KEYWORD true) if both ranges are equal, $(D_KEYWORD false)
+ *          otherwise.
+ */
+bool equal(alias pred = (auto ref a, auto ref b) => a == b, R1, R2)
+          (R1 r1, R2 r2)
+if (allSatisfy!(isInputRange, R1, R2)
+ && is(typeof(pred(r1.front, r2.front)) == bool))
+{
+    static if (isDynamicArray!R1
+            && is(R1 == R2)
+            && __traits(isPOD, ElementType!R1))
+    {
+        return tanya.memory.op.equal(r1, r2);
+    }
+    else
+    {
+        static if (hasLength!R1 && hasLength!R2)
+        {
+            if (r1.length != r2.length)
+            {
+                return false;
+            }
+        }
+        for (; !r1.empty && !r2.empty; r1.popFront(), r2.popFront())
+        {
+            if (!pred(r1.front, r2.front))
+            {
+                return false;
+            }
+        }
+        static if (hasLength!R1 && hasLength!R2)
+        {
+            return true;
+        }
+        else
+        {
+            return r1.empty && r2.empty;
+        }
+    }
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    int[2] range1 = [1, 2];
+    assert(equal(range1[], range1[]));
+
+    int[3] range2 = [1, 2, 3];
+    assert(!equal(range1[], range2[]));
+}
+
+/**
+ * Compares element-wise two ranges for ordering.
+ *
+ * $(D_PSYMBOL compare) returns a negative value if $(D_PARAM r1) is less than
+ * $(D_PARAM r2), a positive value if $(D_PARAM r2) is less than $(D_PARAM r1),
+ * or `0` if $(D_PARAM r1) and $(D_PARAM r2) equal.
+ *
+ * $(D_PSYMBOL compare) iterates both ranges in lockstep. Whichever of them
+ * contains an element that is greater than the respective element at the same
+ * position in the other range is the greater one of the two.
+ *
+ * If one of the ranges becomes empty when iterating, but all elements equal so
+ * far, the range with more elements is the greater one.
+ *
+ * If $(D_PARAM pred) is given, it is used for comparison. $(D_PARAM pred) is
+ * called as $(D_INLINECODE pred(r1.front, r2.front)) and
+ * $(D_INLINECODE pred(r2.front, r1.front)) to perform three-way comparison.
+ * $(D_PARAM pred) should return a $(D_KEYWORD bool).
+ *
+ * If $(D_PARAM pred) is not given, but the element type of $(D_PARAM R1)
+ * defines `opCmp()` for the element type of $(D_PARAM R2), `opCmp()` is used.
+ *
+ * Otherwise the comparison is perfomed using the basic comparison operators.
+ *
+ * Params:
+ *  pred = Predicate used for comparison.
+ *  R1   = First range type.
+ *  R2   = Second range type.
+ *  r1   = First range.
+ *  r2   = Second range.
+ *
+ * Returns: A negative value if $(D_PARAM r1) is less than $(D_PARAM r2), a
+ *          positive value if $D(_PARAM r2) is less than $(D_PARAM r1), `0`
+ *          otherwise.
+ */
+int compare(alias pred, R1, R2)(R1 r1, R2 r2)
+if (allSatisfy!(isInputRange, R1, R2)
+ && is(typeof(pred(r1.front, r2.front)) == bool)
+ && is(typeof(pred(r2.front, r1.front)) == bool))
+{
+    alias predImpl = (ref r1, ref r2) {
+        return pred(r2.front, r1.front) - pred(r1.front, r2.front);
+    };
+    return compareImpl!(predImpl, R1, R2)(r1, r2);
+}
+
+/// ditto
+int compare(R1, R2)(R1 r1, R2 r2)
+if (allSatisfy!(isInputRange, R1, R2)
+ && is(typeof(r1.front < r2.front || r2.front < r1.front)))
+{
+    static if (is(typeof(r1.front.opCmp(r2.front)) == int))
+    {
+        alias pred = (ref r1, ref r2) => r1.front.opCmp(r2.front);
+    }
+    else
+    {
+        alias pred = (ref r1, ref r2) {
+            return (r2.front < r1.front) - (r1.front < r2.front);
+        };
+    }
+    return compareImpl!(pred, R1, R2)(r1, r2);
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    assert(compare("abc", "abc") == 0);
+    assert(compare("abcd", "abc") > 0);
+    assert(compare("ab", "abc") < 0);
+    assert(compare("abc", "abcd") < 0);
+    assert(compare("abc", "ab") > 0);
+    assert(compare("aec", "abc") > 0);
+    assert(compare("aac", "abc") < 0);
+    assert(compare("abc", "aec") < 0);
+    assert(compare("abc", "aab") > 0);
+    assert(compare("aacd", "abc") < 0);
+    assert(compare("abc", "aacd") > 0);
+
+    assert(compare!((a, b) => a > b)("aec", "abc") < 0);
+    assert(compare!((a, b) => a > b)("aac", "abc") > 0);
+}
+
+private int compareImpl(alias pred, R1, R2)(ref R1 r1, ref R2 r2)
+{
+    for (; !r1.empty || !r2.empty; r1.popFront(), r2.popFront())
+    {
+        if (r1.empty)
+        {
+            return -1;
+        }
+        else if (r2.empty)
+        {
+            return 1;
+        }
+        const comparison = pred(r1, r2);
+        if (comparison != 0)
+        {
+            return comparison;
+        }
+    }
+    return 0;
+}

source/tanya/algorithm/iteration.d

@@ -0,0 +1,729 @@
+/* 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-2019.
+ * 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 tanya.algorithm.comparison;
+import tanya.memory.lifetime;
+import tanya.meta.trait;
+import tanya.meta.transform;
+import tanya.range;
+import tanya.typecons;
+
+// These predicates are used to help preserve `const` and `inout` for
+// ranges built on other ranges.
+
+private enum hasInoutFront(T) = is(typeof((inout ref T a) => a.front));
+private enum hasInoutBack(T) = is(typeof((inout ref T a) => a.back));
+private enum hasInoutIndex(T) = is(typeof((inout ref T a, size_t i) => a[i]));
+
+private enum hasConstEmpty(T) = is(typeof(((const T* a) => (*a).empty)(null)) : bool);
+private enum hasConstLength(T) = is(typeof(((const T* a) => (*a).length)(null)) : size_t);
+private enum hasConstSave(T) = is(typeof(((const T* a) => (*a).save())(null)) : T);
+private enum hasConstSlice(T) = is(typeof(((const T* a) => (*a)[0 .. $])(null)) : T);
+
+unittest
+{
+    // Test the definitions.
+    static assert(hasInoutFront!string);
+    static assert(hasInoutBack!string);
+    static assert(hasInoutIndex!string);
+    static assert(hasConstEmpty!string);
+    static assert(hasConstLength!string);
+    static assert(hasConstSave!string);
+    static assert(hasConstSlice!string);
+
+    // Test that Take propagates const/inout correctly.
+    alias TakeString = Take!(string, false);
+    static assert(hasInoutFront!TakeString);
+    static assert(hasInoutBack!TakeString);
+    static assert(hasInoutIndex!TakeString);
+    static assert(hasConstEmpty!TakeString);
+    static assert(hasConstLength!TakeString);
+    static assert(hasConstSave!TakeString);
+    static assert(hasConstSlice!TakeString);
+
+    // Test that Retro propagates const/inout correctly.
+    alias RetroString = Retro!string;
+    static assert(hasInoutFront!RetroString);
+    static assert(hasInoutBack!RetroString);
+    static assert(hasInoutIndex!RetroString);
+    static assert(hasConstEmpty!RetroString);
+    static assert(hasConstLength!RetroString);
+    static assert(hasConstSave!RetroString);
+    static assert(hasConstSlice!RetroString);
+}
+
+private struct Take(R, bool exactly)
+{
+    private R source;
+    size_t length_;
+
+    @disable this();
+
+    private this(R source, size_t length)
+    {
+        this.source = source;
+        static if (!exactly && hasLength!R)
+        {
+            this.length_ = min(source.length, length);
+        }
+        else
+        {
+            this.length_ = length;
+        }
+    }
+
+    mixin(`@property auto ref front() ` ~ (hasInoutFront!R ? `inout ` : ``) ~
+    `in (!empty)
+    {
+        return this.source.front;
+    }`);
+
+    void popFront()
+    in (!empty)
+    {
+        this.source.popFront();
+        --this.length_;
+    }
+
+    mixin(`@property bool empty() ` ~ (exactly || isInfinite!R || hasConstEmpty!R ? `const ` : ``) ~
+    `{
+        static if (exactly || isInfinite!R)
+        {
+            return length == 0;
+        }
+        else
+        {
+            return this.length_ == 0 || this.source.empty;
+        }
+    }`);
+
+    static if (exactly || hasLength!R)
+    {
+        @property size_t length() const
+        {
+            return this.length_;
+        }
+    }
+
+    static if (hasAssignableElements!R)
+    {
+        @property void front(ref ElementType!R value)
+        in (!empty)
+        {
+            this.source.front = value;
+        }
+
+        @property void front(ElementType!R value)
+        in (!empty)
+        {
+            this.source.front = move(value);
+        }
+    }
+
+    static if (isForwardRange!R)
+    {
+        mixin(`typeof(this) save() ` ~ (hasConstSave!R ? `const ` : ``) ~
+        `{
+            return typeof(this)(this.source.save(), length);
+        }`);
+    }
+    static if (isRandomAccessRange!R)
+    {
+        mixin(`@property auto ref back() ` ~ (hasInoutBack!R ? `inout ` : ``) ~
+        `in (!empty)
+        {
+            return this.source[this.length - 1];
+        }`);
+
+        void popBack()
+        in (!empty)
+        {
+            --this.length_;
+        }
+
+        mixin(`auto ref opIndex(size_t i) ` ~ (hasInoutIndex!R ? `inout ` : ``) ~
+        `in (i < length)
+        {
+            return this.source[i];
+        }`);
+
+        static if (hasAssignableElements!R)
+        {
+            @property void back(ref ElementType!R value)
+            in (!empty)
+            {
+                this.source[length - 1] = value;
+            }
+
+            @property void back(ElementType!R value)
+            in (!empty)
+            {
+                this.source[length - 1] = move(value);
+            }
+
+            void opIndexAssign(ref ElementType!R value, size_t i)
+            in (i < length)
+            {
+                this.source[i] = value;
+            }
+
+            void opIndexAssign(ElementType!R value, size_t i)
+            in (i < length)
+            {
+                this.source[i] = move(value);
+            }
+        }
+    }
+
+    static if (!exactly && hasSlicing!R)
+    {
+        static if (is(typeof(length))) alias opDollar = length;
+
+        mixin(`auto opSlice(size_t i, size_t j) ` ~ (hasConstSlice!R ? `const ` : ``) ~
+        `in (i <= j)
+        in (j <= length)
+        {
+            return typeof(this)(this.source[i .. j], length);
+        }`);
+    }
+
+    version (unittest) static assert(isInputRange!Take);
+}
+
+/**
+ * Takes $(D_PARAM n) elements from $(D_PARAM range).
+ *
+ * If $(D_PARAM range) doesn't have $(D_PARAM n) elements, the resulting range
+ * spans all elements of $(D_PARAM range).
+ *
+ * $(D_PSYMBOL take) is particulary useful with infinite ranges. You can take
+ ` $(B n) elements from such range and pass the result to an algorithm which
+ * expects a finit range.
+ *
+ * Params:
+ *  R     = Type of the adapted range.
+ *  range = The range to take the elements from.
+ *  n     = The number of elements to take.
+ *
+ * Returns: A range containing maximum $(D_PARAM n) first elements of
+ *          $(D_PARAM range).
+ *
+ * See_Also: $(D_PSYMBOL takeExactly).
+ */
+auto take(R)(R range, size_t n)
+if (isInputRange!R)
+{
+    static if (hasSlicing!R && hasLength!R)
+    {
+        if (range.length <= n)
+            return range;
+        else
+            return range[0 .. n];
+    }
+    // Special case: take(take(...), n)
+    else static if (is(Range == Take!(RRange, exact), RRange, bool exact))
+    {
+        if (n > range.length_)
+            n = range.length_;
+        static if (exact)
+            // `take(takeExactly(r, n0), n)` is rewritten `takeExactly(r, min(n0, n))`.
+            return Take!(RRange, true)(range.source, n);
+        else
+            // `take(take(r, n0), n)` is rewritten `take(r, min(n0, n))`.
+            return Take!(RRange, false)(range.source, n);
+    }
+    else static if (isInfinite!R)
+    {
+        // If the range is infinite then `take` is the same as `takeExactly`.
+        return Take!(R, true)(range, n);
+    }
+    else
+    {
+        return Take!(R, false)(range, n);
+    }
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    static struct InfiniteRange
+    {
+        private size_t front_ = 1;
+
+        enum bool empty = false;
+
+        @property size_t front() @nogc nothrow pure @safe
+        {
+            return this.front_;
+        }
+
+        @property void front(size_t i) @nogc nothrow pure @safe
+        {
+            this.front_ = i;
+        }
+
+        void popFront() @nogc nothrow pure @safe
+        {
+            ++this.front_;
+        }
+
+        size_t opIndex(size_t i) @nogc nothrow pure @safe
+        {
+            return this.front_ + i;
+        }
+
+        void opIndexAssign(size_t value, size_t i) @nogc nothrow pure @safe
+        {
+            this.front = i + value;
+        }
+
+        InfiniteRange save() @nogc nothrow pure @safe
+        {
+            return this;
+        }
+    }
+
+    auto t = InfiniteRange().take(3);
+    assert(t.length == 3);
+    assert(t.front == 1);
+    assert(t.back == 3);
+
+    t.popFront();
+    assert(t.front == 2);
+    assert(t.back == 3);
+
+    t.popBack();
+    assert(t.front == 2);
+    assert(t.back == 2);
+
+    t.popFront();
+    assert(t.empty);
+}
+
+/**
+ * Takes exactly $(D_PARAM n) elements from $(D_PARAM range).
+ *
+ * $(D_PARAM range) must have at least $(D_PARAM n) elements.
+ *
+ * $(D_PSYMBOL takeExactly) is particulary useful with infinite ranges. You can
+ ` take $(B n) elements from such range and pass the result to an algorithm
+ * which expects a finit range.
+ *
+ * Params:
+ *  R     = Type of the adapted range.
+ *  range = The range to take the elements from.
+ *  n     = The number of elements to take.
+ *
+ * Returns: A range containing $(D_PARAM n) first elements of $(D_PARAM range).
+ *
+ * See_Also: $(D_PSYMBOL take).
+ */
+auto takeExactly(R)(R range, size_t n)
+if (isInputRange!R)
+{
+    static if (hasSlicing!R)
+    {
+        return range[0 .. n];
+    }
+    // Special case: takeExactly(take(range, ...), n) is takeExactly(range, n)
+    else static if (is(Range == Take!(RRange, exact), RRange, bool exact))
+    {
+        assert(n <= range.length_);
+        return Take!(RRange, true)(range.source, n);
+    }
+    else
+    {
+        return Take!(R, true)(range, n);
+    }
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    static struct InfiniteRange
+    {
+        private size_t front_ = 1;
+
+        enum bool empty = false;
+
+        @property size_t front() @nogc nothrow pure @safe
+        {
+            return this.front_;
+        }
+
+        @property void front(size_t i) @nogc nothrow pure @safe
+        {
+            this.front_ = i;
+        }
+
+        void popFront() @nogc nothrow pure @safe
+        {
+            ++this.front_;
+        }
+
+        size_t opIndex(size_t i) @nogc nothrow pure @safe
+        {
+            return this.front_ + i;
+        }
+
+        void opIndexAssign(size_t value, size_t i) @nogc nothrow pure @safe
+        {
+            this.front = i + value;
+        }
+
+        InfiniteRange save() @nogc nothrow pure @safe
+        {
+            return this;
+        }
+    }
+
+    auto t = InfiniteRange().takeExactly(3);
+    assert(t.length == 3);
+    assert(t.front == 1);
+    assert(t.back == 3);
+
+    t.popFront();
+    assert(t.front == 2);
+    assert(t.back == 3);
+
+    t.popBack();
+    assert(t.front == 2);
+    assert(t.back == 2);
+
+    t.popFront();
+    assert(t.empty);
+}
+
+// Reverse-access-order range returned by `retro`.
+private struct Retro(Range)
+{
+    Range source;
+
+    @disable this();
+
+    private this(Range source)
+    {
+        this.source = source;
+    }
+
+    mixin(`Retro save() ` ~ (hasConstSave!Range ? `const ` : ``) ~
+    `{
+        return Retro(source.save());
+    }`);
+
+    mixin(`@property auto ref front() ` ~ (hasInoutBack!Range ? `inout ` : ``) ~
+    `in (!empty)
+    {
+        return this.source.back;
+    }`);
+
+    void popFront()
+    in (!empty)
+    {
+        this.source.popBack();
+    }
+
+    mixin(`@property auto ref back() ` ~ (hasInoutFront!Range ? `inout ` : ``) ~
+    `in (!empty)
+    {
+        return this.source.front;
+    }`);
+
+    void popBack()
+    in (!empty)
+    {
+        this.source.popFront();
+    }
+
+    mixin(`@property bool empty() ` ~ (hasConstEmpty!Range ? `const ` : ``) ~
+    `{
+        return this.source.empty;
+    }`);
+
+    static if (hasLength!Range)
+    {
+        mixin(`@property size_t length() ` ~ (hasConstLength!Range ? `const ` : ``) ~
+        `{
+            return this.source.length;
+        }`);
+    }
+
+    static if (isRandomAccessRange!Range && hasLength!Range)
+    {
+        mixin(`auto ref opIndex(size_t i) ` ~ (hasInoutIndex!Range ? `inout ` : ``) ~
+        `in (i < length)
+        {
+            return this.source[$ - ++i];
+        }`);
+    }
+
+    static if (hasLength!Range && hasSlicing!Range)
+    {
+        alias opDollar = length;
+
+        mixin(`auto opSlice(size_t i, size_t j) ` ~ (hasConstSlice!Range ? `const ` : ``) ~
+        `in (i <= j)
+        in (j <= length)
+        {
+            return typeof(this)(this.source[$-j .. $-i]);
+        }`);
+    }
+
+    static if (hasAssignableElements!Range)
+    {
+        @property void front(ref ElementType!Range value)
+        in (!empty)
+        {
+            this.source.back = value;
+        }
+
+        @property void front(ElementType!Range value)
+        in (!empty)
+        {
+            this.source.back = move(value);
+        }
+
+        @property void back(ref ElementType!Range value)
+        in (!empty)
+        {
+            this.source.front = value;
+        }
+
+        @property void back(ElementType!Range value)
+        in (!empty)
+        {
+            this.source.front = move(value);
+        }
+
+        static if (isRandomAccessRange!Range && hasLength!Range)
+        {
+            void opIndexAssign(ref ElementType!Range value, size_t i)
+            in (i < length)
+            {
+                this.source[$ - ++i] = value;
+            }
+
+            void opIndexAssign(ElementType!Range value, size_t i)
+            in (i < length)
+            {
+                this.source[$ - ++i] = move(value);
+            }
+        }
+    }
+
+    version (unittest) static assert(isBidirectionalRange!Retro);
+}
+
+/**
+ * Iterates a bidirectional range backwards.
+ *
+ * If $(D_PARAM Range) is a random-access range as well, the resulting range
+ * is a random-access range too.
+ *
+ * Params:
+ *  Range = Bidirectional range type.
+ *  range = Bidirectional range.
+ *
+ * Returns: Bidirectional range with the elements order reversed.
+ */
+auto retro(Range)(return Range range)
+if (isBidirectionalRange!Range)
+{
+    // Special case: retro(retro(range)) is range
+    static if (is(Range == Retro!RRange, RRange))
+        return range.source;
+    else
+        return Retro!Range(range);
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    import tanya.algorithm.comparison : equal;
+
+    const int[3] given = [1, 2, 3];
+    const int[3] expected = [3, 2, 1];
+
+    auto actual = retro(given[]);
+
+    assert(actual.length == expected.length);
+    assert(!actual.empty);
+    assert(equal(actual, expected[]));
+}
+
+private struct SingletonByValue(E)
+{
+    private Option!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 == Option!(Unqual!E)) || is(Unqual!U == Option!(const E)))
+    {
+        if (!element.isNothing)
+        {
+            this.element = element.get;
+        }
+    }
+
+    @property ref inout(E) front() inout
+    in (!empty)
+    {
+        return this.element.get;
+    }
+
+    alias back = front;
+
+    void popFront()
+    in (!empty)
+    {
+        this.element.reset();
+    }
+
+    alias popBack = popFront;
+
+    @property bool empty() const
+    {
+        return this.element.isNothing;
+    }
+
+    @property size_t length() const
+    {
+        return !this.element.isNothing;
+    }
+
+    auto save()
+    {
+        return SingletonByValue!E(this.element);
+    }
+
+    auto save() const
+    {
+        return SingletonByValue!(const E)(this.element);
+    }
+
+    ref inout(E) opIndex(size_t i) inout
+    in (!empty)
+    in (i == 0)
+    {
+        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 (!empty)
+    {
+        return *this.element;
+    }
+
+    alias back = front;
+
+    void popFront()
+    in (!empty)
+    {
+        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);
+    }
+
+    auto save() const return
+    {
+        return SingletonByRef!(const E)(*this.element);
+    }
+
+    ref inout(E) opIndex(size_t i) inout return
+    in (!empty)
+    in (i == 0)
+    {
+        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);
+}

source/tanya/algorithm/mutation.d

@@ -0,0 +1,306 @@
+/* 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-2019.
+ * 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;
+
+deprecated("Use tanya.memory.lifetime.swap instead")
+alias swap = tanya.memory.lifetime.swap;
+
+deprecated("Use tanya.memory.lifetime.moveEmplace instead")
+alias moveEmplace = tanya.memory.lifetime.moveEmplace;
+
+deprecated("Use tanya.memory.lifetime.move instead")
+alias move = tanya.memory.lifetime.move;
+
+/**
+ * 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 tanya.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 tanya.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 tanya.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 (__VERSION__ >= 2083
+            && 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 tanya.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);
+}
+
+/**
+ * Rotates the elements of a union of two ranges.
+ *
+ * Performs a left rotation on the given ranges, as if it would be a signle
+ * range, so that [`front.front`, `back.front`$(RPAREN) is a valid range, that
+ * is $(D_PARAM back) would continue $(D_PARAM front).
+ *
+ * The elements are moved so, that the first element of $(D_PARAM back) becomes
+ * the first element of $(D_PARAM front) without changing the relative order of
+ * their elements.
+ *
+ * Params:
+ *  Range = Range type.
+ *  front = Left half.
+ *  back  = Right half.
+ */
+void rotate(Range)(Range front, Range back)
+if (isForwardRange!Range && hasSwappableElements!Range)
+{
+    auto next = back.save();
+
+    while (!front.empty && !next.empty && !sameHead(front, next))
+    {
+        tanya.memory.lifetime.swap(front.front, next.front);
+        front.popFront();
+        next.popFront();
+
+        if (next.empty)
+        {
+            next = back.save();
+        }
+        else if (front.empty)
+        {
+            front = back.save();
+            back = next.save();
+        }
+    }
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    import tanya.algorithm.comparison : equal;
+
+    const int[7] expected = [1, 2, 3, 4, 5, 6, 7];
+    int[7] actual = [5, 6, 3, 4, 1, 2, 7];
+
+    rotate(actual[0 .. 2], actual[4 .. 6]);
+    assert(equal(actual[], expected[]));
+}

source/tanya/algorithm/package.d

@@ -0,0 +1,20 @@
+/* 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-2019.
+ * 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.comparison;
+public import tanya.algorithm.iteration;
+public import tanya.algorithm.mutation;
+public import tanya.algorithm.searching;

source/tanya/algorithm/searching.d

@@ -0,0 +1,53 @@
+/* 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/. */
+
+/**
+ * Searching algorithms.
+ *
+ * Copyright: Eugene Wissner 2018-2019.
+ * 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/searching.d,
+ *                 tanya/algorithm/searching.d)
+ */
+module tanya.algorithm.searching;
+
+import tanya.range;
+
+/**
+ * Counts the elements in an input range.
+ *
+ * If $(D_PARAM R) has length, $(D_PSYMBOL count) returns it, otherwise it
+ * iterates over the range and counts the elements.
+ *
+ * Params:
+ *  R     = Input range type.
+ *  range = Input range.
+ *
+ * Returns: $(D_PARAM range) length.
+ */
+size_t count(R)(R range)
+if (isInputRange!R)
+{
+    static if (hasLength!R)
+    {
+        return range.length;
+    }
+    else
+    {
+        size_t counter;
+        for (; !range.empty; range.popFront(), ++counter)
+        {
+        }
+        return counter;
+    }
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    int[3] array;
+    assert(count(array) == 3);
+}

source/tanya/async/event/epoll.d

@@ -1,181 +1,187 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
+/* 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
+ * 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/. */
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
+
-/**
+/**
- * Copyright: Eugene Wissner 2016-2017.
+ * Event loop implementation for Linux.
- * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
+ *
- *                  Mozilla Public License, v. 2.0).
+ * Copyright: Eugene Wissner 2016-2019.
- * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
+ * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
- */
+ *                  Mozilla Public License, v. 2.0).
-module tanya.async.event.epoll;
+ * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
-
+ * Source: $(LINK2 https://github.com/caraus-ecms/tanya/blob/master/source/tanya/async/event/epoll.d,
-version (linux):
+ *                 tanya/async/event/epoll.d)
-
+ */
-public import core.sys.linux.epoll;
+module tanya.async.event.epoll;
-import tanya.async.protocol;
+
-import tanya.async.event.selector;
+version (D_Ddoc)
-import tanya.async.loop;
+{
-import tanya.async.transport;
+}
-import tanya.async.watcher;
+else version (linux):
-import tanya.container.array;
+
-import tanya.memory;
+import core.stdc.errno;
-import tanya.memory.mmappool;
+public import core.sys.linux.epoll;
-import tanya.network.socket;
+import core.sys.posix.unistd;
-import core.stdc.errno;
+import core.time;
-import core.sys.posix.unistd;
+import tanya.algorithm.comparison;
-import core.time;
+import tanya.async.event.selector;
-import std.algorithm.comparison;
+import tanya.async.loop;
-
+import tanya.async.protocol;
-extern (C) nothrow @nogc
+import tanya.async.transport;
-{
+import tanya.async.watcher;
-    int epoll_create1(int flags);
+import tanya.container.array;
-    int epoll_ctl (int epfd, int op, int fd, epoll_event *event);
+import tanya.memory.allocator;
-    int epoll_wait (int epfd, epoll_event *events, int maxevents, int timeout);
+import tanya.network.socket;
-}
+
-
+extern (C) nothrow @nogc
-final class EpollLoop : SelectorLoop
+{
-{
+    int epoll_create1(int flags);
-    protected int fd;
+    int epoll_ctl (int epfd, int op, int fd, epoll_event *event);
-    private Array!epoll_event events;
+    int epoll_wait (int epfd, epoll_event *events, int maxevents, int timeout);
-
+}
-    /**
+
-     * Initializes the loop.
+final class EpollLoop : SelectorLoop
-     */
+{
-    this() @nogc
+    protected int fd;
-    {
+    private Array!epoll_event events;
-        if ((fd = epoll_create1(EPOLL_CLOEXEC)) < 0)
+
-        {
+    /**
-            throw defaultAllocator.make!BadLoopException("epoll initialization failed");
+     * Initializes the loop.
-        }
+     */
-        super();
+    this() @nogc
-        events = Array!epoll_event(maxEvents, MmapPool.instance);
+    {
-    }
+        if ((fd = epoll_create1(EPOLL_CLOEXEC)) < 0)
-
+        {
-    /**
+            throw defaultAllocator.make!BadLoopException("epoll initialization failed");
-     * Frees loop internals.
+        }
-     */
+        super();
-    ~this() @nogc
+        events = Array!epoll_event(maxEvents);
-    {
+    }
-        close(fd);
+
-    }
+    /**
-
+     * Frees loop internals.
-    /**
+     */
-     * Should be called if the backend configuration changes.
+    ~this() @nogc
-     *
+    {
-     * Params:
+        close(fd);
-     *  watcher   = Watcher.
+    }
-     *  oldEvents = The events were already set.
+
-     *  events    = The events should be set.
+    /**
-     *
+     * Should be called if the backend configuration changes.
-     * Returns: $(D_KEYWORD true) if the operation was successful.
+     *
-     */
+     * Params:
-    protected override bool reify(SocketWatcher watcher,
+     *  watcher   = Watcher.
-                                  EventMask oldEvents,
+     *  oldEvents = The events were already set.
-                                  EventMask events) @nogc
+     *  events    = The events should be set.
-    {
+     *
-        int op = EPOLL_CTL_DEL;
+     * Returns: $(D_KEYWORD true) if the operation was successful.
-        epoll_event ev;
+     */
-
+    protected override bool reify(SocketWatcher watcher,
-        if (events == oldEvents)
+                                  EventMask oldEvents,
-        {
+                                  EventMask events) @nogc
-            return true;
+    {
-        }
+        int op = EPOLL_CTL_DEL;
-        if (events && oldEvents)
+        epoll_event ev;
-        {
+
-            op = EPOLL_CTL_MOD;
+        if (events == oldEvents)
-        }
+        {
-        else if (events && !oldEvents)
+            return true;
-        {
+        }
-            op = EPOLL_CTL_ADD;
+        if (events && oldEvents)
-        }
+        {
-
+            op = EPOLL_CTL_MOD;
-        ev.data.fd = watcher.socket.handle;
+        }
-        ev.events = (events & (Event.read | Event.accept) ? EPOLLIN | EPOLLPRI : 0)
+        else if (events && !oldEvents)
-                  | (events & Event.write ? EPOLLOUT : 0)
+        {
-                  | EPOLLET;
+            op = EPOLL_CTL_ADD;
-
+        }
-        return epoll_ctl(fd, op, watcher.socket.handle, &ev) == 0;
+
-    }
+        ev.data.fd = watcher.socket.handle;
-
+        ev.events = (events & (Event.read | Event.accept) ? EPOLLIN | EPOLLPRI : 0)
-    /**
+                  | (events & Event.write ? EPOLLOUT : 0)
-     * Does the actual polling.
+                  | EPOLLET;
-     */
+
-    protected override void poll() @nogc
+        return epoll_ctl(fd, op, watcher.socket.handle, &ev) == 0;
-    {
+    }
-        // Don't block
+
-        immutable timeout = cast(immutable int) blockTime.total!"msecs";
+    /**
-        auto eventCount = epoll_wait(fd, events.get().ptr, maxEvents, timeout);
+     * Does the actual polling.
-
+     */
-        if (eventCount < 0)
+    protected override void poll() @nogc
-        {
+    {
-            if (errno != EINTR)
+        // Don't block
-            {
+        immutable timeout = cast(immutable int) blockTime.total!"msecs";
-                throw defaultAllocator.make!BadLoopException();
+        auto eventCount = epoll_wait(fd, events.get().ptr, maxEvents, timeout);
-            }
+
-            return;
+        if (eventCount < 0)
-        }
+        {
-
+            if (errno != EINTR)
-        for (auto i = 0; i < eventCount; ++i)
+            {
-        {
+                throw defaultAllocator.make!BadLoopException();
-            auto transport = cast(StreamTransport) connections[events[i].data.fd];
+            }
-
+            return;
-            if (transport is null)
+        }
-            {
+
-                auto connection = cast(ConnectionWatcher) connections[events[i].data.fd];
+        for (auto i = 0; i < eventCount; ++i)
-                assert(connection !is null);
+        {
-
+            auto transport = cast(StreamTransport) connections[events[i].data.fd];
-                acceptConnections(connection);
+
-            }
+            if (transport is null)
-            else if (events[i].events & EPOLLERR)
+            {
-            {
+                auto connection = cast(ConnectionWatcher) connections[events[i].data.fd];
-                kill(transport);
+                assert(connection !is null);
-                continue;
+
-            }
+                acceptConnections(connection);
-            else if (events[i].events & (EPOLLIN | EPOLLPRI | EPOLLHUP))
+            }
-            {
+            else if (events[i].events & EPOLLERR)
-                SocketException exception;
+            {
-                try
+                kill(transport);
-                {
+                continue;
-                    ptrdiff_t received;
+            }
-                    do
+            else if (events[i].events & (EPOLLIN | EPOLLPRI | EPOLLHUP))
-                    {
+            {
-                        received = transport.socket.receive(transport.output[]);
+                SocketException exception;
-                        transport.output += received;
+                try
-                    }
+                {
-                    while (received);
+                    ptrdiff_t received;
-                }
+                    do
-                catch (SocketException e)
+                    {
-                {
+                        received = transport.socket.receive(transport.output[]);
-                    exception = e;
+                        transport.output += received;
-                }
+                    }
-                if (transport.socket.disconnected)
+                    while (received);
-                {
+                }
-                    kill(transport, exception);
+                catch (SocketException e)
-                    continue;
+                {
-                }
+                    exception = e;
-                else if (transport.output.length)
+                }
-                {
+                if (transport.socket.disconnected)
-                    pendings.enqueue(transport);
+                {
-                }
+                    kill(transport, exception);
-            }
+                    continue;
-            if (events[i].events & EPOLLOUT)
+                }
-            {
+                else if (transport.output.length)
-                transport.writeReady = true;
+                {
-                if (transport.input.length)
+                    pendings.insertBack(transport);
-                {
+                }
-                    feed(transport);
+            }
-                }
+            if (events[i].events & EPOLLOUT)
-            }
+            {
-        }
+                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");
+    /**
-    }
+     * 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

@@ -3,28 +3,32 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /**
- * Copyright: Eugene Wissner 2016-2017.
+ * Event loop implementation for Windows.
+ *
+ * Copyright: Eugene Wissner 2016-2019.
  * 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/async/event/iocp.d,
+ *                 tanya/async/event/iocp.d)
  */
 module tanya.async.event.iocp;
 
-version (Windows):
+version (D_Ddoc)
+{
+}
+else version (Windows):
 
-import tanya.container.buffer;
+import core.sys.windows.mswsock;
+import core.sys.windows.winsock2;
 import tanya.async.loop;
 import tanya.async.protocol;
 import tanya.async.transport;
 import tanya.async.watcher;
-import tanya.memory;
+import tanya.container.buffer;
-import tanya.memory.mmappool;
+import tanya.memory.allocator;
 import tanya.network.socket;
-import core.sys.windows.basetyps;
+import tanya.sys.windows.winbase;
-import core.sys.windows.mswsock;
-import core.sys.windows.winbase;
-import core.sys.windows.windef;
-import core.sys.windows.winsock2;
 
 /**
  * Transport for stream sockets.
@@ -52,8 +56,8 @@ final class StreamTransport : SocketWatcher, DuplexTransport, SocketTransport
     this(OverlappedConnectedSocket socket) @nogc
     {
         super(socket);
-        output = ReadBuffer!ubyte(8192, 1024, MmapPool.instance);
+        output = ReadBuffer!ubyte(8192, 1024);
-        input = WriteBuffer!ubyte(8192, MmapPool.instance);
+        input = WriteBuffer!ubyte(8192);
         active = true;
     }
 
@@ -63,11 +67,7 @@ final class StreamTransport : SocketWatcher, DuplexTransport, SocketTransport
      * Postcondition: $(D_INLINECODE socket !is null)
      */
     override @property OverlappedConnectedSocket socket() pure nothrow @safe @nogc
-    out (socket)
+    out (socket; socket !is null)
-    {
-        assert(socket !is null);
-    }
-    body
     {
         return cast(OverlappedConnectedSocket) socket_;
     }
@@ -112,8 +112,7 @@ final class StreamTransport : SocketWatcher, DuplexTransport, SocketTransport
     /**
      * Switches the protocol.
      *
-     * The protocol is deallocated by the event loop, it should currently be
+     * The protocol is deallocated by the event loop.
-     * allocated with $(D_PSYMBOL MmapPool).
      *
      * Params:
      *  protocol = Application protocol.
@@ -121,11 +120,7 @@ final class StreamTransport : SocketWatcher, DuplexTransport, SocketTransport
      * Precondition: $(D_INLINECODE protocol !is null)
      */
     @property void protocol(Protocol protocol) pure nothrow @safe @nogc
-    in
+    in (protocol !is null)
-    {
-        assert(protocol !is null);
-    }
-    body
     {
         protocol_ = protocol;
     }
@@ -145,20 +140,20 @@ final class StreamTransport : SocketWatcher, DuplexTransport, SocketTransport
                 SocketState overlapped;
                 try
                 {
-                    overlapped = MmapPool.instance.make!SocketState;
+                    overlapped = defaultAllocator.make!SocketState;
                     socket.beginSend(input[], overlapped);
                 }
                 catch (SocketException e)
                 {
-                    MmapPool.instance.dispose(overlapped);
+                    defaultAllocator.dispose(overlapped);
-                    MmapPool.instance.dispose(e);
+                    defaultAllocator.dispose(e);
                 }
             }
         }
         else
         {
             protocol.disconnected(exception);
-            MmapPool.instance.dispose(protocol_);
+            defaultAllocator.dispose(protocol_);
             defaultAllocator.dispose(exception);
             active = false;
         }
@@ -178,7 +173,7 @@ final class IOCPLoop : Loop
     {
         super();
 
-        completionPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
+        completionPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, null, 0, 0);
         if (!completionPort)
         {
             throw make!BadLoopException(defaultAllocator,
@@ -208,7 +203,7 @@ final class IOCPLoop : Loop
 
             if (CreateIoCompletionPort(cast(HANDLE) socket.handle,
                                        completionPort,
-                                       cast(ULONG_PTR) (cast(void*) watcher),
+                                       cast(size_t) (cast(void*) watcher),
                                        0) !is completionPort)
             {
                 return false;
@@ -216,25 +211,25 @@ final class IOCPLoop : Loop
 
             try
             {
-                overlapped = MmapPool.instance.make!SocketState;
+                overlapped = defaultAllocator.make!SocketState;
                 socket.beginAccept(overlapped);
             }
             catch (SocketException e)
             {
-                MmapPool.instance.dispose(overlapped);
+                defaultAllocator.dispose(overlapped);
                 defaultAllocator.dispose(e);
                 return false;
             }
         }
-        if (!(oldEvents & Event.read) && (events & Event.read)
+        if ((!(oldEvents & Event.read) && (events & Event.read))
-            || !(oldEvents & Event.write) && (events & Event.write))
+            || (!(oldEvents & Event.write) && (events & Event.write)))
         {
             auto transport = cast(StreamTransport) watcher;
             assert(transport !is null);
 
             if (CreateIoCompletionPort(cast(HANDLE) transport.socket.handle,
                                        completionPort,
-                                       cast(ULONG_PTR) (cast(void*) watcher),
+                                       cast(size_t) (cast(void*) watcher),
                                        0) !is completionPort)
             {
                 return false;
@@ -245,12 +240,12 @@ final class IOCPLoop : Loop
             {
                 try
                 {
-                    overlapped = MmapPool.instance.make!SocketState;
+                    overlapped = defaultAllocator.make!SocketState;
                     transport.socket.beginReceive(transport.output[], overlapped);
                 }
                 catch (SocketException e)
                 {
-                    MmapPool.instance.dispose(overlapped);
+                    defaultAllocator.dispose(overlapped);
                     defaultAllocator.dispose(e);
                     return false;
                 }
@@ -261,16 +256,12 @@ final class IOCPLoop : Loop
 
     private void kill(StreamTransport transport,
                       SocketException exception = null) @nogc
-    in
+    in (transport !is null)
-    {
-        assert(transport !is null);
-    }
-    body
     {
         transport.socket.shutdown();
         defaultAllocator.dispose(transport.socket);
         transport.exception = exception;
-        pendings.enqueue(transport);
+        pendings.insertBack(transport);
     }
 
     /**
@@ -279,8 +270,8 @@ final class IOCPLoop : Loop
     override protected void poll() @nogc
     {
         DWORD lpNumberOfBytes;
-        ULONG_PTR key;
+        size_t key;
-        LPOVERLAPPED overlap;
+        OVERLAPPED* overlap;
         immutable timeout = cast(immutable int) blockTime.total!"msecs";
 
         auto result = GetQueuedCompletionStatus(completionPort,
@@ -288,16 +279,17 @@ final class IOCPLoop : Loop
                                                 &key,
                                                 &overlap,
                                                 timeout);
-        if (result == FALSE && overlap == NULL)
+        if (result == FALSE && overlap is null)
         {
             return; // Timeout
         }
 
-        auto overlapped = (cast(SocketState) ((cast(void*) overlap) - 8));
+        enum size_t offset = size_t.sizeof * 2;
+        auto overlapped = cast(SocketState) ((cast(void*) overlap) - offset);
         assert(overlapped !is null);
         scope (failure)
         {
-            MmapPool.instance.dispose(overlapped);
+            defaultAllocator.dispose(overlapped);
         }
 
         switch (overlapped.event)
@@ -310,13 +302,15 @@ final class IOCPLoop : Loop
                 assert(listener !is null);
 
                 auto socket = listener.endAccept(overlapped);
-                auto transport = MmapPool.instance.make!StreamTransport(socket);
+                auto transport = defaultAllocator.make!StreamTransport(socket);
 
-                connection.incoming.enqueue(transport);
+                connection.incoming.insertBack(transport);
 
-                reify(transport, EventMask(Event.none), EventMask(Event.read, Event.write));
+                reify(transport,
+                      EventMask(Event.none),
+                      EventMask(Event.read | Event.write));
 
-                pendings.enqueue(connection);
+                pendings.insertBack(connection);
                 listener.beginAccept(overlapped);
                 break;
             case OverlappedSocketEvent.read:
@@ -325,8 +319,8 @@ final class IOCPLoop : Loop
 
                 if (!transport.active)
                 {
-                    MmapPool.instance.dispose(transport);
+                    defaultAllocator.dispose(transport);
-                    MmapPool.instance.dispose(overlapped);
+                    defaultAllocator.dispose(overlapped);
                     return;
                 }
 
@@ -356,7 +350,7 @@ final class IOCPLoop : Loop
                     {
                         transport.socket.beginReceive(transport.output[], overlapped);
                     }
-                    pendings.enqueue(transport);
+                    pendings.insertBack(transport);
                 }
                 break;
             case OverlappedSocketEvent.write:

source/tanya/async/event/kqueue.d

@@ -2,15 +2,22 @@
  * 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-2017.
+ * Event loop implementation for *BSD.
+ *
+ * Copyright: Eugene Wissner 2016-2019.
  * 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/async/event/kqueue.d,
+ *                 tanya/async/event/kqueue.d)
  */
 module tanya.async.event.kqueue;
 
-version (OSX)
+version (D_Ddoc)
+{
+}
+else version (OSX)
 {
     version = MacBSD;
 }
@@ -45,14 +52,13 @@ import core.stdc.errno;
 import core.sys.posix.time; // timespec
 import core.sys.posix.unistd;
 import core.time;
-import std.algorithm.comparison;
+import tanya.algorithm.comparison;
 import tanya.async.event.selector;
 import tanya.async.loop;
 import tanya.async.transport;
 import tanya.async.watcher;
 import tanya.container.array;
-import tanya.memory;
+import tanya.memory.allocator;
-import tanya.memory.mmappool;
 import tanya.network.socket;
 
 void EV_SET(kevent_t* kevp, typeof(kevent_t.tupleof) args) pure nothrow @nogc
@@ -78,12 +84,12 @@ enum : short
 
 struct kevent_t
 {
-    uintptr_t    ident; /* identifier for this event */
+    uintptr_t ident; // Identifier for this event
-    short       filter; /* filter for event */
+    short filter; // Filter for event
-    ushort       flags;
+    ushort flags;
-    uint        fflags;
+    uint fflags;
-    intptr_t      data;
+    intptr_t data;
-    void        *udata; /* opaque user data identifier */
+    void* udata; // Opaque user data identifier
 }
 
 enum
@@ -139,8 +145,8 @@ final class KqueueLoop : SelectorLoop
             throw make!BadLoopException(defaultAllocator,
                                         "kqueue initialization failed");
         }
-        events = Array!kevent_t(64, MmapPool.instance);
+        events = Array!kevent_t(64);
-        changes = Array!kevent_t(64, MmapPool.instance);
+        changes = Array!kevent_t(64);
     }
 
     /**
@@ -151,7 +157,7 @@ final class KqueueLoop : SelectorLoop
         close(fd);
     }
 
-    private void set(socket_t socket, short filter, ushort flags) @nogc
+    private void set(SocketType socket, short filter, ushort flags) @nogc
     {
         if (changes.length <= changeCount)
         {
@@ -162,7 +168,7 @@ final class KqueueLoop : SelectorLoop
                filter,
                flags,
                0U,
-               0L,
+               0,
                null);
         ++changeCount;
     }
@@ -211,7 +217,7 @@ final class KqueueLoop : SelectorLoop
         timespec ts;
         blockTime.split!("seconds", "nsecs")(ts.tv_sec, ts.tv_nsec);
 
-        if (changeCount > maxEvents) 
+        if (changeCount > maxEvents)
         {
             events.length = changes.length;
         }
@@ -273,7 +279,7 @@ final class KqueueLoop : SelectorLoop
                 }
                 else if (transport.output.length)
                 {
-                    pendings.enqueue(transport);
+                    pendings.insertBack(transport);
                 }
             }
             else if (events[i].filter == EVFILT_WRITE)

source/tanya/async/event/selector.d

@@ -2,24 +2,30 @@
  * 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-2017.
+ * This module contains base implementations for reactor event loops.
+ *
+ * Copyright: Eugene Wissner 2016-2019.
  * 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/async/event/selector.d,
+ *                 tanya/async/event/selector.d)
  */
 module tanya.async.event.selector;
 
-version (Posix):
+version (D_Ddoc)
+{
+}
+else version (Posix):
 
 import tanya.async.loop;
 import tanya.async.protocol;
 import tanya.async.transport;
 import tanya.async.watcher;
-import tanya.container.buffer;
 import tanya.container.array;
-import tanya.memory;
+import tanya.container.buffer;
-import tanya.memory.mmappool;
+import tanya.memory.allocator;
 import tanya.network.socket;
 
 /**
@@ -54,12 +60,12 @@ package class StreamTransport : SocketWatcher, DuplexTransport, SocketTransport
     {
         assert(loop !is null);
     }
-    body
+    do
     {
         super(socket);
         this.loop = loop;
-        output = ReadBuffer!ubyte(8192, 1024, MmapPool.instance);
+        output = ReadBuffer!ubyte(8192, 1024);
-        input = WriteBuffer!ubyte(8192, MmapPool.instance);
+        input = WriteBuffer!ubyte(8192);
         active = true;
     }
 
@@ -69,22 +75,14 @@ package class StreamTransport : SocketWatcher, DuplexTransport, SocketTransport
      * Postcondition: $(D_INLINECODE socket !is null)
      */
     override @property ConnectedSocket socket() pure nothrow @safe @nogc
-    out (socket)
+    out (socket; socket !is null)
-    {
-        assert(socket !is null);
-    }
-    body
     {
         return cast(ConnectedSocket) socket_;
     }
 
     private @property void socket(ConnectedSocket socket)
     pure nothrow @safe @nogc
-    in
+    in (socket !is null)
-    {
-        assert(socket !is null);
-    }
-    body
     {
         socket_ = socket;
     }
@@ -100,8 +98,7 @@ package class StreamTransport : SocketWatcher, DuplexTransport, SocketTransport
     /**
      * Switches the protocol.
      *
-     * The protocol is deallocated by the event loop, it should currently be
+     * The protocol is deallocated by the event loop.
-     * allocated with $(D_PSYMBOL MmapPool).
      *
      * Params:
      *  protocol = Application protocol.
@@ -109,11 +106,7 @@ package class StreamTransport : SocketWatcher, DuplexTransport, SocketTransport
      * Precondition: $(D_INLINECODE protocol !is null)
      */
     @property void protocol(Protocol protocol) pure nothrow @safe @nogc
-    in
+    in (protocol !is null)
-    {
-        assert(protocol !is null);
-    }
-    body
     {
         protocol_ = protocol;
     }
@@ -135,7 +128,7 @@ package class StreamTransport : SocketWatcher, DuplexTransport, SocketTransport
     {
         closing = true;
         loop.reify(this,
-                   EventMask(Event.read, Event.write),
+                   EventMask(Event.read | Event.write),
                    EventMask(Event.write));
     }
 
@@ -156,7 +149,7 @@ package class StreamTransport : SocketWatcher, DuplexTransport, SocketTransport
         else
         {
             protocol.disconnected(exception);
-            MmapPool.instance.dispose(protocol_);
+            defaultAllocator.dispose(protocol_);
             defaultAllocator.dispose(exception);
             active = false;
         }
@@ -213,18 +206,18 @@ abstract class SelectorLoop : Loop
     this() @nogc
     {
         super();
-        connections = Array!SocketWatcher(maxEvents, MmapPool.instance);
+        this.connections = Array!SocketWatcher(maxEvents);
     }
 
     ~this() @nogc
     {
-        foreach (ref connection; connections)
+        foreach (ref connection; this.connections[])
         {
             // We want to free only the transports. ConnectionWatcher are
             // created by the user and should be freed by himself.
             if (cast(StreamTransport) connection !is null)
             {
-                MmapPool.instance.dispose(connection);
+                defaultAllocator.dispose(connection);
             }
         }
     }
@@ -252,16 +245,12 @@ abstract class SelectorLoop : Loop
      */
     protected void kill(StreamTransport transport,
                         SocketException exception = null) @nogc
-    in
+    in (transport !is null)
-    {
-        assert(transport !is null);
-    }
-    body
     {
         transport.socket.shutdown();
         defaultAllocator.dispose(transport.socket);
         transport.exception = exception;
-        pendings.enqueue(transport);
+        pendings.insertBack(transport);
     }
 
     /**
@@ -278,11 +267,7 @@ abstract class SelectorLoop : Loop
      */
     protected bool feed(StreamTransport transport,
                         SocketException exception = null) @nogc
-    in
+    in (transport !is null)
-    {
-        assert(transport !is null);
-    }
-    body
     {
         while (transport.input.length && transport.writeReady)
         {
@@ -345,11 +330,7 @@ abstract class SelectorLoop : Loop
      *  connection = Connection watcher ready to accept.
      */
     package void acceptConnections(ConnectionWatcher connection) @nogc
-    in
+    in (connection !is null)
-    {
-        assert(connection !is null);
-    }
-    body
     {
         while (true)
         {
@@ -380,7 +361,7 @@ abstract class SelectorLoop : Loop
             }
             if (transport is null)
             {
-                transport = MmapPool.instance.make!StreamTransport(this, client);
+                transport = defaultAllocator.make!StreamTransport(this, client);
                 connections[client.handle] = transport;
             }
             else
@@ -388,13 +369,15 @@ abstract class SelectorLoop : Loop
                 transport.socket = client;
             }
 
-            reify(transport, EventMask(Event.none), EventMask(Event.read, Event.write));
+            reify(transport,
-            connection.incoming.enqueue(transport);
+                  EventMask(Event.none),
+                  EventMask(Event.read | Event.write));
+            connection.incoming.insertBack(transport);
         }
 
         if (!connection.incoming.empty)
         {
-            pendings.enqueue(connection);
+            pendings.insertBack(connection);
         }
     }
 }

source/tanya/async/iocp.d

@@ -3,17 +3,41 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /**
- * Copyright: Eugene Wissner 2016-2017.
+ * This module provides API for Windows I/O Completion Ports.
+ *
+ * Note: Available only on Windows.
+ *
+ * Copyright: Eugene Wissner 2016-2019.
  * 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/async/iocp.d,
+ *                 tanya/async/iocp.d)
  */
 module tanya.async.iocp;
 
-version (Windows):
+version (Windows)
+{
+    version = WindowsDoc;
+}
+else version (D_Ddoc)
+{
+    version = WindowsDoc;
+    version (Windows)
+    {
+    }
+    else
+    {
+        private struct OVERLAPPED
+        {
+        }
+        private alias HANDLE = void*;
+    }
+}
 
-import core.sys.windows.winbase;
+version (WindowsDoc):
-import core.sys.windows.windef;
+
+import tanya.sys.windows.winbase;
 
 /**
  * Provides an extendable representation of a Win32 $(D_PSYMBOL OVERLAPPED)

source/tanya/async/loop.d

@@ -3,10 +3,8 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /**
- * Copyright: Eugene Wissner 2016-2017.
+ * Interface for the event loop implementations and the default event loop
- * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
+ * chooser.
- *                  Mozilla Public License, v. 2.0).
- * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
  *
  * ---
  * import tanya.async;
@@ -15,70 +13,79 @@
  *
  * class EchoProtocol : TransmissionControlProtocol
  * {
- *  private DuplexTransport transport;
+ *     private DuplexTransport transport;
  *
- *  void received(in ubyte[] data) @nogc
+ *     void received(in ubyte[] data) @nogc
- *  {
+ *     {
- *      transport.write(data);
+ *         ubyte[512] buffer;
- *  }
+ *         buffer[0 .. data.length] = data;
+ *         transport.write(buffer[]);
+ *     }
  *
- *  void connected(DuplexTransport transport) @nogc
+ *     void connected(DuplexTransport transport) @nogc
- *  {
+ *     {
- *      this.transport = transport;
+ *         this.transport = transport;
- *  }
+ *     }
  *
- *  void disconnected(SocketException e) @nogc
+ *     void disconnected(SocketException e) @nogc
- *  {
+ *     {
- *  }
+ *     }
  * }
  *
  * void main()
  * {
- *  auto address = defaultAllocator.make!InternetAddress("127.0.0.1", cast(ushort) 8192);
+ *     auto address = defaultAllocator.make!InternetAddress("127.0.0.1", cast(ushort) 8192);
  *
- *  version (Windows)
+ *     version (Windows)
- *  {
+ *     {
- *      auto sock = defaultAllocator.make!OverlappedStreamSocket(AddressFamily.INET);
+ *         auto sock = defaultAllocator.make!OverlappedStreamSocket(AddressFamily.inet);
- *  }
+ *     }
- *  else
+ *     else
- *  {
+ *     {
- *      auto sock = defaultAllocator.make!StreamSocket(AddressFamily.INET);
+ *         auto sock = defaultAllocator.make!StreamSocket(AddressFamily.inet);
- *      sock.blocking = false;
+ *         sock.blocking = false;
- *  }
+ *     }
  *
- *  sock.bind(address);
+ *     sock.bind(address);
- *  sock.listen(5);
+ *     sock.listen(5);
  *
- *  auto io = defaultAllocator.make!ConnectionWatcher(sock);
+ *     auto io = defaultAllocator.make!ConnectionWatcher(sock);
- *  io.setProtocol!EchoProtocol;
+ *     io.setProtocol!EchoProtocol;
  *
- *  defaultLoop.start(io);
+ *     defaultLoop.start(io);
- *  defaultLoop.run();
+ *     defaultLoop.run();
  *
- *  sock.shutdown();
+ *     sock.shutdown();
- *  defaultAllocator.dispose(io);
+ *     defaultAllocator.dispose(io);
- *  defaultAllocator.dispose(sock);
+ *     defaultAllocator.dispose(sock);
- *  defaultAllocator.dispose(address);
+ *     defaultAllocator.dispose(address);
  * }
  * ---
+ *
+ * Copyright: Eugene Wissner 2016-2019.
+ * 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/async/loop.d,
+ *                 tanya/async/loop.d)
  */
 module tanya.async.loop;
 
 import core.time;
-import std.algorithm.iteration;
-import std.algorithm.mutation;
-import std.typecons;
 import tanya.async.transport;
 import tanya.async.watcher;
+import tanya.bitmanip;
 import tanya.container.buffer;
-import tanya.container.queue;
+import tanya.container.list;
-import tanya.memory;
+import tanya.memory.allocator;
-import tanya.memory.mmappool;
 import tanya.network.socket;
 
 version (DisableBackends)
 {
 }
+else version (D_Ddoc)
+{
+}
 else version (linux)
 {
     import tanya.async.event.epoll;
@@ -129,10 +136,10 @@ alias EventMask = BitFlags!Event;
  */
 abstract class Loop
 {
-    private bool done;
+    protected bool done = true;
 
     /// Pending watchers.
-    protected Queue!Watcher pendings;
+    protected DList!Watcher pendings;
 
     /**
      * Returns: Maximal event count can be got at a time
@@ -149,7 +156,6 @@ abstract class Loop
      */
     this() @nogc
     {
-        pendings = Queue!Watcher(MmapPool.instance);
     }
 
     /**
@@ -157,9 +163,9 @@ abstract class Loop
      */
     ~this() @nogc
     {
-        foreach (w; pendings)
+        for (; !this.pendings.empty; this.pendings.removeFront())
         {
-            MmapPool.instance.dispose(w);
+            defaultAllocator.dispose(this.pendings.front);
         }
     }
 
@@ -168,18 +174,18 @@ abstract class Loop
      */
     void run() @nogc
     {
-        done = false;
+        this.done = false;
         do
         {
             poll();
 
             // Invoke pendings
-            foreach (ref w; pendings)
+            for (; !this.pendings.empty; this.pendings.removeFront())
             {
-                w.invoke();
+                this.pendings.front.invoke();
             }
         }
-        while (!done);
+        while (!this.done);
     }
 
     /**
@@ -187,7 +193,7 @@ abstract class Loop
      */
     void unloop() @safe pure nothrow @nogc
     {
-        done = true;
+        this.done = true;
     }
 
     /**
@@ -256,12 +262,8 @@ abstract class Loop
      *              $(D_PSYMBOL maxBlockTime).
      */
     protected @property void blockTime(in Duration blockTime) @safe pure nothrow @nogc
-    in
+    in (blockTime <= 1.dur!"hours", "Too long to wait.")
-    {
+    in (!blockTime.isNegative)
-        assert(blockTime <= 1.dur!"hours", "Too long to wait.");
-        assert(!blockTime.isNegative);
-    }
-    body
     {
         blockTime_ = blockTime;
     }
@@ -308,16 +310,16 @@ class BadLoopException : Exception
     }
     version (Epoll)
     {
-        defaultLoop_ = MmapPool.instance.make!EpollLoop;
+        defaultLoop_ = defaultAllocator.make!EpollLoop;
     }
     else version (IOCP)
     {
-        defaultLoop_ = MmapPool.instance.make!IOCPLoop;
+        defaultLoop_ = defaultAllocator.make!IOCPLoop;
     }
     else version (Kqueue)
     {
         import tanya.async.event.kqueue;
-        defaultLoop_ = MmapPool.instance.make!KqueueLoop;
+        defaultLoop_ = defaultAllocator.make!KqueueLoop;
     }
     return defaultLoop_;
 }
@@ -334,11 +336,7 @@ class BadLoopException : Exception
  *  loop = The event loop.
  */
 @property void defaultLoop(Loop loop) @nogc
-in
+in (loop !is null)
-{
-    assert(loop !is null);
-}
-body
 {
     defaultLoop_ = loop;
 }

source/tanya/async/package.d

@@ -3,10 +3,14 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /**
- * Copyright: Eugene Wissner 2016-2017.
+ * This package provides asynchronous capabilities.
+ *
+ * Copyright: Eugene Wissner 2016-2019.
  * 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/async/package.d,
+ *                 tanya/async/package.d)
  */
 module tanya.async;
 

source/tanya/async/protocol.d

@@ -3,15 +3,23 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /**
- * Copyright: Eugene Wissner 2016-2017.
+ * This module contains protocol which handle data in asynchronous
+ * applications.
+ *
+ * When an event from the network arrives, a protocol method gets
+ * called and can respond to the event.
+ *
+ * Copyright: Eugene Wissner 2016-2019.
  * 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/async/protocol.d,
+ *                 tanya/async/protocol.d)
  */
 module tanya.async.protocol;
 
-import tanya.network.socket;
 import tanya.async.transport;
+import tanya.network.socket;
 
 /**
  * Common protocol interface.

source/tanya/async/transport.d

@@ -3,10 +3,15 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /**
- * Copyright: Eugene Wissner 2016-2017.
+ * This module contains transports which are responsible for data dilvery
+ * between two parties of an asynchronous communication.
+ *
+ * Copyright: Eugene Wissner 2016-2019.
  * 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/async/transport.d,
+ *                 tanya/async/transport.d)
  */
 module tanya.async.transport;
 
@@ -52,16 +57,12 @@ interface DuplexTransport : ReadTransport, WriteTransport
      * Postcondition: $(D_INLINECODE protocol !is null)
      */
     @property Protocol protocol() pure nothrow @safe @nogc
-    out (protocol)
+    out (protocol; protocol !is null);
-    {
-        assert(protocol !is null);
-    }
 
     /**
      * Switches the protocol.
      *
-     * The protocol is deallocated by the event loop, it should currently be
+     * The protocol is deallocated by the event loop.
-     * allocated with $(D_PSYMBOL MmapPool).
      *
      * Params:
      *  protocol = Application protocol.
@@ -69,10 +70,7 @@ interface DuplexTransport : ReadTransport, WriteTransport
      * Precondition: $(D_INLINECODE protocol !is null)
      */
     @property void protocol(Protocol protocol) pure nothrow @safe @nogc
-    in
+    in (protocol !is null);
-    {
-        assert(protocol !is null);
-    }
 
 
     /**

source/tanya/async/watcher.d

@@ -3,22 +3,23 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /**
- * Copyright: Eugene Wissner 2016-2017.
+ * Watchers register user's interest in some event.
+ *
+ * Copyright: Eugene Wissner 2016-2019.
  * 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/async/watcher.d,
+ *                 tanya/async/watcher.d)
  */
 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.container.list;
-import tanya.memory;
+import tanya.memory.allocator;
-import tanya.memory.mmappool;
 import tanya.network.socket;
 
 /**
@@ -51,11 +52,7 @@ abstract class SocketWatcher : Watcher
      * Precondition: $(D_INLINECODE socket !is null)
      */
     this(Socket socket) pure nothrow @safe @nogc
-    in
+    in (socket !is null)
-    {
-        assert(socket !is null);
-    }
-    body
     {
         socket_ = socket;
     }
@@ -75,7 +72,7 @@ abstract class SocketWatcher : Watcher
 class ConnectionWatcher : SocketWatcher
 {
     /// Incoming connection queue.
-    Queue!DuplexTransport incoming;
+    DList!DuplexTransport incoming;
 
     private Protocol delegate() @nogc protocolFactory;
 
@@ -86,7 +83,6 @@ class ConnectionWatcher : SocketWatcher
     this(Socket socket) @nogc
     {
         super(socket);
-        incoming = Queue!DuplexTransport(MmapPool.instance);
     }
 
     /**
@@ -95,23 +91,19 @@ class ConnectionWatcher : SocketWatcher
      */
     void setProtocol(P : Protocol)() @nogc
     {
-        this.protocolFactory = () @nogc => cast(Protocol) MmapPool.instance.make!P;
+        this.protocolFactory = () @nogc => cast(Protocol) defaultAllocator.make!P;
     }
 
     /**
      * Invokes new connection callback.
      */
     override void invoke() @nogc
-    in
+    in (protocolFactory !is null, "Protocol isn't set.")
     {
-        assert(protocolFactory !is null, "Protocol isn't set.");
+        for (; !this.incoming.empty; this.incoming.removeFront())
-    }
-    body
-    {
-        foreach (transport; incoming)
         {
-            transport.protocol = protocolFactory();
+            this.incoming.front.protocol = protocolFactory();
-            transport.protocol.connected(transport);
+            this.incoming.front.protocol.connected(this.incoming.front);
         }
     }
 }

source/tanya/bitmanip.d

@@ -0,0 +1,318 @@
+/* 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/. */
+
+/**
+ * Bit manipulation.
+ *
+ * Copyright: Eugene Wissner 2018-2019.
+ * 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/bitmanip.d,
+ *                 tanya/bitmanip.d)
+ */
+module tanya.bitmanip;
+
+import tanya.meta.metafunction;
+import tanya.meta.trait;
+import tanya.meta.transform;
+
+/**
+ * Determines whether $(D_PARAM E) is a $(D_KEYWORD enum), whose members can be
+ * used as bit flags.
+ *
+ * This is the case if all members of $(D_PARAM E) are integral numbers that
+ * are either 0 or positive integral powers of 2.
+ *
+ * Params:
+ *  E = Some $(D_KEYWORD enum).
+ *
+ * Returns: $(D_KEYWORD true) if $(D_PARAM E) contains only bit flags,
+ *          $(D_KEYWORD false) otherwise.
+ */
+template isBitFlagEnum(E)
+{
+    enum bool isValid(OriginalType!E x) = x == 0
+                                       || (x > 0 && ((x & (x - 1)) == 0));
+    static if (isIntegral!E)
+    {
+        enum bool isBitFlagEnum = allSatisfy!(isValid, EnumMembers!E);
+    }
+    else
+    {
+        enum bool isBitFlagEnum = false;
+    }
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    enum Valid
+    {
+        none = 0,
+        one = 1 << 0,
+        two = 1 << 1,
+    }
+    static assert(isBitFlagEnum!Valid);
+
+    enum Invalid
+    {
+        one,
+        two,
+        three,
+        four,
+    }
+    static assert(!isBitFlagEnum!Invalid);
+
+    enum Negative
+    {
+        one = -1,
+        two = -2,
+    }
+    static assert(!isBitFlagEnum!Negative);
+}
+
+/**
+ * Validates that $(D_PARAM field) contains only bits from $(D_PARAM E).
+ *
+ * Params:
+ *  E     = Some $(D_KEYWORD enum).
+ *  field = Bit field.
+ *
+ * Returns: $(D_KEYWORD true) if $(D_PARAM field) is valid, $(D_KEYWORD false)
+ *          otherwise.
+ */
+bool containsBitFlags(E)(E field)
+if (isBitFlagEnum!E)
+{
+    OriginalType!E fillField()
+    {
+        typeof(return) full;
+        static foreach (member; EnumMembers!E)
+        {
+            full |= member;
+        }
+        return full;
+    }
+    enum OriginalType!E full = fillField();
+    return (field & ~full) == OriginalType!E.init;
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    enum E
+    {
+        one,
+        two,
+        three,
+    }
+    assert(containsBitFlags(E.one | E.two));
+    assert(!containsBitFlags(cast(E) 0x8));
+}
+
+/**
+ * Allows to use $(D_KEYWORD enum) values as a set of bit flags.
+ *
+ * $(D_PSYMBOL BitFlags) behaves the same as a bit field of type $(D_PARAM E),
+ * but does additional cheks to ensure that the bit field contains only valid
+ * values, this is only values from $(D_PARAM E).
+ *
+ * Params:
+ *  E = Some $(D_KEYWORD enum).
+ */
+struct BitFlags(E)
+if (isBitFlagEnum!E)
+{
+    private OriginalType!E field;
+
+    /**
+     * Constructs $(D_PSYMBOL BitFlags) from $(D_PARAM field).
+     *
+     * Params:
+     *  field = Bits to be set.
+     */
+    this(E field)
+    {
+        this.field = field;
+    }
+
+    /**
+     * Converts $(D_PSYMBOL BitFlags) to a boolean.
+     *
+     * It is $(D_KEYWORD true) if any bit is set, $(D_KEYWORD false) otherwise.
+     *
+     * Returns: $(D_KEYWORD true) if this $(D_PSYMBOL BitFlags) contains any
+     *          set bits, $(D_KEYWORD false) otherwise.
+     */
+    bool opCast(T : bool)()
+    {
+        return this.field != 0;
+    }
+
+    /**
+     * Converts to the original type of $(D_PARAM E) ($(D_KEYWORD int) by
+     * default).
+     *
+     * Returns: $(D_KEYWORD this) as $(D_INLINECODE OriginalType!T).
+     */
+    OriginalType!E opCast(T : OriginalType!E)() const
+    {
+        return this.field;
+    }
+
+    /**
+     * Tests (&), sets (|) or toggles (^) bits.
+     *
+     * Params:
+     *  op   = Operation.
+     *  that = 0 or more bit flags.
+     *
+     * Returns: New $(D_PSYMBOL BitFlags) object.
+     */
+    BitFlags opBinary(string op)(E that) const
+    if (op == "&" || op == "|" || op == "^")
+    {
+        BitFlags result = this;
+        mixin("return result " ~ op ~ "= that;");
+    }
+
+    /// ditto
+    BitFlags opBinary(string op)(BitFlags that) const
+    if (op == "&" || op == "|" || op == "^")
+    {
+        BitFlags result = this;
+        mixin("return result " ~ op ~ "= that;");
+    }
+
+    /// ditto
+    BitFlags opBinaryRight(string op)(E that) const
+    if (op == "&" || op == "|" || op == "^")
+    {
+        BitFlags result = this;
+        mixin("return result " ~ op ~ "= that;");
+    }
+
+    /**
+     * Tests (&), sets (|) or toggles (^) bits.
+     *
+     * Params:
+     *  op   = Operation.
+     *  that = 0 or more bit flags.
+     *
+     * Returns: $(D_KEYWORD this).
+     */
+    ref BitFlags opOpAssign(string op)(E that)
+    if (op == "&" || op == "|" || op == "^")
+    {
+        mixin("this.field " ~ op ~ "= that;");
+        return this;
+    }
+
+    /// ditto
+    ref BitFlags opOpAssign(string op)(BitFlags that)
+    if (op == "&" || op == "|" || op == "^")
+    {
+        mixin("this.field " ~ op ~ "= that.field;");
+        return this;
+    }
+
+    /**
+     * Inverts all bit flags.
+     *
+     * Returns: New $(D_PSYMBOL BitFlags) object with all bits inverted.
+     */
+    BitFlags opUnary(string op : "~")() const
+    {
+        BitFlags result;
+        result.field  = ~this.field;
+        return result;
+    }
+
+    /**
+     * Assigns a bit field.
+     *
+     * Params:
+     *  that = Bit field of type $(D_PARAM E).
+     *
+     * Returns: $(D_KEYWORD this).
+     */
+    ref BitFlags opAssign(E that)
+    {
+        this.field = that;
+        return this;
+    }
+
+    /**
+     * Compares this $(D_PSYMBOL BitFlags) object to another bit field.
+     *
+     * Params:
+     *  that = $(D_PSYMBOL BitFlags) object or a bit field of type
+     *         $(D_PARAM E).
+     *
+     * Returns: $(D_KEYWORD true) if $(D_KEYWORD this) and $(D_PARAM that)
+     *          contain the same bits ,$(D_KEYWORD false) otherwise.
+     */
+    bool opEquals(E that) const
+    {
+        return this.field == that;
+    }
+
+    /// ditto
+    bool opEquals(BitFlags that) const
+    {
+        return this.field == that.field;
+    }
+
+    /**
+     * Generates a hash value of this object.
+     *
+     * Returns: Hash value.
+     */
+    size_t toHash() const
+    {
+        return cast(size_t) this.field;
+    }
+}
+
+/**
+ * Creates a $(D_PSYMBOL BitFlags) object initialized with $(D_PARAM field).
+ *
+ * Params:
+ *  E     = Some $(D_KEYWORD enum).
+ *  field = Bits to be set.
+ */
+BitFlags!E bitFlags(E)(E field)
+if (isBitFlagEnum!E)
+{
+    return BitFlags!E(field);
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    enum E
+    {
+        one = 1 << 0,
+        two = 1 << 1,
+        three = 1 << 2,
+    }
+    // Construct with E.one and E.two set
+    auto flags = bitFlags(E.one | E.two);
+
+    // Test wheter E.one is set
+    assert(flags & E.one);
+
+    // Toggle E.one
+    flags ^= E.one;
+    assert(!(flags & E.one));
+
+    // Set E.three
+    flags |= E.three;
+    assert(flags & E.three);
+
+    // Clear E.three
+    flags &= ~E.three;
+    assert(!(flags & E.three));
+}

source/tanya/container/buffer.d

@@ -3,27 +3,26 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /**
- * Copyright: Eugene Wissner 2016-2017.
+ * This module contains buffers designed for C-style input/output APIs.
+ *
+ * Copyright: Eugene Wissner 2016-2019.
  * 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/buffer.d,
+ *                 tanya/container/buffer.d)
  */
 module tanya.container.buffer;
 
-import std.traits;
+import tanya.memory.allocator;
-import tanya.memory;
+import tanya.meta.trait;
 
 version (unittest)
 {
     private int fillBuffer(ubyte[] buffer,
-                           in size_t size,
                            int start = 0,
                            int end = 10) @nogc pure nothrow
-    in
+    in (start < end)
-    {
-        assert(start < end);
-    }
-    body
     {
         auto numberRead = end - start;
         for (ubyte i; i < numberRead; ++i)
@@ -48,7 +47,7 @@ version (unittest)
  *  T = Buffer type.
  */
 struct ReadBuffer(T = ubyte)
-    if (isScalarType!T)
+if (isScalarType!T)
 {
     /// Internal buffer.
     private T[] buffer_;
@@ -63,17 +62,14 @@ struct ReadBuffer(T = ubyte)
     private size_t ring;
 
     /// Available space.
-    private immutable size_t minAvailable = 1024;
+    private size_t minAvailable = 1024;
 
     /// Size by which the buffer will grow.
-    private immutable size_t blockSize = 8192;
+    private size_t blockSize = 8192;
 
-    invariant
+    invariant (this.length_ <= this.buffer_.length);
-    {
+    invariant (this.blockSize > 0);
-        assert(length_ <= buffer_.length);
+    invariant (this.minAvailable > 0);
-        assert(blockSize > 0);
-        assert(minAvailable > 0);
-    }
 
     /**
      * Creates a new read buffer.
@@ -86,23 +82,19 @@ struct ReadBuffer(T = ubyte)
      *                 $(D_PSYMBOL free) < $(D_PARAM minAvailable)).
      *  allocator    = Allocator.
      */
-    this(in size_t size,
+    this(size_t size,
-         in size_t minAvailable = 1024,
+         size_t minAvailable = 1024,
          shared Allocator allocator = defaultAllocator) @trusted
     {
         this(allocator);
         this.minAvailable = minAvailable;
         this.blockSize = size;
-        buffer_ = cast(T[]) allocator_.allocate(size * T.sizeof);
+        this.buffer_ = cast(T[]) allocator_.allocate(size * T.sizeof);
     }
 
-    /// Ditto.
+    /// ditto
     this(shared Allocator allocator)
-    in
+    in (allocator_ is null)
-    {
-        assert(allocator_ is null);
-    }
-    body
     {
         allocator_ = allocator;
     }
@@ -112,11 +104,11 @@ struct ReadBuffer(T = ubyte)
      */
     ~this() @trusted
     {
-        allocator.deallocate(buffer_);
+        allocator.deallocate(this.buffer_);
     }
 
     ///
-    unittest
+    @nogc nothrow pure @safe unittest
     {
         ReadBuffer!ubyte b;
         assert(b.capacity == 0);
@@ -128,7 +120,7 @@ struct ReadBuffer(T = ubyte)
      */
     @property size_t capacity() const
     {
-        return buffer_.length;
+        return this.buffer_.length;
     }
 
     /**
@@ -136,10 +128,10 @@ struct ReadBuffer(T = ubyte)
      */
     @property size_t length() const
     {
-        return length_ - start;
+        return this.length_ - start;
     }
 
-    /// Ditto.
+    /// ditto
     alias opDollar = length;
 
     /**
@@ -149,7 +141,7 @@ struct ReadBuffer(T = ubyte)
      */
     void clear()
     {
-        start = length_ = ring;
+        start = this.length_ = ring;
     }
 
     /**
@@ -161,7 +153,7 @@ struct ReadBuffer(T = ubyte)
     }
 
     ///
-    unittest
+    @nogc nothrow pure @system unittest
     {
         ReadBuffer!ubyte b;
         size_t numberRead;
@@ -169,7 +161,7 @@ struct ReadBuffer(T = ubyte)
         assert(b.free == 0);
 
         // Fills the buffer with values 0..10
-        numberRead = fillBuffer(b[], b.free, 0, 10);
+        numberRead = fillBuffer(b[], 0, 10);
         b += numberRead;
         assert(b.free == b.blockSize - numberRead);
         b.clear();
@@ -184,23 +176,23 @@ struct ReadBuffer(T = ubyte)
      *
      * Returns: $(D_KEYWORD this).
      */
-    ref ReadBuffer opOpAssign(string op)(in size_t length)
+    ref ReadBuffer opOpAssign(string op)(size_t length)
-        if (op == "+")
+    if (op == "+")
     {
-        length_ += length;
+        this.length_ += length;
         ring = start;
         return this;
     }
 
     ///
-    unittest
+    @nogc nothrow pure @system unittest
     {
         ReadBuffer!ubyte b;
         size_t numberRead;
         ubyte[] result;
 
         // Fills the buffer with values 0..10
-        numberRead = fillBuffer(b[], b.free, 0, 10);
+        numberRead = fillBuffer(b[], 0, 10);
         b += numberRead;
 
         result = b[0 .. $];
@@ -210,10 +202,10 @@ struct ReadBuffer(T = ubyte)
         b.clear();
 
         // It shouldn't overwrite, but append another 5 bytes to the buffer
-        numberRead = fillBuffer(b[], b.free, 0, 10);
+        numberRead = fillBuffer(b[], 0, 10);
         b += numberRead;
 
-        numberRead = fillBuffer(b[], b.free, 20, 25);
+        numberRead = fillBuffer(b[], 20, 25);
         b += numberRead;
 
         result = b[0..$];
@@ -231,9 +223,9 @@ struct ReadBuffer(T = ubyte)
      *
      * Returns: Array between $(D_PARAM start) and $(D_PARAM end).
      */
-    T[] opSlice(in size_t start, in size_t end)
+    T[] opSlice(size_t start, size_t end)
     {
-        return buffer_[this.start + start .. this.start + end];
+        return this.buffer_[this.start + start .. this.start + end];
     }
 
     /**
@@ -247,35 +239,36 @@ struct ReadBuffer(T = ubyte)
     {
         if (start > 0)
         {
-            auto ret = buffer_[0 .. start];
+            auto ret = this.buffer_[0 .. start];
             ring = 0;
             return ret;
         }
         else
         {
-            if (capacity - length < minAvailable)
+            if (capacity - length < this.minAvailable)
             {
-                void[] buf = buffer_;
+                void[] buf = this.buffer_;
-                immutable cap = capacity;
+                const cap = capacity;
                 () @trusted {
-                    allocator.reallocate(buf, (cap + blockSize) * T.sizeof);
+                    allocator.reallocate(buf,
-                    buffer_ = cast(T[]) buf;
+                                         (cap + this.blockSize) * T.sizeof);
+                    this.buffer_ = cast(T[]) buf;
                 }();
             }
-            ring = length_;
+            ring = this.length_;
-            return buffer_[length_ .. $];
+            return this.buffer_[this.length_ .. $];
         }
     }
 
     ///
-    unittest
+    @nogc nothrow pure @system unittest
     {
         ReadBuffer!ubyte b;
         size_t numberRead;
         ubyte[] result;
 
         // Fills the buffer with values 0..10
-        numberRead = fillBuffer(b[], b.free, 0, 10);
+        numberRead = fillBuffer(b[], 0, 10);
         b += numberRead;
 
         assert(b.length == 10);
@@ -289,11 +282,6 @@ struct ReadBuffer(T = ubyte)
     mixin DefaultAllocator;
 }
 
-private unittest
-{
-    static assert(is(ReadBuffer!int));
-}
-
 /**
  * Circular, self-expanding buffer with overflow support. Can be used with
  * functions returning the number of the transferred bytes.
@@ -307,7 +295,7 @@ private unittest
  *  T = Buffer type.
  */
 struct WriteBuffer(T = ubyte)
-    if (isScalarType!T)
+if (isScalarType!T)
 {
     /// Internal buffer.
     private T[] buffer_;
@@ -319,17 +307,14 @@ struct WriteBuffer(T = ubyte)
     private size_t ring;
 
     /// Size by which the buffer will grow.
-    private immutable size_t blockSize;
+    private const size_t blockSize;
 
     /// The position of the free area in the buffer.
     private size_t position;
 
-    invariant
+    invariant (this.blockSize > 0);
-    {
+    // Position can refer to an element outside the buffer if the buffer is full.
-        assert(blockSize > 0);
+    invariant (this.position <= this.buffer_.length);
-        // Position can refer to an element outside the buffer if the buffer is full.
-        assert(position <= buffer_.length);
-    }
 
     /**
      * Params:
@@ -339,18 +324,14 @@ struct WriteBuffer(T = ubyte)
      *
      * Precondition: $(D_INLINECODE size > 0 && allocator !is null)
      */
-    this(in size_t size, shared Allocator allocator = defaultAllocator) @trusted
+    this(size_t size, shared Allocator allocator = defaultAllocator) @trusted
-    in
+    in (size > 0)
+    in (allocator !is null)
     {
-        assert(size > 0);
+        this.blockSize = size;
-        assert(allocator !is null);
-    }
-    body
-    {
-        blockSize = size;
         ring = size - 1;
         allocator_ = allocator;
-        buffer_ = cast(T[]) allocator_.allocate(size * T.sizeof);
+        this.buffer_ = cast(T[]) allocator_.allocate(size * T.sizeof);
     }
 
     @disable this();
@@ -360,7 +341,7 @@ struct WriteBuffer(T = ubyte)
      */
     ~this()
     {
-        allocator.deallocate(buffer_);
+        allocator.deallocate(this.buffer_);
     }
 
     /**
@@ -368,7 +349,7 @@ struct WriteBuffer(T = ubyte)
      */
     @property size_t capacity() const
     {
-        return buffer_.length;
+        return this.buffer_.length;
     }
 
     /**
@@ -381,21 +362,21 @@ struct WriteBuffer(T = ubyte)
      */
     @property size_t length() const
     {
-        if (position > ring || position < start) // Buffer overflowed
+        if (this.position > ring || this.position < start) // Buffer overflowed
         {
             return ring - start + 1;
         }
         else
         {
-            return position - start;
+            return this.position - start;
         }
     }
 
-    /// Ditto.
+    /// ditto
     alias opDollar = length;
 
     ///
-    unittest
+    @nogc nothrow pure @system unittest
     {
         auto b = WriteBuffer!ubyte(4);
         ubyte[3] buf = [48, 23, 255];
@@ -430,61 +411,62 @@ struct WriteBuffer(T = ubyte)
      * Params:
      *  buffer = Buffer chunk got with $(D_PSYMBOL opIndex).
      */
-    ref WriteBuffer opOpAssign(string op)(in T[] buffer)
+    ref WriteBuffer opOpAssign(string op)(const T[] buffer)
-        if (op == "~")
+    if (op == "~")
     {
         size_t end, start;
 
-        if (position >= this.start && position <= ring)
+        if (this.position >= this.start && this.position <= ring)
         {
             auto afterRing = ring + 1;
 
-            end = position + buffer.length;
+            end = this.position + buffer.length;
             if (end > afterRing)
             {
                 end = afterRing;
             }
-            start = end - position;
+            start = end - this.position;
-            buffer_[position .. end] = buffer[0 .. start];
+            this.buffer_[this.position .. end] = buffer[0 .. start];
             if (end == afterRing)
             {
-                position = this.start == 0 ? afterRing : 0;
+                this.position = this.start == 0 ? afterRing : 0;
             }
             else
             {
-                position = end;
+                this.position = end;
             }
         }
 
         // Check if we have some free space at the beginning
-        if (start < buffer.length && position < this.start)
+        if (start < buffer.length && this.position < this.start)
         {
-            end = position + buffer.length - start;
+            end = this.position + buffer.length - start;
             if (end > this.start)
             {
                 end = this.start;
             }
-            auto areaEnd = end - position + start;
+            auto areaEnd = end - this.position + start;
-            buffer_[position .. end] = buffer[start .. areaEnd];
+            this.buffer_[this.position .. end] = buffer[start .. areaEnd];
-            position = end == this.start ? ring + 1 : end - position;
+            this.position = end == this.start ? ring + 1 : end - this.position;
             start = areaEnd;
         }
 
         // And if we still haven't found any place, save the rest in the overflow area
         if (start < buffer.length)
         {
-            end = position + buffer.length - start;
+            end = this.position + buffer.length - start;
             if (end > capacity)
             {
-                auto newSize = (end / blockSize * blockSize + blockSize) * T.sizeof;
+                const newSize = end / this.blockSize * this.blockSize
+                              + this.blockSize;
                 () @trusted {
-                    void[] buf = buffer_;
+                    void[] buf = this.buffer_;
-                    allocator.reallocate(buf, newSize);
+                    allocator.reallocate(buf, newSize * T.sizeof);
-                    buffer_ = cast(T[]) buf;
+                    this.buffer_ = cast(T[]) buf;
                 }();
             }
-            buffer_[position .. end] = buffer[start .. $];
+            this.buffer_[this.position .. end] = buffer[start .. $];
-            position = end;
+            this.position = end;
             if (this.start == 0)
             {
                 ring = capacity - 1;
@@ -494,42 +476,6 @@ struct WriteBuffer(T = ubyte)
         return this;
     }
 
-    ///
-    unittest
-    {
-        auto b = WriteBuffer!ubyte(4);
-        ubyte[3] buf = [48, 23, 255];
-
-        b ~= buf;
-        assert(b.capacity == 4);
-        assert(b.buffer_[0] == 48 && b.buffer_[1] == 23 && b.buffer_[2] == 255);
-
-        b += 2;
-        b ~= buf;
-        assert(b.capacity == 4);
-        assert(b.buffer_[0] == 23 && b.buffer_[1] == 255
-            && b.buffer_[2] == 255 && b.buffer_[3] == 48);
-
-        b += 2;
-        b ~= buf;
-        assert(b.capacity == 8);
-        assert(b.buffer_[0] == 23 && b.buffer_[1] == 255
-            && b.buffer_[2] == 48 && b.buffer_[3] == 23 && b.buffer_[4] == 255);
-    }
-
-    ///
-    unittest
-    {
-        auto b = WriteBuffer!ubyte(2);
-        ubyte[3] buf = [48, 23, 255];
-
-        b ~= buf;
-        assert(b.start == 0);
-        assert(b.capacity == 4);
-        assert(b.ring == 3);
-        assert(b.position == 3);
-    }
-
     /**
      * Sets how many bytes were written. It will shrink the buffer
      * appropriately. Always call it after $(D_PSYMBOL opIndex).
@@ -539,13 +485,9 @@ struct WriteBuffer(T = ubyte)
      *
      * Returns: $(D_KEYWORD this).
      */
-    ref WriteBuffer opOpAssign(string op)(in size_t length)
+    ref WriteBuffer opOpAssign(string op)(size_t length)
-        if (op == "+")
+    if (op == "+")
-    in
+    in (length <= this.length)
-    {
-        assert(length <= this.length);
-    }
-    body
     {
         auto afterRing = ring + 1;
         auto oldStart = start;
@@ -554,42 +496,42 @@ struct WriteBuffer(T = ubyte)
         {
             return this;
         }
-        else if (position <= afterRing)
+        else if (this.position <= afterRing)
         {
             start += length;
-            if (start > 0 && position == afterRing)
+            if (start > 0 && this.position == afterRing)
             {
-                position = oldStart;
+                this.position = oldStart;
             }
         }
         else
         {
-            auto overflow = position - afterRing;
+            auto overflow = this.position - afterRing;
 
             if (overflow > length)
             {
-                immutable afterLength = afterRing + length;
+                const afterLength = afterRing + length;
-                buffer_[start .. start + length] = buffer_[afterRing .. afterLength];
+                this.buffer_[start .. start + length] = this.buffer_[afterRing .. afterLength];
-                buffer_[afterRing .. afterLength] = buffer_[afterLength .. position];
+                this.buffer_[afterRing .. afterLength] = this.buffer_[afterLength .. this.position];
-                position -= length;
+                this.position -= length;
             }
             else if (overflow == length)
             {
-                buffer_[start .. start + overflow] = buffer_[afterRing .. position];
+                this.buffer_[start .. start + overflow] = this.buffer_[afterRing .. this.position];
-                position -= overflow;
+                this.position -= overflow;
             }
             else
             {
-                buffer_[start .. start + overflow] = buffer_[afterRing .. position];
+                this.buffer_[start .. start + overflow] = this.buffer_[afterRing .. this.position];
-                position = overflow;
+                this.position = overflow;
             }
             start += length;
 
-            if (start == position)
+            if (start == this.position)
             {
-                if (position != afterRing)
+                if (this.position != afterRing)
                 {
-                    position = 0;
+                    this.position = 0;
                 }
                 start = 0;
                 ring = capacity - 1;
@@ -603,7 +545,7 @@ struct WriteBuffer(T = ubyte)
     }
 
     ///
-    unittest
+    @nogc nothrow pure @system unittest
     {
         auto b = WriteBuffer!ubyte(6);
         ubyte[6] buf = [23, 23, 255, 128, 127, 9];
@@ -629,22 +571,20 @@ struct WriteBuffer(T = ubyte)
      *
      * Returns: A chunk of data buffer.
      */
-    T[] opSlice(in size_t start, in size_t end)
+    T[] opSlice(size_t start, size_t end)
     {
-        immutable internStart = this.start + start;
+        if (this.position > ring || this.position < start) // Buffer overflowed
-
-        if (position > ring || position < start) // Buffer overflowed
         {
-            return buffer_[this.start .. ring + 1 - length + end];
+            return this.buffer_[this.start .. ring + 1 - length + end];
         }
         else
         {
-            return buffer_[this.start .. this.start + end];
+            return this.buffer_[this.start .. this.start + end];
         }
     }
 
     ///
-    unittest
+    @nogc nothrow pure @system unittest
     {
         auto b = WriteBuffer!ubyte(6);
         ubyte[6] buf = [23, 23, 255, 128, 127, 9];
@@ -682,7 +622,36 @@ struct WriteBuffer(T = ubyte)
     mixin DefaultAllocator;
 }
 
-private unittest
+@nogc nothrow pure @system unittest
 {
-    static assert(is(typeof(WriteBuffer!int(5))));
+    auto b = WriteBuffer!ubyte(4);
+    ubyte[3] buf = [48, 23, 255];
+
+    b ~= buf;
+    assert(b.capacity == 4);
+    assert(b.buffer_[0] == 48 && b.buffer_[1] == 23 && b.buffer_[2] == 255);
+
+    b += 2;
+    b ~= buf;
+    assert(b.capacity == 4);
+    assert(b.buffer_[0] == 23 && b.buffer_[1] == 255
+        && b.buffer_[2] == 255 && b.buffer_[3] == 48);
+
+    b += 2;
+    b ~= buf;
+    assert(b.capacity == 8);
+    assert(b.buffer_[0] == 23 && b.buffer_[1] == 255
+        && b.buffer_[2] == 48 && b.buffer_[3] == 23 && b.buffer_[4] == 255);
+}
+
+@nogc nothrow pure @system unittest
+{
+    auto b = WriteBuffer!ubyte(2);
+    ubyte[3] buf = [48, 23, 255];
+
+    b ~= buf;
+    assert(b.start == 0);
+    assert(b.capacity == 4);
+    assert(b.ring == 3);
+    assert(b.position == 3);
 }

source/tanya/container/entry.d

@@ -5,13 +5,22 @@
 /*
  * Internal package used by containers that rely on entries/nodes.
  *
- * Copyright: Eugene Wissner 2016-2017.
+ * Copyright: Eugene Wissner 2016-2019.
  * 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;
+import tanya.typecons;
+
 package struct SEntry(T)
 {
     // Item content.
@@ -29,3 +38,275 @@ package struct DEntry(T)
     // 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
+    {
+        alias KV = Tuple!(K, "key", 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 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 (allocator !is null)
+    {
+        this.array = Buckets(allocator);
+    }
+
+    this(T)(ref T data, shared Allocator allocator)
+    if (is(Unqual!T == HashArray))
+    in (allocator !is null)
+    {
+        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 (allocator !is null)
+    {
+        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 (n < primes.length)
+    {
+        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;
+    }
+}

source/tanya/container/hashtable.d

@@ -0,0 +1,990 @@
+/* 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/. */
+
+/**
+ * Hash table.
+ *
+ * Copyright: Eugene Wissner 2018-2019.
+ * 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/hashtable.d,
+ *                 tanya/container/hashtable.d)
+ */
+module tanya.container.hashtable;
+
+import tanya.algorithm.mutation;
+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 whose element type is a tuple of a key and the
+ * respective value.
+ *
+ * Params:
+ *  T = Type of the internal hash storage.
+ */
+struct Range(T)
+{
+    private alias KV = CopyConstness!(T, T.Bucket.KV);
+    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 (!empty)
+    in (this.dataRange.front.status == BucketStatus.used)
+    out (; empty || this.dataRange.back.status == BucketStatus.used)
+    {
+        do
+        {
+            this.dataRange.popFront();
+        }
+        while (!empty && dataRange.front.status != BucketStatus.used);
+    }
+
+    void popBack()
+    in (!empty)
+    in (this.dataRange.back.status == BucketStatus.used)
+    out (; empty || this.dataRange.back.status == BucketStatus.used)
+    {
+        do
+        {
+            this.dataRange.popBack();
+        }
+        while (!empty && dataRange.back.status != BucketStatus.used);
+    }
+
+    @property ref inout(KV) front() inout
+    in (!empty)
+    in (this.dataRange.front.status == BucketStatus.used)
+    {
+        return this.dataRange.front.kv;
+    }
+
+    @property ref inout(KV) back() inout
+    in (!empty)
+    in (this.dataRange.back.status == BucketStatus.used)
+    {
+        return this.dataRange.back.kv;
+    }
+
+    Range opIndex()
+    {
+        return typeof(return)(this.dataRange[]);
+    }
+
+    Range!(const T) opIndex() const
+    {
+        return typeof(return)(this.dataRange[]);
+    }
+}
+
+/**
+ * Bidirectional range iterating over the key of a $(D_PSYMBOL HashTable).
+ *
+ * Params:
+ *  T = Type of the internal hash storage.
+ */
+struct ByKey(T)
+{
+    private alias Key = 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 ByKey save()
+    {
+        return this;
+    }
+
+    @property bool empty() const
+    {
+        return this.dataRange.empty();
+    }
+
+    @property void popFront()
+    in (!empty)
+    in (this.dataRange.front.status == BucketStatus.used)
+    out (; empty || this.dataRange.back.status == BucketStatus.used)
+    {
+        do
+        {
+            this.dataRange.popFront();
+        }
+        while (!empty && dataRange.front.status != BucketStatus.used);
+    }
+
+    @property void popBack()
+    in (!empty)
+    in (this.dataRange.back.status == BucketStatus.used)
+    out (; empty || this.dataRange.back.status == BucketStatus.used)
+    {
+        do
+        {
+            this.dataRange.popBack();
+        }
+        while (!empty && dataRange.back.status != BucketStatus.used);
+    }
+
+    @property ref inout(Key) front() inout
+    in (!empty)
+    in (this.dataRange.front.status == BucketStatus.used)
+    {
+        return this.dataRange.front.key;
+    }
+
+    @property ref inout(Key) back() inout
+    in (!empty)
+    in (this.dataRange.back.status == BucketStatus.used)
+    {
+        return this.dataRange.back.key;
+    }
+
+    ByKey opIndex()
+    {
+        return typeof(return)(this.dataRange[]);
+    }
+
+    ByKey!(const T) opIndex() const
+    {
+        return typeof(return)(this.dataRange[]);
+    }
+}
+
+/**
+ * Bidirectional range iterating over the key of a $(D_PSYMBOL HashTable).
+ *
+ * Params:
+ *  T = Type of the internal hash storage.
+ */
+struct ByValue(T)
+{
+    private alias Value = CopyConstness!(T, T.Value);
+    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 ByValue save()
+    {
+        return this;
+    }
+
+    @property bool empty() const
+    {
+        return this.dataRange.empty();
+    }
+
+    @property void popFront()
+    in (!empty)
+    in (this.dataRange.front.status == BucketStatus.used)
+    out (; empty || this.dataRange.back.status == BucketStatus.used)
+    {
+        do
+        {
+            this.dataRange.popFront();
+        }
+        while (!empty && dataRange.front.status != BucketStatus.used);
+    }
+
+    @property void popBack()
+    in (!empty)
+    in (this.dataRange.back.status == BucketStatus.used)
+    out (; empty || this.dataRange.back.status == BucketStatus.used)
+    {
+        do
+        {
+            this.dataRange.popBack();
+        }
+        while (!empty && dataRange.back.status != BucketStatus.used);
+    }
+
+    @property ref inout(Value) front() inout
+    in (!empty)
+    in (this.dataRange.front.status == BucketStatus.used)
+    {
+        return this.dataRange.front.kv.value;
+    }
+
+    @property ref inout(Value) back() inout
+    in (!empty)
+    in (this.dataRange.back.status == BucketStatus.used)
+    {
+        return this.dataRange.back.kv.value;
+    }
+
+    ByValue opIndex()
+    {
+        return typeof(return)(this.dataRange[]);
+    }
+
+    ByValue!(const T) opIndex() const
+    {
+        return typeof(return)(this.dataRange[]);
+    }
+}
+
+/**
+ * Hash table is a data structure that stores pairs of keys and values without
+ * any particular order.
+ *
+ * This $(D_PSYMBOL HashTable) is implemented using closed hashing. Hash
+ * collisions are resolved with linear probing.
+ *
+ * $(D_PARAM Key) should be hashable with $(D_PARAM hasher). $(D_PARAM hasher)
+ * is a callable that accepts an argument of type $(D_PARAM Key) and returns a
+ * hash value for it ($(D_KEYWORD size_t)).
+ *
+ * Params:
+ *  Key    = Key type.
+ *  Value  = Value type.
+ *  hasher = Hash function for $(D_PARAM Key).
+ */
+struct HashTable(Key, Value, alias hasher = hash)
+if (isHashFunction!(hasher, Key))
+{
+    private alias HashArray = .HashArray!(hasher, Key, Value);
+    private alias Buckets = HashArray.Buckets;
+
+    private HashArray data;
+
+    /// Type of the key-value pair stored in the hash table.
+    alias KeyValue = HashArray.Bucket.KV;
+
+    /// The range types for $(D_PSYMBOL HashTable).
+    alias Range = .Range!HashArray;
+
+    /// ditto
+    alias ConstRange = .Range!(const HashArray);
+
+    /// ditto
+    alias ByKey = .ByKey!(const HashArray);
+
+    /// ditto
+    alias ByValue = .ByValue!HashArray;
+
+    /// ditto
+    alias ConstByValue = .ByValue!(const HashArray);
+
+    invariant (this.data.lengthIndex < primes.length);
+
+    /**
+     * Constructor.
+     *
+     * Params:
+     *  n         = Minimum number of buckets.
+     *  allocator = Allocator.
+     *
+     * Precondition: $(D_INLINECODE allocator !is null).
+     */
+    this(size_t n, shared Allocator allocator = defaultAllocator)
+    in (allocator !is null)
+    {
+        this(allocator);
+        this.data.rehash(n);
+    }
+
+    ///
+    @nogc nothrow pure @safe unittest
+    {
+        auto hashTable = HashTable!(string, int)(5);
+        assert(hashTable.capacity == 7);
+    }
+
+    /// ditto
+    this(shared Allocator allocator)
+    in (allocator !is null)
+    {
+        this.data = HashArray(allocator);
+    }
+
+    /**
+     * Initializes this $(D_PARAM HashTable) 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 == HashTable))
+    in (allocator !is null)
+    {
+        this.data = HashArray(init.data, allocator);
+    }
+
+    /// ditto
+    this(S)(S init, shared Allocator allocator = defaultAllocator)
+    if (is(S == HashTable))
+    in (allocator !is null)
+    {
+        this.data.move(init.data, allocator);
+    }
+
+    /**
+     * Constructs the hash table from a forward range.
+     *
+     * Params:
+     *  R         = Range type.
+     *  range     = Forward range.
+     *  allocator = Allocator.
+     *
+     * Precondition: $(D_INLINECODE allocator !is null).
+     */
+    this(R)(R range, shared Allocator allocator = defaultAllocator)
+    if (isForwardRange!R && is(ElementType!R == KeyValue))
+    in (allocator !is null)
+    {
+        this(allocator);
+        insert(range);
+    }
+
+    ///
+    @nogc nothrow pure @safe unittest
+    {
+        alias KeyValue = HashTable!(string, int).KeyValue;
+
+        KeyValue[2] range = [KeyValue("one", 1), KeyValue("two", 2)];
+        auto hashTable = HashTable!(string, int)(range[]);
+
+        assert(hashTable["one"] == 1);
+        assert(hashTable["two"] == 2);
+    }
+
+    /**
+     * Initializes the hash table from a static array.
+     *
+     * Params:
+     *  n         = Array size.
+     *  array     = Static array.
+     *  allocator = Allocator.
+     *
+     * Precondition: $(D_INLINECODE allocator !is null).
+     */
+    this(size_t n)(KeyValue[n] array,
+         shared Allocator allocator = defaultAllocator)
+    in (allocator !is null)
+    {
+        insert(array[]);
+    }
+
+    ///
+    @nogc nothrow pure @safe unittest
+    {
+        alias KeyValue = HashTable!(string, int).KeyValue;
+        auto hashTable = HashTable!(string, int)([KeyValue("one", 1), KeyValue("two", 2)]);
+
+        assert(hashTable["one"] == 1);
+        assert(hashTable["two"] == 2);
+    }
+
+    /**
+     * Assigns another hash table.
+     *
+     * 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 == HashTable))
+    {
+        this.data = that.data;
+        return this;
+    }
+
+    /// ditto
+    ref typeof(this) opAssign(S)(S that) @trusted
+    if (is(S == HashTable))
+    {
+        this.data.swap(that.data);
+        return this;
+    }
+
+    /**
+     * Returns: Used allocator.
+     *
+     * Postcondition: $(D_INLINECODE allocator !is null)
+     */
+    @property shared(Allocator) allocator() const
+    out (allocator; allocator !is null)
+    {
+        return this.data.array.allocator;
+    }
+
+    /**
+     * Maximum amount of elements this $(D_PSYMBOL HashTable) 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 HashTable) capacity.
+     */
+    @property size_t capacity() const
+    {
+        return this.data.capacity;
+    }
+
+    ///
+    @nogc nothrow pure @safe unittest
+    {
+        HashTable!(string, int) hashTable;
+        assert(hashTable.capacity == 0);
+
+        hashTable["eight"] = 8;
+        assert(hashTable.capacity == 3);
+    }
+
+    /**
+     * Returns the number of elements in the container.
+     *
+     * Returns: The number of elements in the container.
+     */
+    @property size_t length() const
+    {
+        return this.data.length;
+    }
+
+    ///
+    @nogc nothrow pure @safe unittest
+    {
+        HashTable!(string, int) hashTable;
+        assert(hashTable.length == 0);
+
+        hashTable["eight"] = 8;
+        assert(hashTable.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
+    {
+        HashTable!(string, int) hashTable;
+        assert(hashTable.empty);
+        hashTable["five"] = 5;
+        assert(!hashTable.empty);
+    }
+
+    /**
+     * Removes all elements.
+     */
+    void clear()
+    {
+        this.data.clear();
+    }
+
+    ///
+    @nogc nothrow pure @safe unittest
+    {
+        HashTable!(string, int) hashTable;
+        hashTable["five"] = 5;
+        assert(!hashTable.empty);
+        hashTable.clear();
+        assert(hashTable.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 value at $(D_PARAM key) or reassigns the element if
+     * $(D_PARAM key) already exists in the hash table.
+     *
+     * Params:
+     *  key   = The key to insert the value at.
+     *  value = The value to be inserted.
+     *
+     * Returns: Just inserted element.
+     */
+    ref Value opIndexAssign()(auto ref Value value, auto ref Key key)
+    {
+        auto e = ((ref v) @trusted => &this.data.insert(v))(key);
+        if (e.status != BucketStatus.used)
+        {
+            static if (__traits(isRef, key))
+            {
+                e.key = key;
+            }
+            else
+            {
+                e.moveKey(key);
+            }
+        }
+        static if (__traits(isRef, value))
+        {
+            return e.kv.value = value;
+        }
+        else
+        {
+            return e.kv.value = move(value);
+        }
+    }
+
+    ///
+    @nogc nothrow pure @safe unittest
+    {
+        HashTable!(string, int) hashTable;
+        assert("Pachycephalosaurus" !in hashTable);
+
+        hashTable["Pachycephalosaurus"] = 6;
+        assert(hashTable.length == 1);
+        assert("Pachycephalosaurus" in hashTable);
+
+        hashTable["Pachycephalosaurus"] = 6;
+        assert(hashTable.length == 1);
+        assert("Pachycephalosaurus" in hashTable);
+    }
+
+    /**
+     * Inserts a new element in the hash table.
+     *
+     * If the element with the same key was already in the table, it reassigns
+     * it with the new value, but $(D_PSYMBOL insert) returns `0`. Otherwise
+     * `1` is returned.
+     *
+     * Params:
+     *  keyValue = Key/value pair.
+     *
+     * Returns: The number of the inserted elements with a unique key.
+     */
+    size_t insert()(ref KeyValue keyValue)
+    {
+        auto e = ((ref v) @trusted => &this.data.insert(v))(keyValue.key);
+        size_t inserted;
+        if (e.status != BucketStatus.used)
+        {
+            e.key = keyValue.key;
+            inserted = 1;
+        }
+        e.kv.value = keyValue.value;
+        return inserted;
+    }
+
+    /// ditto
+    size_t insert()(KeyValue keyValue)
+    {
+        auto e = ((ref v) @trusted => &this.data.insert(v))(keyValue.key);
+        size_t inserted;
+        if (e.status != BucketStatus.used)
+        {
+            e.moveKey(keyValue.key);
+            inserted = 1;
+        }
+        move(keyValue.value, e.kv.value);
+        return inserted;
+    }
+
+    ///
+    @nogc nothrow pure @safe unittest
+    {
+        HashTable!(string, int) hashTable;
+
+        assert(hashTable.insert(hashTable.KeyValue("number", 1)) == 1);
+        assert(hashTable["number"] == 1);
+        assert(hashTable.insert(hashTable.KeyValue("number", 2)) == 0);
+        assert(hashTable["number"] == 2);
+    }
+
+    /**
+     * Inserts a forward range of key/value pairs into the hash table.
+     *
+     * If some of the elements in the $(D_PARAM range) have the same key, they
+     * are reassigned but are not counted as inserted elements. So the value
+     * returned by this function will be less than the range length.
+     *
+     * Params:
+     *  R     = Range type.
+     *  range = Forward range.
+     *
+     * Returns: The number of the inserted elements with a unique key.
+     */
+    size_t insert(R)(R range)
+    if (isForwardRange!R && is(ElementType!R == KeyValue))
+    {
+        size_t count;
+        foreach (e; range)
+        {
+            count += insert(e);
+        }
+        return count;
+    }
+
+    ///
+    @nogc nothrow pure @safe unittest
+    {
+        HashTable!(string, int) hashTable;
+
+        hashTable.KeyValue[2] range = [
+            hashTable.KeyValue("one", 1),
+            hashTable.KeyValue("two", 2),
+        ];
+
+        assert(hashTable.insert(range[]) == 2);
+        assert(hashTable["one"] == 1);
+        assert(hashTable["two"] == 2);
+    }
+
+    /**
+     * Find the element with the key $(D_PARAM key).
+     *
+     * Params:
+     *  T   = Type comparable with the key type, used for the lookup.
+     *  key = The key to be find.
+     *
+     * Returns: The value associated with $(D_PARAM key).
+     *
+     * Precondition: Element with $(D_PARAM key) is in this hash table.
+     */
+    ref Value opIndex(T)(auto ref const T key)
+    if (ifTestable!(T, a => Key.init == a))
+    {
+        const code = this.data.locateBucket(key);
+
+        for (auto range = this.data.array[code .. $]; !range.empty; range.popFront())
+        {
+            if (key == range.front.key)
+            {
+                return range.front.kv.value;
+            }
+        }
+        assert(false, "Range violation");
+    }
+
+    ///
+    @nogc nothrow pure @safe unittest
+    {
+        HashTable!(string, int) hashTable;
+        hashTable["Triceratops"] = 7;
+        assert(hashTable["Triceratops"] == 7);
+    }
+
+    /**
+     * Removes the element with the key $(D_PARAM key).
+     *
+     * The method returns the number of elements removed. Since
+     * the hash table contains only unique keys, $(D_PARAM remove) always
+     * returns `1` if an element with the $(D_PARAM key) was found, `0`
+     * otherwise.
+     *
+     * Params:
+     *  key = The key to be removed.
+     *
+     * Returns: Number of the removed elements.
+     */
+    size_t remove(Key key)
+    {
+        return this.data.remove(key);
+    }
+
+    ///
+    @nogc nothrow pure @safe unittest
+    {
+        HashTable!(string, int) hashTable;
+        hashTable["Euoplocephalus"] = 6;
+
+        assert("Euoplocephalus" in hashTable);
+        assert(hashTable.remove("Euoplocephalus") == 1);
+        assert(hashTable.remove("Euoplocephalus") == 0);
+        assert("Euoplocephalus" !in hashTable);
+    }
+
+    /**
+     * Looks for $(D_PARAM key) in this hash table.
+     *
+     * Params:
+     *  T   = Type comparable with the key type, used for the lookup.
+     *  key = The key to look for.
+     *
+     * Returns: $(D_KEYWORD true) if $(D_PARAM key) exists in the hash table,
+     *          $(D_KEYWORD false) otherwise.
+     */
+    bool opBinaryRight(string op : "in", T)(auto ref const T key) const
+    if (ifTestable!(T, a => Key.init == a))
+    {
+        return key in this.data;
+    }
+
+    ///
+    @nogc nothrow pure @safe unittest
+    {
+        HashTable!(string, int) hashTable;
+
+        assert("Shantungosaurus" !in hashTable);
+        hashTable["Shantungosaurus"] = 15;
+        assert("Shantungosaurus" in hashTable);
+
+        assert("Ceratopsia" !in hashTable);
+    }
+
+    /**
+     * 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 whose element type is a tuple of a key and
+     * the respective value.
+     *
+     * 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
+    {
+        HashTable!(string, int) hashTable;
+        assert(hashTable[].empty);
+
+        hashTable["Iguanodon"] = 9;
+        assert(!hashTable[].empty);
+        assert(hashTable[].front == hashTable.KeyValue("Iguanodon", 9));
+        assert(hashTable[].back == hashTable.KeyValue("Iguanodon", 9));
+    }
+
+    /**
+     * Returns a bidirectional range that iterats over the keys of this
+     * $(D_PSYMBOL HashTable).
+     *
+     * This function always returns a $(D_KEYWORD const) range, since changing
+     * a key of a hash table would probably change its hash value and require
+     * rehashing.
+     *
+     * Returns: $(D_KEYWORD const) bidirectional range that iterates over the
+     *          keys of the container.
+     *
+     * See_Also: $(D_PSYMBOL byValue).
+     */
+    ByKey byKey() const
+    {
+        return typeof(return)(this.data.array[]);
+    }
+
+    ///
+    @nogc nothrow pure @safe unittest
+    {
+        HashTable!(string, int) hashTable;
+        hashTable["one"] = 1;
+        hashTable["two"] = 2;
+
+        auto byKey = hashTable.byKey();
+        assert(!byKey.empty);
+
+        assert(byKey.front == "one" || byKey.front == "two");
+        assert(byKey.back == "one" || byKey.back == "two");
+        assert(byKey.front != byKey.back);
+
+        byKey.popFront();
+        assert(byKey.front == byKey.back);
+
+        byKey.popBack();
+        assert(byKey.empty);
+    }
+
+    /**
+     * Returns a bidirectional range that iterats over the values of this
+     * $(D_PSYMBOL HashTable).
+     *
+     * Returns: A bidirectional range that iterates over the values of the
+     *          container.
+     *
+     * See_Also: $(D_PSYMBOL byKey).
+     */
+    ByValue byValue()
+    {
+        return typeof(return)(this.data.array[]);
+    }
+
+    /// ditto
+    ConstByValue byValue() const
+    {
+        return typeof(return)(this.data.array[]);
+    }
+
+    ///
+    @nogc nothrow pure @safe unittest
+    {
+        HashTable!(string, int) hashTable;
+        hashTable["one"] = 1;
+        hashTable["two"] = 2;
+
+        auto byValue = hashTable.byValue();
+        assert(!byValue.empty);
+
+        assert(byValue.front == 1 || byValue.front == 2);
+        assert(byValue.back == 1 || byValue.back == 2);
+        assert(byValue.front != byValue.back);
+
+        byValue.popFront();
+        assert(byValue.front == byValue.back);
+
+        byValue.popBack();
+        assert(byValue.empty);
+    }
+}
+
+@nogc nothrow pure @safe unittest
+{
+    auto dinos = HashTable!(string, int)(17);
+    assert(dinos.empty);
+
+    dinos["Ornithominus"] = 4;
+    dinos["Tyrannosaurus"] = 12;
+    dinos["Deinonychus"] = 3;
+    dinos["Stegosaurus"] = 6;
+    dinos["Brachiosaurus"] = 25;
+
+    assert(dinos.length == 5);
+    assert(dinos["Ornithominus"] == 4);
+    assert(dinos["Stegosaurus"] == 6);
+    assert(dinos["Deinonychus"] == 3);
+    assert(dinos["Tyrannosaurus"] == 12);
+    assert(dinos["Brachiosaurus"] == 25);
+
+    dinos.clear();
+    assert(dinos.empty);
+}

source/tanya/container/package.d

@@ -5,15 +5,18 @@
 /**
  * Abstract data types whose instances are collections of other objects.
  *
- * Copyright: Eugene Wissner 2016-2017.
+ * Copyright: Eugene Wissner 2016-2019.
  * 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.queue;

source/tanya/container/queue.d

@@ -1,288 +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/. */
-
-/**
- * FIFO queue.
- *
- * Copyright: Eugene Wissner 2016-2017.
- * 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 core.exception;
-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();
-        }
-    }
-
-    /**
-     * 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(SEntry!T)* i = first; 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);
-    }
-
-    private void enqueueEntry(ref SEntry!T* entry)
-    {
-        if (empty)
-        {
-            first = rear = entry;
-        }
-        else
-        {
-            rear.next = entry;
-            rear = rear.next;
-        }
-    }
-
-    private SEntry!T* allocateEntry()
-    {
-        auto temp = cast(SEntry!T*) allocator.allocate(SEntry!T.sizeof);
-        if (temp is null)
-        {
-            onOutOfMemoryError();
-        }
-        return temp;
-    }
-
-    /**
-     * Inserts a new element.
-     *
-     * Params:
-     *  x = New element.
-     */
-    void enqueue(ref T x)
-    {
-        auto temp = allocateEntry();
-
-        *temp = SEntry!T.init;
-        temp.content = x;
-
-        enqueueEntry(temp);
-    }
-
-    /// Ditto.
-    void enqueue(T x)
-    {
-        auto temp = allocateEntry();
-
-        moveEmplace(x, (*temp).content);
-        (*temp).next = null;
-
-        enqueueEntry(temp);
-    }
-
-    ///
-    unittest
-    {
-        Queue!int q;
-
-        assert(q.empty);
-        q.enqueue(8);
-        q.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 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);
-    }
-    body
-    {
-        auto n = first.next;
-        T ret = move(first.content);
-
-        allocator.dispose(first);
-        first = n;
-        return ret;
-    }
-
-    ///
-    unittest
-    {
-        Queue!int q;
-
-        q.enqueue(8);
-        q.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.
-     *
-     * Returns: The value returned from $(D_PARAM dg).
-     */
-    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);
-        q.enqueue(4);
-        q.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);
-        q.enqueue(4);
-        q.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);
-    }
-
-    private SEntry!T* first;
-    private SEntry!T* rear;
-
-    mixin DefaultAllocator;
-}
-
-///
-unittest
-{
-    Queue!int q;
-
-    q.enqueue(5);
-    assert(!q.empty);
-
-    q.enqueue(4);
-    q.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

@@ -0,0 +1,587 @@
+/* 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-2019.
+ * 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 (!empty)
+    in (this.dataRange.front.status == BucketStatus.used)
+    out (; empty || this.dataRange.back.status == BucketStatus.used)
+    {
+        do
+        {
+            this.dataRange.popFront();
+        }
+        while (!empty && dataRange.front.status != BucketStatus.used);
+    }
+
+    void popBack()
+    in (!empty)
+    in (this.dataRange.back.status == BucketStatus.used)
+    out (; empty || this.dataRange.back.status == BucketStatus.used)
+    {
+        do
+        {
+            this.dataRange.popBack();
+        }
+        while (!empty && dataRange.back.status != BucketStatus.used);
+    }
+
+    @property ref inout(E) front() inout
+    in (!empty)
+    in (this.dataRange.front.status == BucketStatus.used)
+    {
+        return this.dataRange.front.key;
+    }
+
+    @property ref inout(E) back() inout
+    in (!empty)
+    in (this.dataRange.back.status == BucketStatus.used)
+    {
+        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 (this.data.lengthIndex < primes.length);
+    invariant (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 (allocator !is null)
+    {
+        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 (allocator !is null)
+    {
+        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 (allocator !is null)
+    {
+        this.data = HashArray(init.data, allocator);
+    }
+
+    /// ditto
+    this(S)(S init, shared Allocator allocator = defaultAllocator)
+    if (is(S == Set))
+    in (allocator !is null)
+    {
+        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)(R range, shared Allocator allocator = defaultAllocator)
+    if (isForwardRange!R && isImplicitlyConvertible!(ElementType!R, T))
+    in (allocator !is null)
+    {
+        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 (allocator !is null)
+    {
+        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; allocator !is null)
+    {
+        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)(R range)
+    if (isForwardRange!R && isImplicitlyConvertible!(ElementType!R, T))
+    {
+        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

@@ -0,0 +1,564 @@
+/* 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-2019.
+ * 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 tanya.container.string;
+import tanya.memory.allocator;
+deprecated("Use tanya.memory.lifetime.emplace instead")
+public import tanya.memory.lifetime : emplace;
+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 (base >= 2)
+in (base <= 36)
+{
+    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/exception.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 2017-2019.
+ * 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/exception.d,
+ *                 tanya/exception.d)
+ */
+deprecated("Use tanya.memory.allocator instead")
+module tanya.exception;
+
+public import tanya.memory.allocator : onOutOfMemoryError, OutOfMemoryError;

source/tanya/functional.d

@@ -0,0 +1,18 @@
+/* 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/. */
+
+/*
+ * Functions that manipulate other functions and their argument lists.
+ *
+ * Copyright: Eugene Wissner 2018-2019.
+ * 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/functional.d,
+ *                 tanya/functional.d)
+ */
+deprecated("Use tanya.memory.lifetime instead")
+module tanya.functional;
+
+public import tanya.memory.lifetime : forward;

source/tanya/hash/lookup.d

@@ -0,0 +1,340 @@
+/* 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-2019.
+ * 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 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/hash/package.d

@@ -0,0 +1,15 @@
+/* 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 2018-2019.
+ * 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;
+
+public import tanya.hash.lookup;

source/tanya/math/mp.d

@@ -5,19 +5,25 @@
 /**
  * Arbitrary precision arithmetic.
  *
- * Copyright: Eugene Wissner 2016-2017.
+ * Copyright: Eugene Wissner 2016-2019.
  * 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/mp.d,
+ *                 tanya/math/mp.d)
  */
 module tanya.math.mp;
 
-import std.algorithm;
+import tanya.algorithm.comparison;
-import std.ascii;
+import tanya.algorithm.iteration;
-import std.range;
+import tanya.algorithm.mutation;
-import std.traits;
 import tanya.container.array;
-import tanya.memory;
+import tanya.encoding.ascii;
+import tanya.memory.allocator;
+import tanya.memory.lifetime;
+import tanya.meta.trait;
+import tanya.meta.transform;
+import tanya.range;
 
 /**
  * Algebraic sign.
@@ -66,24 +72,23 @@ struct Integer
      * Precondition: $(D_INLINECODE allocator !is null)
      */
     this(T)(const T value, shared Allocator allocator = defaultAllocator)
-        if (isIntegral!T)
+    if (isIntegral!T)
     {
         this(allocator);
         this = value;
     }
 
-    /// Ditto.
+    /// ditto
     this(T)(ref T value, shared Allocator allocator = defaultAllocator)
-        if (is(Unqual!T == Integer))
+    if (is(Unqual!T == Integer))
     {
         this(allocator);
         this = value;
     }
 
-    /// Ditto.
+    /// ditto
     this(T)(T value, shared Allocator allocator = defaultAllocator)
-    nothrow @safe @nogc
+    if (is(T == Integer))
-        if (is(T == Integer))
     {
         this(allocator);
         if (allocator is value.allocator)
@@ -101,13 +106,9 @@ struct Integer
         }
     }
 
-    /// Ditto.
+    /// ditto
-    this(shared Allocator allocator) pure nothrow @safe @nogc
+    this(shared Allocator allocator) @nogc nothrow pure @safe
-    in
+    in (allocator !is null)
-    {
-        assert(allocator !is null);
-    }
-    body
     {
         this.allocator_ = allocator;
     }
@@ -126,8 +127,8 @@ struct Integer
     this(R)(const Sign sign,
             R value,
             shared Allocator allocator = defaultAllocator)
-        if (isBidirectionalRange!R && hasLength!R
+    if (isBidirectionalRange!R && hasLength!R
-         && is(Unqual!(ElementType!R) == ubyte))
+     && is(Unqual!(ElementType!R) == ubyte))
     {
         this(allocator);
         grow(value.length / (digitBitCount / 8) + 1);
@@ -153,7 +154,8 @@ struct Integer
         }
     }
 
-    nothrow @safe @nogc unittest
+    ///
+    @nogc nothrow pure @safe unittest
     {
         ubyte[8] range = [ 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xdd, 0xee ];
         auto integer = Integer(Sign.positive, range[]);
@@ -170,10 +172,9 @@ struct Integer
      *
      * Precondition: $(D_INLINECODE allocator !is null)
      */
-    this(R)(R value,
+    this(R)(R value, shared Allocator allocator = defaultAllocator)
-            shared Allocator allocator = defaultAllocator)
+    if (isBidirectionalRange!R && hasLength!R
-        if (isBidirectionalRange!R && hasLength!R
+     && is(Unqual!(ElementType!R) == ubyte))
-         && is(Unqual!(ElementType!R) == ubyte))
     {
         this(Sign.positive, value, allocator);
 
@@ -185,7 +186,7 @@ struct Integer
     }
 
     ///
-    nothrow @safe @nogc unittest
+    @nogc nothrow pure @safe unittest
     {
         {
             ubyte[8] range = [ 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xdd, 0xee ];
@@ -202,17 +203,17 @@ struct Integer
     /**
      * Copies the integer.
      */
-    this(this) nothrow @trusted @nogc
+    this(this) @nogc nothrow pure @safe
     {
         auto tmp = allocator.resize!digit(null, this.size);
-        this.rep[0 .. this.size].copy(tmp);
+        copy(this.rep[0 .. this.size], tmp);
         this.rep = tmp;
     }
 
     /**
      * Destroys the integer.
      */
-    ~this() nothrow @trusted @nogc
+    ~this() @nogc nothrow pure @safe
     {
         allocator.resize(this.rep, 0);
     }
@@ -222,7 +223,7 @@ struct Integer
     ];
 
     // Counts the number of LSBs before the first non-zero bit.
-    private ptrdiff_t countLSBs() const pure nothrow @safe @nogc
+    private ptrdiff_t countLSBs() const @nogc nothrow pure @safe
     {
         if (this.size == 0)
         {
@@ -254,7 +255,7 @@ struct Integer
     /**
      * Returns: Number of bytes in the two's complement representation.
      */
-    @property size_t length() const pure nothrow @safe @nogc
+    @property size_t length() const @nogc nothrow pure @safe
     {
         if (this.sign)
         {
@@ -277,6 +278,19 @@ struct Integer
         }
     }
 
+    ///
+    @nogc nothrow pure @safe unittest
+    {
+        {
+            Integer i;
+            assert(i.length == 0);
+        }
+        {
+            auto i = Integer(-123456789);
+            assert(i.length == 4);
+        }
+    }
+
     /**
      * Assigns a new value.
      *
@@ -287,7 +301,7 @@ struct Integer
      * Returns: $(D_KEYWORD this).
      */
     ref Integer opAssign(T)(const T value)
-        if (isIntegral!T)
+    if (isIntegral!T)
     {
         rep[0 .. this.size].fill(digit.init);
         grow(digitBitCount / 8 + 1);
@@ -320,21 +334,21 @@ struct Integer
         return this;
     }
 
-    /// Ditto.
+    /// ditto
-    ref Integer opAssign(T)(ref T value) @trusted
+    ref Integer opAssign(T)(ref T value)
-        if (is(Unqual!T == Integer))
+    if (is(Unqual!T == Integer))
     {
         this.rep = allocator.resize(this.rep, value.size);
-        value.rep[0 .. value.size].copy(this.rep[0 .. value.size]);
+        copy(value.rep[0 .. value.size], this.rep[0 .. value.size]);
         this.size = value.size;
         this.sign = value.sign;
 
         return this;
     }
 
-    /// Ditto.
+    /// ditto
-    ref Integer opAssign(T)(T value) nothrow @safe @nogc
+    ref Integer opAssign(T)(T value)
-        if (is(T == Integer))
+    if (is(T == Integer))
     {
         swap(this.rep, value.rep);
         swap(this.sign, value.sign);
@@ -356,9 +370,9 @@ struct Integer
         return this.size > 0;
     }
 
-    /// Ditto.
+    /// ditto
     T opCast(T)() const
-        if (isIntegral!T && isUnsigned!T)
+    if (isIntegral!T && isUnsigned!T)
     {
         T ret;
         ubyte shift;
@@ -370,15 +384,17 @@ struct Integer
         return ret;
     }
 
-    /// Ditto.
+    /// ditto
     T opCast(T)() const
-        if (isIntegral!T && isSigned!T)
+    if (isIntegral!T && isSigned!T)
     {
-        return this.sign ? -(cast(Unsigned!T) this) : cast(Unsigned!T) this;
+        return this.sign
+            ? cast(T) -(cast(Promoted!(Unsigned!T)) (cast(Unsigned!T) this))
+            : cast(Unsigned!T) this;
     }
 
     ///
-    @safe @nogc unittest
+    @nogc nothrow pure @safe unittest
     {
         auto integer = Integer(79);
         assert(cast(ushort) integer == 79);
@@ -402,14 +418,14 @@ struct Integer
         assert(cast(long) integer == 0);
     }
 
-    /* trim unused digits 
+    /* Trim unused digits.
      *
      * This is used to ensure that leading zero digits are
      * trimed and the leading "size" digit will be non-zero
      * Typically very fast.  Also fixes the sign if there
      * are no more leading digits
      */
-    void contract() nothrow @safe @nogc
+    void contract() @nogc nothrow pure @safe
     {
         /* decrease size while the most significant digit is
          * zero.
@@ -426,7 +442,7 @@ struct Integer
         }
     }
 
-    private void grow(const size_t size) nothrow @trusted @nogc
+    private void grow(const size_t size) @nogc nothrow pure @safe
     {
         if (this.rep.length >= size)
         {
@@ -437,7 +453,7 @@ struct Integer
         this.rep[oldLength .. $].fill(digit.init);
     }
 
-    private size_t countBits() const pure nothrow @safe @nogc
+    private size_t countBits() const @nogc nothrow pure @safe
     {
         if (this.size == 0)
         {
@@ -455,7 +471,7 @@ struct Integer
     }
 
     private void add(ref const Integer summand, ref Integer sum)
-    const nothrow @safe @nogc
+    const @nogc nothrow pure @safe
     {
         const(digit)[] max, min;
 
@@ -506,7 +522,7 @@ struct Integer
     }
 
     private void add(const digit summand, ref Integer sum)
-    const nothrow @safe @nogc
+    const @nogc nothrow pure @safe
     {
         sum.grow(this.size + 2);
 
@@ -532,7 +548,7 @@ struct Integer
     }
 
     private void subtract(ref const Integer subtrahend, ref Integer difference)
-    const nothrow @safe @nogc
+    const @nogc nothrow pure @safe
     {
         difference.grow(this.size);
 
@@ -568,7 +584,7 @@ struct Integer
     }
 
     private void subtract(const digit subtrahend, ref Integer difference)
-    const nothrow @safe @nogc
+    const @nogc nothrow pure @safe
     {
         difference.grow(this.size);
 
@@ -597,7 +613,7 @@ struct Integer
     }
 
     // Compare the magnitude.
-    private int compare(ref const Integer that) const pure nothrow @safe @nogc
+    private int compare(ref const Integer that) const @nogc nothrow pure @safe
     {
         if (this.size > that.size)
         {
@@ -609,7 +625,7 @@ struct Integer
         }
         return this.rep[0 .. this.size]
                    .retro
-                   .cmp(that.rep[0 .. that.size].retro);
+                   .compare(that.rep[0 .. that.size].retro);
     }
 
     /**
@@ -646,7 +662,7 @@ struct Integer
     }
 
     ///
-    @safe @nogc unittest
+    @nogc nothrow pure @safe unittest
     {
         auto integer1 = Integer(1019);
         auto integer2 = Integer(1019);
@@ -662,9 +678,9 @@ struct Integer
         assert(integer1 > integer2);
     }
 
-    /// Ditto.
+    /// ditto
     int opCmp(I)(const I that) const
-        if (isIntegral!I)
+    if (isIntegral!I)
     {
         if (that < 0 && !this.sign)
         {
@@ -692,7 +708,7 @@ struct Integer
     }
 
     ///
-    @safe @nogc unittest
+    @nogc nothrow pure @safe unittest
     {
         auto integer = Integer(1019);
 
@@ -710,13 +726,13 @@ struct Integer
      * Returns: Whether the two integers are equal.
      */
     bool opEquals(I)(auto ref const I that) const
-        if (is(I : Integer) || isIntegral!I)
+    if (is(I : Integer) || isIntegral!I)
     {
         return opCmp!I(that) == 0;
     }
 
     ///
-    @safe @nogc unittest
+    @nogc nothrow pure @safe unittest
     {
         auto integer = Integer(1019);
 
@@ -752,7 +768,7 @@ struct Integer
     }
 
     ///
-    unittest
+    @nogc nothrow pure @safe unittest
     {
         {
             auto h1 = Integer(1019);
@@ -774,7 +790,7 @@ struct Integer
         }
     }
 
-    /// Ditto.
+    /// ditto
     ref Integer opOpAssign(string op : "-")(auto ref const Integer operand)
     {
         if (this.sign != operand.sign)
@@ -794,7 +810,7 @@ struct Integer
     }
 
     ///
-    unittest
+    @nogc nothrow pure @safe unittest
     {
         {
             auto h1 = Integer(3);
@@ -822,7 +838,7 @@ struct Integer
         }
     }
 
-    /// Ditto.
+    /// ditto
     ref Integer opOpAssign(string op : "*")(auto ref const Integer operand)
     {
         const digits = this.size + operand.size + 1;
@@ -838,7 +854,7 @@ struct Integer
     }
 
     ///
-    nothrow @safe @nogc unittest
+    @nogc nothrow pure @safe unittest
     {
         auto h1 = Integer(123);
         auto h2 = Integer(456);
@@ -846,52 +862,23 @@ struct Integer
         assert(h1 == 56088);
     }
 
-    /// Ditto.
+    /// ditto
     ref Integer opOpAssign(string op : "/")(auto ref const Integer operand)
-    in
+    in (operand.length > 0, "Division by zero.")
-    {
-        assert(operand.length > 0, "Division by zero.");
-    }
-    body
     {
         divide(operand, this);
         return this;
     }
 
-     /// Ditto.
+     /// ditto
     ref Integer opOpAssign(string op : "%")(auto ref const Integer operand)
-    in
+    in (operand.length > 0, "Division by zero")
-    {
-        assert(operand.length > 0, "Division by zero.");
-    }
-    body
     {
         divide(operand, null, this);
         return this;
     }
 
-    nothrow @safe @nogc unittest
+    /// ditto
-    {
-        auto h1 = Integer(18);
-        auto h2 = Integer(4);
-        h1 %= h2;
-        assert(h1 == 2);
-
-        h1 = 8;
-        h1 %= h2;
-        assert(h1 == 0);
-
-        h1 = 7;
-        h1 %= h2;
-        assert(h1 == 3);
-
-        h1 = 56088;
-        h2 = 456;
-        h1 /= h2;
-        assert(h1 == 123);
-    }
-
-    /// Ditto.
     ref Integer opOpAssign(string op : ">>")(const size_t operand)
     {
         if (operand == 0)
@@ -910,7 +897,7 @@ struct Integer
             const shift = digitBitCount - bit;
             digit carry;
 
-            foreach (ref d; this.rep[0 .. this.size].retro)
+            foreach_reverse (ref d; this.rep[0 .. this.size])
             {
                 const newCarry = d & mask;
                 d = (d >> bit) | (carry << shift);
@@ -922,7 +909,7 @@ struct Integer
     }
 
     ///
-    nothrow @safe @nogc unittest
+    @nogc nothrow pure @safe unittest
     {
         auto integer = Integer(4294967294);
         integer >>= 10;
@@ -953,7 +940,7 @@ struct Integer
         assert(integer == 0);
     }
 
-    /// Ditto.
+    /// ditto
     ref Integer opOpAssign(string op : "<<")(const size_t operand)
     {
         const step = operand / digitBitCount;
@@ -990,7 +977,7 @@ struct Integer
     }
 
     ///
-    nothrow @safe @nogc unittest
+    @nogc nothrow pure @safe unittest
     {
         auto integer = Integer(4294967295);
         integer <<= 1;
@@ -1008,11 +995,14 @@ struct Integer
     Integer opUnary(string op : "~")() const
     {
         auto ret = Integer(this, allocator);
-        ret.rep[0 .. ret.size].each!((ref a) => a = ~a & mask);
+        foreach (ref a; ret.rep[0 .. ret.size])
+        {
+            a = ~a & mask;
+        }
         return ret;
     }
 
-    /// Ditto.
+    /// ditto
     Integer opUnary(string op : "-")() const
     {
         auto ret = Integer(this, allocator);
@@ -1033,8 +1023,8 @@ struct Integer
         return this;
     }
 
-    //
+    ///
-    nothrow @safe @nogc unittest
+    @nogc nothrow pure @safe unittest
     {
         auto h1 = Integer(79);
         Integer h2;
@@ -1050,10 +1040,10 @@ struct Integer
         assert(h1 == 79);
 
         h2 = ~h1;
-        assert(h2 == ~cast(ubyte) 79);
+        assert(h2 == cast(ubyte) ~79);
     }
 
-    /// Ditto.
+    /// ditto
     ref Integer opUnary(string op : "++")()
     {
         if (this.sign)
@@ -1067,7 +1057,7 @@ struct Integer
         return this;
     }
 
-    /// Ditto.
+    /// ditto
     ref Integer opUnary(string op : "--")()
     {
         if (this.size == 0)
@@ -1087,7 +1077,7 @@ struct Integer
     }
 
     ///
-    nothrow @safe @nogc unittest
+    @nogc nothrow pure @safe unittest
     {
         Integer integer;
 
@@ -1132,32 +1122,28 @@ struct Integer
      * Returns: Result.
      */
     Integer opBinary(string op)(auto ref const Integer operand) const
-        if ((op == "+" || op == "-") || (op == "*"))
+    if ((op == "+" || op == "-") || (op == "*"))
     {
         mixin("return Integer(this, allocator) " ~ op ~ "= operand;");
     }
 
-    /// Ditto.
+    /// ditto
     Integer opBinary(string op)(const auto ref Integer operand) const
-        if (op == "/" || op == "%")
+    if (op == "/" || op == "%")
-    in
+    in (operand.length > 0, "Division by zero")
-    {
-        assert(operand.length > 0, "Division by zero.");
-    }
-    body
     {
         mixin("return Integer(this, allocator) " ~ op ~ "= operand;");
     }
 
-    /// Ditto.
+    /// ditto
     Integer opBinary(string op)(const size_t operand) const
-        if (op == "<<" || op == ">>")
+    if (op == "<<" || op == ">>")
     {
         mixin("return Integer(this, allocator) " ~ op ~ "= operand;");
     }
 
     // Shift right a certain amount of digits.
-    private void shiftRight(const size_t operand) nothrow @safe @nogc
+    private void shiftRight(const size_t operand) @nogc nothrow pure @safe
     {
         if (operand == 0)
         {
@@ -1176,7 +1162,7 @@ struct Integer
     }
 
     // Shift left a certain amount of digits.
-    private void shiftLeft(const size_t operand) nothrow @safe @nogc
+    private void shiftLeft(const size_t operand) @nogc nothrow pure @safe
     {
         if (operand == 0)
         {
@@ -1198,7 +1184,7 @@ struct Integer
     }
 
     private void multiply(const digit factor, ref Integer product)
-    const nothrow @safe @nogc
+    const @nogc nothrow pure @safe
     {
         product.grow(this.size + 1);
         product.sign = this.sign;
@@ -1224,7 +1210,7 @@ struct Integer
 
     private void multiply(ref const Integer factor,
                           ref Integer product,
-                          const size_t digits) const nothrow @safe @nogc
+                          const size_t digits) const @nogc nothrow pure @safe
     {
         Integer intermediate;
         intermediate.grow(digits);
@@ -1232,7 +1218,7 @@ struct Integer
 
         for (size_t i; i < this.size; ++i)
         {
-            const limit = min(factor.size, digits - i);
+            const limit = min(cast(size_t) factor.size, digits - i);
             word carry;
             auto k = i;
 
@@ -1255,16 +1241,11 @@ struct Integer
 
     private void divide(Q, ARGS...)(ref const Integer divisor,
                                     auto ref Q quotient,
-                                    ref ARGS args)
+                                    ref ARGS args) const
-    const nothrow @safe @nogc
+    if ((is(Q : typeof(null))
-        if ((is(Q : typeof(null))
+     || (is(Q : Integer) && __traits(isRef, quotient)))
-         || (is(Q : Integer) && __traits(isRef, quotient)))
+     && (ARGS.length == 0 || (ARGS.length == 1 && is(ARGS[0] : Integer))))
-         && (ARGS.length == 0 || (ARGS.length == 1 && is(ARGS[0] : Integer))))
+    in (divisor != 0, "Division by zero")
-    in
-    {
-        assert(divisor != 0, "Division by zero.");
-    }
-    body
     {
         if (compare(divisor) < 0)
         {
@@ -1389,7 +1370,7 @@ struct Integer
         }
     }
 
-    private Integer square() nothrow @safe @nogc
+    private Integer square() @nogc nothrow pure @safe
     {
         Integer result;
         const resultSize = 2 * this.size + 1;
@@ -1429,7 +1410,7 @@ struct Integer
     }
 
     // Returns 2^^n.
-    private Integer exp2(size_t n) const nothrow @safe @nogc
+    private Integer exp2(size_t n) const @nogc nothrow pure @safe
     {
         auto ret = Integer(allocator);
         const bytes = n / digitBitCount;
@@ -1444,12 +1425,12 @@ struct Integer
     /**
      * Returns: Two's complement representation of the integer.
      */
-    Array!ubyte toArray() const nothrow @safe @nogc
+    Array!ubyte toArray() const @nogc nothrow pure @safe
     out (array)
     {
         assert(array.length == length);
     }
-    body
+    do
     {
         Array!ubyte array;
 
@@ -1484,58 +1465,22 @@ struct Integer
             tmp = this;
         }
 
-        do
+        array.length = length;
+        for (size_t i = array.length - 1; tmp != 0; tmp >>= 8, --i)
         {
-            array.insertBack(cast(ubyte) (tmp.rep[0] & 0xff));
+            array[i] = (cast(ubyte) (tmp.rep[0] & 0xff));
-            tmp >>= 8;
         }
-        while (tmp != 0);
-
-        array[].reverse();
 
         return array;
     }
 
     ///
-    nothrow @safe @nogc unittest
+    @nogc nothrow pure @safe unittest
     {
         {
             auto integer = Integer(0x66778899aabbddee);
             ubyte[8] expected = [ 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xdd, 0xee ];
 
-            auto array = integer.toArray();
-            assert(equal(array[], expected[]));
-        }
-        {
-            auto integer = Integer(0x03);
-            ubyte[1] expected = [ 0x03 ];
-
-            auto array = integer.toArray();
-            assert(equal(array[], expected[]));
-        }
-        {
-            ubyte[63] expected = [
-                0x02, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
-                0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
-                0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
-                0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
-                0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
-                0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
-                0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38,
-                0x39, 0x3a, 0x3b, 0x00, 0x61, 0x62, 0x63,
-            ];
-            auto integer = Integer(Sign.positive, expected[]);
-
-            auto array = integer.toArray();
-            assert(equal(array[], expected[]));
-        }
-        {
-            ubyte[14] expected = [
-                0x22, 0x33, 0x44, 0x55, 0x05, 0x06, 0x07,
-                0x08, 0x3a, 0x3b, 0x00, 0x61, 0x62, 0x63,
-            ];
-            auto integer = Integer(Sign.positive, expected[]);
-
             auto array = integer.toArray();
             assert(equal(array[], expected[]));
         }

source/tanya/math/nbtheory.d

@@ -0,0 +1,167 @@
+/* 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/. */
+
+/**
+ * Number theory.
+ *
+ * Copyright: Eugene Wissner 2017-2019.
+ * 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/nbtheory.d,
+ *                 tanya/math/nbtheory.d)
+ */
+module tanya.math.nbtheory;
+
+import tanya.math.mp;
+import tanya.meta.trait;
+import tanya.meta.transform;
+
+version (TanyaNative)
+{
+    private extern float fabs(float) @nogc nothrow pure @safe;
+    private extern double fabs(double) @nogc nothrow pure @safe;
+    private extern real fabs(real) @nogc nothrow pure @safe;
+
+    private extern double log(double) @nogc nothrow pure @safe;
+    private extern float logf(float) @nogc nothrow pure @safe;
+    private extern real logl(real) @nogc nothrow pure @safe;
+}
+else
+{
+    import core.math : fabs;
+    import std.math : log;
+}
+
+/**
+ * Calculates the absolute value of a number.
+ *
+ * Params:
+ *  T = Argument type.
+ *  x = Argument.
+ *
+ * Returns: Absolute value of $(D_PARAM x).
+ */
+Unqual!T abs(T)(T x)
+if (isIntegral!T)
+{
+    static if (isSigned!T)
+    {
+        return x >= 0 ? x : -x;
+    }
+    else
+    {
+        return x;
+    }
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    int i = -1;
+    assert(i.abs == 1);
+    static assert(is(typeof(i.abs) == int));
+
+    uint u = 1;
+    assert(u.abs == 1);
+    static assert(is(typeof(u.abs) == uint));
+}
+
+/// ditto
+Unqual!T abs(T)(T x)
+if (isFloatingPoint!T)
+{
+    return fabs(x);
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    float f = -1.64;
+    assert(f.abs == 1.64F);
+    static assert(is(typeof(f.abs) == float));
+
+    double d = -1.64;
+    assert(d.abs == 1.64);
+    static assert(is(typeof(d.abs) == double));
+
+    real r = -1.64;
+    assert(r.abs == 1.64L);
+    static assert(is(typeof(r.abs) == real));
+}
+
+/// ditto
+T abs(T : Integer)(const auto ref T x)
+{
+    auto result = Integer(x, x.allocator);
+    result.sign = Sign.positive;
+    return result;
+}
+
+/// ditto
+T abs(T : Integer)(T x)
+{
+    x.sign = Sign.positive;
+    return x;
+}
+
+version (D_Ddoc)
+{
+    /**
+     * Calculates natural logarithm of $(D_PARAM x).
+     *
+     * Params:
+     *  T = Argument type.
+     *  x = Argument.
+     *
+     * Returns: Natural logarithm of $(D_PARAM x).
+     */
+    Unqual!T ln(T)(T x)
+    if (isFloatingPoint!T);
+}
+else version (TanyaNative)
+{
+    Unqual!T ln(T)(T x) @nogc nothrow pure @safe
+    if (isFloatingPoint!T)
+    {
+        static if (is(Unqual!T == float))
+        {
+            return logf(x);
+        }
+        else static if (is(Unqual!T == double))
+        {
+            return log(x);
+        }
+        else
+        {
+            return logl(x);
+        }
+    }
+}
+else
+{
+    Unqual!T ln(T)(T x)
+    if (isFloatingPoint!T)
+    {
+        return log(x);
+    }
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    import tanya.math;
+
+    assert(isNaN(ln(-7.389f)));
+    assert(isNaN(ln(-7.389)));
+    assert(isNaN(ln(-7.389L)));
+
+    assert(isInfinity(ln(0.0f)));
+    assert(isInfinity(ln(0.0)));
+    assert(isInfinity(ln(0.0L)));
+
+    assert(ln(1.0f) == 0.0f);
+    assert(ln(1.0) == 0.0);
+    assert(ln(1.0L) == 0.0L);
+}

source/tanya/math/package.d

@@ -3,20 +3,546 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /**
- * Copyright: Eugene Wissner 2016-2017.
+ * 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-2019.
  * 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)
  */
 module tanya.math;
 
-import std.traits;
+import tanya.math.mp;
-public import tanya.math.mp;
+import tanya.math.nbtheory;
-public import tanya.math.random;
+import tanya.meta.trait;
+import tanya.meta.transform;
 
-version (unittest)
+/// Floating-point number precisions according to IEEE-754.
+enum IEEEPrecision : ubyte
 {
-    import std.algorithm.iteration;
+    single = 4, /// Single precision: 64-bit.
+    double_ = 8, /// Single precision: 64-bit.
+    doubleExtended = 10, /// Double extended precision: 80-bit.
+}
+
+/**
+ * Tests the precision of floating-point type $(D_PARAM F).
+ *
+ * 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).
+ *
+ * Params:
+ *  F = Type to be tested.
+ *
+ * Returns: Precision according to IEEE-754.
+ *
+ * See_Also: $(D_PSYMBOL IEEEPrecision).
+ */
+template ieeePrecision(F)
+if (isFloatingPoint!F)
+{
+    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");
+    }
+}
+
+///
+@nogc nothrow pure @safe 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;
+}
+
+///
+@nogc nothrow pure @safe 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);
+}
+
+/**
+ * Determines whether $(D_PARAM x) is a finite number.
+ *
+ * Params:
+ *  F = Type of the floating point number.
+ *  x = Floating point number.
+ *
+ * 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,
+ *          $(D_KEYWORD false) otherwise.
+ */
+bool isNaN(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)
+    {
+        const maskedMantissa = bits.mantissa & bits.mantissaMask;
+        if ((bits.exp == bits.expMask && maskedMantissa != 0)
+         || ((bits.exp != 0) && (bits.mantissa < (1L << 63))))
+        {
+            return true;
+        }
+        return false;
+    }
+}
+
+///
+@nogc nothrow pure @safe 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));
 }
 
 /**
@@ -39,12 +565,8 @@ version (unittest)
  * Precondition: $(D_INLINECODE z > 0)
  */
 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)
+if (isIntegral!I && isIntegral!G && isIntegral!H)
-in
+in (z > 0, "Division by zero")
-{
-    assert(z > 0, "Division by zero.");
-}
-body
 {
     G mask = G.max / 2 + 1;
     H result;
@@ -78,19 +600,14 @@ body
     return result;
 }
 
-/// Ditto.
+/// ditto
 I pow(I)(const auto ref I x, const auto ref I y, const auto ref I z)
-    if (is(I == Integer))
+if (is(I == Integer))
-in
+in (z.length > 0, "Division by zero")
-{
-    assert(z.length > 0, "Division by zero.");
-}
-body
 {
     size_t i;
     auto tmp1 = Integer(x, x.allocator);
     auto result = Integer(x.allocator);
-    bool firstBit;
 
     if (x.size == 0 && y.size != 0)
     {
@@ -119,7 +636,7 @@ body
 }
 
 ///
-pure nothrow @safe @nogc unittest
+@nogc nothrow pure @safe unittest
 {
     assert(pow(3, 5, 7) == 5);
     assert(pow(2, 2, 1) == 0);
@@ -133,7 +650,7 @@ pure nothrow @safe @nogc unittest
 }
 
 ///
-unittest
+@nogc nothrow pure @safe unittest
 {
     assert(pow(Integer(3), Integer(5), Integer(7)) == 5);
     assert(pow(Integer(2), Integer(2), Integer(1)) == 0);
@@ -155,47 +672,16 @@ unittest
  * Returns: $(D_KEYWORD true) if $(D_PARAM x) is a prime number,
  *          $(D_KEYWORD false) otherwise.
  */
-bool isPseudoprime(ulong x) nothrow pure @safe @nogc
+bool isPseudoprime(ulong x) @nogc nothrow pure @safe
 {
     return pow(2, x - 1, x) == 1;
 }
 
 ///
-unittest
+@nogc nothrow pure @safe unittest
 {
-    uint[30] known = [74623, 74653, 74687, 74699, 74707, 74713, 74717, 74719,
+    assert(74623.isPseudoprime);
-                      74843, 74747, 74759, 74761, 74771, 74779, 74797, 74821,
+    assert(104729.isPseudoprime);
-                      74827, 9973, 104729, 15485867, 49979693, 104395303,
+    assert(15485867.isPseudoprime);
-                      593441861, 104729, 15485867, 49979693, 104395303,
+    assert(!15485868.isPseudoprime);
-                      593441861, 899809363, 982451653];
-
-    known.each!((ref x) => assert(isPseudoprime(x)));
-}
-
-/**
- * Params:
- *  I = Value type.
- *  x = Value.
- *
- * Returns: The absolute value of a number.
- */
-I abs(I : Integer)(const auto ref I x)
-{
-    auto result = Integer(x, x.allocator);
-    result.sign = Sign.positive;
-    return result;
-}
-
-/// Ditto.
-I abs(I : Integer)(I x)
-{
-    x.sign = Sign.positive;
-    return x;
-}
-
-/// Ditto.
-I abs(I)(const I x)
-    if (isIntegral!I)
-{
-    return x >= 0 ? x : -x;
 }

source/tanya/math/random.d

@@ -5,19 +5,17 @@
 /**
  * Random number generator.
  *
- * Copyright: Eugene Wissner 2016.
+ * Copyright: Eugene Wissner 2016-2019.
  * 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)
  */
 module tanya.math.random;
 
-import std.digest.sha;
+import tanya.memory.allocator;
-import std.typecons;
+import tanya.typecons;
-import tanya.memory;
-
-/// Block size of entropy accumulator (SHA-512).
-enum blockSize = 64;
 
 /// Maximum amount gathered from the entropy sources.
 enum maxGather = 128;
@@ -37,7 +35,7 @@ class EntropyException : Exception
     this(string msg,
          string file = __FILE__,
          size_t line = __LINE__,
-         Throwable next = null) pure @safe nothrow const @nogc
+         Throwable next = null) const @nogc nothrow pure @safe
     {
         super(msg, file, line, next);
     }
@@ -54,17 +52,17 @@ abstract class EntropySource
     /**
      * Returns: Minimum bytes required from the entropy source.
      */
-    @property immutable(ubyte) threshold() const @safe pure nothrow;
+    @property ubyte threshold() const @nogc nothrow pure @safe;
 
     /**
      * Returns: Whether this entropy source is strong.
      */
-    @property immutable(bool) strong() const @safe pure nothrow;
+    @property bool strong() const @nogc nothrow pure @safe;
 
     /**
      * Returns: Amount of already generated entropy.
      */
-    @property ushort size() const @safe pure nothrow
+    @property ushort size() const @nogc nothrow pure @safe
     {
         return size_;
     }
@@ -74,7 +72,7 @@ abstract class EntropySource
      *  size = Amount of already generated entropy. Cannot be smaller than the
      *         already set value.
      */
-    @property void size(ushort size) @safe pure nothrow
+    @property void size(ushort size) @nogc nothrow pure @safe
     {
         size_ = size;
     }
@@ -87,14 +85,40 @@ abstract class EntropySource
      *           to fill the buffer).
      *
      * Returns: Number of bytes that were copied to the $(D_PARAM output)
-     *          or $(D_PSYMBOL Nullable!ubyte.init) on error.
+     *          or nothing on error.
+     *
+     * Postcondition: Returned length is less than or equal to
+     *                $(D_PARAM output) length.
      */
-    Nullable!ubyte poll(out ubyte[maxGather] output);
+    Option!ubyte poll(out ubyte[maxGather] output) @nogc
+    out (length; length.isNothing || length.get <= maxGather);
+}
+
+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;
 }
 
 version (linux)
 {
-    extern (C) long syscall(long number, ...) nothrow;
+    import core.stdc.config : c_long;
+    private extern(C) c_long syscall(c_long number, ...) @nogc nothrow @system;
 
     /**
      * Uses getrandom system call.
@@ -104,7 +128,7 @@ version (linux)
         /**
          * Returns: Minimum bytes required from the entropy source.
          */
-        override @property immutable(ubyte) threshold() const @safe pure nothrow
+        override @property ubyte threshold() const @nogc nothrow pure @safe
         {
             return 32;
         }
@@ -112,7 +136,7 @@ version (linux)
         /**
          * Returns: Whether this entropy source is strong.
          */
-        override @property immutable(bool) strong() const @safe pure nothrow
+        override @property bool strong() const @nogc nothrow pure @safe
         {
             return true;
         }
@@ -125,18 +149,14 @@ version (linux)
          *           to fill the buffer).
          *
          * Returns: Number of bytes that were copied to the $(D_PARAM output)
-         *          or $(D_PSYMBOL Nullable!ubyte.init) on error.
+         *          or nothing on error.
          */
-        override Nullable!ubyte poll(out ubyte[maxGather] output) nothrow
+        override Option!ubyte poll(out ubyte[maxGather] output) @nogc 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);
+            import mir.linux._asm.unistd : NR_getrandom;
-            Nullable!ubyte ret;
+            auto length = syscall(NR_getrandom, output.ptr, output.length, 0);
+            Option!ubyte ret;
 
             if (length >= 0)
             {
@@ -146,175 +166,161 @@ version (linux)
         }
     }
 }
-
+else version (SecureARC4Random)
-/**
- * Pseudorandom number generator.
- * ---
- * auto entropy = defaultAllocator.make!Entropy();
- *
- * ubyte[blockSize] output;
- *
- * output = entropy.random;
- *
- * defaultAllocator.dispose(entropy);
- * ---
- */
-class Entropy
 {
-    /// Entropy sources.
+    private extern(C) void arc4random_buf(scope void* buf, size_t nbytes)
-    protected EntropySource[] sources;
+    @nogc nothrow @system;
-
-    private ubyte sourceCount_;
-
-    private shared Allocator allocator;
-
-    /// Entropy accumulator.
-    protected SHA!(maxGather * 8, 512) accumulator;
 
     /**
-     * Params:
+     * Uses arc4random_buf.
-     *  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)
+    class PlatformEntropySource : EntropySource
-    in
     {
-        assert(maxSources > 0 && maxSources <= ubyte.max);
+        /**
-        assert(allocator !is null);
+         * Returns: Minimum bytes required from the entropy source.
-    }
+         */
-    body
+        override @property ubyte threshold() const @nogc nothrow pure @safe
-    {
-        allocator.resize(sources, maxSources);
-
-        version (linux)
         {
-            this ~= allocator.make!PlatformEntropySource;
+            return 32;
-        }
-    }
-
-    /**
-     * 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();
+        /**
-
+         * Returns: Whether this entropy source is strong.
-        // Reset accumulator and counters and recycle existing entropy
+         */
-        accumulator.start();
+        override @property bool strong() const @nogc nothrow pure @safe
-
-        // Perform second SHA-512 on entropy
-        output = sha512Of(output);
-
-        for (ubyte i = 0; i < sourceCount; ++i)
         {
-            sources[i].size = 0;
+            return true;
-        }
-        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;
+         * Poll the entropy source.
-
+         *
-        accumulator.put(header);
+         * Params:
-        accumulator.put(data[0..length]);
+         *  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 Option!ubyte poll(out ubyte[maxGather] output)
+        @nogc nothrow @safe
+        {
+            (() @trusted => arc4random_buf(output.ptr, output.length))();
+            return Option!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 Option!ubyte poll(out ubyte[maxGather] output)
+        @nogc nothrow @safe
+        {
+            Option!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;
+        }
     }
 }

source/tanya/memory/allocator.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/. */
-
-/**
- * Copyright: Eugene Wissner 2016-2017.
- * 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;
-
-    /**
-     * 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, in size_t size) shared nothrow @nogc;
-}

source/tanya/memory/package.d

@@ -1,309 +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/. */
-
-/**
- * Copyright: Eugene Wissner 2016-2017.
- * 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;
-import std.algorithm.iteration;
-public import std.experimental.allocator : make;
-import std.traits;
-public import tanya.memory.allocator;
-
-/**
- * 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)
-    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_;
-    }
-}
-
-// 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
-out (allocator)
-{
-    assert(allocator !is null);
-}
-body
-{
-    return allocator;
-}
-
-@property void defaultAllocator(shared(Allocator) allocator) nothrow @safe @nogc
-in
-{
-    assert(allocator !is null);
-}
-body
-{
-    .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(const size_t size, const 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
- * 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
-        {
-            onOutOfMemoryErrorNoGC();
-        }
-    }
-
-    void[] buf = array;
-    if (!allocator.reallocate(buf, length * T.sizeof))
-    {
-        onOutOfMemoryErrorNoGC();
-    }
-    // Casting from void[] is unsafe, but we know we cast to the original type.
-    array = cast(T[]) buf;
-
-    return array;
-}
-
-private 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);
-}
-
-/*
- * Destroys the object.
- * Returns the memory should be freed.
- */
-package(tanya) void[] finalize(T)(ref T* p)
-{
-    static if (hasElaborateDestructor!T)
-    {
-        destroy(*p);
-    }
-    return (cast(void*) p)[0 .. T.sizeof];
-}
-
-package(tanya) void[] finalize(T)(ref T p)
-    if (is(T == class) || is(T == interface))
-{
-    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)
-        {
-            (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);
-    }
-    return support;
-}
-
-package(tanya) void[] finalize(T)(ref T[] p)
-{
-    static if (hasElaborateDestructor!(typeof(p[0])))
-    {
-        p.each!((ref e) => destroy(e));
-    }
-    return p;
-}
-
-/**
- * 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;
-}
-
-private unittest
-{
-    struct S
-    {
-        ~this()
-        {
-        }
-    }
-    auto p = cast(S[]) defaultAllocator.allocate(S.sizeof);
-
-    defaultAllocator.dispose(p);
-}

source/tanya/net/iface.d

@@ -0,0 +1,210 @@
+/* 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-2019.
+ * 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 (TanyaNative)
+{
+    import mir.linux._asm.unistd;
+    import tanya.sys.linux.syscall;
+    import tanya.sys.posix.ioctl;
+    import tanya.sys.posix.net.if_;
+    import tanya.sys.posix.socket;
+}
+else version (Windows)
+{
+    import tanya.sys.windows.ifdef;
+    import tanya.sys.windows.iphlpapi;
+}
+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 (TanyaNative)
+    {
+        if (name.length >= IF_NAMESIZE)
+        {
+            return 0;
+        }
+        ifreq ifreq_ = void;
+
+        copy(name, ifreq_.ifr_name[]);
+        ifreq_.ifr_name[name.length] = '\0';
+
+        auto socket = syscall(AF_INET,
+                              SOCK_DGRAM | SOCK_CLOEXEC,
+                              0,
+                              NR_socket);
+        if (socket <= 0)
+        {
+            return 0;
+        }
+        scope (exit)
+        {
+            syscall(socket, NR_close);
+        }
+        if (syscall(socket,
+                    SIOCGIFINDEX,
+                    cast(ptrdiff_t) &ifreq_,
+                    NR_ioctl) == 0)
+        {
+            return ifreq_.ifr_ifindex;
+        }
+        return 0;
+    }
+    else 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 (TanyaNative)
+    {
+        ifreq ifreq_ = void;
+        ifreq_.ifr_ifindex = index;
+
+        auto socket = syscall(AF_INET,
+                              SOCK_DGRAM | SOCK_CLOEXEC,
+                              0,
+                              NR_socket);
+        if (socket <= 0)
+        {
+            return String();
+        }
+        scope (exit)
+        {
+            syscall(socket, NR_close);
+        }
+        if (syscall(socket,
+                    SIOCGIFNAME,
+                    cast(ptrdiff_t) &ifreq_,
+                    NR_ioctl) == 0)
+        {
+            return String(findNullTerminated(ifreq_.ifr_name));
+        }
+        return String();
+    }
+    else 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));
+    }
+}

source/tanya/net/inet.d

@@ -0,0 +1,216 @@
+/* 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-2019.
+ * 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 (value <= (2 ^^ (L * 8)) - 1)
+    {
+        this.value = value & StorageType.max;
+    }
+
+    /**
+     * Returns: LSB.
+     *
+     * Precondition: $(D_INLINECODE length > 0).
+     */
+    @property ubyte back() const
+    in (this.length > 0)
+    {
+        return this.value & 0xff;
+    }
+
+    /**
+     * Returns: MSB.
+     *
+     * Precondition: $(D_INLINECODE length > 0).
+     */
+    @property ubyte front() const
+    in (this.length > 0)
+    {
+        return (this.value >> ((this.length - 1) * 8)) & 0xff;
+    }
+
+    /**
+     * Eliminates the LSB.
+     *
+     * Precondition: $(D_INLINECODE length > 0).
+     */
+    void popBack()
+    in (this.length > 0)
+    {
+        this.value >>= 8;
+        --this.size;
+    }
+
+    /**
+     * Eliminates the MSB.
+     *
+     * Precondition: $(D_INLINECODE length > 0).
+     */
+    void popFront()
+    in (this.length > 0)
+    {
+        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

@@ -0,0 +1,20 @@
+/* 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-2019.
+ * 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

@@ -0,0 +1,411 @@
+/* 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-2019.
+ * 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 tanya.conv;
+import tanya.encoding.ascii;
+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/network/inet.d

@@ -1,356 +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-2017.
- * 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.network.inet;
-
-import std.math;
-import std.range.primitives;
-import std.traits;
-
-version (unittest)
-{
-    version (Windows)
-    {
-        import core.sys.windows.winsock2;
-        version = PlattformUnittest;
-    }
-    else version (Posix)
-    {
-        import core.sys.posix.arpa.inet;
-        version = PlattformUnittest;
-    }
-}
-
-/**
- * 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;
-
-    const pure nothrow @safe @nogc 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 ^^ (length * 8) - 1).
-     */
-    this(T)(const T value)
-        if (isUnsigned!T)
-    in
-    {
-        assert(value <= pow(2, L * 8) - 1);
-    }
-    body
-    {
-        this.value = value & StorageType.max;
-    }
-
-    /**
-     * Returns: LSB.
-     *
-     * Precondition: $(D_INLINECODE length > 0).
-     */
-    @property ubyte back() const
-    in
-    {
-        assert(this.length > 0);
-    }
-    body
-    {
-        return this.value & 0xff;
-    }
-
-    /**
-     * Returns: MSB.
-     *
-     * Precondition: $(D_INLINECODE length > 0).
-     */
-    @property ubyte front() const
-    in
-    {
-        assert(this.length > 0);
-    }
-    body
-    {
-        return (this.value >> ((this.length - 1) * 8)) & 0xff;
-    }
-
-    /**
-     * Eliminates the LSB.
-     *
-     * Precondition: $(D_INLINECODE length > 0).
-     */
-    void popBack()
-    in
-    {
-        assert(this.length > 0);
-    }
-    body
-    {
-        this.value >>= 8;
-        --this.size;
-    }
-
-    /**
-     * Eliminates the MSB.
-     *
-     * Precondition: $(D_INLINECODE length > 0).
-     */
-    void popFront()
-    in
-    {
-        assert(this.length > 0);
-    }
-    body
-    {
-        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;
-    }
-}
-
-///
-pure nothrow @safe @nogc 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);
-}
-
-// Static.
-private unittest
-{
-    static assert(isBidirectionalRange!(NetworkOrder!4));
-    static assert(isBidirectionalRange!(NetworkOrder!8));
-    static assert(!is(NetworkOrder!9));
-    static assert(!is(NetworkOrder!1));
-}
-
-// Tests against the system's htonl, htons.
-version (PlattformUnittest)
-{
-    private unittest
-    {
-        for (uint counter; counter <= 8 * uint.sizeof; ++counter)
-        {
-            const value = pow(2, counter) - 1;
-            const inNetworkOrder = htonl(value);
-            const p = cast(ubyte*) &inNetworkOrder;
-            auto networkOrder = NetworkOrder!4(value);
-
-            assert(networkOrder.length == 4);
-            assert(!networkOrder.empty);
-            assert(networkOrder.front == *p);
-            assert(networkOrder.back == *(p + 3));
-
-            networkOrder.popBack();
-            assert(networkOrder.length == 3);
-            assert(networkOrder.front == *p);
-            assert(networkOrder.back == *(p + 2));
-
-            networkOrder.popFront();
-            assert(networkOrder.length == 2);
-            assert(networkOrder.front == *(p + 1));
-            assert(networkOrder.back == *(p + 2));
-
-            networkOrder.popFront();
-            assert(networkOrder.length == 1);
-            assert(networkOrder.front == *(p + 2));
-            assert(networkOrder.back == *(p + 2));
-
-            networkOrder.popBack();
-            assert(networkOrder.length == 0);
-            assert(networkOrder.empty);
-        }
-
-        for (ushort counter; counter <= 8 * ushort.sizeof; ++counter)
-        {
-            const value = cast(ushort) (pow(2, counter) - 1);
-            const inNetworkOrder = htons(value);
-            const p = cast(ubyte*) &inNetworkOrder;
-
-            auto networkOrder = NetworkOrder!2(value);
-
-            assert(networkOrder.length == 2);
-            assert(!networkOrder.empty);
-            assert(networkOrder.front == *p);
-            assert(networkOrder.back == *(p + 1));
-
-            networkOrder.popBack();
-            assert(networkOrder.length == 1);
-            assert(networkOrder.front == *p);
-            assert(networkOrder.back == *p);
-
-            networkOrder.popBack();
-            assert(networkOrder.length == 0);
-            assert(networkOrder.empty);
-
-            networkOrder = NetworkOrder!2(value);
-
-            networkOrder.popFront();
-            assert(networkOrder.length == 1);
-            assert(networkOrder.front == *(p + 1));
-            assert(networkOrder.back == *(p + 1));
-
-            networkOrder.popFront();
-            assert(networkOrder.length == 0);
-            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;
-}
-
-///
-pure nothrow @safe @nogc unittest
-{
-    const value = 0xae34e2u;
-    auto networkOrder = NetworkOrder!4(value);
-    assert(networkOrder.toHostOrder() == value);
-}
-
-// Tests against the system's htonl, htons.
-version (PlattformUnittest)
-{
-    private unittest
-    {
-        for (uint counter; counter <= 8 * uint.sizeof; ++counter)
-        {
-            const value = pow(2, counter) - 1;
-            const inNetworkOrder = htonl(value);
-            const p = cast(ubyte*) &inNetworkOrder;
-            auto networkOrder = NetworkOrder!4(value);
-
-            assert(p[0 .. uint.sizeof].toHostOrder() == value);
-        }
-        for (ushort counter; counter <= 8 * ushort.sizeof; ++counter)
-        {
-            const value = cast(ushort) (pow(2, counter) - 1);
-            const inNetworkOrder = htons(value);
-            const p = cast(ubyte*) &inNetworkOrder;
-            auto networkOrder = NetworkOrder!2(value);
-
-            assert(p[0 .. ushort.sizeof].toHostOrder() == value);
-        }
-    }
-}

source/tanya/network/package.d

@@ -5,13 +5,13 @@
 /**
  * Network programming.
  *
- * Copyright: Eugene Wissner 2016-2017.
+ * Copyright: Eugene Wissner 2016-2019.
  * 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/network/package.d,
+ *                 tanya/network/package.d)
  */
 module tanya.network;
 
-public import tanya.network.inet;
 public import tanya.network.socket;
-public import tanya.network.url;

source/tanya/range/adapter.d

@@ -0,0 +1,204 @@
+/* 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-2019.
+ * 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(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(ref Array data) @trusted
+        {
+            this.data = data[];
+        }
+
+        void opCall(T)(auto ref T data)
+        if (is(T : E))
+        in (!this.data.empty)
+        {
+            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

@@ -0,0 +1,204 @@
+/* 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-2019.
+ * 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 (array.length > 0)
+{
+    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 (array.length > 0)
+{
+    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)(scope ref inout(T)[] array)
+in (array.length > 0)
+{
+    array = array[1 .. $];
+}
+
+/// ditto
+void popBack(T)(scope ref inout(T)[] array)
+in (array.length > 0)
+{
+    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

@@ -0,0 +1,20 @@
+/* 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-2019.
+ * 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;

source/tanya/typecons.d

@@ -0,0 +1,701 @@
+/* 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 constructors.
+ *
+ * This module contains templates that allow to build new types from the
+ * available ones.
+ *
+ * Copyright: Eugene Wissner 2017-2019.
+ * 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/typecons.d,
+ *                 tanya/typecons.d)
+ */
+module tanya.typecons;
+
+import tanya.format;
+import tanya.memory.lifetime;
+import tanya.meta.metafunction;
+import tanya.meta.trait;
+
+/**
+ * $(D_PSYMBOL Tuple) can store two or more heterogeneous objects.
+ *
+ * The objects can by accessed by index as `obj[0]` and `obj[1]` or by optional
+ * names (e.g. `obj.first`).
+ *
+ * $(D_PARAM Specs) contains a list of object types and names. First
+ * comes the object type, then an optional string containing the name.
+ * If you want the object be accessible only by its index (`0` or `1`),
+ * just skip the name.
+ *
+ * Params:
+ *  Specs = Field types and names.
+ *
+ * See_Also: $(D_PSYMBOL tuple).
+ */
+template Tuple(Specs...)
+{
+    template parseSpecs(size_t fieldCount, Specs...)
+    {
+        static if (Specs.length == 0)
+        {
+            alias parseSpecs = AliasSeq!();
+        }
+        else static if (is(Specs[0]) && fieldCount < 2)
+        {
+            static if (is(typeof(Specs[1]) == string))
+            {
+                alias parseSpecs
+                    = AliasSeq!(Pack!(Specs[0], Specs[1]),
+                                parseSpecs!(fieldCount + 1, Specs[2 .. $]));
+            }
+            else
+            {
+                alias parseSpecs
+                    = AliasSeq!(Pack!(Specs[0]),
+                                parseSpecs!(fieldCount + 1, Specs[1 .. $]));
+            }
+        }
+        else
+        {
+            static assert(false, "Invalid argument: " ~ Specs[0].stringof);
+        }
+    }
+
+    alias ChooseType(alias T) = T.Seq[0];
+    alias ParsedSpecs = parseSpecs!(0, Specs);
+
+    static assert(ParsedSpecs.length > 1, "Invalid argument count");
+
+    private string formatAliases(size_t n, Specs...)()
+    {
+        static if (Specs.length == 0)
+        {
+            return "";
+        }
+        else
+        {
+            string fieldAlias;
+            static if (Specs[0].length == 2)
+            {
+                char[21] buffer;
+                fieldAlias = "alias " ~ Specs[0][1] ~ " = expand["
+                           ~ integral2String(n, buffer).idup ~ "];";
+            }
+            return fieldAlias ~ formatAliases!(n + 1, Specs[1 .. $])();
+        }
+    }
+
+    struct Tuple
+    {
+        /// Field types.
+        alias Types = Map!(ChooseType, ParsedSpecs);
+
+        // Create field aliases.
+        mixin(formatAliases!(0, ParsedSpecs[0 .. $])());
+
+        /// Represents the values of the $(D_PSYMBOL Tuple) as a list of values.
+        Types expand;
+
+        alias expand this;
+    }
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    auto pair = Tuple!(int, "first", string, "second")(1, "second");
+    assert(pair.first == 1);
+    assert(pair[0] == 1);
+    assert(pair.second == "second");
+    assert(pair[1] == "second");
+}
+
+/**
+ * Creates a new $(D_PSYMBOL Tuple).
+ *
+ * Params:
+ *  Names = Field names.
+ *
+ * See_Also: $(D_PSYMBOL Tuple).
+ */
+template tuple(Names...)
+{
+    /**
+     * Creates a new $(D_PSYMBOL Tuple).
+     *
+     * Params:
+     *  Args = Field types.
+     *  args = Field values.
+     *
+     * Returns: Newly created $(D_PSYMBOL Tuple).
+     */
+    auto tuple(Args...)(auto ref Args args)
+    if (Args.length >= Names.length && isTypeTuple!Args)
+    {
+        alias Zipped = ZipWith!(AliasSeq, Pack!Args, Pack!Names);
+        alias Nameless = Args[Names.length .. $];
+
+        return Tuple!(Zipped, Nameless)(forward!args);
+    }
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    auto t = tuple!("one", "two")(20, 5);
+    assert(t.one == 20);
+    assert(t.two == 5);
+}
+
+/**
+ * $(D_PSYMBOL Option) is a type that contains an optional value.
+ *
+ * Params:
+ *  T = Type of the encapsulated value.
+ *
+ * See_Also: $(D_PSYMBOL option).
+ */
+struct Option(T)
+{
+    private bool isNothing_ = true;
+    private T value = void;
+
+    /**
+     * Constructs a new option with $(D_PARAM value).
+     *
+     * Params:
+     *  value = Encapsulated value.
+     */
+    this()(ref T value)
+    {
+        this.value = value;
+        this.isNothing_ = false;
+    }
+
+    /// ditto
+    this()(T value) @trusted
+    {
+        moveEmplace(value, this.value);
+        this.isNothing_ = false;
+    }
+
+    /**
+     * Tells if the option is just a value or nothing.
+     *
+     * Returns: $(D_KEYWORD true) if this $(D_PSYMBOL Option) contains a nothing,
+     *          $(D_KEYWORD false) if it contains a value.
+     */
+    @property bool isNothing() const
+    {
+        return this.isNothing_;
+    }
+
+    /**
+     * Returns the encapsulated value.
+     *
+     * Returns: Value encapsulated in this $(D_PSYMBOL Option).
+     *
+     * See_Also: $(D_PSYMBOL or).
+     *
+     * Precondition: `!isNothing`.
+     */
+    @property ref inout(T) get() inout
+    in (!isNothing, "Option is nothing")
+    {
+        return this.value;
+    }
+
+    /// ditto
+    deprecated("Call Option.get explicitly instead of relying on alias this")
+    @property ref inout(T) get_() inout
+    in (!isNothing, "Option is nothing")
+    {
+        return this.value;
+    }
+
+    /**
+     * Returns the encapsulated value if available or a default value
+     * otherwise.
+     *
+     * Note that the contained value can be returned by reference only if the
+     * default value is passed by reference as well.
+     *
+     * Params:
+     *  U            = Type of the default value.
+     *  defaultValue = Default value.
+     *
+     * Returns: The value of this $(D_PSYMBOL Option) if available,
+     *          $(D_PARAM defaultValue) otherwise.
+     *
+     * See_Also: $(D_PSYMBOL isNothing), $(D_PSYMBOL get).
+     */
+    @property U or(U)(U defaultValue) inout
+    if (is(U == T) && isCopyable!T)
+    {
+        return isNothing ? defaultValue : this.value;
+    }
+
+    /// ditto
+    @property ref inout(T) or(ref inout(T) defaultValue) inout
+    {
+        return isNothing ? defaultValue : this.value;
+    }
+
+    /**
+     * Casts this $(D_PSYMBOL Option) to $(D_KEYWORD bool).
+     *
+     * An $(D_PSYMBOL Option) is $(D_KEYWORD true) if it contains a value,
+     * ($D_KEYWORD false) if it contains nothing.
+     *
+     * Returns: $(D_KEYWORD true) if this $(D_PSYMBOL Option) contains a value,
+     *          ($D_KEYWORD false) if it contains nothing.
+     */
+    bool opCast(U : bool)()
+    {
+        return !isNothing;
+    }
+
+    /**
+     * Compares this $(D_PSYMBOL Option) with $(D_PARAM that).
+     *
+     * If both objects are options of the same type and they don't contain a
+     * value, they are considered equal. If only one of them contains a value,
+     * they aren't equal. Otherwise, the encapsulated values are compared for
+     * equality.
+     *
+     * If $(D_PARAM U) is a type comparable with the type encapsulated by this
+     * $(D_PSYMBOL Option), the value of this $(D_PSYMBOL Option) is compared
+     * with $(D_PARAM that), this $(D_PSYMBOL Option) must have a value then.
+     *
+     * Params:
+     *  U    = Type of the object to compare with.
+     *  that = Object to compare with.
+     *
+     * Returns: $(D_KEYWORD true) if this $(D_PSYMBOL Option) and
+     *          $(D_PARAM that) are equal, $(D_KEYWORD false) if not.
+     *
+     * Precondition: `!isNothing` if $(D_PARAM U) is equality comparable with
+     *               $(D_PARAM T).
+     */
+    bool opEquals(U)(auto ref const U that) const
+    if (is(U == Option))
+    {
+        if (!isNothing && !that.isNothing)
+        {
+            return this.value == that.value;
+        }
+        return isNothing == that.isNothing;
+    }
+
+    /// ditto
+    bool opEquals(U)(auto ref const U that) const
+    if (ifTestable!(U, a => a == T.init) && !is(U == Option))
+    in (!isNothing)
+    {
+        return get == that;
+    }
+
+    /**
+     * Resets this $(D_PSYMBOL Option) and destroys the contained value.
+     *
+     * $(D_PSYMBOL reset) can be safely called on an $(D_PSYMBOL Option) that
+     * doesn't contain any value.
+     */
+    void reset()
+    {
+        static if (hasElaborateDestructor!T)
+        {
+            destroy(this.value);
+        }
+        this.isNothing_ = true;
+    }
+
+    /**
+     * Assigns a new value.
+     *
+     * Params:
+     *  U    = Type of the new value.
+     *  that = New value.
+     *
+     * Returns: $(D_KEYWORD this).
+     */
+    ref typeof(this) opAssign(U)(ref U that)
+    if (is(U : T) && !is(U == Option))
+    {
+        this.value = that;
+        this.isNothing_ = false;
+        return this;
+    }
+
+    /// ditto
+    ref typeof(this) opAssign(U)(U that)
+    if (is(U == T))
+    {
+        move(that, this.value);
+        this.isNothing_ = false;
+        return this;
+    }
+
+    /// ditto
+    ref typeof(this) opAssign(U)(ref U that)
+    if (is(U == Option))
+    {
+        if (that.isNothing)
+        {
+            reset();
+        }
+        else
+        {
+            this.value = that.get;
+            this.isNothing_ = false;
+        }
+        return this;
+    }
+
+    /// ditto
+    ref typeof(this) opAssign(U)(U that)
+    if (is(U == Option))
+    {
+        move(that.value, this.value);
+        this.isNothing_ = that.isNothing_;
+        return this;
+    }
+
+    version (D_Ddoc)
+    {
+        /**
+         * If $(D_PARAM T) has a `toHash()` method, $(D_PSYMBOL Option) defines
+         * `toHash()` which returns `T.toHash()` if it is set or 0 otherwise.
+         *
+         * Returns: Hash value.
+         */
+        size_t toHash() const;
+    }
+    else static if (is(typeof(T.init.toHash()) == size_t))
+    {
+        size_t toHash() const
+        {
+            return isNothing ? 0U : this.value.toHash();
+        }
+    }
+
+    alias get_ this;
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    Option!int option;
+    assert(option.isNothing);
+    assert(option.or(8) == 8);
+    
+    option = 5;
+    assert(!option.isNothing);
+    assert(option.get == 5);
+    assert(option.or(8) == 5);
+
+    option.reset();
+    assert(option.isNothing);
+}
+
+/**
+ * Creates a new $(D_PSYMBOL Option).
+ *
+ * Params:
+ *  T     = Option type.
+ *  value = Initial value.
+ *
+ * See_Also: $(D_PSYMBOL Option).
+ */
+Option!T option(T)(auto ref T value)
+{
+    return Option!T(forward!value);
+}
+
+/// ditto
+Option!T option(T)()
+{
+    return Option!T();
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    assert(option!int().isNothing);
+    assert(option(5) == 5);
+}
+
+/**
+ * Type that can hold one of the types listed as its template parameters.
+ *
+ * $(D_PSYMBOL Variant) is a type similar to $(D_KEYWORD union), but
+ * $(D_PSYMBOL Variant) keeps track of the actually used type and throws an
+ * assertion error when trying to access an invalid type at runtime.
+ *
+ * Params:
+ *  Specs = Types this $(D_SPYBMOL Variant) can hold.
+ */
+template Variant(Specs...)
+if (isTypeTuple!Specs && NoDuplicates!Specs.length == Specs.length)
+{
+    union AlignedUnion(Args...)
+    {
+        static if (Args.length > 0)
+        {
+            Args[0] value;
+        }
+        static if (Args.length > 1)
+        {
+            AlignedUnion!(Args[1 .. $]) rest;
+        }
+    }
+
+    private struct VariantAccessorInfo
+    {
+        string accessor;
+        ptrdiff_t tag;
+    }
+
+    template accessor(T, Union)
+    {
+        enum VariantAccessorInfo info = accessorImpl!(T, Union, 1);
+        enum accessor = VariantAccessorInfo("this.values" ~ info.accessor, info.tag);
+    }
+
+    template accessorImpl(T, Union, size_t tag)
+    {
+        static if (is(T == typeof(Union.value)))
+        {
+            enum accessorImpl = VariantAccessorInfo(".value", tag);
+        }
+        else
+        {
+            enum VariantAccessorInfo info = accessorImpl!(T, typeof(Union.rest), tag + 1);
+            enum accessorImpl = VariantAccessorInfo(".rest" ~ info.accessor, info.tag);
+        }
+    }
+
+    struct Variant
+    {
+        /// Types can be present in this $(D_PSYMBOL Variant).
+        alias Types = Specs;
+
+        private ptrdiff_t tag = -1;
+        private AlignedUnion!Types values;
+
+        /**
+         * Constructs this $(D_PSYMBOL Variant) with one of the types supported
+         * in it.
+         *
+         * Params:
+         *  T     = Type of the initial value.
+         *  value = Initial value.
+         */
+        this(T)(ref T value)
+        if (canFind!(T, Types))
+        {
+            copyAssign!T(value);
+        }
+
+        /// ditto
+        this(T)(T value)
+        if (canFind!(T, Types))
+        {
+            moveAssign!T(value);
+        }
+
+        ~this()
+        {
+            reset();
+        }
+
+        this(this)
+        {
+            alias pred(U) = hasElaborateCopyConstructor!(U.Seq[1]);
+            static foreach (Type; Filter!(pred, Enumerate!Types))
+            {
+                if (this.tag == Type.Seq[0])
+                {
+                    get!(Type.Seq[1]).__postblit();
+                }
+            }
+        }
+
+        /**
+         * Tells whether this $(D_PSYMBOL Variant) is initialized.
+         *
+         * Returns: $(D_KEYWORD true) if this $(D_PSYMBOL Variant) contains a
+         *          value, $(D_KEYWORD false) otherwise.
+         */
+        bool hasValue() const
+        {
+            return this.tag != -1;
+        }
+
+        /**
+         * Tells whether this $(D_PSYMBOL Variant) holds currently a value of
+         * type $(D_PARAM T).
+         *
+         * Params:
+         *  T = Examined type.
+         *
+         * Returns: $(D_KEYWORD true) if this $(D_PSYMBOL Variant) currently
+         *          contains a value of type $(D_PARAM T), $(D_KEYWORD false)
+         *          otherwise.
+         */
+        bool peek(T)() const
+        if (canFind!(T, Types))
+        {
+            return this.tag == staticIndexOf!(T, Types);
+        }
+
+        /**
+         * Returns the underlying value, assuming it is of the type $(D_PARAM T).
+         *
+         * Params:
+         *  T = Type of the value should be returned.
+         *
+         * Returns: The underyling value.
+         *
+         * Precondition: The $(D_PSYMBOL Variant) has a value.
+         *
+         * See_Also: $(D_PSYMBOL peek), $(D_PSYMBOL hasValue).
+         */
+        ref inout(T) get(T)() inout
+        if (canFind!(T, Types))
+        in (this.tag == staticIndexOf!(T, Types), "Variant isn't initialized")
+        {
+            mixin("return " ~ accessor!(T, AlignedUnion!Types).accessor ~ ";");
+        }
+
+        /**
+         * Reassigns the value.
+         *
+         * Params:
+         *  T    = Type of the new value
+         *  that = New value.
+         *
+         * Returns: $(D_KEYWORD this).
+         */
+        ref typeof(this) opAssign(T)(T that)
+        if (canFind!(T, Types))
+        {
+            reset();
+            return moveAssign!T(that);
+        }
+
+        /// ditto
+        ref typeof(this) opAssign(T)(ref T that)
+        if (canFind!(T, Types))
+        {
+            reset();
+            return copyAssign!T(that);
+        }
+
+        private ref typeof(this) moveAssign(T)(ref T that) @trusted
+        {
+            this.tag = staticIndexOf!(T, Types);
+
+            enum string accessorMixin = accessor!(T, AlignedUnion!Types).accessor;
+            moveEmplace(that, mixin(accessorMixin));
+
+            return this;
+        }
+
+        private ref typeof(this) copyAssign(T)(ref T that) return
+        {
+            this.tag = staticIndexOf!(T, Types);
+
+            enum string accessorMixin = accessor!(T, AlignedUnion!Types).accessor;
+            emplace!T((() @trusted => (&mixin(accessorMixin))[0 .. 1])(), that);
+
+            return this;
+        }
+
+        private void reset()
+        {
+            alias pred(U) = hasElaborateDestructor!(U.Seq[1]);
+            static foreach (Type; Filter!(pred, Enumerate!Types))
+            {
+                if (this.tag == Type.Seq[0])
+                {
+                    destroy(get!(Type.Seq[1]));
+                }
+            }
+        }
+
+        /**
+         * Returns $(D_PSYMBOL TypeInfo) corresponding to the current type.
+         *
+         * If this $(D_PSYMBOL Variant) isn't initialized, returns
+         * $(D_KEYWORD null).
+         *
+         * Returns: $(D_PSYMBOL TypeInfo) of the current type.
+         */
+        @property TypeInfo type()
+        {
+            static foreach (i, Type; Types)
+            {
+                if (this.tag == i)
+                {
+                    return typeid(Type);
+                }
+            }
+            return null;
+        }
+
+        /**
+         * Compares this $(D_PSYMBOL Variant) with another one with the same
+         * specification for equality.
+         *
+         * $(UL
+         *  $(LI If both hold values of the same type, these values are
+         *       compared.)
+         *  $(LI If they hold values of different types, then the
+         *       $(D_PSYMBOL Variant)s aren't equal.)
+         *  $(LI If only one of them is initialized but another one not, they
+         *       aren't equal.)
+         *  $(LI If neither of them is initialized, they are equal.)
+         * )
+         *
+         * Params:
+         *  that = The $(D_PSYMBOL Variant) to compare with.
+         *
+         * Returns: $(D_KEYWORD true) if this $(D_PSYMBOL Variant) is equal to
+         *          $(D_PARAM that), $(D_KEYWORD false) otherwise.
+         */
+        bool opEquals()(auto ref inout Variant that) inout
+        {
+            if (this.tag != that.tag)
+            {
+                return false;
+            }
+            static foreach (i, Type; Types)
+            {
+                if (this.tag == i)
+                {
+                    return get!Type == that.get!Type;
+                }
+            }
+            return true;
+        }
+    }
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    Variant!(int, double) variant = 5;
+    assert(variant.peek!int);
+    assert(variant.get!int == 5);
+
+    variant = 5.4;
+    assert(!variant.peek!int);
+    assert(variant.get!double == 5.4);
+}

sys/dub.json

@@ -0,0 +1,12 @@
+{
+	"name": "sys",
+	"description": "Low-level operating system bindings and definitions",
+	"targetType": "library",
+
+	"sourcePaths": [
+		"."
+	],
+	"importPaths": [
+		"."
+	]
+}

sys/tanya/sys/linux/syscall.d

@@ -0,0 +1,59 @@
+/* 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 2018-2019.
+ * 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.sys.linux.syscall;
+
+version (TanyaNative):
+
+extern ptrdiff_t syscall(ptrdiff_t, ptrdiff_t)
+@nogc nothrow @system;
+
+extern ptrdiff_t syscall(ptrdiff_t, ptrdiff_t, ptrdiff_t)
+@nogc nothrow @system;
+
+extern ptrdiff_t syscall(ptrdiff_t, ptrdiff_t, ptrdiff_t, ptrdiff_t)
+@nogc nothrow @system;
+
+extern ptrdiff_t syscall(ptrdiff_t,
+                         ptrdiff_t,
+                         ptrdiff_t,
+                         ptrdiff_t,
+                         ptrdiff_t,
+                         ptrdiff_t,
+                         ptrdiff_t) @nogc nothrow @system;
+
+// Same syscalls as above but pure.
+private template getOverloadMangling(size_t n)
+{
+    enum string getOverloadMangling = __traits(getOverloads,
+                                               tanya.sys.linux.syscall,
+                                               "syscall")[n].mangleof;
+}
+
+pragma(mangle, getOverloadMangling!0)
+extern ptrdiff_t syscall_(ptrdiff_t, ptrdiff_t)
+@nogc nothrow pure @system;
+
+pragma(mangle, getOverloadMangling!1)
+extern ptrdiff_t syscall_(ptrdiff_t, ptrdiff_t, ptrdiff_t)
+@nogc nothrow pure @system;
+
+pragma(mangle, getOverloadMangling!2)
+extern ptrdiff_t syscall_(ptrdiff_t, ptrdiff_t, ptrdiff_t, ptrdiff_t)
+@nogc nothrow pure @system;
+
+pragma(mangle, getOverloadMangling!3)
+extern ptrdiff_t syscall_(ptrdiff_t,
+                          ptrdiff_t,
+                          ptrdiff_t,
+                          ptrdiff_t,
+                          ptrdiff_t,
+                          ptrdiff_t,
+                          ptrdiff_t) @nogc nothrow pure @system;

sys/tanya/sys/posix/ioctl.d

@@ -0,0 +1,76 @@
+/* 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 2018-2019.
+ * 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.sys.posix.ioctl;
+
+version (TanyaNative):
+
+enum
+{
+    SIOCADDRT = 0x890B, // Add routing table entry.
+    SIOCDELRT = 0x890C, // Delete routing table entry.
+    SIOCRTMSG = 0x890D, // Call to routing system.
+
+    SIOCGIFNAME = 0x8910, // Get iface name.
+    SIOCSIFLINK = 0x8911, // Set iface channel.
+    SIOCGIFCONF = 0x8912, // Get iface list.
+    SIOCGIFFLAGS = 0x8913, // Get flags.
+    SIOCSIFFLAGS = 0x8914, // Set flags.
+    SIOCGIFADDR = 0x8915, // Get PA address.
+    SIOCSIFADDR = 0x8916, // Set PA address.
+    SIOCGIFDSTADDR = 0x8917, // Get remote PA address.
+    SIOCSIFDSTADDR = 0x8918, // Set remote PA address.
+    SIOCGIFBRDADDR = 0x8919, // Get broadcast PA address.
+    SIOCSIFBRDADDR = 0x891a, // Set broadcast PA address.
+    SIOCGIFNETMASK = 0x891b, // Get network PA mask.
+    SIOCSIFNETMASK = 0x891c, // Set network PA mask.
+    SIOCGIFMETRIC = 0x891d, // Get metric.
+    SIOCSIFMETRIC = 0x891e, // Set metric.
+    SIOCGIFMEM = 0x891f, // Get memory address (BSD).
+    SIOCSIFMEM = 0x8920, // Set memory address (BSD).
+    SIOCGIFMTU = 0x8921, // Get MTU size.
+    SIOCSIFMTU = 0x8922, // Set MTU size.
+    SIOCSIFNAME = 0x8923, // Set interface name.
+    SIOCSIFHWADDR = 0x8924, // Set hardware address.
+    SIOCGIFENCAP = 0x8925, // Get/set encapsulations.
+    SIOCSIFENCAP = 0x8926,
+    SIOCGIFHWADDR = 0x8927, // Get hardware address.
+    SIOCGIFSLAVE = 0x8929, // Driver slaving support.
+    SIOCSIFSLAVE = 0x8930,
+    SIOCADDMULTI = 0x8931, // Multicast address lists.
+    SIOCDELMULTI = 0x8932,
+    SIOCGIFINDEX = 0x8933, // Name -> if_index mapping.
+    SIOGIFINDEX = SIOCGIFINDEX, // Misprint compatibility.
+    SIOCSIFPFLAGS = 0x8934, // Set/get extended flags set.
+    SIOCGIFPFLAGS = 0x8935,
+    SIOCDIFADDR = 0x8936, // Delete PA address.
+    SIOCSIFHWBROADCAST = 0x8937, // Set hardware broadcast address.
+    SIOCGIFCOUNT = 0x8938, // Get number of devices.
+
+    SIOCGIFBR = 0x8940, // Bridging support.
+    SIOCSIFBR = 0x8941, // Set bridging options.
+
+    SIOCGIFTXQLEN = 0x8942, // Get the tx queue length.
+    SIOCSIFTXQLEN = 0x8943, // Set the tx queue length.
+
+    SIOCDARP = 0x8953, // Delete ARP table entry.
+    SIOCGARP = 0x8954, // Get ARP table entry.
+    SIOCSARP = 0x8955, // Set ARP table entry.
+
+    SIOCDRARP = 0x8960, // Delete RARP table entry.
+    SIOCGRARP = 0x8961, // Get RARP table entry.
+    SIOCSRARP = 0x8962, // Set RARP table entry.
+
+    SIOCGIFMAP = 0x8970, // Get device parameters.
+    SIOCSIFMAP = 0x8971, // Set device parameters.
+
+    SIOCADDDLCI = 0x8980, // Create new DLCI device.
+    SIOCDELDLCI = 0x8981, // Delete DLCI device.
+}

sys/tanya/sys/posix/mman.d

@@ -0,0 +1,29 @@
+/* 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 2018-2019.
+ * 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.sys.posix.mman;
+
+version (TanyaNative):
+
+enum
+{
+    PROT_EXEC = 0x4, // Page can be executed.
+    PROT_NONE = 0x0, // Page cannot be accessed.
+    PROT_READ = 0x1, // Page can be read.
+    PROT_WRITE = 0x2, // Page can be written.
+}
+
+enum
+{
+    MAP_FIXED = 0x10, // Interpret addr exactly.
+    MAP_PRIVATE = 0x02, // Changes are private.
+    MAP_SHARED = 0x01, // Share changes.
+    MAP_ANONYMOUS = 0x20, // Don't use a file.
+}

sys/tanya/sys/posix/net/if_.d

@@ -2,15 +2,24 @@
  * 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/. */
 
-/**
+/*
- * Single-dimensioned array.
+ * Copyright: Eugene Wissner 2018-2019.
- *
- * Copyright: Eugene Wissner 2016-2017.
  * 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)
  */
-deprecated("Use tanya.container.array instead.")
+module tanya.sys.posix.net.if_;
-module tanya.container.vector;
 
-public import tanya.container.array;
+version (TanyaNative):
+
+enum size_t IF_NAMESIZE = 16;
+
+struct ifreq
+{
+    char[IF_NAMESIZE] ifr_name;
+
+    union
+    {
+        int ifr_ifindex;
+    }
+}

sys/tanya/sys/posix/socket.d

@@ -0,0 +1,150 @@
+/* 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 2018-2019.
+ * 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.sys.posix.socket;
+
+version (TanyaNative):
+
+/*
+ * Protocol families.
+ */
+enum
+{
+    PF_UNSPEC = 0, // Unspecified.
+    PF_LOCAL = 1, // Local to host (pipes and file-domain).
+    PF_UNIX = PF_LOCAL, // POSIX name for PF_LOCAL.
+    PF_FILE = PF_LOCAL, // Another non-standard name for PF_LOCAL.
+    PF_INET = 2, // IP protocol family.
+    PF_AX25 = 3, // Amateur Radio AX.25.
+    PF_IPX = 4, // Novell Internet Protocol.
+    PF_APPLETALK = 5, // Appletalk DDP.
+    PF_NETROM = 6, // Amateur radio NetROM.
+    PF_BRIDGE = 7, // Multiprotocol bridge.
+    PF_ATMPVC = 8, // ATM PVCs.
+    PF_X25 = 9, // Reserved for X.25 project.
+    PF_INET6 = 10, // IP version 6.
+    PF_ROSE = 11, // Amateur Radio X.25 PLP.
+    PF_DECnet = 12, // Reserved for DECnet project.
+    PF_NETBEUI = 13, // Reserved for 802.2LLC project.
+    PF_SECURITY = 14, // Security callback pseudo AF.
+    PF_KEY = 15, // PF_KEY key management API.
+    PF_NETLINK = 16, // Kernel user interface device.
+    PF_ROUTE = PF_NETLINK, // Alias to emulate 4.4BSD.
+    PF_PACKET = 17, // Packet family.
+    PF_ASH = 18, // Ash.
+    PF_ECONET = 19, // Acorn Econet.
+    PF_ATMSVC = 20, // ATM SVCs.
+    PF_RDS = 21, // RDS sockets.
+    PF_SNA = 22, // Linux SNA Project.
+    PF_IRDA = 23, // IRDA sockets.
+    PF_PPPOX = 24, // PPPoX sockets.
+    PF_WANPIPE = 25, // Wanpipe API sockets.
+    PF_LLC = 26, // Linux LLC.
+    PF_IB = 27, // Native InfiniBand address.
+    PF_MPLS = 28, // MPLS.
+    PF_CAN = 29, // Controller Area Network.
+    PF_TIPC = 30, // TIPC sockets.
+    PF_BLUETOOTH = 31, // Bluetooth sockets.
+    PF_IUCV = 32, // IUCV sockets.
+    PF_RXRPC = 33, // RxRPC sockets.
+    PF_ISDN = 34, // mISDN sockets.
+    PF_PHONET = 35, // Phonet sockets.
+    PF_IEEE802154 = 36, // IEEE 802.15.4 sockets.
+    PF_CAIF = 37, // CAIF sockets.
+    PF_ALG = 38, // Algorithm sockets.
+    PF_NFC = 39, // NFC sockets.
+    PF_VSOCK = 40, // vSockets.
+    PF_MAX = 41, // For now.
+}
+
+/*
+ * Address families.
+ */
+enum
+{
+    AF_UNSPEC = PF_UNSPEC,
+    AF_LOCAL = PF_LOCAL,
+    AF_UNIX = PF_UNIX,
+    AF_FILE = PF_FILE,
+    AF_INET = PF_INET,
+    AF_AX25 = PF_AX25,
+    AF_IPX = PF_IPX,
+    AF_APPLETALK = PF_APPLETALK,
+    AF_NETROM = PF_NETROM,
+    AF_BRIDGE = PF_BRIDGE,
+    AF_ATMPVC = PF_ATMPVC,
+    AF_X25 = PF_X25,
+    AF_INET6 = PF_INET6,
+    AF_ROSE = PF_ROSE,
+    AF_DECnet = PF_DECnet,
+    AF_NETBEUI = PF_NETBEUI,
+    AF_SECURITY = PF_SECURITY,
+    AF_KEY = PF_KEY,
+    AF_NETLINK = PF_NETLINK,
+    AF_ROUTE = PF_ROUTE,
+    AF_PACKET = PF_PACKET,
+    AF_ASH = PF_ASH,
+    AF_ECONET = PF_ECONET,
+    AF_ATMSVC = PF_ATMSVC,
+    AF_RDS = PF_RDS,
+    AF_SNA = PF_SNA,
+    AF_IRDA = PF_IRDA,
+    AF_PPPOX = PF_PPPOX,
+    AF_WANPIPE = PF_WANPIPE,
+    AF_LLC = PF_LLC,
+    AF_IB = PF_IB,
+    AF_MPLS = PF_MPLS,
+    AF_CAN = PF_CAN,
+    AF_TIPC = PF_TIPC,
+    AF_BLUETOOTH = PF_BLUETOOTH,
+    AF_IUCV = PF_IUCV,
+    AF_RXRPC = PF_RXRPC,
+    AF_ISDN = PF_ISDN,
+    AF_PHONET = PF_PHONET,
+    AF_IEEE802154 = PF_IEEE802154,
+    AF_CAIF = PF_CAIF,
+    AF_ALG = PF_ALG,
+    AF_NFC = PF_NFC,
+    AF_VSOCK = PF_VSOCK,
+    AF_MAX = PF_MAX,
+}
+
+/*
+ * Types of sockets.
+ */
+enum
+{
+    // Sequenced, reliable, connection-based byte streams.
+    SOCK_STREAM = 1,
+    // Connectionless, unreliable datagrams of fixed maximum length.
+    SOCK_DGRAM = 2,
+    // Raw protocol interface.
+    SOCK_RAW = 3,
+    // Reliably-delivered messages.
+    SOCK_RDM = 4,
+    // Sequenced, reliable, connection-based, datagrams of fixed maximum
+    // length.
+    SOCK_SEQPACKET = 5,
+    // Datagram Congestion Control Protocol.
+    SOCK_DCCP = 6,
+    // Linux specific way of getting packets at the dev level. For writing rarp
+    // and other similar things on the user level.
+    SOCK_PACKET = 10,
+}
+
+/*
+ * Flags to be ORed into the type parameter of socket and socketpair and used
+ * for the flags parameter of paccept.
+ */
+enum
+{
+    SOCK_CLOEXEC = 0x80000, // Atomically set close-on-exec flag for the new descriptor(s).
+    SOCK_NONBLOCK = 0x800, // Atomically mark descriptor(s) as non-blocking.
+}

sys/tanya/sys/windows/def.d

@@ -0,0 +1,64 @@
+/* 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/. */
+
+/**
+ * Base type definitions and aliases.
+ *
+ * This module doesn't provide aliases for all types used by Windows, but only
+ * for types that can vary on different platforms. For example there is no
+ * need to define `INT32` alias for D, since $(D_KEYWORD int) is always a
+ * 32-bit signed integer. But `int` and its Windows alias `INT` is not the
+ * same on all platforms in C, so its size can be something differen than
+ * 32 bit, therefore an $(D_PSYMBOL INT) alias is available in this module.
+ * $(D_PARAM TCHAR) can be a $(D_KEYWORD char) if Unicode isn't supported or
+ * $(D_KEYWORD wchar) if Unicode is supported, so $(D_PSYMBOL TCHAR) is
+ * defined here.
+ * Also aliases for specific types like $(D_PSYMBOL SOCKET) are defined here.
+ *
+ * Copyright: Eugene Wissner 2017-2019.
+ * 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.sys.windows.def;
+
+version (Windows):
+
+alias BYTE = ubyte;
+alias TBYTE = wchar; // If Unicode, otherwise char.
+alias CHAR = char; // Signed or unsigned char.
+alias WCHAR = wchar;
+alias TCHAR = wchar; // If Unicode, otherwise char.
+alias SHORT = short;
+alias USHORT = ushort;
+alias WORD = ushort;
+alias INT = int;
+alias UINT = uint;
+alias LONG = int;
+alias ULONG = uint;
+alias DWORD = uint;
+alias LONGLONG = long; // Or double.
+alias ULONGLONG = ulong; // Or double.
+alias DWORDLONG = ulong;
+alias FLOAT = float;
+alias BOOL = int;
+alias BOOLEAN = BYTE;
+
+alias HANDLE = void*;
+enum HANDLE INVALID_HANDLE_VALUE = cast(HANDLE) -1;
+
+enum TRUE = 1;
+enum FALSE = 0;
+
+alias PSTR = CHAR*;
+alias PWSTR = WCHAR*;
+alias PTSTR = TCHAR*;
+
+align(1) struct GUID
+{
+    uint Data1;
+    ushort Data2;
+    ushort Data3;
+    char[8] Data4;
+}

sys/tanya/sys/windows/ifdef.d

@@ -0,0 +1,28 @@
+/* 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 2018-2019.
+ * 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.sys.windows.ifdef;
+
+version (Windows):
+
+import tanya.sys.windows.def;
+
+union NET_LUID_LH
+{
+    ulong Value;
+    ulong Info;
+}
+
+alias NET_LUID = NET_LUID_LH;
+alias IF_LUID = NET_LUID_LH;
+
+alias NET_IFINDEX = ULONG;
+
+enum size_t IF_MAX_STRING_SIZE = 256;

sys/tanya/sys/windows/iphlpapi.d

@@ -0,0 +1,37 @@
+/* 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 2018-2019.
+ * 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.sys.windows.iphlpapi;
+
+version (Windows):
+
+import tanya.sys.windows.def;
+import tanya.sys.windows.ifdef;
+
+extern(Windows)
+DWORD ConvertInterfaceNameToLuidA(const(CHAR)* InterfaceName,
+                                  NET_LUID* InterfaceLuid)
+@nogc nothrow @system;
+
+extern(Windows)
+DWORD ConvertInterfaceLuidToIndex(const(NET_LUID)* InterfaceLuid,
+                                  NET_IFINDEX* InterfaceIndex)
+@nogc nothrow @system;
+
+extern(Windows)
+DWORD ConvertInterfaceIndexToLuid(NET_IFINDEX InterfaceIndex,
+                                  NET_LUID* InterfaceLuid)
+@nogc nothrow @system;
+
+extern(Windows)
+DWORD ConvertInterfaceLuidToNameA(const(NET_LUID)* InterfaceLuid,
+                                  PSTR InterfaceName,
+                                  size_t Length)
+@nogc nothrow @system;

sys/tanya/sys/windows/package.d

@@ -0,0 +1,19 @@
+/* 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 2017-2019.
+ * 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.sys.windows;
+
+version (Windows):
+
+public import tanya.sys.windows.def;
+public import tanya.sys.windows.ifdef;
+public import tanya.sys.windows.iphlpapi;
+public import tanya.sys.windows.winbase;
+public import tanya.sys.windows.winsock2;

sys/tanya/sys/windows/winbase.d

@@ -0,0 +1,53 @@
+/* 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/. */
+
+/**
+ * Definitions from winbase.h.
+ *
+ * Copyright: Eugene Wissner 2017-2019.
+ * 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.sys.windows.winbase;
+
+version (Windows):
+
+public import tanya.sys.windows.def;
+
+struct OVERLAPPED
+{
+    size_t Internal;
+    size_t InternalHigh;
+    union
+    {
+        struct
+        {
+            DWORD Offset;
+            DWORD OffsetHigh;
+        }
+        void* Pointer;
+    }
+    HANDLE hEvent;
+}
+
+extern(Windows)
+HANDLE CreateIoCompletionPort(HANDLE FileHandle,
+                              HANDLE ExistingCompletionPort,
+                              size_t CompletionKey,
+                              DWORD NumberOfConcurrentThreads)
+nothrow @system @nogc;
+
+extern(Windows)
+BOOL GetQueuedCompletionStatus(HANDLE CompletionPort,
+                               DWORD* lpNumberOfBytes,
+                               size_t* lpCompletionKey,
+                               OVERLAPPED** lpOverlapped,
+                               DWORD dwMilliseconds) nothrow @system @nogc;
+
+extern(Windows)
+BOOL GetOverlappedResult(HANDLE hFile,
+                         OVERLAPPED* lpOverlapped,
+                         DWORD* lpNumberOfBytesTransferred,
+                         BOOL bWait) nothrow @system @nogc;

sys/tanya/sys/windows/winsock2.d

@@ -0,0 +1,217 @@
+/* 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/. */
+
+/**
+ * Definitions from winsock2.h, ws2def.h and MSWSock.h.
+ *
+ * Copyright: Eugene Wissner 2017-2019.
+ * 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.sys.windows.winsock2;
+
+version (Windows):
+
+public import tanya.sys.windows.def;
+public import tanya.sys.windows.winbase;
+
+alias SOCKET = size_t;
+enum SOCKET INVALID_SOCKET = ~0;
+enum SOCKET_ERROR = -1;
+
+enum
+{
+    IOC_UNIX     = 0x00000000,
+    IOC_WS2      = 0x08000000,
+    IOC_PROTOCOL = 0x10000000,
+    IOC_VOID     = 0x20000000,         // No parameters.
+    IOC_OUT      = 0x40000000,         // Copy parameters back.
+    IOC_IN       = 0x80000000,         // Copy parameters into.
+    IOC_VENDOR   = 0x18000000,
+    IOC_WSK      = (IOC_WS2 | 0x07000000), // _WIN32_WINNT >= 0x0600.
+    IOC_INOUT    = (IOC_IN | IOC_OUT), // Copy parameter into and get back.
+}
+
+template _WSAIO(int x, int y)
+{
+    enum _WSAIO = IOC_VOID | x | y;
+}
+template _WSAIOR(int x, int y)
+{
+    enum _WSAIOR = IOC_OUT | x | y;
+}
+template _WSAIOW(int x, int y)
+{
+    enum _WSAIOW = IOC_IN | x | y;
+}
+template _WSAIORW(int x, int y)
+{
+    enum _WSAIORW = IOC_INOUT | x | y;
+}
+
+alias SIO_ASSOCIATE_HANDLE               = _WSAIOW!(IOC_WS2, 1);
+alias SIO_ENABLE_CIRCULAR_QUEUEING       = _WSAIO!(IOC_WS2, 2);
+alias SIO_FIND_ROUTE                     = _WSAIOR!(IOC_WS2, 3);
+alias SIO_FLUSH                          = _WSAIO!(IOC_WS2, 4);
+alias SIO_GET_BROADCAST_ADDRESS          = _WSAIOR!(IOC_WS2, 5);
+alias SIO_GET_EXTENSION_FUNCTION_POINTER = _WSAIORW!(IOC_WS2, 6);
+alias SIO_GET_QOS                        = _WSAIORW!(IOC_WS2, 7);
+alias SIO_GET_GROUP_QOS                  = _WSAIORW!(IOC_WS2, 8);
+alias SIO_MULTIPOINT_LOOPBACK            = _WSAIOW!(IOC_WS2, 9);
+alias SIO_MULTICAST_SCOPE                = _WSAIOW!(IOC_WS2, 10);
+alias SIO_SET_QOS                        = _WSAIOW!(IOC_WS2, 11);
+alias SIO_SET_GROUP_QOS                  = _WSAIOW!(IOC_WS2, 12);
+alias SIO_TRANSLATE_HANDLE               = _WSAIORW!(IOC_WS2, 13);
+alias SIO_ROUTING_INTERFACE_QUERY        = _WSAIORW!(IOC_WS2, 20);
+alias SIO_ROUTING_INTERFACE_CHANGE       = _WSAIOW!(IOC_WS2, 21);
+alias SIO_ADDRESS_LIST_QUERY             = _WSAIOR!(IOC_WS2, 22);
+alias SIO_ADDRESS_LIST_CHANGE            = _WSAIO!(IOC_WS2, 23);
+alias SIO_QUERY_TARGET_PNP_HANDLE        = _WSAIOR!(IOC_WS2, 24);
+alias SIO_NSP_NOTIFY_CHANGE              = _WSAIOW!(IOC_WS2, 25);
+
+alias GROUP = uint;
+
+enum
+{
+    WSA_FLAG_OVERLAPPED = 0x01,
+    WSA_FLAG_MULTIPOINT_C_ROOT = 0x02,
+    WSA_FLAG_MULTIPOINT_C_LEAF = 0x04,
+    WSA_FLAG_MULTIPOINT_D_ROOT = 0x08,
+    WSA_FLAG_MULTIPOINT_D_LEAF = 0x10,
+    WSA_FLAG_ACCESS_SYSTEM_SECURITY = 0x40,
+    WSA_FLAG_NO_HANDLE_INHERIT = 0x80,
+    WSA_FLAG_REGISTERED_IO = 0x100,
+}
+
+enum MAX_PROTOCOL_CHAIN = 7;
+enum BASE_PROTOCOL = 1;
+enum LAYERED_PROTOCOL = 0;
+enum WSAPROTOCOL_LEN = 255;
+
+struct WSAPROTOCOLCHAIN
+{
+    int ChainLen;
+    DWORD[MAX_PROTOCOL_CHAIN] ChainEntries;
+}
+
+struct WSABUF
+{
+    ULONG len;
+    CHAR* buf;
+}
+
+struct WSAPROTOCOL_INFO
+{
+    DWORD                      dwServiceFlags1;
+    DWORD                      dwServiceFlags2;
+    DWORD                      dwServiceFlags3;
+    DWORD                      dwServiceFlags4;
+    DWORD                      dwProviderFlags;
+    GUID                       ProviderId;
+    DWORD                      dwCatalogEntryId;
+    WSAPROTOCOLCHAIN           ProtocolChain;
+    int                        iVersion;
+    int                        iAddressFamily;
+    int                        iMaxSockAddr;
+    int                        iMinSockAddr;
+    int                        iSocketType;
+    int                        iProtocol;
+    int                        iProtocolMaxOffset;
+    int                        iNetworkByteOrder;
+    int                        iSecurityScheme;
+    DWORD                      dwMessageSize;
+    DWORD                      dwProviderReserved;
+    TCHAR[WSAPROTOCOL_LEN + 1] szProtocol;
+}
+
+const GUID WSAID_GETACCEPTEXSOCKADDRS = {
+    0xb5367df2, 0xcbac, 0x11cf,
+    [0x95, 0xca, 0x00, 0x80, 0x5f, 0x48, 0xa1, 0x92],
+};
+
+const GUID WSAID_ACCEPTEX = {
+    0xb5367df1, 0xcbac, 0x11cf,
+    [0x95, 0xca, 0x00, 0x80, 0x5f, 0x48, 0xa1, 0x92],
+};
+
+alias LPWSAOVERLAPPED_COMPLETION_ROUTINE = void function(DWORD dwError,
+                                                         DWORD cbTransferred,
+                                                         OVERLAPPED* lpOverlapped,
+                                                         DWORD dwFlags) nothrow @nogc;
+
+extern(Windows)
+SOCKET WSASocket(int af,
+                 int type,
+                 int protocol,
+                 WSAPROTOCOL_INFO* lpProtocolInfo,
+                 GROUP g,
+                 DWORD dwFlags) nothrow @system @nogc;
+
+extern(Windows)
+int WSARecv(SOCKET s,
+            WSABUF* lpBuffers,
+            DWORD dwBufferCount,
+            DWORD* lpNumberOfBytesRecvd,
+            DWORD* lpFlags,
+            OVERLAPPED* lpOverlapped,
+            LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
+nothrow @system @nogc;
+
+extern(Windows)
+int WSASend(SOCKET s,
+            WSABUF* lpBuffers,
+            DWORD dwBufferCount,
+            DWORD* lpNumberOfBytesRecvd,
+            DWORD lpFlags,
+            OVERLAPPED* lpOverlapped,
+            LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
+nothrow @system @nogc;
+
+extern(Windows)
+int WSAIoctl(SOCKET s,
+             uint dwIoControlCode,
+             void* lpvInBuffer,
+             uint cbInBuffer,
+             void* lpvOutBuffer,
+             uint cbOutBuffer,
+             uint* lpcbBytesReturned,
+             OVERLAPPED* lpOverlapped,
+             LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)             
+nothrow @system @nogc;
+
+alias ADDRESS_FAMILY = USHORT;
+
+struct SOCKADDR
+{
+    ADDRESS_FAMILY sa_family;           // Address family.
+    CHAR[14] sa_data;                   // Up to 14 bytes of direct address.
+}
+
+alias LPFN_GETACCEPTEXSOCKADDRS = void function(void*,
+                                                DWORD,
+                                                DWORD,
+                                                DWORD,
+                                                SOCKADDR**,
+                                                INT*,
+                                                SOCKADDR**,
+                                                INT*) nothrow @nogc;
+
+alias LPFN_ACCEPTEX = extern(Windows) BOOL function(SOCKET,
+                                                    SOCKET,
+                                                    void*,
+                                                    DWORD,
+                                                    DWORD,
+                                                    DWORD,
+                                                    DWORD*,
+                                                    OVERLAPPED*) @nogc nothrow;
+
+enum
+{
+    SO_MAXDG = 0x7009,
+    SO_MAXPATHDG = 0x700A,
+    SO_UPDATE_ACCEPT_CONTEXT = 0x700B,
+    SO_CONNECT_TIME = 0x700C,
+    SO_UPDATE_CONNECT_CONTEXT = 0x7010,
+}

test/dub.json

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