Add dmd 2.075.0 support

std.algorithm.mutation copy is unable to copy a char range into a char array slice.

.gitignore

@@ -1,11 +1,14 @@
 # Binary
 *.[oa]
+*.exe
 
 # D
 .dub
 __test__*__
 __test__*__.core
-/tanya-test-library
+/tanya-test-library*
 
 /docs/
 /docs.json
+
+/*.lst

.travis.yml

@@ -1,23 +1,38 @@
 sudo: false
 
 os:
- - linux
+  - linux
- - osx
+  - osx
 
 language: d
 
 d:
- - dmd-2.074.1
+  - dmd-2.075.0
- - dmd-2.073.2
+  - dmd-2.074.1
- - dmd-2.072.2
+  - dmd-2.073.2
- - dmd-2.071.2
+  - dmd-2.072.2
+  - dmd-2.071.2
 
 env: 
- matrix:
+  matrix:
-  - ARCH=x86_64
+    - ARCH=x86_64
+    - ARCH=x86
+
+addons:
+  apt:
+    packages:
+      - gcc-multilib
+
+before_script:
+  - if [ "$PS1" = '(dmd-2.075.0)' ]; then
+      export UNITTEST="unittest-cov";
+    fi
 
 script:
- - dub test -b unittest-cov --arch=$ARCH
+  - dub test -b ${UNITTEST:-unittest} --arch=$ARCH --compiler=$DC
+  - if [ "$UNITTEST" = "unittest-cov" -a "$ARCH" = "x86_64" -a "$TRAVIS_OS_NAME" = "linux" ]; then
+      dub fetch dscanner && dub run dscanner -- -Isource --styleCheck;
+    fi
 
 after_success:
- - bash <(curl -s https://codecov.io/bash)
+  - test "$UNITTEST" = "unittest-cov" && bash <(curl -s https://codecov.io/bash)

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,92 @@
+# 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://issues.caraus.io/projects/tanya/issues) bugs and usage problems you
+encounter.
+* **Fixing issues**: [The bug tracker](https://issues.caraus.io/projects/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 in issue. I'll try to answer as soon
+as I can. Tanya uses an external
+[bug tracker](https://issues.caraus.io/projects/tanya/issues). You should
+[register](https://issues.caraus.io/account/register) before you can report your issue. 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.
+
+Some issues have a category assigned to them. Such issues belong mostly to a larger part of the library that is
+currently in development. The category specifies then the git branch development happens on. The remaining issues
+can be fixed directly in master.
+
+In the [roadmap](https://issues.caraus.io/projects/tanya/roadmap) you can find a list of issues that are planned
+to be fixed till a specific release. Version numbers refer to the versions in the
+[git repository](https://github.com/caraus-ecms/tanya/releases).
+
+
+## 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 a pull request. See https://help.github.com/articles/syncing-a-fork/ for a
+step-by-step guide.
+
+### Fixing a bug
+
+Add an unittest that demonstrates the bug along with a short description:
+
+```d
+// Issue ###: https://issues.caraus.io/issues/###.
+private unittest
+{
+}
+```
+
+### Adding new features
+
+* Use Ddoc to document the feature.
+* Add some unittests that prevent new bugs and demonstrate how the feature is supposed to work.
+
+### 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).
+
+
+## Questions and suggestions
+
+* [Open an issue](https://issues.caraus.io/projects/tanya/issues)
+* [Send an email](mailto:info@caraus.de)

README.md

@@ -17,22 +17,129 @@ data structures and utilities that depend on the Garbage Collector in Phobos.
 
 * [Bug tracker](https://issues.caraus.io/projects/tanya/issues)
 * [Documentation](https://docs.caraus.io/tanya)
+* [Contribution guidelines](CONTRIBUTING.md)
+
 
 ## Overview
 
-Tanya consists of the following packages:
+Tanya consists of the following packages and (top-level) modules:
 
 * `async`: Event loop (epoll, kqueue and IOCP).
 * `container`: Queue, Array, Singly and doubly linked lists, Buffers, UTF-8
 string, Hash set.
+* `format`: Formatting and conversion functions.
 * `math`: Arbitrary precision integer and a set of functions.
 * `memory`: Tools for manual memory management (allocators, smart pointers).
-* `network`: URL-Parsing, sockets, utilities.
+* `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.
+* `typecons`: Templates that allow to build new types based on the available
+ones.
+
+
+## Basic usage
+
+### 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);
+}
+```
+
+### 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 7th element.
+```
+
+There are more containers in the `tanya.container` package.
+
+
+## Development
 
 ### Supported compilers
 
 | dmd     |
 |:-------:|
+| 2.075.0 |
 | 2.074.1 |
 | 2.073.2 |
 | 2.072.2 |
@@ -48,7 +155,13 @@ Following modules are under development:
 | 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)                                    |
 
-### Further characteristics
+### Release management
+
+3-week release cycle.
+
+Deprecated features are removed after one release (in approximately 6 weeks after deprecating).
+
+## Further characteristics
 
 * Tanya is a native D library without any external dependencies.
 
@@ -57,12 +170,8 @@ is being tested on Windows and FreeBSD as well.
 
 * The library isn't thread-safe yet.
 
-## Release management
 
-3-week release cycle.
+## Feedback
 
-Deprecated features are removed after one release (in approximately 6 weeks after deprecating).
+Any feedback about your experience with tanya would be greatly appreciated. Feel free to
-
+[contact me](mailto:info@caraus.de).
-## Contributing
-
-Feel free to contact me if you have any questions: info@caraus.de.

appveyor.yml

@@ -1,52 +1,78 @@
 platform: x64
-os: Visual Studio 2017
+os: Visual Studio 2015
 
 environment:
- matrix:
+  matrix:
-  - DC: dmd
+    - DC: dmd
-    DVersion: 2.074.1
+      DVersion: 2.075.0
-    arch: x86
+      arch: x64
-  - DC: dmd
+    - DC: dmd
-    DVersion: 2.073.2
+      DVersion: 2.075.0
-    arch: x86
+      arch: x86
-  - DC: dmd
+    - DC: dmd
-    DVersion: 2.072.2
+      DVersion: 2.074.1
-    arch: x86
+      arch: x64
-  - DC: dmd
+    - DC: dmd
-    DVersion: 2.071.2
+      DVersion: 2.074.1
-    arch: x86
+      arch: x86
+    - DC: dmd
+      DVersion: 2.073.2
+      arch: x64
+    - DC: dmd
+      DVersion: 2.073.2
+      arch: x86
+    - DC: dmd
+      DVersion: 2.072.2
+      arch: x64
+    - DC: dmd
+      DVersion: 2.072.2
+      arch: x86
+    - DC: dmd
+      DVersion: 2.071.2
+      arch: x64
+    - DC: dmd
+      DVersion: 2.071.2
+      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";
+          Invoke-WebRequest "http://code.dlang.org/files/dub-1.2.1-windows-x86.zip" -OutFile "dub.zip";
-            7z x dub.zip -odub > $null;
+          7z x dub.zip -odub > $null;
-            Move-Item "dub/dub.exe" "C:\dmd2\windows\bin"
+          Move-Item "dub/dub.exe" "C:\dmd2\windows\bin"
-          }
+        }
 
 before_build:
+  - ps: if($env:arch -eq "x86"){
+          $env:compilersetupargs = "x86";
+          $env:Darch = "x86";
+        }
+        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 -b unittest --arch=%Darch% --compiler=%DC%

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="disabled"
+; 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="disabled"
+; Check for explicitly annotated unittests
+explicitly_annotated_unittests="disabled"
+; Check for useless usage of the final attribute
+final_attribute_check="skip-unittest"

source/tanya/async/event/epoll.d

@@ -2,7 +2,9 @@
  * 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/. */
 
-/**
+/*
+ * Event loop implementation for Linux.
+ *
  * Copyright: Eugene Wissner 2016-2017.
  * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
  *                  Mozilla Public License, v. 2.0).
@@ -10,7 +12,10 @@
  */
 module tanya.async.event.epoll;
 
-version (linux):
+version (D_Ddoc)
+{
+}
+else version (linux):
 
 public import core.sys.linux.epoll;
 import tanya.async.protocol;

source/tanya/async/event/iocp.d

@@ -2,7 +2,9 @@
  * 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/. */
 
-/**
+/*
+ * Event loop implementation for Windows.
+ *
  * Copyright: Eugene Wissner 2016-2017.
  * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
  *                  Mozilla Public License, v. 2.0).
@@ -10,7 +12,10 @@
  */
 module tanya.async.event.iocp;
 
-version (Windows):
+version (D_Ddoc)
+{
+}
+else version (Windows):
 
 import tanya.container.buffer;
 import tanya.async.loop;
@@ -226,8 +231,8 @@ final class IOCPLoop : Loop
                 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);

source/tanya/async/event/kqueue.d

@@ -2,7 +2,9 @@
  * 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/. */
 
-/**
+/*
+ * Event loop implementation for *BSD.
+ *
  * Copyright: Eugene Wissner 2016-2017.
  * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
  *                  Mozilla Public License, v. 2.0).
@@ -10,7 +12,10 @@
  */
 module tanya.async.event.kqueue;
 
-version (OSX)
+version (D_Ddoc)
+{
+}
+else version (OSX)
 {
     version = MacBSD;
 }

source/tanya/async/event/selector.d

@@ -2,7 +2,9 @@
  * 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 base implementations for reactor event loops.
+ *
  * Copyright: Eugene Wissner 2016-2017.
  * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
  *                  Mozilla Public License, v. 2.0).
@@ -10,7 +12,10 @@
  */
 module tanya.async.event.selector;
 
-version (Posix):
+version (D_Ddoc)
+{
+}
+else version (Posix):
 
 import tanya.async.loop;
 import tanya.async.protocol;

source/tanya/async/iocp.d

@@ -3,6 +3,10 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /**
+ * This module provides API for Windows I/O Completion Ports.
+ *
+ * Note: Available only on Windows.
+ *
  * Copyright: Eugene Wissner 2016-2017.
  * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
  *                  Mozilla Public License, v. 2.0).
@@ -10,7 +14,26 @@
  */
 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*;
+    }
+}
+
+version (WindowsDoc):
 
 import core.sys.windows.winbase;
 import core.sys.windows.windef;

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;
@@ -61,6 +59,11 @@
  *  defaultAllocator.dispose(address);
  * }
  * ---
+ *
+ * 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.async.loop;
 
@@ -79,6 +82,9 @@ import tanya.network.socket;
 version (DisableBackends)
 {
 }
+else version (D_Ddoc)
+{
+}
 else version (linux)
 {
     import tanya.async.event.epoll;
@@ -109,6 +115,30 @@ else version (DragonFlyBSD)
 {
     version = Kqueue;
 }
+version (unittest)
+{
+    final class TestLoop : Loop
+    {
+        override protected bool reify(SocketWatcher watcher,
+                                      EventMask oldEvents,
+                                      EventMask events) @nogc
+        {
+            return true;
+        }
+
+        override protected void poll() @nogc
+        {
+            assert(!this.done);
+            unloop();
+        }
+
+        override protected @property uint maxEvents()
+        const pure nothrow @safe @nogc
+        {
+            return 64U;
+        }
+    }
+}
 
 /**
  * Events.
@@ -129,7 +159,7 @@ alias EventMask = BitFlags!Event;
  */
 abstract class Loop
 {
-    private bool done;
+    private bool done = true;
 
     /// Pending watchers.
     protected Queue!Watcher pendings;
@@ -144,6 +174,14 @@ abstract class Loop
         return 128U;
     }
 
+    private unittest
+    {
+        auto loop = defaultAllocator.make!TestLoop;
+        assert(loop.maxEvents == 64);
+
+        defaultAllocator.dispose(loop);
+    }
+
     /**
      * Initializes the loop.
      */
@@ -168,18 +206,18 @@ abstract class Loop
      */
     void run() @nogc
     {
-        done = false;
+        this.done = false;
         do
         {
             poll();
 
             // Invoke pendings
-            foreach (ref w; pendings)
+            foreach (ref w; this.pendings)
             {
                 w.invoke();
             }
         }
-        while (!done);
+        while (!this.done);
     }
 
     /**
@@ -187,7 +225,32 @@ abstract class Loop
      */
     void unloop() @safe pure nothrow @nogc
     {
-        done = true;
+        this.done = true;
+    }
+
+    private unittest
+    {
+        auto loop = defaultAllocator.make!TestLoop;
+        assert(loop.done);
+
+        loop.run();
+        assert(loop.done);
+
+        defaultAllocator.dispose(loop);
+    }
+
+    private unittest
+    {
+        auto loop = defaultAllocator.make!TestLoop;
+        auto watcher = defaultAllocator.make!DummyWatcher;
+        loop.pendings.enqueue(watcher);
+
+        assert(!watcher.invoked);
+        loop.run();
+        assert(watcher.invoked);
+
+        defaultAllocator.dispose(loop);
+        defaultAllocator.dispose(watcher);
     }
 
     /**
@@ -266,6 +329,17 @@ abstract class Loop
         blockTime_ = blockTime;
     }
 
+    private unittest
+    {
+        auto loop = defaultAllocator.make!TestLoop;
+        assert(loop.blockTime == 1.dur!"minutes");
+
+        loop.blockTime = 2.dur!"minutes";
+        assert(loop.blockTime == 2.dur!"minutes");
+
+        defaultAllocator.dispose(loop);
+    }
+
     /**
      * Does the actual polling.
      */
@@ -344,3 +418,16 @@ body
 }
 
 private Loop defaultLoop_;
+
+private unittest
+{
+    auto oldLoop = defaultLoop_;
+    auto loop = defaultAllocator.make!TestLoop;
+
+    defaultLoop = loop;
+    assert(defaultLoop_ is loop);
+    assert(defaultLoop is loop);
+
+    defaultLoop_ = oldLoop;
+    defaultAllocator.dispose(loop);
+}

source/tanya/async/package.d

@@ -3,6 +3,8 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /**
+ * This package provides asynchronous capabilities.
+ *
  * Copyright: Eugene Wissner 2016-2017.
  * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
  *                  Mozilla Public License, v. 2.0).

source/tanya/async/protocol.d

@@ -3,6 +3,12 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /**
+ * 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-2017.
  * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
  *                  Mozilla Public License, v. 2.0).

source/tanya/async/transport.d

@@ -3,6 +3,9 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /**
+ * This module contains transports which are responsible for data dilvery
+ * between two parties of an asynchronous communication.
+ *
  * Copyright: Eugene Wissner 2016-2017.
  * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
  *                  Mozilla Public License, v. 2.0).

source/tanya/async/watcher.d

@@ -3,6 +3,8 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /**
+ * Watchers register user's interest in some event.
+ *
  * Copyright: Eugene Wissner 2016-2017.
  * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
  *                  Mozilla Public License, v. 2.0).
@@ -36,6 +38,19 @@ abstract class Watcher
     void invoke() @nogc;
 }
 
+version (unittest)
+{
+    final class DummyWatcher : Watcher
+    {
+        bool invoked;
+
+        override void invoke() @nogc
+        {
+            this.invoked = true;
+        }
+    }
+}
+
 /**
  * Socket watcher.
  */

source/tanya/container/array.d

@@ -22,20 +22,17 @@ import std.meta;
 import std.traits;
 import tanya.memory;
 
-deprecated("Use tanya.container.array instead.")
-alias Vector = Array;
-
 /**
  * Random-access range for the $(D_PSYMBOL Array).
  *
  * Params:
- *  E = Element type.
+ *  A = Array type.
  */
-struct Range(E)
+struct Range(A)
 {
+    private alias E = PointerTarget!(typeof(A.data));
     private E* begin, end;
-    private alias ContainerType = CopyConstness!(E, Array!(Unqual!E));
+    private A* container;
-    private ContainerType* container;
 
     invariant
     {
@@ -45,7 +42,7 @@ struct Range(E)
         assert(this.end <= this.container.data + this.container.length);
     }
 
-    private this(ref ContainerType container, E* begin, E* end) @trusted
+    private this(ref A container, E* begin, E* end) @trusted
     in
     {
         assert(begin <= end);
@@ -133,7 +130,7 @@ struct Range(E)
         return typeof(return)(*this.container, this.begin, this.end);
     }
 
-    Range!(const E) opIndex() const
+    A.ConstRange opIndex() const
     {
         return typeof(return)(*this.container, this.begin, this.end);
     }
@@ -149,7 +146,7 @@ struct Range(E)
         return typeof(return)(*this.container, this.begin + i, this.begin + j);
     }
 
-    Range!(const E) opSlice(const size_t i, const size_t j) const @trusted
+    A.ConstRange opSlice(const size_t i, const size_t j) const @trusted
     in
     {
         assert(i <= j);
@@ -175,10 +172,10 @@ struct Range(E)
 struct Array(T)
 {
     /// The range types for $(D_PSYMBOL Array).
-    alias Range = .Range!T;
+    alias Range = .Range!Array;
 
     /// Ditto.
-    alias ConstRange = .Range!(const T);
+    alias ConstRange = .Range!(const Array);
 
     private size_t length_;
     private T* data;
@@ -654,9 +651,9 @@ struct Array(T)
     body
     {
         auto end = this.data + this.length;
-        moveAll(.Range!T(this, r.end, end), .Range!T(this, r.begin, end));
+        moveAll(Range(this, r.end, end), Range(this, r.begin, end));
         length = length - r.length;
-        return .Range!T(this, r.begin, this.data + length);
+        return Range(this, r.begin, this.data + length);
     }
 
     ///
@@ -866,7 +863,7 @@ struct Array(T)
     }
     body
     {
-        return insertAfter(.Range!T(this, this.data, r.begin), el);
+        return insertAfter(Range(this, this.data, r.begin), el);
     }
 
     /// Ditto.
@@ -1620,6 +1617,9 @@ private unittest
     }
     A a1, a2;
     auto v1 = Array!A([a1, a2]);
+
+    // Issue 232: https://issues.caraus.io/issues/232.
+    static assert(is(Array!(A*)));
 }
 
 private @safe @nogc unittest

source/tanya/container/buffer.d

@@ -3,6 +3,8 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /**
+ * This module contains buffers designed for C-style input/output APIs.
+ *
  * Copyright: Eugene Wissner 2016-2017.
  * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
  *                  Mozilla Public License, v. 2.0).

source/tanya/container/string.d

@@ -3,7 +3,19 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /**
- * UTF-8 string.
+ * UTF-8 encoded string.
+ *
+ * You can create a $(D_PSYMBOL String) from a literal string, single character
+ * or character range. Characters can be of the type $(D_KEYWORD char),
+ * $(D_KEYWORD wchar) or $(D_KEYWORD dchar). Literal strings, characters and
+ * character ranges can be also inserted into an existing string.
+ *
+ * $(D_PSYMBOL String) is always valid UTF-8. Inserting an invalid sequence
+ * or working on a corrupted $(D_PSYMBOL String) causes
+ * $(D_PSYMBOL UTFException) to be thrown.
+ *
+ * Internally $(D_PSYMBOL String) is represented by a sequence of
+ * $(D_KEYWORD char)s.
  *
  * Copyright: Eugene Wissner 2017.
  * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
@@ -70,7 +82,7 @@ class UTFException : Exception
  *  E = Element type ($(D_KEYWORD char) or $(D_INLINECODE const(char))).
  */
 struct ByCodeUnit(E)
-    if (is(Unqual!E == char))
+if (is(Unqual!E == char))
 {
     private E* begin, end;
     private alias ContainerType = CopyConstness!(E, String);
@@ -212,7 +224,7 @@ struct ByCodeUnit(E)
  *  E = Element type ($(D_KEYWORD char) or $(D_INLINECODE const(char))).
  */
 struct ByCodePoint(E)
-    if (is(Unqual!E == char))
+if (is(Unqual!E == char))
 {
     private E* begin, end;
     private alias ContainerType = CopyConstness!(E, String);
@@ -358,9 +370,9 @@ struct String
      * Precondition: $(D_INLINECODE allocator is null).
      */
     this(S)(const S str, shared Allocator allocator = defaultAllocator)
-        if (!isInfinite!S
+    if (!isInfinite!S
-         && isInputRange!S
+     && isInputRange!S
-         && isSomeChar!(ElementEncodingType!S))
+     && isSomeChar!(ElementEncodingType!S))
     {
         this(allocator);
         insertBack(str);
@@ -400,7 +412,7 @@ struct String
      */
     this(S)(S init, shared Allocator allocator = defaultAllocator)
     nothrow @trusted @nogc
-        if (is(S == String))
+    if (is(S == String))
     {
         this(allocator);
         if (allocator !is init.allocator)
@@ -425,7 +437,7 @@ struct String
     /// Ditto.
     this(S)(ref S init, shared Allocator allocator = defaultAllocator)
     nothrow @trusted @nogc
-        if (is(Unqual!S == String))
+    if (is(Unqual!S == String))
     {
         this(allocator);
         reserve(init.length);
@@ -456,7 +468,7 @@ struct String
     this(C)(const size_t n,
             const C chr,
             shared Allocator allocator = defaultAllocator) @trusted
-        if (isSomeChar!C)
+    if (isSomeChar!C)
     {
         this(allocator);
         if (n == 0)
@@ -500,6 +512,12 @@ struct String
         }
     }
 
+    @safe @nogc unittest
+    {
+        auto s = String(0, 'K');
+        assert(s.length == 0);
+    }
+
     /**
      * Destroys the string.
      */
@@ -528,10 +546,10 @@ struct String
     }
 
     private size_t insertWideChar(C)(auto ref const C chr) @trusted
-        if (is(C == wchar) || is(C == dchar))
+    if (is(C == wchar) || is(C == dchar))
     in
     {
-        assert(capacity - length >= C.sizeof);
+        assert(capacity - length >= 3);
     }
     body
     {
@@ -549,7 +567,7 @@ struct String
             this.length_ += 2;
             return 2;
         }
-        else if (chr < 0xd800 || chr - 0xe000 < 0x2000)
+        else if (chr < 0xd800 || (chr >= 0xe000 && chr <= 0xffff))
         {
             *dst++ = 0xe0 | (chr >> 12) & 0xff;
             *dst++ = 0x80 | ((chr >> 6) & 0x3f);
@@ -587,9 +605,9 @@ struct String
     /// Ditto.
     size_t insertBack(const wchar chr) @trusted @nogc
     {
-        reserve(length + wchar.sizeof);
+        reserve(length + 3);
 
-        auto ret = insertWideChar(chr);
+        const ret = insertWideChar(chr);
         if (ret == 0)
         {
             throw defaultAllocator.make!UTFException("Invalid UTF-16 sequeunce");
@@ -597,12 +615,34 @@ struct String
         return ret;
     }
 
+    // Allocates enough space for 3-byte character.
+    private @safe @nogc unittest
+    {
+        String s;
+        s.insertBack('\u8100');
+    }
+
+    private @safe @nogc unittest
+    {
+        UTFException exception;
+        try
+        {
+            auto s = String(1, cast(wchar) 0xd900);
+        }
+        catch (UTFException e)
+        {
+            exception = e;
+        }
+        assert(exception !is null);
+        defaultAllocator.dispose(exception);
+    }
+
     /// Ditto.
     size_t insertBack(const dchar chr) @trusted @nogc
     {
         reserve(length + dchar.sizeof);
 
-        auto ret = insertWideChar(chr);
+        const ret = insertWideChar(chr);
         if (ret > 0)
         {
             return ret;
@@ -618,6 +658,21 @@ struct String
         }
     }
 
+    private @safe @nogc unittest
+    {
+        UTFException exception;
+        try
+        {
+            auto s = String(1, cast(dchar) 0xd900);
+        }
+        catch (UTFException e)
+        {
+            exception = e;
+        }
+        assert(exception !is null);
+        defaultAllocator.dispose(exception);
+    }
+
     /**
      * Inserts a stringish range at the end of the string.
      *
@@ -630,9 +685,9 @@ struct String
      * Throws: $(D_PSYMBOL UTFException).
      */
     size_t insertBack(R)(R str) @trusted
-        if (!isInfinite!R
+    if (!isInfinite!R
-         && isInputRange!R
+     && isInputRange!R
-         && is(Unqual!(ElementEncodingType!R) == char))
+     && is(Unqual!(ElementEncodingType!R) == char))
     {
         size_t size;
         static if (hasLength!R || isNarrowString!R)
@@ -694,9 +749,9 @@ struct String
 
     /// Ditto.
     size_t insertBack(R)(R str) @trusted
-        if (!isInfinite!R
+    if (!isInfinite!R
-         && isInputRange!R
+     && isInputRange!R
-         && is(Unqual!(ElementEncodingType!R) == wchar))
+     && is(Unqual!(ElementEncodingType!R) == wchar))
     {
         static if (hasLength!R || isNarrowString!R)
         {
@@ -760,9 +815,9 @@ struct String
 
     /// Ditto.
     size_t insertBack(R)(R str) @trusted
-        if (!isInfinite!R
+    if (!isInfinite!R
-         && isInputRange!R
+     && isInputRange!R
-         && is(Unqual!(ElementEncodingType!R) == dchar))
+     && is(Unqual!(ElementEncodingType!R) == dchar))
     {
         static if (hasLength!R || isSomeString!R)
         {
@@ -854,6 +909,9 @@ struct String
 
         s.shrink(18);
         assert(s.capacity == 21);
+
+        s.shrink(22);
+        assert(s.capacity == 21);
     }
 
     /**
@@ -875,8 +933,8 @@ struct String
      * Slicing assignment.
      *
      * Params:
-     *  R     = Type of the assigned slice.
+     *  R     = $(D_KEYWORD char).
-     *  value = New value (single value, range or string).
+     *  value = Assigned character, range or string.
      *  i     = Slice start.
      *  j     = Slice end.
      *
@@ -888,7 +946,7 @@ struct String
     ByCodeUnit!char opSliceAssign(R)(ByCodeUnit!R value,
                                      const size_t i,
                                      const size_t j) @trusted
-        if (is(Unqual!R == char))
+    if (is(Unqual!R == char))
     in
     {
         assert(i <= j);
@@ -897,8 +955,9 @@ struct String
     }
     body
     {
-        copy(value, this.data[i .. j]);
+        auto target = opSlice(i, j);
-        return opSlice(i, j);
+        copy(value, target);
+        return target;
     }
 
     /// Ditto.
@@ -948,25 +1007,32 @@ struct String
         return this.data[0 .. this.length_];
     }
 
+    ///
+    nothrow @safe @nogc unittest
+    {
+        auto s = String("Char array.");
+        assert(s.get().length == 11);
+    }
+
     /**
      * Returns null-terminated string. The returned string is managed by this
      * object and shouldn't be freed.
      *
      * Returns: Null-terminated string.
      */
-    const(char)[] toStringz() nothrow @trusted @nogc
+    const(char)* toStringz() nothrow @nogc
     {
         reserve(length + 1);
         this.data[length] = '\0';
-        return this.data[0 .. length + 1];
+        return this.data;
     }
 
     ///
-    @safe @nogc unittest
+    @nogc unittest
     {
         auto s = String("C string.");
-        assert(s.toStringz().length == 10);
+        assert(s.toStringz()[0] == 'C');
-        assert(s.toStringz()[$ - 1] == '\0');
+        assert(s.toStringz()[9] == '\0');
     }
 
     /**
@@ -1092,6 +1158,16 @@ struct String
         return length == 0;
     }
 
+    ///
+    @safe @nogc unittest
+    {
+        String s;
+        assert(s.empty);
+
+        s.insertBack('K');
+        assert(!s.empty);
+    }
+
     /**
      * Params:
      *  i = Slice start.
@@ -1172,7 +1248,7 @@ struct String
      * Returns: $(D_KEYWORD this).
      */
     ref String opAssign(S)(S that)
-        if (is(S == String))
+    if (is(S == String))
     {
         swap(this.data, that.data);
         swap(this.length_, that.length_);
@@ -1183,7 +1259,7 @@ struct String
 
     /// Ditto.
     ref String opAssign(S)(ref S that) @trusted
-        if (is(Unqual!S == String))
+    if (is(Unqual!S == String))
     {
         reserve(that.length);
         that.data[0 .. that.length].copy(this.data[0 .. that.length]);
@@ -1210,9 +1286,9 @@ struct String
      * Throws: $(D_PSYMBOL UTFException).
      */
     ref String opAssign(S)(S that) nothrow
-        if (!isInfinite!S
+    if (!isInfinite!S
-         && isInputRange!S
+     && isInputRange!S
-         && isSomeChar!(ElementEncodingType!S))
+     && isSomeChar!(ElementEncodingType!S))
     {
         this.length_ = 0;
         insertBack(that);
@@ -1237,14 +1313,14 @@ struct String
      *          greater than $(D_PARAM that), if equal `0`, else `-1`.
      */
     int opCmp(S)(auto ref S that) const @trusted
-        if (is(Unqual!S == String))
+    if (is(Unqual!S == String))
     {
         return cmp(this.data[0 .. length], that.data[0 .. that.length]);
     }
 
     /// Ditto.
     int opCmp(S)(ByCodeUnit!S that) const @trusted
-        if (is(Unqual!S == char))
+    if (is(Unqual!S == char))
     {
         return cmp(this.data[0 .. length],
                    that.begin[0 .. that.end - that.begin]);
@@ -1252,7 +1328,7 @@ struct String
 
     /// Ditto.
     int opCmp(S)(ByCodePoint!S that) const @trusted
-        if (is(Unqual!S == char))
+    if (is(Unqual!S == char))
     {
         return cmp(this.data[0 .. length],
                    that.begin[0 .. that.end - that.begin]);
@@ -1282,7 +1358,7 @@ struct String
      *          otherwise.
      */
     bool opEquals(S)(auto ref S that) const @trusted
-        if (is(Unqual!S == String))
+    if (is(Unqual!S == String))
     {
         return equal(this.data[0 .. length], that.data[0 .. that.length]);
     }
@@ -1297,7 +1373,7 @@ struct String
      *          $(D_KEYWORD false) otherwise.
      */
     bool opEquals(S)(ByCodeUnit!S that) const @trusted
-        if (is(Unqual!S == char))
+    if (is(Unqual!S == char))
     {
         return equal(this.data[0 .. length],
                      that.begin[0 .. that.end - that.begin]);
@@ -1305,7 +1381,7 @@ struct String
 
     /// Ditto.
     bool opEquals(S)(ByCodePoint!S that) const @trusted
-        if (is(Unqual!S == char))
+    if (is(Unqual!S == char))
     {
         return equal(this.data[0 .. length],
                      that.begin[0 .. that.end - that.begin]);
@@ -1350,35 +1426,66 @@ struct String
         return opIndex(pos) = value;
     }
 
+    ///
+    @safe @nogc unittest
+    {
+        auto s = String("alea iacta est.");
+
+        s[0] = 'A';
+        assert(s[0] == 'A');
+    }
+
     /**
-     * Assigns a range or a string.
+     * Slicing assignment.
      *
      * Params:
-     *  R     = Value type.
+     *  R     = $(D_KEYWORD char).
-     *  value = Value.
+     *  value = Assigned character, range or string.
      *
-     * Returns: Assigned value.
+     * Returns: Range over the string.
      *
      * Precondition: $(D_INLINECODE length == value.length).
      */
     ByCodeUnit!char opIndexAssign(R)(ByCodeUnit!R value)
-        if (is(Unqual!R == char))
+    if (is(Unqual!R == char))
     {
         return opSliceAssign(value, 0, length);
     }
 
+    private unittest
+    {
+        auto s1 = String("Buttercup");
+        auto s2 = String("Cap");
+        s2[] = s1[6 .. $];
+        assert(s2 == "cup");
+    }
+
     /// Ditto.
     ByCodeUnit!char opIndexAssign(const char value) pure nothrow @safe @nogc
     {
         return opSliceAssign(value, 0, length);
     }
 
+    private unittest
+    {
+        auto s1 = String("Wow");
+        s1[] = 'a';
+        assert(s1 == "aaa");
+    }
+
     /// Ditto.
     ByCodeUnit!char opIndexAssign(const char[] value) pure nothrow @safe @nogc
     {
         return opSliceAssign(value, 0, length);
     }
 
+    private unittest
+    {
+        auto s1 = String("ö");
+        s1[] = "oe";
+        assert(s1 == "oe");
+    }
+
     /**
      * Remove all characters beloning to $(D_PARAM r).
      *
@@ -1392,7 +1499,7 @@ struct String
      * Precondition: $(D_PARAM r) refers to a region of $(D_KEYWORD this).
      */
     R remove(R)(R r) @trusted
-        if (is(R == ByCodeUnit!char) || is(R == ByCodePoint!char))
+    if (is(R == ByCodeUnit!char) || is(R == ByCodePoint!char))
     in
     {
         assert(r.container is &this);
@@ -1442,10 +1549,10 @@ struct String
      * Precondition: $(D_PARAM r) refers to a region of $(D_KEYWORD this).
      */
     size_t insertAfter(T, R)(R r, T el) @trusted
-        if ((isSomeChar!T || (!isInfinite!T
+    if ((isSomeChar!T || (!isInfinite!T
-         && isInputRange!T
+     && isInputRange!T
-         && isSomeChar!(ElementEncodingType!T)))
+     && isSomeChar!(ElementEncodingType!T)))
-         && (is(R == ByCodeUnit!char) || is(R == ByCodePoint!char)))
+     && (is(R == ByCodeUnit!char) || is(R == ByCodePoint!char)))
     in
     {
         assert(r.container is &this);
@@ -1475,10 +1582,10 @@ struct String
 
     ///
     size_t insertBefore(T, R)(R r, T el) @trusted
-        if ((isSomeChar!T || (!isInfinite!T
+    if ((isSomeChar!T || (!isInfinite!T
-         && isInputRange!T
+     && isInputRange!T
-         && isSomeChar!(ElementEncodingType!T)))
+     && isSomeChar!(ElementEncodingType!T)))
-         && (is(R == ByCodeUnit!char) || is(R == ByCodePoint!char)))
+     && (is(R == ByCodeUnit!char) || is(R == ByCodePoint!char)))
     in
     {
         assert(r.container is &this);

source/tanya/format/conv.d

@@ -0,0 +1,537 @@
+/* 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.
+ * 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.format.conv;
+
+import std.traits;
+import tanya.memory;
+
+/**
+ * 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);
+    }
+}
+
+/**
+ * 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;
+    }
+}
+
+///
+pure nothrow @safe @nogc unittest
+{
+    auto val = 5.to!int();
+    assert(val == 5);
+    static assert(is(typeof(val) == int));
+}
+
+private pure nothrow @safe @nogc unittest
+{
+    int val = 5;
+    assert(val.to!int() == 5);
+}
+
+/**
+ * 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;
+    }
+}
+
+private pure nothrow @safe @nogc unittest
+{
+    // ubyte -> ushort
+    assert((cast(ubyte) 0).to!ushort == 0);
+    assert((cast(ubyte) 1).to!ushort == 1);
+    assert((cast(ubyte) (ubyte.max - 1)).to!ushort == ubyte.max - 1);
+    assert((cast(ubyte) ubyte.max).to!ushort == ubyte.max);
+
+    // ubyte -> short
+    assert((cast(ubyte) 0).to!short == 0);
+    assert((cast(ubyte) 1).to!short == 1);
+    assert((cast(ubyte) (ubyte.max - 1)).to!short == ubyte.max - 1);
+    assert((cast(ubyte) ubyte.max).to!short == ubyte.max);
+}
+
+private unittest
+{
+    // ubyte <- ushort
+    assert((cast(ushort) 0).to!ubyte == 0);
+    assert((cast(ushort) 1).to!ubyte == 1);
+    assert((cast(ushort) (ubyte.max - 1)).to!ubyte == ubyte.max - 1);
+    assert((cast(ushort) ubyte.max).to!ubyte == ubyte.max);
+
+    // ubyte <- short
+    assert((cast(short) 0).to!ubyte == 0);
+    assert((cast(short) 1).to!ubyte == 1);
+    assert((cast(short) (ubyte.max - 1)).to!ubyte == ubyte.max - 1);
+    assert((cast(short) ubyte.max).to!ubyte == ubyte.max);
+
+    // short <-> int
+    assert(short.min.to!int == short.min);
+    assert((short.min + 1).to!int == short.min + 1);
+    assert((cast(short) -1).to!int == -1);
+    assert((cast(short) 0).to!int == 0);
+    assert((cast(short) 1).to!int == 1);
+    assert((short.max - 1).to!int == short.max - 1);
+    assert(short.max.to!int == short.max);
+
+    assert((cast(int) short.min).to!short == short.min);
+    assert((cast(int) short.min + 1).to!short == short.min + 1);
+    assert((cast(int) -1).to!short == -1);
+    assert((cast(int) 0).to!short == 0);
+    assert((cast(int) 1).to!short == 1);
+    assert((cast(int) short.max - 1).to!short == short.max - 1);
+    assert((cast(int) short.max).to!short == short.max);
+
+    // uint <-> int
+    assert((cast(uint) 0).to!int == 0);
+    assert((cast(uint) 1).to!int == 1);
+    assert((cast(uint) (int.max - 1)).to!int == int.max - 1);
+    assert((cast(uint) int.max).to!int == int.max);
+
+    assert((cast(int) 0).to!uint == 0);
+    assert((cast(int) 1).to!uint == 1);
+    assert((cast(int) (int.max - 1)).to!uint == int.max - 1);
+    assert((cast(int) int.max).to!uint == int.max);
+}
+
+private unittest
+{
+    ConvException exception;
+    try
+    {
+        assert(int.min.to!short == int.min);
+    }
+    catch (ConvException e)
+    {
+        exception = e;
+    }
+    assert(exception !is null);
+    defaultAllocator.dispose(exception);
+}
+
+private unittest
+{
+    ConvException exception;
+    try
+    {
+        assert(int.max.to!short == int.max);
+    }
+    catch (ConvException e)
+    {
+        exception = e;
+    }
+    assert(exception !is null);
+    defaultAllocator.dispose(exception);
+}
+
+private unittest
+{
+    ConvException exception;
+    try
+    {
+        assert(uint.max.to!ushort == ushort.max);
+    }
+    catch (ConvException e)
+    {
+        exception = e;
+    }
+    assert(exception !is null);
+    defaultAllocator.dispose(exception);
+}
+
+private unittest
+{
+    ConvException exception;
+    try
+    {
+        assert((-1).to!uint == -1);
+    }
+    catch (ConvException e)
+    {
+        exception = e;
+    }
+    assert(exception !is null);
+    defaultAllocator.dispose(exception);
+}
+
+private @nogc unittest
+{
+    enum Test : int
+    {
+        one,
+        two,
+    }
+    assert(Test.one.to!int == 0);
+    assert(Test.two.to!int == 1);
+}
+
+/**
+ * Converts a number to a boolean.
+ *
+ * Params:
+ *  From = Source type.
+ *  To   = Target type.
+ *  from = Source value.
+ *
+ * Returns: $(D_KEYWORD true) if $(D_INLINECODE from > 0 && from <= 1),
+ *          otherwise $(D_KEYWORD false).
+ *
+ * Throws: $(D_PSYMBOL ConvException) if $(D_PARAM from) is greater than `1` or
+ *         less than `0`.
+ */
+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");
+}
+
+private @nogc unittest
+{
+    assert(0.0.to!bool == false);
+    assert(0.2.to!bool == true);
+    assert(0.5.to!bool == true);
+    assert(1.0.to!bool == true);
+
+    assert(0.to!bool == false);
+    assert(1.to!bool == true);
+}
+
+private @nogc unittest
+{
+    ConvException exception;
+    try
+    {
+        assert((-1).to!bool == true);
+    }
+    catch (ConvException e)
+    {
+        exception = e;
+    }
+    assert(exception !is null);
+    defaultAllocator.dispose(exception);
+}
+
+private @nogc unittest
+{
+    ConvException exception;
+    try
+    {
+        assert(2.to!bool == true);
+    }
+    catch (ConvException e)
+    {
+        exception = e;
+    }
+    assert(exception !is null);
+    defaultAllocator.dispose(exception);
+}
+
+/**
+ * Converts a boolean to a number. $(D_KEYWORD true) is `1`, $(D_KEYWORD false)
+ * is `0`.
+ *
+ * Params:
+ *  From = Source type.
+ *  To   = Target type.
+ *  from = Source value.
+ *
+ * Returns: `1` if $(D_PARAM from) is $(D_KEYWORD true), otherwise `0`.
+ */
+To to(To, From)(From from)
+if (is(Unqual!From == bool) && isNumeric!To && !is(Unqual!To == Unqual!From))
+{
+    return from;
+}
+
+///
+pure nothrow @safe @nogc 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 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 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);
+}
+
+private @nogc unittest
+{
+    ConvException exception;
+    try
+    {
+        assert(2147483647.5.to!int == 2147483647);
+    }
+    catch (ConvException e)
+    {
+        exception = e;
+    }
+    assert(exception !is null);
+    defaultAllocator.dispose(exception);
+}
+
+private @nogc unittest
+{
+    ConvException exception;
+    try
+    {
+        assert((-2147483648.5).to!int == -2147483648);
+    }
+    catch (ConvException e)
+    {
+        exception = e;
+    }
+    assert(exception !is null);
+    defaultAllocator.dispose(exception);
+}
+
+private @nogc unittest
+{
+    ConvException exception;
+    try
+    {
+        assert((-21474.5).to!uint == -21474);
+    }
+    catch (ConvException e)
+    {
+        exception = e;
+    }
+    assert(exception !is null);
+    defaultAllocator.dispose(exception);
+}
+
+/**
+ * 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 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);
+}
+
+private @nogc unittest
+{
+    enum Test : uint
+    {
+        one,
+        two,
+    }
+
+    ConvException exception;
+    try
+    {
+        assert(5.to!Test == Test.one);
+    }
+    catch (ConvException e)
+    {
+        exception = e;
+    }
+    assert(exception !is null);
+    defaultAllocator.dispose(exception);
+}

source/tanya/format/package.d

@@ -3,14 +3,13 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /**
- * Single-dimensioned array.
+ * This package contains formatting and conversion functions.
  *
- * Copyright: Eugene Wissner 2016-2017.
+ * Copyright: Eugene Wissner 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.format;
-module tanya.container.vector;
 
-public import tanya.container.array;
+public import tanya.format.conv;

source/tanya/math/package.d

@@ -3,6 +3,8 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /**
+ * This package provides mathematical functions.
+ *
  * Copyright: Eugene Wissner 2016-2017.
  * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
  *                  Mozilla Public License, v. 2.0).

source/tanya/math/random.d

@@ -54,17 +54,17 @@ abstract class EntropySource
     /**
      * Returns: Minimum bytes required from the entropy source.
      */
-    @property immutable(ubyte) threshold() const @safe pure nothrow;
+    @property ubyte threshold() const pure nothrow @safe @nogc;
 
     /**
      * Returns: Whether this entropy source is strong.
      */
-    @property immutable(bool) strong() const @safe pure nothrow;
+    @property bool strong() const pure nothrow @safe @nogc;
 
     /**
      * Returns: Amount of already generated entropy.
      */
-    @property ushort size() const @safe pure nothrow
+    @property ushort size() const pure nothrow @safe @nogc
     {
         return size_;
     }
@@ -74,7 +74,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) pure nothrow @safe @nogc
     {
         size_ = size;
     }
@@ -89,12 +89,12 @@ abstract class EntropySource
      * Returns: Number of bytes that were copied to the $(D_PARAM output)
      *          or $(D_PSYMBOL Nullable!ubyte.init) on error.
      */
-    Nullable!ubyte poll(out ubyte[maxGather] output);
+    Nullable!ubyte poll(out ubyte[maxGather] output) @nogc;
 }
 
 version (linux)
 {
-    extern (C) long syscall(long number, ...) nothrow;
+    extern (C) long syscall(long number, ...) nothrow @system @nogc;
 
     /**
      * Uses getrandom system call.
@@ -104,7 +104,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 pure nothrow @safe @nogc
         {
             return 32;
         }
@@ -112,7 +112,7 @@ version (linux)
         /**
          * Returns: Whether this entropy source is strong.
          */
-        override @property immutable(bool) strong() const @safe pure nothrow
+        override @property bool strong() const pure nothrow @safe @nogc
         {
             return true;
         }
@@ -127,7 +127,7 @@ version (linux)
          * Returns: Number of bytes that were copied to the $(D_PARAM output)
          *          or $(D_PSYMBOL Nullable!ubyte.init) on error.
          */
-        override Nullable!ubyte poll(out ubyte[maxGather] output) nothrow
+        override Nullable!ubyte poll(out ubyte[maxGather] output) nothrow @nogc
         out (length)
         {
             assert(length <= maxGather);
@@ -145,6 +145,18 @@ version (linux)
             return ret;
         }
     }
+
+    version (X86_64)
+    {
+        private unittest
+        {
+            auto entropy = defaultAllocator.make!Entropy();
+            ubyte[blockSize] output;
+            output = entropy.random;
+
+            defaultAllocator.dispose(entropy);
+        }
+    }
 }
 
 /**
@@ -177,7 +189,8 @@ class Entropy
      *  allocator  = Allocator to allocate entropy sources available on the
      *               system.
      */
-    this(size_t maxSources = 20, shared Allocator allocator = defaultAllocator)
+    this(const size_t maxSources = 20,
+         shared Allocator allocator = defaultAllocator) @nogc
     in
     {
         assert(maxSources > 0 && maxSources <= ubyte.max);
@@ -196,7 +209,7 @@ class Entropy
     /**
      * Returns: Amount of the registered entropy sources.
      */
-    @property ubyte sourceCount() const @safe pure nothrow
+    @property ubyte sourceCount() const pure nothrow @safe @nogc
     {
         return sourceCount_;
     }
@@ -212,7 +225,7 @@ class Entropy
      * See_Also:
      *  $(D_PSYMBOL EntropySource)
      */
-    Entropy opOpAssign(string Op)(EntropySource source) @safe pure nothrow
+    Entropy opOpAssign(string Op)(EntropySource source) pure nothrow @safe @nogc
         if (Op == "~")
     in
     {
@@ -230,7 +243,7 @@ class Entropy
      * Throws: $(D_PSYMBOL EntropyException) if no strong entropy source was
      *         registered or it failed.
      */
-    @property ubyte[blockSize] random()
+    @property ubyte[blockSize] random() @nogc
     in
     {
         assert(sourceCount_ > 0, "No entropy sources defined.");
@@ -301,13 +314,13 @@ class Entropy
      */
     protected void update(in ubyte sourceId,
                           ref ubyte[maxGather] data,
-                          ubyte length) @safe pure nothrow
+                          ubyte length) pure nothrow @safe @nogc
     {
         ubyte[2] header;
 
         if (length > blockSize)
         {
-            data[0..64] = sha512Of(data);
+            data[0 .. 64] = sha512Of(data);
             length = blockSize;
         }
 
@@ -315,6 +328,6 @@ class Entropy
         header[1] = length;
 
         accumulator.put(header);
-        accumulator.put(data[0..length]);
+        accumulator.put(data[0 .. length]);
     }
 }

source/tanya/memory/allocator.d

@@ -3,6 +3,11 @@
  * 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-2017.
  * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
  *                  Mozilla Public License, v. 2.0).
@@ -28,7 +33,7 @@ interface Allocator
      *
      * Returns: Pointer to the new allocated memory.
      */
-    void[] allocate(in size_t size) shared nothrow @nogc;
+    void[] allocate(const size_t size) shared pure nothrow @nogc;
 
     /**
      * Deallocates a memory block.
@@ -38,7 +43,7 @@ interface Allocator
      *
      * Returns: Whether the deallocation was successful.
      */
-    bool deallocate(void[] p) shared nothrow @nogc;
+    bool deallocate(void[] p) shared pure nothrow @nogc;
 
     /**
      * Increases or decreases the size of a memory block.
@@ -49,7 +54,7 @@ interface Allocator
      *
      * Returns: Pointer to the allocated memory.
      */
-    bool reallocate(ref void[] p, in size_t size) shared nothrow @nogc;
+    bool reallocate(ref void[] p, const size_t size) shared pure nothrow @nogc;
 
     /**
      * Reallocates a memory block in place if possible or returns
@@ -63,5 +68,12 @@ interface 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, const size_t size)
+    shared pure nothrow @nogc;
+}
+
+package template GetPureInstance(T : Allocator)
+{
+    alias GetPureInstance = shared(T) function()
+                            pure nothrow @nogc;
 }

source/tanya/memory/mallocator.d

@@ -3,6 +3,8 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /**
+ * Allocator based on $(D_PSYMBOL malloc), $(D_PSYMBOL realloc) and $(D_PSYMBOL free).
+ *
  * Copyright: Eugene Wissner 2017.
  * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
  *                  Mozilla Public License, v. 2.0).
@@ -11,14 +13,21 @@
 module tanya.memory.mallocator;
 
 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)
+                               pure nothrow @system @nogc;
+    private alias FreeType = extern (C) void function(void*)
+                             pure nothrow @system @nogc;
+    private alias ReallocType = extern (C) void* function(void*, size_t)
+                                pure nothrow @system @nogc;
+
     /**
      * Allocates $(D_PARAM size) bytes of memory.
      *
@@ -27,13 +36,13 @@ final class Mallocator : Allocator
      *
      * Returns: The pointer to the new allocated memory.
      */
-    void[] allocate(in size_t size) shared nothrow @nogc
+    void[] allocate(const size_t size) shared pure nothrow @nogc
     {
-        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];
     }
@@ -42,10 +51,11 @@ final class Mallocator : Allocator
     @nogc nothrow 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,11 +66,11 @@ final class Mallocator : Allocator
      *
      * Returns: Whether the deallocation was successful.
      */
-    bool deallocate(void[] p) shared nothrow @nogc
+    bool deallocate(void[] p) shared pure nothrow @nogc
     {
         if (p !is null)
         {
-            free(p.ptr - psize);
+            (cast(FreeType) &free)(p.ptr - psize);
         }
         return true;
     }
@@ -84,11 +94,19 @@ 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, const size_t size)
+    shared pure nothrow @nogc
     {
         return false;
     }
 
+    ///
+    @nogc nothrow unittest
+    {
+        void[] p;
+        assert(!Mallocator.instance.reallocateInPlace(p, 8));
+    }
+
     /**
      * Increases or decreases the size of a memory block.
      *
@@ -98,7 +116,7 @@ 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, const size_t size) shared pure nothrow @nogc
     {
         if (size == 0)
         {
@@ -115,7 +133,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)
             {
@@ -144,24 +162,34 @@ final class Mallocator : Allocator
         assert(p is null);
     }
 
+    // Fails with false.
+    private @nogc nothrow unittest
+    {
+        void[] p = Mallocator.instance.allocate(20);
+        void[] oldP = p;
+        assert(!Mallocator.instance.reallocate(p, size_t.max - Mallocator.psize * 2));
+        assert(oldP is p);
+        Mallocator.instance.deallocate(p);
+    }
+
     /**
      * Returns: The alignment offered.
      */
     @property uint alignment() shared const pure nothrow @safe @nogc
     {
-        return cast(uint) max(double.alignof, real.alignof);
+        return (void*).alignof;
     }
 
-    /**
+    private nothrow @nogc unittest
-     * Static allocator instance and initializer.
+    {
-     *
+        assert(Mallocator.instance.alignment == (void*).alignof);
-     * Returns: The global $(D_PSYMBOL Allocator) instance.
+    }
-     */
+
-    static @property ref shared(Mallocator) instance() @nogc nothrow
+    static private shared(Mallocator) instantiate() nothrow @nogc
     {
         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 +201,23 @@ final class Mallocator : Allocator
         return instance_;
     }
 
+    /**
+     * Static allocator instance and initializer.
+     *
+     * Returns: The global $(D_PSYMBOL Allocator) instance.
+     */
+    static @property shared(Mallocator) instance() pure nothrow @nogc
+    {
+        return (cast(GetPureInstance!Mallocator) &instantiate)();
+    }
+
     ///
     @nogc nothrow unittest
     {
         assert(instance is instance);
     }
 
-    private enum psize = 8;
+    private enum ushort psize = 8;
 
     private shared static Mallocator instance_;
 }

source/tanya/memory/mmappool.d

@@ -3,6 +3,8 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /**
+ * Native allocator for Posix and Windows.
+ *
  * Copyright: Eugene Wissner 2016-2017.
  * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
  *                  Mozilla Public License, v. 2.0).
@@ -16,14 +18,63 @@ import tanya.memory.allocator;
 
 version (Posix)
 {
-    import core.stdc.errno;
+    import core.sys.posix.sys.mman : PROT_READ, PROT_WRITE, MAP_PRIVATE,
-    import core.sys.posix.sys.mman;
+                                     MAP_ANON, MAP_FAILED;
     import core.sys.posix.unistd;
+
+    extern (C)
+    private void* mmap(void* addr,
+                       size_t len,
+                       int prot,
+                       int flags,
+                       int fd,
+                       off_t offset) pure nothrow @system @nogc;
+
+    extern (C)
+    private int munmap(void* addr, size_t len) pure nothrow @system @nogc;
+
+    private void* mapMemory(const size_t len) pure nothrow @system @nogc
+    {
+        void* p = mmap(null,
+                       len,
+                       PROT_READ | PROT_WRITE,
+                       MAP_PRIVATE | MAP_ANON,
+                       -1,
+                       0);
+        return p is MAP_FAILED ? null : p;
+    }
+
+    private bool unmapMemory(shared void* addr, const size_t len)
+    pure nothrow @system @nogc
+    {
+        return munmap(cast(void*) addr, len) == 0;
+    }
 }
 else version (Windows)
 {
-    import core.sys.windows.winbase;
+    import core.sys.windows.winbase : GetSystemInfo, SYSTEM_INFO;
-    import core.sys.windows.windows;
+
+    extern (Windows)
+    private void* VirtualAlloc(void*, size_t, uint, uint)
+    pure nothrow @system @nogc;
+
+    extern (Windows)
+    private int VirtualFree(void* addr, size_t len, uint)
+    pure nothrow @system @nogc;
+
+    private void* mapMemory(const size_t len) pure nothrow @system @nogc
+    {
+        return VirtualAlloc(null,
+                            len,
+                            0x00001000, // MEM_COMMIT
+                            0x04); // PAGE_READWRITE
+    }
+
+    private bool unmapMemory(shared void* addr, const size_t len)
+    pure nothrow @system @nogc
+    {
+        return VirtualFree(cast(void*) addr, 0, 0x8000) == 0;
+    }
 }
 
 /**
@@ -50,18 +101,21 @@ else version (Windows)
  */
 final class MmapPool : Allocator
 {
-    invariant
+    version (none)
     {
-        for (auto r = &head; *r !is null; r = &((*r).next))
+        pure nothrow @nogc 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);
         }
     }
 
@@ -73,13 +127,17 @@ final class MmapPool : Allocator
      *
      * Returns: Pointer to the new allocated memory.
      */
-    void[] allocate(in size_t size) shared nothrow @nogc
+    void[] allocate(const size_t size) shared pure nothrow @nogc
     {
-        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)
@@ -94,13 +152,32 @@ final class MmapPool : Allocator
     nothrow unittest
     {
         auto p = MmapPool.instance.allocate(20);
-
         assert(p);
-
         MmapPool.instance.deallocate(p);
+
+        p = MmapPool.instance.allocate(0);
+        assert(p.length == 0);
     }
 
-    /**
+    // Issue 245: https://issues.caraus.io/issues/245.
+    private @nogc unittest
+    {
+        // allocate() check.
+        size_t tooMuchMemory = size_t.max
+                             - MmapPool.alignment_
+                             - BlockEntry.sizeof * 2
+                             - RegionEntry.sizeof
+                             - MmapPool.instance.pageSize;
+        assert(MmapPool.instance.allocate(tooMuchMemory) is null);
+
+        assert(MmapPool.instance.allocate(size_t.max) is null);
+
+        // initializeRegion() check.
+        tooMuchMemory = size_t.max - MmapPool.alignment_;
+        assert(MmapPool.instance.allocate(tooMuchMemory) is null);
+    }
+
+    /*
      * 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 +186,7 @@ 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) shared pure nothrow @nogc
     {
         Block block1;
         RegionLoop: for (auto r = head; r !is null; r = r.next)
@@ -169,7 +246,7 @@ final class MmapPool : Allocator
      *
      * Returns: Whether the deallocation was successful.
      */
-    bool deallocate(void[] p) shared nothrow @nogc
+    bool deallocate(void[] p) shared pure nothrow @nogc
     {
         if (p.ptr is null)
         {
@@ -191,14 +268,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)
@@ -242,7 +312,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, const size_t size)
+    shared pure nothrow @nogc
     {
         if (p is null || size == 0)
         {
@@ -258,19 +329,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 is too small
+             * * The next block isn't free
+             * * Requested size is too large
+             */
             return false;
         }
         if (block1.next.size >= delta + alignment_)
@@ -333,7 +410,7 @@ 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, const size_t size) shared pure nothrow @nogc
     {
         if (size == 0)
         {
@@ -394,19 +471,14 @@ final class MmapPool : Allocator
         MmapPool.instance.deallocate(p);
     }
 
-    /**
+    static private shared(MmapPool) instantiate() nothrow @nogc
-     * Static allocator instance and initializer.
-     *
-     * Returns: Global $(D_PSYMBOL MmapPool) instance.
-     */
-    static @property ref shared(MmapPool) instance() nothrow @nogc
     {
         if (instance_ is null)
         {
             // Get system dependend page size.
             version (Posix)
             {
-                pageSize = sysconf(_SC_PAGE_SIZE);
+                size_t pageSize = sysconf(_SC_PAGE_SIZE);
                 if (pageSize < 65536)
                 {
                     pageSize = pageSize * 65536 / pageSize;
@@ -416,23 +488,35 @@ final class MmapPool : Allocator
             {
                 SYSTEM_INFO si;
                 GetSystemInfo(&si);
-                pageSize = si.dwPageSize;
+                size_t pageSize = si.dwPageSize;
             }
 
-            immutable instanceSize = addAlignment(__traits(classInstanceSize, MmapPool));
+            const instanceSize = addAlignment(__traits(classInstanceSize,
+                                              MmapPool));
 
             Region head; // Will become soon our region list head
-            void* data = initializeRegion(instanceSize, head);
+            void* data = initializeRegion(instanceSize, head, pageSize);
             if (data !is null)
             {
                 memcpy(data, typeid(MmapPool).initializer.ptr, instanceSize);
                 instance_ = cast(shared MmapPool) data;
                 instance_.head = head;
+                instance_.pageSize = pageSize;
             }
         }
         return instance_;
     }
 
+    /**
+     * Static allocator instance and initializer.
+     *
+     * Returns: Global $(D_PSYMBOL MmapPool) instance.
+     */
+    static @property shared(MmapPool) instance() pure nothrow @nogc
+    {
+        return (cast(GetPureInstance!MmapPool) &instantiate)();
+    }
+
     ///
     nothrow unittest
     {
@@ -448,34 +532,21 @@ 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,
-    nothrow @nogc
+                                          ref Region head,
+                                          const size_t pageSize)
+    pure nothrow @nogc
     {
-        immutable regionSize = calculateRegionSize(size);
+        const regionSize = calculateRegionSize(size, pageSize);
-
+        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 +584,9 @@ final class MmapPool : Allocator
         return data;
     }
 
-    private void* initializeRegion(size_t size) shared nothrow @nogc
+    private void* initializeRegion(const size_t size) shared pure nothrow @nogc
     {
-        return initializeRegion(size, head);
+        return initializeRegion(size, this.head, this.pageSize);
     }
 
     /*
@@ -524,33 +595,24 @@ 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) pure nothrow @safe @nogc
-    pure nothrow @safe @nogc
-    out (result)
-    {
-        assert(result > 0);
-    }
-    body
     {
         return (x - 1) / alignment_ * alignment_ + alignment_;
     }
 
     /*
      * Params:
-     *  x = Required space.
+     *  x        = Required space.
+     *  pageSize = Page size.
      *
      * 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
+                                              ref const size_t pageSize)
-    out (result)
+    pure nothrow @safe @nogc
     {
-        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;
     }
 
     /**
@@ -560,10 +622,16 @@ final class MmapPool : Allocator
     {
         return alignment_;
     }
-    private enum alignment_ = 8;
+
+    private nothrow @nogc unittest
+    {
+        assert(MmapPool.instance.alignment == MmapPool.alignment_);
+    }
+
+    private enum uint alignment_ = 8;
 
     private shared static MmapPool instance_;
-    private shared static size_t pageSize;
+    private shared size_t pageSize;
 
     private shared struct RegionEntry
     {
@@ -588,7 +656,7 @@ final class MmapPool : Allocator
 
 // A lot of allocations/deallocations, but it is the minimum caused a
 // segmentation fault because MmapPool reallocateInPlace moves a block wrong.
-unittest
+private @nogc unittest
 {
     auto a = MmapPool.instance.allocate(16);
     auto d = MmapPool.instance.allocate(16);

source/tanya/memory/package.d

@@ -3,6 +3,8 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /**
+ * Dynamic memory management.
+ *
  * Copyright: Eugene Wissner 2016-2017.
  * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
  *                  Mozilla Public License, v. 2.0).
@@ -12,9 +14,12 @@ module tanya.memory;
 
 import core.exception;
 import std.algorithm.iteration;
-public import std.experimental.allocator : make;
+import std.algorithm.mutation;
+import std.conv;
+import std.range;
 import std.traits;
 public import tanya.memory.allocator;
+import tanya.memory.mmappool;
 
 /**
  * The mixin generates common methods for classes and structs using
@@ -33,7 +38,7 @@ mixin template DefaultAllocator()
      *
      * Precondition: $(D_INLINECODE allocator_ !is null)
      */
-    this(shared Allocator allocator)
+    this(shared Allocator allocator) pure nothrow @safe @nogc
     in
     {
         assert(allocator !is null);
@@ -51,7 +56,7 @@ mixin template DefaultAllocator()
      *
      * Postcondition: $(D_INLINECODE allocator !is null)
      */
-    protected @property shared(Allocator) allocator() nothrow @safe @nogc
+    protected @property shared(Allocator) allocator() pure nothrow @safe @nogc
     out (allocator)
     {
         assert(allocator !is null);
@@ -66,7 +71,7 @@ mixin template DefaultAllocator()
     }
 
     /// Ditto.
-    @property shared(Allocator) allocator() const nothrow @trusted @nogc
+    @property shared(Allocator) allocator() const pure nothrow @trusted @nogc
     out (allocator)
     {
         assert(allocator !is null);
@@ -82,26 +87,44 @@ mixin template DefaultAllocator()
 }
 
 // From druntime
-private extern (C) void _d_monitordelete(Object h, bool det) nothrow @nogc;
+extern (C)
+private void _d_monitordelete(Object h, bool det) pure nothrow @nogc;
 
 shared Allocator allocator;
 
-shared static this() nothrow @trusted @nogc
+shared static this() nothrow @nogc
 {
-    import tanya.memory.mmappool;
     allocator = MmapPool.instance;
 }
 
-@property ref shared(Allocator) defaultAllocator() nothrow @safe @nogc
+private shared(Allocator) getAllocatorInstance() nothrow @nogc
+{
+    return allocator;
+}
+
+/**
+ * Returns: Default allocator.
+ *
+ * Postcondition: $(D_INLINECODE allocator !is null).
+ */
+@property shared(Allocator) defaultAllocator() pure nothrow @trusted @nogc
 out (allocator)
 {
     assert(allocator !is null);
 }
 body
 {
-    return allocator;
+    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) nothrow @safe @nogc
 in
 {
@@ -112,6 +135,17 @@ body
     .allocator = allocator;
 }
 
+private nothrow @nogc unittest
+{
+    import tanya.memory.mallocator;
+
+    auto oldAllocator = defaultAllocator;
+    defaultAllocator = Mallocator.instance;
+    assert(defaultAllocator is Mallocator.instance);
+
+    defaultAllocator = oldAllocator;
+}
+
 /**
  * Returns the size in bytes of the state that needs to be allocated to hold an
  * object of type $(D_PARAM T).
@@ -258,7 +292,8 @@ package(tanya) void[] finalize(T)(ref T p)
         // 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);
+            alias DtorType = void function(Object) pure nothrow @safe @nogc;
+            (cast(DtorType) c.destructor)(ob);
         }
     }
     while ((c = c.base) !is null);
@@ -307,3 +342,148 @@ private unittest
 
     defaultAllocator.dispose(p);
 }
+
+// Works with interfaces.
+private pure unittest
+{
+    interface I
+    {
+    }
+    class C : I
+    {
+    }
+    auto c = defaultAllocator.make!C();
+    I i = c;
+
+    defaultAllocator.dispose(i);
+    defaultAllocator.dispose(i);
+}
+
+/**
+ * Constructs a new class instance of type $(D_PARAM T) using $(D_PARAM args)
+ * as the parameter list for the constructor of $(D_PARAM T).
+ *
+ * Params:
+ *  T         = Class type.
+ *  A         = Types of the arguments to the constructor of $(D_PARAM T).
+ *  allocator = Allocator.
+ *  args      = Constructor arguments of $(D_PARAM T).
+ * 
+ * Returns: Newly created $(D_PSYMBOL T).
+ *
+ * Precondition: $(D_INLINECODE allocator !is null)
+ */
+T make(T, A...)(shared Allocator allocator, auto ref A args)
+if (is(T == class))
+in
+{
+    assert(allocator !is null);
+}
+body
+{
+    T ret;
+    const size = stateSize!T;
+
+    auto mem = (() @trusted => allocator.allocate(size))();
+    if (mem is null)
+    {
+        onOutOfMemoryError();
+    }
+    scope (failure)
+    {
+        () @trusted { allocator.deallocate(mem); }();
+    }
+
+    ret = emplace!T(mem[0 .. size], args);
+
+    return ret;
+}
+
+/**
+ * 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 (!is(T == interface)
+ && !is(T == class)
+ && !isAssociativeArray!T
+ && !isArray!T)
+in
+{
+    assert(allocator !is null);
+}
+body
+{
+    typeof(return) ret;
+    const size = stateSize!T;
+
+    auto mem = (() @trusted => allocator.allocate(size))();
+    if (mem is null)
+    {
+        onOutOfMemoryError();
+    }
+    scope (failure)
+    {
+        () @trusted { allocator.deallocate(mem); }();
+    }
+
+    auto ptr = (() @trusted => (cast(T*) mem[0 .. size].ptr))();
+    ret = emplace!T(ptr, args);
+
+    return ret;
+}
+
+///
+unittest
+{
+    int* i = defaultAllocator.make!int(5);
+    assert(*i == 5);
+    defaultAllocator.dispose(i);
+}
+
+/**
+ * Constructs a new array with $(D_PARAM size) elements.
+ *
+ * Params:
+ *  T         = Array type.
+ *  allocator = Allocator.
+ *  size      = Array size.
+ *
+ * Returns: Newly created array.
+ *
+ * Precondition: $(D_INLINECODE allocator !is null
+ *                           && n <= size_t.max / ElementType!T.sizeof)
+ */
+T make(T)(shared Allocator allocator, const size_t n)
+if (isArray!T)
+in
+{
+    assert(allocator !is null);
+    assert(n <= size_t.max / ElementType!T.sizeof);
+}
+body
+{
+    auto ret = allocator.resize!(ElementType!T)(null, n);
+    ret.uninitializedFill(ElementType!T.init);
+    return ret;
+}
+
+///
+unittest
+{
+    int[] i = defaultAllocator.make!(int[])(2);
+    assert(i.length == 2);
+    assert(i[0] == int.init && i[1] == int.init);
+    defaultAllocator.dispose(i);
+}

source/tanya/memory/smartref.d

@@ -3,12 +3,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /**
+ * Smart pointers.
+ *
+ * A smart pointer is an object that wraps a raw pointer or a reference
+ * (class, array) to manage its lifetime.
+ *
  * 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.types;
+module tanya.memory.smartref;
 
 import core.exception;
 import std.algorithm.comparison;
@@ -30,16 +35,16 @@ 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
     {
-        assert(counter > 0);
+        assert(this.counter > 0);
     }
     body
     {
@@ -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,18 +116,13 @@ 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.
@@ -159,7 +154,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 +178,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,10 +196,17 @@ struct RefCounted(T)
             finalize(this.storage.payload);
             this.storage.payload = Payload!T.init;
         }
-        move(rhs, this.storage.payload);
+        this.storage.payload = rhs;
         return this;
     }
 
+    private @nogc unittest
+    {
+        auto rc = defaultAllocator.refCounted!int(5);
+        rc = defaultAllocator.make!int(7);
+        assert(*rc == 7);
+    }
+
     /// Ditto.
     ref typeof(this) opAssign(typeof(null))
     {
@@ -225,6 +227,14 @@ struct RefCounted(T)
         return this;
     }
 
+    private @nogc unittest
+    {
+        RefCounted!int rc;
+        assert(!rc.isInitialized);
+        rc = null;
+        assert(!rc.isInitialized);
+    }
+
     /// Ditto.
     ref typeof(this) opAssign(typeof(this) rhs)
     {
@@ -239,36 +249,36 @@ struct RefCounted(T)
      *
      * Precondition: $(D_INLINECODE cound > 0).
      */
-    Payload!T get() pure nothrow @safe @nogc
+    inout(Payload!T) get() inout
     in
     {
-        assert(count > 0, "Attempted to access an uninitialized reference.");
+        assert(count > 0, "Attempted to access an uninitialized reference");
     }
     body
     {
-        return storage.payload;
+        return this.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;
         }
     }
 
@@ -278,7 +288,7 @@ struct RefCounted(T)
      */
     @property bool isInitialized() const
     {
-        return storage !is null;
+        return this.storage !is null;
     }
 
     /**
@@ -288,7 +298,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;
@@ -299,7 +309,7 @@ struct RefCounted(T)
 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);
@@ -312,6 +322,43 @@ unittest
     assert(*rc.storage.payload == 9);
 }
 
+private @nogc unittest
+{
+    auto rc = defaultAllocator.refCounted!int(5);
+
+    void func(RefCounted!int param) @nogc
+    {
+        assert(param.count == 2);
+        param = defaultAllocator.make!int(7);
+        assert(param.count == 1);
+        assert(*param == 7);
+    }
+    func(rc);
+    assert(rc.count == 1);
+    assert(*rc == 5);
+}
+
+private @nogc unittest
+{
+    RefCounted!int rc;
+
+    void func(RefCounted!int param) @nogc
+    {
+        assert(param.count == 0);
+        param = defaultAllocator.make!int(7);
+        assert(param.count == 1);
+        assert(*param == 7);
+    }
+    func(rc);
+    assert(rc.count == 0);
+}
+
+private unittest
+{
+    RefCounted!int rc1, rc2;
+    static assert(is(typeof(rc1 = rc2)));
+}
+
 version (unittest)
 {
     private class A
@@ -340,7 +387,7 @@ version (unittest)
     }
 }
 
-private unittest
+private @nogc unittest
 {
     uint destroyed;
     auto a = defaultAllocator.make!A(destroyed);
@@ -350,7 +397,7 @@ private unittest
         auto rc = RefCounted!A(a, defaultAllocator);
         assert(rc.count == 1);
 
-        void func(RefCounted!A rc)
+        void func(RefCounted!A rc) @nogc
         {
             assert(rc.count == 2);
         }
@@ -366,12 +413,19 @@ private unittest
     assert(rc.count == 1);
 }
 
-private unittest
+private @nogc unittest
+{
+    auto rc = RefCounted!int(defaultAllocator);
+    assert(!rc.isInitialized);
+    assert(rc.allocator is defaultAllocator);
+}
+
+private @nogc unittest
 {
     auto rc = defaultAllocator.refCounted!int(5);
     assert(rc.count == 1);
 
-    void func(RefCounted!int rc)
+    void func(RefCounted!int rc) @nogc
     {
         assert(rc.count == 2);
         rc = null;
@@ -393,7 +447,7 @@ private unittest
     auto rc = defaultAllocator.refCounted!int(5);
     assert(*rc == 5);
 
-    void func(RefCounted!int rc)
+    void func(RefCounted!int rc) @nogc
     {
         assert(rc.count == 2);
         rc = defaultAllocator.refCounted!int(4);
@@ -433,8 +487,8 @@ private unittest
  * 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
 {
     assert(allocator !is null);
@@ -486,7 +540,7 @@ body
  */
 RefCounted!T refCounted(T)(shared Allocator allocator, const size_t size)
 @trusted
-    if (isArray!T)
+if (isArray!T)
 in
 {
     assert(allocator !is null);
@@ -494,8 +548,7 @@ in
 }
 body
 {
-    auto payload = allocator.resize!(ElementType!T)(null, size);
+    return RefCounted!T(allocator.make!T(size), allocator);
-    return RefCounted!T(payload, allocator);
 }
 
 ///
@@ -504,7 +557,7 @@ 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)
         {
@@ -534,7 +587,7 @@ private @nogc unittest
     static assert(!is(typeof(defaultAllocator.refCounted!E(5))));
     {
         auto rc = defaultAllocator.refCounted!B(3);
-        assert(rc.get.prop == 3);
+        assert(rc.get().prop == 3);
     }
     {
         auto rc = defaultAllocator.refCounted!E();
@@ -548,6 +601,14 @@ private @nogc unittest
     assert(rc.length == 5);
 }
 
+private @nogc unittest
+{
+    auto p1 = defaultAllocator.make!int(5);
+    auto p2 = p1;
+    auto rc = RefCounted!int(p1, defaultAllocator);
+    assert(rc.get() is p2);
+}
+
 private @nogc unittest
 {
     static bool destroyed = false;
@@ -566,12 +627,12 @@ private @nogc unittest
 }
 
 /**
- * $(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,16 +652,10 @@ 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.
@@ -615,7 +670,7 @@ struct Scoped(T)
     }
 
     /**
-     * $(D_PSYMBOL Scoped) is noncopyable.
+     * $(D_PSYMBOL Unique) is noncopyable.
      */
     @disable this(this);
 
@@ -624,32 +679,28 @@ 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;
     }
 
@@ -669,37 +720,83 @@ struct Scoped(T)
         return this;
     }
 
+    ///
+    @nogc 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 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 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;
 }
@@ -708,8 +805,7 @@ struct Scoped(T)
 @nogc 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);
 }
 
@@ -726,14 +822,14 @@ struct Scoped(T)
         }
     }
     {
-        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:
@@ -742,40 +838,40 @@ struct Scoped(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
 {
     assert(allocator !is null);
 }
 body
 {
-    auto payload = allocator.make!(T, shared Allocator, A)(args);
+    auto payload = allocator.make!(T, A)(args);
-    return Scoped!T(payload, allocator);
+    return Unique!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.
  *  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)
  */
-Scoped!T scoped(T)(shared Allocator allocator, const size_t size)
+Unique!T unique(T)(shared Allocator allocator, const size_t size)
 @trusted
-    if (isArray!T)
+if (isArray!T)
 in
 {
     assert(allocator !is null);
@@ -784,18 +880,18 @@ in
 body
 {
     auto payload = allocator.resize!(ElementType!T)(null, size);
-    return Scoped!T(payload, allocator);
+    return Unique!T(payload, allocator);
 }
 
 private unittest
 {
-    static assert(is(typeof(defaultAllocator.scoped!B(5))));
+    static assert(is(typeof(defaultAllocator.unique!B(5))));
-    static assert(is(typeof(defaultAllocator.scoped!(int[])(5))));
+    static assert(is(typeof(defaultAllocator.unique!(int[])(5))));
 }
 
 private unittest
 {
-    auto s = defaultAllocator.scoped!int(5);
+    auto s = defaultAllocator.unique!int(5);
     assert(*s == 5);
 
     s = null;
@@ -804,9 +900,24 @@ private unittest
 
 private unittest
 {
-    auto s = defaultAllocator.scoped!int(5);
+    auto s = defaultAllocator.unique!int(5);
     assert(*s == 5);
 
-    s = defaultAllocator.scoped!int(4);
+    s = defaultAllocator.unique!int(4);
     assert(*s == 4);
 }
+
+private @nogc unittest
+{
+    auto p1 = defaultAllocator.make!int(5);
+    auto p2 = p1;
+
+    auto rc = Unique!int(p1, defaultAllocator);
+    assert(rc.get() is p2);
+}
+
+private @nogc unittest
+{
+    auto rc = Unique!int(defaultAllocator);
+    assert(rc.allocator is defaultAllocator);
+}

source/tanya/net/inet.d

@@ -10,7 +10,7 @@
  *                  Mozilla Public License, v. 2.0).
  * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
  */
-module tanya.network.inet;
+module tanya.net.inet;
 
 import std.math;
 import std.range.primitives;

source/tanya/net/package.d

@@ -0,0 +1,16 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Network programming.
+ *
+ * Copyright: Eugene Wissner 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.net;
+
+public import tanya.net.inet;
+public import tanya.net.uri;

source/tanya/net/uri.d

@@ -0,0 +1,573 @@
+/* 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.
+ * 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.net.uri;
+
+import std.ascii : isAlphaNum, isDigit;
+import std.uni : isAlpha, isNumber;
+import tanya.memory;
+
+/**
+ * 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 @safe pure nothrow
+    {
+        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) pure @nogc
+    {
+        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
+            {
+                // Schemas like mailto: and zlib: may not have any slash after
+                // them.
+                if (!parsePort(source[pos .. $]))
+                {
+                    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.isNumber &&
+                         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) pure nothrow @safe @nogc
+    {
+        ptrdiff_t i = 1;
+        float lPort = 0;
+
+        for (; i < port.length && port[i].isDigit() && i <= 6; ++i)
+        {
+            lPort += (port[i] - '0') / cast(float) (10 ^^ (i - 1));
+        }
+        if (i != 1 && (i == port.length || port[i] == '/'))
+        {
+            lPort *= 10 ^^ (i - 2);
+            if (lPort > ushort.max)
+            {
+                return false;
+            }
+            this.port = cast(ushort) lPort;
+            return true;
+        }
+        return false;
+    }
+}
+
+///
+@nogc 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");
+}
+
+private @nogc unittest
+{
+    auto u = URL("127.0.0.1");
+    assert(u.path == "127.0.0.1");
+
+    u = URL("http://127.0.0.1");
+    assert(u.scheme == "http");
+    assert(u.host == "127.0.0.1");
+
+    u = URL("http://127.0.0.1:9000");
+    assert(u.scheme == "http");
+    assert(u.host == "127.0.0.1");
+    assert(u.port == 9000);
+
+    u = URL("127.0.0.1:80");
+    assert(u.host == "127.0.0.1");
+    assert(u.port == 80);
+    assert(u.path is null);
+
+    u = URL("//example.net");
+    assert(u.host == "example.net");
+    assert(u.scheme is null);
+
+    u = URL("//example.net?q=before:after");
+    assert(u.host == "example.net");
+    assert(u.query == "q=before:after");
+
+    u = URL("localhost:8080");
+    assert(u.host == "localhost");
+    assert(u.port == 8080);
+    assert(u.path is null);
+
+    u = URL("ftp:");
+    assert(u.scheme == "ftp");
+
+    u = URL("file:///C:\\Users");
+    assert(u.scheme == "file");
+    assert(u.path == "C:\\Users");
+
+    u = URL("localhost:66000");
+    assert(u.scheme == "localhost");
+    assert(u.path == "66000");
+
+    u = URL("file:///home/");
+    assert(u.scheme == "file");
+    assert(u.path == "/home/");
+
+    u = URL("file:///home/?q=asdf");
+    assert(u.scheme == "file");
+    assert(u.path == "/home/");
+    assert(u.query == "q=asdf");
+
+    u = URL("http://secret@example.org");
+    assert(u.scheme == "http");
+    assert(u.host == "example.org");
+    assert(u.user == "secret");
+
+    u = URL("h_tp://:80");
+    assert(u.path == "h_tp://:80");
+    assert(u.port == 0);
+
+    u = URL("zlib:/home/user/file.gz");
+    assert(u.scheme == "zlib");
+    assert(u.path == "/home/user/file.gz");
+
+    u = URL("h_tp:asdf");
+    assert(u.path == "h_tp:asdf");
+}
+
+private @nogc unittest
+{
+    URIException exception;
+    try
+    {
+        auto u = URL("http://:80");
+    }
+    catch (URIException e)
+    {
+        exception = e;
+    }
+    assert(exception !is null);
+    defaultAllocator.dispose(exception);
+}
+
+private @nogc unittest
+{
+    URIException exception;
+    try
+    {
+        auto u = URL(":80");
+    }
+    catch (URIException e)
+    {
+        exception = e;
+    }
+    assert(exception !is null);
+    defaultAllocator.dispose(exception);
+}
+
+private @nogc unittest
+{
+    URIException exception;
+    try
+    {
+        auto u = URL("http://user1:pass1@user2:pass2@example.org");
+    }
+    catch (URIException e)
+    {
+        exception = e;
+    }
+    assert(exception !is null);
+    defaultAllocator.dispose(exception);
+}
+
+private @nogc unittest
+{
+    URIException exception;
+    try
+    {
+        auto u = URL("http://blah.com:port");
+    }
+    catch (URIException e)
+    {
+        exception = e;
+    }
+    assert(exception !is null);
+    defaultAllocator.dispose(exception);
+}
+
+private @nogc unittest
+{
+    URIException exception;
+    try
+    {
+        auto u = URL("http://blah.com:66000");
+    }
+    catch (URIException e)
+    {
+        exception = e;
+    }
+    assert(exception !is null);
+    defaultAllocator.dispose(exception);
+}
+
+// Issue 254: https://issues.caraus.io/issues/254.
+private @system @nogc unittest
+{
+    auto u = URL("ftp://");
+    assert(u.scheme == "ftp");
+}
+
+/**
+ * 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
+{
+    return URL(source);
+}
+
+///
+@nogc 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/package.d

@@ -12,6 +12,4 @@
  */
 module tanya.network;
 
-public import tanya.network.inet;
 public import tanya.network.socket;
-public import tanya.network.url;

source/tanya/os/error.d

@@ -0,0 +1,337 @@
+/* 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.
+ * 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.os.error;
+
+// 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 orR 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),
+    }
+
+    /**
+     * Constructor.
+     *
+     * Params:
+     *  value = Numeric error code.
+     */
+    this(const ErrorNo value) pure nothrow @safe @nogc
+    {
+        this.value_ = value;
+    }
+
+    ///
+    pure nothrow @safe @nogc 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() pure nothrow @safe @nogc
+    {
+        this.value_ = ErrorNo.success;
+    }
+
+    ///
+    pure nothrow @safe @nogc 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_;
+    }
+
+    ///
+    pure nothrow @safe @nogc 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) pure nothrow @safe @nogc
+    {
+        this.value_ = that;
+        return this;
+    }
+
+    /// Ditto.
+    ref ErrorCode opAssign()(auto ref const ErrorCode that)
+    pure nothrow @safe @nogc
+    {
+        this.value_ = that.value_;
+        return this;
+    }
+
+    ///
+    pure nothrow @safe @nogc unittest
+    {
+        {
+            ErrorCode ec;
+            assert(ec == ErrorCode.success);
+
+            ec = ErrorCode.fault;
+            assert(ec == ErrorCode.fault);
+        }
+        {
+            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 pure nothrow @safe @nogc
+    {
+        return this.value_ == that;
+    }
+
+    /// Ditto.
+    bool opEquals()(auto ref const ErrorCode that)
+    const pure nothrow @safe @nogc
+    {
+        return this.value_ == that.value_;
+    }
+
+    ///
+    pure nothrow @safe @nogc unittest
+    {
+        {
+            ErrorCode ec1 = ErrorCode.fault;
+            ErrorCode ec2 = ErrorCode.accessDenied;
+
+            assert(ec1 != ec2);
+            assert(ec1 != ErrorCode.accessDenied);
+            assert(ErrorCode.fault != ec2);
+        }
+        {
+            ErrorCode ec1 = ErrorCode.fault;
+            ErrorCode ec2 = ErrorCode.fault;
+
+            assert(ec1 == ec2);
+            assert(ec1 == ErrorCode.fault);
+            assert(ErrorCode.fault == ec2);
+        }
+    }
+
+    private ErrorNo value_ = ErrorNo.success;
+
+    alias ErrorNo this;
+}

source/tanya/os/package.d

@@ -0,0 +1,16 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * This package provides platform-independent interfaces to operating system
+ * functionality.
+ *
+ * Copyright: Eugene Wissner 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.os;
+
+public import tanya.os.error;