From 4794e84c1372da34a4961505d6a809de0f07ab55 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Wed, 22 Nov 2017 16:34:02 +1100
Subject: [PATCH 01/56] build: prefer target specific includes and libs

---
 CMakeLists.txt | 30 +++++++++++++++++-------------
 1 file changed, 17 insertions(+), 13 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index dae941d7..14a94bb7 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -29,8 +29,6 @@ RAGEL_TARGET(json-flat json/flat.cpp.rl ${CMAKE_CURRENT_BINARY_DIR}/json/flat.cp
 RAGEL_TARGET(uri uri.cpp.rl ${CMAKE_CURRENT_BINARY_DIR}/uri.cpp)
 RAGEL_TARGET(version version.cpp.rl ${CMAKE_CURRENT_BINARY_DIR}/version.cpp)
 
-include_directories(${CMAKE_CURRENT_SOURCE_DIR})
-
 
 ###############################################################################
 set (UTIL_FILES)
@@ -74,16 +72,6 @@ else ()
 endif ()
 
 
-###############################################################################
-# platform libraries
-search_libs (SHM_LIBS shm_open rt)
-search_libs (DL_LIBS dlopen dl)
-search_libs (CLOCK_LIB clock_gettime rt c)
-search_libs (MATH_LIB cos m)
-
-list (APPEND LIBS ${SHM_LIBS} ${DL_LIBS} ${CLOCK_LIB} ${MATH_LIB})
-
-
 ###############################################################################
 # platform wrappers
 list (
@@ -415,9 +403,23 @@ list (
     view.hpp
 )
 
+
 ###############################################################################
 add_library(cruft-util ${UTIL_FILES})
-target_link_libraries (cruft-util ${LIBS})
+target_link_libraries (cruft-util PUBLIC ${LIBS})
+target_include_directories(cruft-util PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}")
+
+###############################################################################
+# platform libraries
+search_libs (SHM_LIBS shm_open rt)
+search_libs (DL_LIBS dlopen dl)
+search_libs (CLOCK_LIBS clock_gettime rt c)
+search_libs (MATH_LIBS cos m)
+
+target_link_libraries(cruft-util PUBLIC ${SHM_LIBS})
+target_link_libraries(cruft-util PUBLIC ${DL_LIBS})
+target_link_libraries(cruft-util PUBLIC ${CLOCK_LIBS})
+target_link_libraries(cruft-util PUBLIC ${MATH_LIBS})
 
 
 ###############################################################################
@@ -425,6 +427,7 @@ foreach (tool hash json-clean json-schema json-validate scratch)
     add_executable (util_${tool} tools/${tool}.cpp)
     set_target_properties (util_${tool} PROPERTIES OUTPUT_NAME ${tool})
     target_link_libraries (util_${tool} cruft-util)
+    target_include_directories(util_${tool} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
 endforeach ()
 
 
@@ -512,6 +515,7 @@ if (TESTS)
         string(REPLACE "/" "_" name "test/${t}")
         add_executable(util_${name} test/${t}.cpp)
         target_link_libraries(util_${name} PRIVATE cruft-util)
+        target_include_directories(util_${name} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
         add_test(NAME util_${name} COMMAND util_${name})
     endforeach(t)
 endif ()

From 34788756d2f2dc77ad29e0195efb5eb7061d298a Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Wed, 22 Nov 2017 16:49:37 +1100
Subject: [PATCH 02/56] build: don't use './' as an include prefix

GCC produces ODR error when including paths of the form './foo' and
'foo' in the same binary. Rather than managing duplication we just
universally pick the absolute form over the relative form.
---
 algo/sort.hpp                     |  2 +-
 alloc/affix.cpp                   |  2 +-
 alloc/allocator.cpp               |  2 +-
 alloc/allocator.hpp               |  2 +-
 alloc/arena.cpp                   |  2 +-
 alloc/arena.hpp                   |  2 +-
 alloc/fallback.cpp                |  2 +-
 alloc/linear.cpp                  |  2 +-
 alloc/malloc.cpp                  |  2 +-
 alloc/null.cpp                    |  2 +-
 alloc/stack.cpp                   |  2 +-
 ascii.hpp                         |  2 +-
 backtrace_execinfo.cpp            |  8 ++++----
 backtrace_stackwalk.cpp           |  8 ++++----
 backtrace_win32.cpp               |  8 ++++----
 bezier.cpp                        | 10 +++++-----
 bezier1.cpp                       |  2 +-
 bezier2.cpp                       |  6 +++---
 bezier3.cpp                       |  2 +-
 cast.hpp                          |  2 +-
 cmdopt.cpp                        |  6 +++---
 cmdopt.ipp                        |  4 ++--
 colour.cpp                        | 10 +++++-----
 coord/ops.hpp                     |  4 ++--
 crypto/ice.cpp                    |  2 +-
 debug.hpp                         |  4 ++--
 debug.ipp                         |  2 +-
 debug_posix.cpp                   |  6 +++---
 debug_win32.cpp                   |  8 ++++----
 except.cpp                        |  6 +++---
 exe_linux.cpp                     |  6 +++---
 exe_win32.cpp                     |  2 +-
 extent.cpp                        |  6 +++---
 fixed.hpp                         |  6 +++---
 fixup/experimental/filesystem     |  2 +-
 fixup/experimental/filesystem.cpp |  2 +-
 format.ipp                        |  6 +++---
 geom/aabb.cpp                     |  4 ++--
 geom/iostream.cpp                 |  4 ++--
 geom/iostream.hpp                 |  2 +-
 geom/ray.cpp                      |  6 +++---
 hash/adler.cpp                    |  4 ++--
 hash/adler.hpp                    |  2 +-
 hash/crc.cpp                      |  2 +-
 hash/fletcher.cpp                 |  2 +-
 hash/fwd.hpp                      |  6 +++---
 hash/keccak.cpp                   |  2 +-
 hash/murmur.hpp                   |  6 +++---
 hash/murmur/murmur2.hpp           |  2 +-
 hash/ripemd.cpp                   |  2 +-
 hash/sha1.cpp                     |  2 +-
 hash/simple.cpp                   |  2 +-
 hash/xxhash.cpp                   |  8 ++++----
 introspection.hpp                 |  4 ++--
 io.hpp                            |  6 +++---
 io_posix.cpp                      |  2 +-
 io_posix.ipp                      |  2 +-
 io_win32.cpp                      |  6 +++---
 io_win32.hpp                      |  6 +++---
 json/schema.cpp                   |  6 +++---
 json/schema.hpp                   |  2 +-
 json/tree.cpp                     |  6 +++---
 json/tree.hpp                     |  4 ++--
 log.hpp                           |  4 ++--
 maths.hpp                         |  4 ++--
 matrix3.cpp                       |  2 +-
 memory/buffer/circular.cpp        |  2 +-
 memory/buffer/paged.cpp           |  2 +-
 memory/deleter.cpp                |  2 +-
 memory/system.cpp                 |  2 +-
 point.cpp                         |  4 ++--
 pool.ipp                          |  4 ++--
 posix/dir.cpp                     |  2 +-
 posix/dir.hpp                     |  2 +-
 posix/fd.cpp                      |  2 +-
 posix/map.hpp                     |  2 +-
 quaternion.cpp                    |  6 +++---
 quaternion.hpp                    |  2 +-
 rand/mwc64x.cpp                   |  2 +-
 rand/xorshift.cpp                 |  2 +-
 region.cpp                        |  6 +++---
 sarray.cpp                        |  2 +-
 sarray.hpp                        |  2 +-
 string.cpp                        |  2 +-
 string.hpp                        |  2 +-
 strongdef.cpp                     |  2 +-
 term.cpp                          |  4 ++--
 test/exe.cpp                      |  4 ++--
 test/geom/ray.cpp                 |  8 ++++----
 test/iterator.cpp                 |  4 ++--
 test/pool.cpp                     |  4 ++--
 test/stream.cpp                   |  4 ++--
 test/typeidx.cpp                  |  4 ++--
 time.cpp                          |  4 ++--
 time.hpp                          |  5 +++--
 time_posix.cpp                    |  4 ++--
 typeidx.cpp                       |  2 +-
 vector.ipp                        |  2 +-
 view.cpp                          |  2 +-
 view.hpp                          |  4 ++--
 view.ipp                          |  5 +++--
 win32/handle.cpp                  |  2 +-
 102 files changed, 189 insertions(+), 187 deletions(-)

diff --git a/algo/sort.hpp b/algo/sort.hpp
index 008a40c1..09c07037 100644
--- a/algo/sort.hpp
+++ b/algo/sort.hpp
@@ -44,6 +44,6 @@ namespace cruft::util::sort {
     soa (RandomIt key_first, RandomIt key_last, Comparator comp, Args ...values);
 }
 
-#include "./sort.ipp"
+#include "sort.ipp"
 
 #endif
diff --git a/alloc/affix.cpp b/alloc/affix.cpp
index 87f37ba4..26ebd72d 100644
--- a/alloc/affix.cpp
+++ b/alloc/affix.cpp
@@ -14,7 +14,7 @@
  * Copyright 2015 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./affix.hpp"
+#include "affix.hpp"
 
 using util::alloc::affix;
 
diff --git a/alloc/allocator.cpp b/alloc/allocator.cpp
index 0747499b..6b898bc5 100644
--- a/alloc/allocator.cpp
+++ b/alloc/allocator.cpp
@@ -1 +1 @@
-#include "./allocator.hpp"
+#include "allocator.hpp"
diff --git a/alloc/allocator.hpp b/alloc/allocator.hpp
index cca7cfc6..1b4babc0 100644
--- a/alloc/allocator.hpp
+++ b/alloc/allocator.hpp
@@ -38,6 +38,6 @@ namespace util::alloc {
     };
 }
 
-#include "./allocator.ipp"
+#include "allocator.ipp"
 
 #endif
diff --git a/alloc/arena.cpp b/alloc/arena.cpp
index ca065a58..a29f7c79 100644
--- a/alloc/arena.cpp
+++ b/alloc/arena.cpp
@@ -1 +1 @@
-#include "./arena.hpp"
+#include "arena.hpp"
diff --git a/alloc/arena.hpp b/alloc/arena.hpp
index a61939bb..ddfe9663 100644
--- a/alloc/arena.hpp
+++ b/alloc/arena.hpp
@@ -66,6 +66,6 @@ namespace util::alloc {
     };
 }
 
-#include "./arena.ipp"
+#include "arena.ipp"
 
 #endif
diff --git a/alloc/fallback.cpp b/alloc/fallback.cpp
index 76435d99..fa2fe52e 100644
--- a/alloc/fallback.cpp
+++ b/alloc/fallback.cpp
@@ -1 +1 @@
-#include "./fallback.hpp"
+#include "fallback.hpp"
diff --git a/alloc/linear.cpp b/alloc/linear.cpp
index cd61b5a3..07f03416 100644
--- a/alloc/linear.cpp
+++ b/alloc/linear.cpp
@@ -14,7 +14,7 @@
  * Copyright 2015 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./linear.hpp"
+#include "linear.hpp"
 
 #include "../pointer.hpp"
 #include "../debug.hpp"
diff --git a/alloc/malloc.cpp b/alloc/malloc.cpp
index cc5afd1e..072b1892 100644
--- a/alloc/malloc.cpp
+++ b/alloc/malloc.cpp
@@ -14,7 +14,7 @@
  * Copyright 2015 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./malloc.hpp"
+#include "malloc.hpp"
 
 #include "../debug.hpp"
 
diff --git a/alloc/null.cpp b/alloc/null.cpp
index 7e041fa6..4dc80c02 100644
--- a/alloc/null.cpp
+++ b/alloc/null.cpp
@@ -15,7 +15,7 @@
  */
 
 
-#include "./null.hpp"
+#include "null.hpp"
 
 #include "../debug.hpp"
 
diff --git a/alloc/stack.cpp b/alloc/stack.cpp
index 3956fd65..95f8a7c2 100644
--- a/alloc/stack.cpp
+++ b/alloc/stack.cpp
@@ -14,7 +14,7 @@
  * Copyright 2015-2016 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./stack.hpp"
+#include "stack.hpp"
 
 #include "../debug.hpp"
 #include "../pointer.hpp"
diff --git a/ascii.hpp b/ascii.hpp
index 5f13b77f..61e16bcf 100644
--- a/ascii.hpp
+++ b/ascii.hpp
@@ -17,7 +17,7 @@
 #ifndef __CRUFT_UTIL_ASCII_HPP
 #define __CRUFT_UTIL_ASCII_HPP
 
-#include "./annotation.hpp"
+#include "annotation.hpp"
 
 #include <cstdint>
 #include <stdexcept>
diff --git a/backtrace_execinfo.cpp b/backtrace_execinfo.cpp
index 4bb0c8d4..0c93ecf8 100644
--- a/backtrace_execinfo.cpp
+++ b/backtrace_execinfo.cpp
@@ -17,10 +17,10 @@
 
 #include "backtrace.hpp"
 
-#include "./debug.hpp"
-#include "./exe.hpp"
-#include "./io.hpp"
-#include "./cast.hpp"
+#include "debug.hpp"
+#include "exe.hpp"
+#include "io.hpp"
+#include "cast.hpp"
 
 #include <sstream>
 #include <cstdio>
diff --git a/backtrace_stackwalk.cpp b/backtrace_stackwalk.cpp
index d744877e..2cd14020 100644
--- a/backtrace_stackwalk.cpp
+++ b/backtrace_stackwalk.cpp
@@ -14,11 +14,11 @@
  * Copyright 2016 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./backtrace.hpp"
+#include "backtrace.hpp"
 
-#include "./debug.hpp"
-#include "./except.hpp"
-#include "./types.hpp"
+#include "debug.hpp"
+#include "except.hpp"
+#include "types.hpp"
 
 #include <windows.h>
 #include <dbghelp.h>
diff --git a/backtrace_win32.cpp b/backtrace_win32.cpp
index ae5470a0..378ac7c6 100644
--- a/backtrace_win32.cpp
+++ b/backtrace_win32.cpp
@@ -15,11 +15,11 @@
  *      2012-2016, Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./backtrace.hpp"
+#include "backtrace.hpp"
 
-#include "./win32/handle.hpp"
-#include "./debug.hpp"
-#include "./except.hpp"
+#include "win32/handle.hpp"
+#include "debug.hpp"
+#include "except.hpp"
 
 #include <cstdlib>
 #include <windows.h>
diff --git a/bezier.cpp b/bezier.cpp
index 0966a416..b02319ea 100644
--- a/bezier.cpp
+++ b/bezier.cpp
@@ -14,12 +14,12 @@
  * Copyright 2015-2016 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./bezier.hpp"
+#include "bezier.hpp"
 
-#include "./debug.hpp"
-#include "./polynomial.hpp"
-#include "./stream.hpp"
-#include "./coord/iostream.hpp"
+#include "debug.hpp"
+#include "polynomial.hpp"
+#include "stream.hpp"
+#include "coord/iostream.hpp"
 
 #include <algorithm>
 #include <iterator>
diff --git a/bezier1.cpp b/bezier1.cpp
index b645fbd4..97c280ea 100644
--- a/bezier1.cpp
+++ b/bezier1.cpp
@@ -14,7 +14,7 @@
  * Copyright 2015-2016 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./bezier.hpp"
+#include "bezier.hpp"
 
 #include <array>
 #include <iostream>
diff --git a/bezier2.cpp b/bezier2.cpp
index cb252207..9e6619a2 100644
--- a/bezier2.cpp
+++ b/bezier2.cpp
@@ -14,10 +14,10 @@
  * Copyright 2015-2016 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./bezier.hpp"
+#include "bezier.hpp"
 
-#include "./polynomial.hpp"
-#include "./coord/iostream.hpp"
+#include "polynomial.hpp"
+#include "coord/iostream.hpp"
 
 
 ///////////////////////////////////////////////////////////////////////////////
diff --git a/bezier3.cpp b/bezier3.cpp
index f34c7452..0721b924 100644
--- a/bezier3.cpp
+++ b/bezier3.cpp
@@ -14,7 +14,7 @@
  * Copyright 2015-2016 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./bezier.hpp"
+#include "bezier.hpp"
 
 #include "coord/iostream.hpp"
 
diff --git a/cast.hpp b/cast.hpp
index 6afc863b..f477c936 100644
--- a/cast.hpp
+++ b/cast.hpp
@@ -17,7 +17,7 @@
 #ifndef __UTIL_CAST_HPP
 #define __UTIL_CAST_HPP
 
-#include "./debug.hpp"
+#include "debug.hpp"
 
 #include <type_traits>
 #include <limits>
diff --git a/cmdopt.cpp b/cmdopt.cpp
index 451e5739..875d9d27 100644
--- a/cmdopt.cpp
+++ b/cmdopt.cpp
@@ -14,10 +14,10 @@
  * Copyright 2013-2016 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./cmdopt.hpp"
+#include "cmdopt.hpp"
 
-#include "./cast.hpp"
-#include "./debug.hpp"
+#include "cast.hpp"
+#include "debug.hpp"
 
 #include <cstring>
 #include <iostream>
diff --git a/cmdopt.ipp b/cmdopt.ipp
index 047c397a..4153b850 100644
--- a/cmdopt.ipp
+++ b/cmdopt.ipp
@@ -23,8 +23,8 @@
 #include <iterator>
 #include <sstream>
 
-#include "./introspection.hpp"
-#include "./iterator.hpp"
+#include "introspection.hpp"
+#include "iterator.hpp"
 
 namespace util::cmdopt {
     ///////////////////////////////////////////////////////////////////////////
diff --git a/colour.cpp b/colour.cpp
index ff11cb4b..a38567fb 100644
--- a/colour.cpp
+++ b/colour.cpp
@@ -14,12 +14,12 @@
  * Copyright 2010-2017 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./colour.hpp"
+#include "colour.hpp"
 
-#include "./ascii.hpp"
-#include "./debug.hpp"
-#include "./log.hpp"
-#include "./range.hpp"
+#include "ascii.hpp"
+#include "debug.hpp"
+#include "log.hpp"
+#include "range.hpp"
 
 #include <array>
 #include <map>
diff --git a/coord/ops.hpp b/coord/ops.hpp
index 52cab527..9d6a36ab 100644
--- a/coord/ops.hpp
+++ b/coord/ops.hpp
@@ -11,13 +11,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
- * Copyright 2012-2016 Danny Robson <danny@nerdcruft.net>
+ * Copyright 2012-2017 Danny Robson <danny@nerdcruft.net>
  */
 
 #ifndef __UTIL_COORDS_OPS
 #define __UTIL_COORDS_OPS
 
-#include "./fwd.hpp"
+#include "fwd.hpp"
 
 #include "../debug.hpp"
 #include "../maths.hpp"
diff --git a/crypto/ice.cpp b/crypto/ice.cpp
index ac5f2501..31dcf769 100644
--- a/crypto/ice.cpp
+++ b/crypto/ice.cpp
@@ -21,7 +21,7 @@
 // Software Encryption - Fourth International Workshop, Haifa, Israel,
 // Springer-Verlag, pp. 69-82, 1997
 
-#include "./ice.hpp"
+#include "ice.hpp"
 
 #include "../endian.hpp"
 #include "../debug.hpp"
diff --git a/debug.hpp b/debug.hpp
index e111ce48..82ca9585 100644
--- a/debug.hpp
+++ b/debug.hpp
@@ -391,14 +391,14 @@ namespace util::debug {
 }
 
 
-#include "./debug.ipp"
+#include "debug.ipp"
 
 
 ///////////////////////////////////////////////////////////////////////////////
 // XXX: maths needs to be included so that CHECK_EQ/NEQ can call almost_equal,
 // but maths.hpp might be using CHECK_ macros so we must include maths.hpp
 // after we define the CHECK_ macros so the preprocessor can resolve them.
-#include "./maths.hpp"
+#include "maths.hpp"
 
 
 #endif // __DEBUG_HPP
diff --git a/debug.ipp b/debug.ipp
index 5371c2e0..15da902a 100644
--- a/debug.ipp
+++ b/debug.ipp
@@ -20,7 +20,7 @@
 
 #define __UTIL_DEBUG_IPP
 
-#include "./format.hpp"
+#include "format.hpp"
 
 #include <limits>
 
diff --git a/debug_posix.cpp b/debug_posix.cpp
index 12348312..93db5332 100644
--- a/debug_posix.cpp
+++ b/debug_posix.cpp
@@ -15,16 +15,16 @@
  *      2011-2016, Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./debug.hpp"
+#include "debug.hpp"
 
-#include "./log.hpp"
+#include "log.hpp"
+#include "platform.hpp"
 
 #include <unistd.h>
 #include <sys/ptrace.h>
 #include <sys/wait.h>
 #include <signal.h>
 
-#include "./platform.hpp"
 
 #if defined(PLATFORM_FREEBSD)
 #define PTRACE_ATTACH PT_ATTACH
diff --git a/debug_win32.cpp b/debug_win32.cpp
index 5f10357b..bc785ed0 100644
--- a/debug_win32.cpp
+++ b/debug_win32.cpp
@@ -14,11 +14,11 @@
  * Copyright 2016 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./debug.hpp"
+#include "debug.hpp"
 
-#include "./except.hpp"
-#include "./log.hpp"
-#include "./except.hpp"
+#include "except.hpp"
+#include "log.hpp"
+#include "except.hpp"
 
 #include <windows.h>
 #include <iostream>
diff --git a/except.cpp b/except.cpp
index d902c840..11887d50 100644
--- a/except.cpp
+++ b/except.cpp
@@ -14,10 +14,10 @@
  * Copyright 2010 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./except.hpp"
+#include "except.hpp"
 
-#include "./debug.hpp"
-#include "./platform.hpp"
+#include "debug.hpp"
+#include "platform.hpp"
 
 #include <cstring>
 #include <cerrno>
diff --git a/exe_linux.cpp b/exe_linux.cpp
index a7f02317..6a29de99 100644
--- a/exe_linux.cpp
+++ b/exe_linux.cpp
@@ -14,10 +14,10 @@
  * Copyright 2010-2016 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./exe.hpp"
+#include "exe.hpp"
 
-#include "./except.hpp"
-#include "./cast.hpp"
+#include "except.hpp"
+#include "cast.hpp"
 
 #include <vector>
 #include <experimental/filesystem>
diff --git a/exe_win32.cpp b/exe_win32.cpp
index ca0f832e..b67f69d9 100644
--- a/exe_win32.cpp
+++ b/exe_win32.cpp
@@ -14,7 +14,7 @@
  * Copyright 2010-2016 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./exe.hpp"
+#include "exe.hpp"
 
 #include "except.hpp"
 
diff --git a/extent.cpp b/extent.cpp
index 03b4becb..5da4f70f 100644
--- a/extent.cpp
+++ b/extent.cpp
@@ -14,10 +14,10 @@
  * Copyright 2010-2016 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./extent.hpp"
+#include "extent.hpp"
 
-#include "./debug.hpp"
-#include "./maths.hpp"
+#include "debug.hpp"
+#include "maths.hpp"
 
 #include <algorithm>
 #include <numeric>
diff --git a/fixed.hpp b/fixed.hpp
index 5f6d7fca..7b025b7d 100644
--- a/fixed.hpp
+++ b/fixed.hpp
@@ -17,9 +17,9 @@
 #ifndef __UTIL_FIXED_HPP
 #define __UTIL_FIXED_HPP
 
-#include "./types/bits.hpp"
-#include "./maths.hpp"
-#include "./endian.hpp"
+#include "types/bits.hpp"
+#include "maths.hpp"
+#include "endian.hpp"
 
 #include <ostream>
 
diff --git a/fixup/experimental/filesystem b/fixup/experimental/filesystem
index 375196f7..b342cdce 100644
--- a/fixup/experimental/filesystem
+++ b/fixup/experimental/filesystem
@@ -1 +1 @@
-#include "./filesystem.hpp"
+#include "filesystem.hpp"
diff --git a/fixup/experimental/filesystem.cpp b/fixup/experimental/filesystem.cpp
index 4ad7156f..bd890218 100644
--- a/fixup/experimental/filesystem.cpp
+++ b/fixup/experimental/filesystem.cpp
@@ -14,7 +14,7 @@
  * Copyright 2016 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./filesystem.hpp"
+#include "filesystem.hpp"
 
 #include "../../except.hpp"
 
diff --git a/format.ipp b/format.ipp
index a8258323..1d0048d5 100644
--- a/format.ipp
+++ b/format.ipp
@@ -14,9 +14,9 @@
  * Copyright 2015-2016 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./ascii.hpp"
-#include "./debug.hpp"
-#include "./maths.hpp"
+#include "ascii.hpp"
+#include "debug.hpp"
+#include "maths.hpp"
 
 #include <cstring>
 #include <cstddef>
diff --git a/geom/aabb.cpp b/geom/aabb.cpp
index b2601671..2aa1052a 100644
--- a/geom/aabb.cpp
+++ b/geom/aabb.cpp
@@ -15,9 +15,9 @@
  */
 
 
-#include "./aabb.hpp"
+#include "aabb.hpp"
 
-#include "./iostream.hpp"
+#include "iostream.hpp"
 #include "../coord/iostream.hpp"
 #include "../debug.hpp"
 
diff --git a/geom/iostream.cpp b/geom/iostream.cpp
index bc5add01..625b30e4 100644
--- a/geom/iostream.cpp
+++ b/geom/iostream.cpp
@@ -14,9 +14,9 @@
  * Copyright 2015 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./iostream.hpp"
+#include "iostream.hpp"
 
-#include "./sphere.hpp"
+#include "sphere.hpp"
 #include "../coord/iostream.hpp"
 
 
diff --git a/geom/iostream.hpp b/geom/iostream.hpp
index 507aecab..ffe348b9 100644
--- a/geom/iostream.hpp
+++ b/geom/iostream.hpp
@@ -17,7 +17,7 @@
 #ifndef __UTIL_GEOM_IOSTREAM_HPP
 #define __UTIL_GEOM_IOSTREAM_HPP
 
-#include "./fwd.hpp"
+#include "fwd.hpp"
 
 #include <ostream>
 
diff --git a/geom/ray.cpp b/geom/ray.cpp
index 41fa0d76..60252f1d 100644
--- a/geom/ray.cpp
+++ b/geom/ray.cpp
@@ -14,10 +14,10 @@
  * Copyright 2015 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./ray.hpp"
+#include "ray.hpp"
 
-#include "./iostream.hpp"
-#include "./ops.hpp"
+#include "iostream.hpp"
+#include "ops.hpp"
 #include "../coord/iostream.hpp"
 #include "../debug.hpp"
 
diff --git a/hash/adler.cpp b/hash/adler.cpp
index 8a1102ec..d9f93dbe 100644
--- a/hash/adler.cpp
+++ b/hash/adler.cpp
@@ -14,9 +14,9 @@
  * Copyright 2010-2014 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./adler.hpp"
+#include "adler.hpp"
 
-#include "./fletcher.hpp"
+#include "fletcher.hpp"
 #include "../debug.hpp"
 
 static constexpr unsigned MODULUS = 65521;
diff --git a/hash/adler.hpp b/hash/adler.hpp
index f233ecd7..37bb6fe3 100644
--- a/hash/adler.hpp
+++ b/hash/adler.hpp
@@ -17,7 +17,7 @@
 #ifndef __UTIL_HASH_ADLER_HPP
 #define __UTIL_HASH_ADLER_HPP
 
-#include "./fletcher.hpp"
+#include "fletcher.hpp"
 
 #include <cstdint>
 
diff --git a/hash/crc.cpp b/hash/crc.cpp
index 38398e67..ebefc88b 100644
--- a/hash/crc.cpp
+++ b/hash/crc.cpp
@@ -14,7 +14,7 @@
  * Copyright 2011 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./crc.hpp"
+#include "crc.hpp"
 
 #include "../bitwise.hpp"
 #include "../debug.hpp"
diff --git a/hash/fletcher.cpp b/hash/fletcher.cpp
index a29dac95..e8a05125 100644
--- a/hash/fletcher.cpp
+++ b/hash/fletcher.cpp
@@ -15,7 +15,7 @@
  */
 
 
-#include "./fletcher.hpp"
+#include "fletcher.hpp"
 
 #include "../debug.hpp"
 
diff --git a/hash/fwd.hpp b/hash/fwd.hpp
index b4fd9bee..90c97b43 100644
--- a/hash/fwd.hpp
+++ b/hash/fwd.hpp
@@ -21,9 +21,9 @@
 // directly, and are unlikely to change given their inherent
 // lightweight nature.
 
-#include "./fasthash.hpp"
-#include "./fnv1a.hpp"
-#include "./murmur.hpp"
+#include "fasthash.hpp"
+#include "fnv1a.hpp"
+#include "murmur.hpp"
 
 
 // Forward declerations of class based hashes
diff --git a/hash/keccak.cpp b/hash/keccak.cpp
index 224c4116..c0936fec 100644
--- a/hash/keccak.cpp
+++ b/hash/keccak.cpp
@@ -1,4 +1,4 @@
-#include "./keccak.hpp"
+#include "keccak.hpp"
 
 #include "../endian.hpp"
 #include "../maths.hpp"
diff --git a/hash/murmur.hpp b/hash/murmur.hpp
index 6d774264..6a4d5931 100644
--- a/hash/murmur.hpp
+++ b/hash/murmur.hpp
@@ -17,8 +17,8 @@
 #ifndef __UTIL_HASH_MURMUR_HPP
 #define __UTIL_HASH_MURMUR_HPP
 
-#include "./murmur/murmur1.hpp"
-#include "./murmur/murmur2.hpp"
-#include "./murmur/murmur3.hpp"
+#include "murmur/murmur1.hpp"
+#include "murmur/murmur2.hpp"
+#include "murmur/murmur3.hpp"
 
 #endif
diff --git a/hash/murmur/murmur2.hpp b/hash/murmur/murmur2.hpp
index 721e148c..6f41da26 100644
--- a/hash/murmur/murmur2.hpp
+++ b/hash/murmur/murmur2.hpp
@@ -31,7 +31,7 @@ namespace util::hash::murmur2 {
     uint64_t hash_64 (const void *restrict data, size_t len, uint64_t seed);
 }
 
-#include "./murmur2.ipp"
+#include "murmur2.ipp"
 
 #endif
 
diff --git a/hash/ripemd.cpp b/hash/ripemd.cpp
index 369561a2..49510100 100644
--- a/hash/ripemd.cpp
+++ b/hash/ripemd.cpp
@@ -15,7 +15,7 @@
  *      2014, Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./ripemd.hpp"
+#include "ripemd.hpp"
 
 #include "../debug.hpp"
 #include "../bitwise.hpp"
diff --git a/hash/sha1.cpp b/hash/sha1.cpp
index 3f26a780..331056ad 100644
--- a/hash/sha1.cpp
+++ b/hash/sha1.cpp
@@ -14,7 +14,7 @@
  * Copyright 2013 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./sha1.hpp"
+#include "sha1.hpp"
 
 #include "../bitwise.hpp"
 #include "../debug.hpp"
diff --git a/hash/simple.cpp b/hash/simple.cpp
index 20ee090a..22eb18a3 100644
--- a/hash/simple.cpp
+++ b/hash/simple.cpp
@@ -14,4 +14,4 @@
  * Copyright 2016, Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./simple.hpp"
+#include "simple.hpp"
diff --git a/hash/xxhash.cpp b/hash/xxhash.cpp
index 465cc640..87767f0f 100644
--- a/hash/xxhash.cpp
+++ b/hash/xxhash.cpp
@@ -14,11 +14,11 @@
  * Copyright 2016 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./xxhash.hpp"
+#include "xxhash.hpp"
 
-#include "./debug.hpp"
-#include "./bitwise.hpp"
-#include "./endian.hpp"
+#include "../bitwise.hpp"
+#include "../debug.hpp"
+#include "../endian.hpp"
 
 using util::hash::xxhash;
 
diff --git a/introspection.hpp b/introspection.hpp
index 4aeab3f6..38bff553 100644
--- a/introspection.hpp
+++ b/introspection.hpp
@@ -17,8 +17,8 @@
 #ifndef __UTIL_INTROSPECTION_HPP
 #define __UTIL_INTROSPECTION_HPP
 
-#include "./preprocessor.hpp"
-#include "./variadic.hpp"
+#include "preprocessor.hpp"
+#include "variadic.hpp"
 
 #include <array>
 #include <cstddef>
diff --git a/io.hpp b/io.hpp
index 521109b5..36cd14e2 100644
--- a/io.hpp
+++ b/io.hpp
@@ -116,11 +116,11 @@ namespace util {
 }
 
 #ifdef PLATFORM_WIN32
-#include "./io_win32.hpp"
+#include "io_win32.hpp"
 #else
-#include "./io_posix.hpp"
+#include "io_posix.hpp"
 #endif
 
-#include "./io.ipp"
+#include "io.ipp"
 
 #endif
diff --git a/io_posix.cpp b/io_posix.cpp
index f4b612d0..9bca4ce4 100644
--- a/io_posix.cpp
+++ b/io_posix.cpp
@@ -16,10 +16,10 @@
 
 #include "io.hpp"
 
+#include "cast.hpp"
 #include "debug.hpp"
 #include "except.hpp"
 #include "posix/fd.hpp"
-#include "./cast.hpp"
 
 #include <sys/stat.h>
 
diff --git a/io_posix.ipp b/io_posix.ipp
index d6814682..2e66c300 100644
--- a/io_posix.ipp
+++ b/io_posix.ipp
@@ -20,7 +20,7 @@
 
 #define __UTIL_IO_POSIX_IPP
 
-#include "./pointer.hpp"
+#include "pointer.hpp"
 
 
 ///////////////////////////////////////////////////////////////////////////////
diff --git a/io_win32.cpp b/io_win32.cpp
index 521c2fdd..bd08b1a2 100644
--- a/io_win32.cpp
+++ b/io_win32.cpp
@@ -14,10 +14,10 @@
  * Copyright 2014 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./io_win32.hpp"
+#include "io_win32.hpp"
 
-#include "./debug.hpp"
-#include "./except.hpp"
+#include "debug.hpp"
+#include "except.hpp"
 
 #include <windows.h>
 
diff --git a/io_win32.hpp b/io_win32.hpp
index 079da417..eef0e3b8 100644
--- a/io_win32.hpp
+++ b/io_win32.hpp
@@ -17,9 +17,9 @@
 #ifndef __UTIL_IO_WIN32_HPP
 #define __UTIL_IO_WIN32_HPP
 
-#include "./io.hpp"
-#include "./win32/handle.hpp"
-#include "./view.hpp"
+#include "io.hpp"
+#include "win32/handle.hpp"
+#include "view.hpp"
 
 #include <cstdint>
 #include <experimental/filesystem>
diff --git a/json/schema.cpp b/json/schema.cpp
index 172c1de6..aff1afc0 100644
--- a/json/schema.cpp
+++ b/json/schema.cpp
@@ -14,10 +14,10 @@
  * Copyright 2015 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./schema.hpp"
+#include "schema.hpp"
 
-#include "./tree.hpp"
-#include "./except.hpp"
+#include "tree.hpp"
+#include "except.hpp"
 
 #include "../io.hpp"
 #include "../maths.hpp"
diff --git a/json/schema.hpp b/json/schema.hpp
index 6522d85c..4398bf1d 100644
--- a/json/schema.hpp
+++ b/json/schema.hpp
@@ -17,7 +17,7 @@
 #ifndef __UTIL_JSON_SCHEMA_HPP
 #define __UTIL_JSON_SCHEMA_HPP
 
-#include "./fwd.hpp"
+#include "fwd.hpp"
 
 #include <experimental/filesystem>
 
diff --git a/json/tree.cpp b/json/tree.cpp
index 770511cb..40b4055f 100644
--- a/json/tree.cpp
+++ b/json/tree.cpp
@@ -15,10 +15,10 @@
  */
 
 
-#include "./tree.hpp"
+#include "tree.hpp"
 
-#include "./except.hpp"
-#include "./flat.hpp"
+#include "except.hpp"
+#include "flat.hpp"
 
 #include "../debug.hpp"
 #include "../io.hpp"
diff --git a/json/tree.hpp b/json/tree.hpp
index 8cf3708f..1ac06a3e 100644
--- a/json/tree.hpp
+++ b/json/tree.hpp
@@ -17,8 +17,8 @@
 #ifndef __UTIL_JSON_TREE_HPP
 #define __UTIL_JSON_TREE_HPP
 
-#include "./flat.hpp"
-#include "./fwd.hpp"
+#include "flat.hpp"
+#include "fwd.hpp"
 
 #include "../iterator.hpp"
 #include "../view.hpp"
diff --git a/log.hpp b/log.hpp
index aa30788c..b41ee7af 100644
--- a/log.hpp
+++ b/log.hpp
@@ -17,8 +17,8 @@
 #ifndef __UTIL_LOG_HPP
 #define __UTIL_LOG_HPP
 
-#include "./nocopy.hpp"
-#include "./preprocessor.hpp"
+#include "nocopy.hpp"
+#include "preprocessor.hpp"
 
 #include <ostream>
 #include <string>
diff --git a/maths.hpp b/maths.hpp
index 9e8e9f35..5ad376bc 100644
--- a/maths.hpp
+++ b/maths.hpp
@@ -21,8 +21,8 @@
 // it triggers a circular dependency; debug -> format -> maths -> debug
 // instead, just use cassert
 
-#include "./types/traits.hpp"
-#include "./float.hpp"
+#include "types/traits.hpp"
+#include "float.hpp"
 
 #include <algorithm>
 #include <cassert>
diff --git a/matrix3.cpp b/matrix3.cpp
index 64b0b678..d4398a20 100644
--- a/matrix3.cpp
+++ b/matrix3.cpp
@@ -14,7 +14,7 @@
  * Copyright 2015 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./matrix.hpp"
+#include "matrix.hpp"
 
 using util::matrix;
 
diff --git a/memory/buffer/circular.cpp b/memory/buffer/circular.cpp
index 457db4fe..a091a667 100644
--- a/memory/buffer/circular.cpp
+++ b/memory/buffer/circular.cpp
@@ -14,7 +14,7 @@
  * Copyright 2015 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./circular.hpp"
+#include "circular.hpp"
 
 #include "../system.hpp"
 #include "../../debug.hpp"
diff --git a/memory/buffer/paged.cpp b/memory/buffer/paged.cpp
index 5d937e90..3a141de7 100644
--- a/memory/buffer/paged.cpp
+++ b/memory/buffer/paged.cpp
@@ -14,7 +14,7 @@
  * Copyright 2015 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./paged.hpp"
+#include "paged.hpp"
 
 #include "../system.hpp"
 #include "../../except.hpp"
diff --git a/memory/deleter.cpp b/memory/deleter.cpp
index 9ec8d645..9b30b0e6 100644
--- a/memory/deleter.cpp
+++ b/memory/deleter.cpp
@@ -14,7 +14,7 @@
  * Copyright 2015 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./deleter.hpp"
+#include "deleter.hpp"
 
 using util::memory::owner_deleter;
 
diff --git a/memory/system.cpp b/memory/system.cpp
index a06b610b..acf4eefb 100644
--- a/memory/system.cpp
+++ b/memory/system.cpp
@@ -14,7 +14,7 @@
  * Copyright 2015 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./system.hpp"
+#include "system.hpp"
 
 #include "../except.hpp"
 #include "../cast.hpp"
diff --git a/point.cpp b/point.cpp
index fc1bef83..bbda9bc6 100644
--- a/point.cpp
+++ b/point.cpp
@@ -14,9 +14,9 @@
  * Copyright 2011-2016 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./point.hpp"
+#include "point.hpp"
 
-#include "./debug.hpp"
+#include "debug.hpp"
 
 #include <cstdlib>
 
diff --git a/pool.ipp b/pool.ipp
index ea02ac98..34a53f1f 100644
--- a/pool.ipp
+++ b/pool.ipp
@@ -20,12 +20,12 @@
 
 #define __UTIL_POOL_IPP
 
+#include "debug.hpp"
+
 #include <cstdint>
 #include <new>
 #include <string>
 
-#include "./debug.hpp"
-
 
 namespace util {
     //-------------------------------------------------------------------------
diff --git a/posix/dir.cpp b/posix/dir.cpp
index 2c48ad6c..e8e3fce6 100644
--- a/posix/dir.cpp
+++ b/posix/dir.cpp
@@ -14,7 +14,7 @@
  * Copyright 2015 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./dir.hpp"
+#include "dir.hpp"
 
 #include "../except.hpp"
 
diff --git a/posix/dir.hpp b/posix/dir.hpp
index d27d6d68..8476a12e 100644
--- a/posix/dir.hpp
+++ b/posix/dir.hpp
@@ -48,6 +48,6 @@ namespace util::posix {
     };
 }
 
-#include "./dir.ipp"
+#include "dir.ipp"
 
 #endif
diff --git a/posix/fd.cpp b/posix/fd.cpp
index 8d16dbc4..9bee1779 100644
--- a/posix/fd.cpp
+++ b/posix/fd.cpp
@@ -14,7 +14,7 @@
  * Copyright 2016 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./fd.hpp"
+#include "fd.hpp"
 
 #include "../except.hpp"
 
diff --git a/posix/map.hpp b/posix/map.hpp
index b3a51e9b..33fbd133 100644
--- a/posix/map.hpp
+++ b/posix/map.hpp
@@ -17,7 +17,7 @@
 #ifndef __CRUFT_UTIL_POSIX_HPP
 #define __CRUFT_UTIL_POSIX_HPP
 
-#include "./fd.hpp"
+#include "fd.hpp"
 
 #include <sys/mman.h>
 #include <cstdint>
diff --git a/quaternion.cpp b/quaternion.cpp
index b868aa60..3d0d7975 100644
--- a/quaternion.cpp
+++ b/quaternion.cpp
@@ -15,10 +15,10 @@
  */
 
 
-#include "./quaternion.hpp"
+#include "quaternion.hpp"
 
-#include "./debug.hpp"
-#include "./vector.hpp"
+#include "debug.hpp"
+#include "vector.hpp"
 
 #include <cmath>
 
diff --git a/quaternion.hpp b/quaternion.hpp
index d1897ea8..52eea91a 100644
--- a/quaternion.hpp
+++ b/quaternion.hpp
@@ -126,6 +126,6 @@ namespace util {
     operator<< (std::ostream&, quaternion<T>);
 }
 
-#include "./quaternion.ipp"
+#include "quaternion.ipp"
 
 #endif
diff --git a/rand/mwc64x.cpp b/rand/mwc64x.cpp
index 07aaaf3c..0a0a2274 100644
--- a/rand/mwc64x.cpp
+++ b/rand/mwc64x.cpp
@@ -15,7 +15,7 @@
  */
 
 
-#include "./mwc64x.hpp"
+#include "mwc64x.hpp"
 
 #include "../debug.hpp"
 
diff --git a/rand/xorshift.cpp b/rand/xorshift.cpp
index df1f1c42..d38c42b0 100644
--- a/rand/xorshift.cpp
+++ b/rand/xorshift.cpp
@@ -14,7 +14,7 @@
  * Copyright 2015-2016 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./xorshift.hpp"
+#include "xorshift.hpp"
 
 #include "../debug.hpp"
 
diff --git a/region.cpp b/region.cpp
index df6b3a5b..39def184 100644
--- a/region.cpp
+++ b/region.cpp
@@ -15,11 +15,11 @@
  */
 
 
-#include "./region.hpp"
+#include "region.hpp"
 
-#include "./debug.hpp"
+#include "debug.hpp"
 
-#include "./coord/iostream.hpp"
+#include "coord/iostream.hpp"
 
 #include <array>
 
diff --git a/sarray.cpp b/sarray.cpp
index 287fb71c..2aad7134 100644
--- a/sarray.cpp
+++ b/sarray.cpp
@@ -14,4 +14,4 @@
  * Copyright 2017 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./sarray.hpp"
+#include "sarray.hpp"
diff --git a/sarray.hpp b/sarray.hpp
index 377deeb5..57b6f359 100644
--- a/sarray.hpp
+++ b/sarray.hpp
@@ -17,7 +17,7 @@
 #ifndef CRUFT_UTIL_SARRAY_HPP
 #define CRUFT_UTIL_SARRAY_HPP
 
-#include "./iterator.hpp"
+#include "iterator.hpp"
 
 #include <cstdlib>
 #include <stdexcept>
diff --git a/string.cpp b/string.cpp
index 34423493..8367347a 100644
--- a/string.cpp
+++ b/string.cpp
@@ -14,7 +14,7 @@
  * Copyright 2011-2016 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./string.hpp"
+#include "string.hpp"
 
 #include <cstring>
 #include <codecvt>
diff --git a/string.hpp b/string.hpp
index d7c9434e..c93f809a 100644
--- a/string.hpp
+++ b/string.hpp
@@ -17,7 +17,7 @@
 #ifndef __UTIL_STRING_HPP
 #define __UTIL_STRING_HPP
 
-#include "./view.hpp"
+#include "view.hpp"
 
 
 namespace util {
diff --git a/strongdef.cpp b/strongdef.cpp
index 4d7a888c..1c591def 100644
--- a/strongdef.cpp
+++ b/strongdef.cpp
@@ -14,7 +14,7 @@
  * Copyright 2015 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./strongdef.hpp"
+#include "strongdef.hpp"
 
 using util::strongdef;
 
diff --git a/term.cpp b/term.cpp
index 78ed2316..cbc87074 100644
--- a/term.cpp
+++ b/term.cpp
@@ -14,9 +14,9 @@
  * Copyright 2016-2017 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./term.hpp"
+#include "term.hpp"
 
-#include "./string.hpp"
+#include "string.hpp"
 
 #include <experimental/filesystem>
 #include <cstdlib>
diff --git a/test/exe.cpp b/test/exe.cpp
index 1f909382..8ab1c909 100644
--- a/test/exe.cpp
+++ b/test/exe.cpp
@@ -1,6 +1,6 @@
-#include "./tap.hpp"
+#include "../tap.hpp"
 
-#include "./exe.hpp"
+#include "../exe.hpp"
 
 #include <iostream>
 
diff --git a/test/geom/ray.cpp b/test/geom/ray.cpp
index 45d989e4..495cdb96 100644
--- a/test/geom/ray.cpp
+++ b/test/geom/ray.cpp
@@ -1,7 +1,7 @@
-#include "geom/aabb.hpp"
-#include "geom/plane.hpp"
-#include "geom/ray.hpp"
-#include "tap.hpp"
+#include "../../geom/aabb.hpp"
+#include "../../geom/plane.hpp"
+#include "../../geom/ray.hpp"
+#include "../../tap.hpp"
 
 using util::geom::ray2f;
 using util::geom::ray3f;
diff --git a/test/iterator.cpp b/test/iterator.cpp
index 78760608..a1bc50a6 100644
--- a/test/iterator.cpp
+++ b/test/iterator.cpp
@@ -1,6 +1,6 @@
-#include "tap.hpp"
+#include "../tap.hpp"
 
-#include "./iterator.hpp"
+#include "../iterator.hpp"
 
 #include <vector>
 #include <array>
diff --git a/test/pool.cpp b/test/pool.cpp
index 81c412e4..b26809ee 100644
--- a/test/pool.cpp
+++ b/test/pool.cpp
@@ -1,6 +1,6 @@
-#include "pool.hpp"
+#include "../pool.hpp"
 
-#include "tap.hpp"
+#include "../tap.hpp"
 
 #include <set>
 #include <vector>
diff --git a/test/stream.cpp b/test/stream.cpp
index 320ef3ff..bce8204f 100644
--- a/test/stream.cpp
+++ b/test/stream.cpp
@@ -1,6 +1,6 @@
-#include "tap.hpp"
+#include "../tap.hpp"
 
-#include "stream.hpp"
+#include "../stream.hpp"
 
 
 ///////////////////////////////////////////////////////////////////////////////
diff --git a/test/typeidx.cpp b/test/typeidx.cpp
index ed3ae9bf..c6b26403 100644
--- a/test/typeidx.cpp
+++ b/test/typeidx.cpp
@@ -1,6 +1,6 @@
-#include "tap.hpp"
+#include "../tap.hpp"
 
-#include "./typeidx.hpp"
+#include "../typeidx.hpp"
 
 
 ///////////////////////////////////////////////////////////////////////////////
diff --git a/time.cpp b/time.cpp
index fba55178..6086b319 100644
--- a/time.cpp
+++ b/time.cpp
@@ -14,9 +14,9 @@
  * Copyright 2010-2016 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./time.hpp"
+#include "time.hpp"
 
-#include "./log.hpp"
+#include "log.hpp"
 
 #include <chrono>
 
diff --git a/time.hpp b/time.hpp
index 5fcca2b6..60c12b1a 100644
--- a/time.hpp
+++ b/time.hpp
@@ -17,11 +17,12 @@
 #ifndef __UTIL_TIME_HPP
 #define __UTIL_TIME_HPP
 
+#include "stats.hpp"
+
 #include <chrono>
 #include <cstdint>
 #include <string>
 
-#include "./stats.hpp"
 
 namespace util {
     // ------------------------------------------------------------------------
@@ -89,6 +90,6 @@ namespace util {
     };
 }
 
-#include "./time.ipp"
+#include "time.ipp"
 
 #endif // __UTIL_TIME_HPP
diff --git a/time_posix.cpp b/time_posix.cpp
index 43b496b4..7805fad2 100644
--- a/time_posix.cpp
+++ b/time_posix.cpp
@@ -14,9 +14,9 @@
  * Copyright 2010-2016 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./time.hpp"
+#include "time.hpp"
 
-#include "./cast.hpp"
+#include "cast.hpp"
 
 #include <ctime>
 
diff --git a/typeidx.cpp b/typeidx.cpp
index 3231bd10..03b0fd59 100644
--- a/typeidx.cpp
+++ b/typeidx.cpp
@@ -14,7 +14,7 @@
  * Copyright 2017 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./typeidx.hpp"
+#include "typeidx.hpp"
 
 
 ///////////////////////////////////////////////////////////////////////////////
diff --git a/vector.ipp b/vector.ipp
index 5d2add75..a390fd7e 100644
--- a/vector.ipp
+++ b/vector.ipp
@@ -20,7 +20,7 @@
 #define __UTIL_VECTOR_IPP
 #endif
 
-#include "./maths.hpp"
+#include "maths.hpp"
 
 
 ///////////////////////////////////////////////////////////////////////////////
diff --git a/view.cpp b/view.cpp
index 40d011dd..1a4d49a2 100644
--- a/view.cpp
+++ b/view.cpp
@@ -14,7 +14,7 @@
  * Copyright 2016 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./view.hpp"
+#include "view.hpp"
 
 #include <iterator>
 
diff --git a/view.hpp b/view.hpp
index 4072e598..432757e3 100644
--- a/view.hpp
+++ b/view.hpp
@@ -18,7 +18,7 @@
 #ifndef __UTIL_VIEW_HPP
 #define __UTIL_VIEW_HPP
 
-#include "./types/traits.hpp"
+#include "types/traits.hpp"
 
 #include <cstdlib>
 #include <ostream>
@@ -133,6 +133,6 @@ namespace util {
     operator<< (std::ostream&, view<T>);
 }
 
-#include "./view.ipp"
+#include "view.ipp"
 
 #endif
diff --git a/view.ipp b/view.ipp
index dc42b71b..e7e122c8 100644
--- a/view.ipp
+++ b/view.ipp
@@ -20,9 +20,10 @@
 #endif
 #define __UTIL_VIEW_IPP
 
+#include "view.hpp"
 
-#include "./debug.hpp"
-#include "./iterator.hpp"
+#include "debug.hpp"
+#include "iterator.hpp"
 
 
 ///////////////////////////////////////////////////////////////////////////////
diff --git a/win32/handle.cpp b/win32/handle.cpp
index 9fff2ec7..bfe73aa4 100644
--- a/win32/handle.cpp
+++ b/win32/handle.cpp
@@ -1,4 +1,4 @@
-#include "./handle.hpp"
+#include "handle.hpp"
 
 #include "../except.hpp"
 

From d3f434b523b4a6b41b1024fc993a86a0cd6f3683 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Wed, 22 Nov 2017 17:03:00 +1100
Subject: [PATCH 03/56] coord: make template parameters more flexible

The coordinate system was unable to support types that prohibited
redim or retype operations. Additionally, the `tags' type used for
providing named data parameters was unwiedly.

We remove much of the dependance on template template parameters in the
defined operations and instead define these in terms of a template
specialisation of is_coord.

The tag types were replaced with direct specialisation of the `store'
struct by the primary type, and passing this type through use of the
CRTP.
---
 CMakeLists.txt      |   2 +-
 colour.cpp          | 450 --------------------------
 colour.hpp          | 138 ++++----
 colour.ipp          |  12 -
 coord/base.hpp      |  83 +++--
 coord/fwd.hpp       |  15 +-
 coord/init.hpp      |  34 +-
 coord/iostream.hpp  |   4 +-
 coord/names.hpp     |  42 ---
 coord/ops.hpp       | 750 +++++++++++++++++++++++---------------------
 coord/store.hpp     | 230 +++++---------
 coord/traits.hpp    | 170 ++++++++++
 extent.cpp          |   6 +-
 extent.hpp          |  32 +-
 geom/aabb.cpp       |  86 -----
 geom/aabb.hpp       |  14 +-
 geom/plane.cpp      |   3 +-
 geom/plane.hpp      |   7 +-
 hash/bsdsum.cpp     |   5 +-
 maths.hpp           |   6 +-
 matrix.cpp          | 115 +++----
 matrix.hpp          | 172 +++++++---
 matrix.ipp          | 104 +++---
 matrix2.cpp         |  12 +-
 matrix3.cpp         |  26 +-
 matrix4.cpp         | 135 ++++++--
 point.hpp           |   4 +-
 quaternion.hpp      |  10 +-
 random.hpp          |  40 ++-
 test/affine.cpp     |  48 +--
 test/colour.cpp     |  76 +----
 test/geom/aabb.cpp  |  37 ---
 test/point.cpp      |   5 +
 test/quaternion.cpp |   4 +-
 test/string.cpp     |  11 +-
 vector.hpp          |   4 +-
 view.cpp            |   2 +-
 37 files changed, 1296 insertions(+), 1598 deletions(-)
 delete mode 100644 coord/names.hpp
 create mode 100644 coord/traits.hpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 14a94bb7..08633272 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -180,9 +180,9 @@ list (
     coord.hpp
     coord/init.hpp
     coord/iostream.hpp
-    coord/names.hpp
     coord/ops.hpp
     coord/store.hpp
+    coord/traits.hpp
     crypto/arc4.cpp
     crypto/arc4.hpp
     crypto/ice.cpp
diff --git a/colour.cpp b/colour.cpp
index a38567fb..1525606e 100644
--- a/colour.cpp
+++ b/colour.cpp
@@ -15,453 +15,3 @@
  */
 
 #include "colour.hpp"
-
-#include "ascii.hpp"
-#include "debug.hpp"
-#include "log.hpp"
-#include "range.hpp"
-
-#include <array>
-#include <map>
-
-///////////////////////////////////////////////////////////////////////////////
-using util::colour;
-using util::colour3f;
-using util::colour4f;
-
-
-///////////////////////////////////////////////////////////////////////////////
-template <size_t S, typename T>
-colour<S,T>
-colour<S,T>::parse_html (const char *fmt)
-{
-    // ensure the format is the correct length
-    auto len = strlen (fmt);
-
-    switch (len) {
-    case 1 + 2 * S:
-        if (*fmt != '#')
-            throw std::invalid_argument ("missing leading hash");
-        ++fmt;
-        break;
-
-    case 2 * S:
-        break;
-
-    default:
-        throw std::invalid_argument ("format is the wrong length");
-    }
-
-    // parse the octets
-    util::colour<S,uint8_t> res;
-    for (size_t i = 0; i < res.size (); ++i) {
-        auto a = util::ascii::from_hex (fmt[i*2+0]);
-        auto b = util::ascii::from_hex (fmt[i*2+1]);
-
-        res[i] = (a << 4u) | b;
-    }
-
-    return res.template cast<T> ();
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-static const std::map<std::string, colour<4,uint8_t>>
-HTML_COLOURS { {
-    { "white",      { 0xff, 0xff, 0xff, 0xff } },
-    { "silver",     { 0xc0, 0xc0, 0xc0, 0xff } },
-    { "gray",       { 0x80, 0x80, 0x80, 0xff } },
-    { "black",      { 0x00, 0x00, 0x00, 0xff } },
-    { "red",        { 0xff, 0x00, 0x00, 0xff } },
-    { "maroon",     { 0x80, 0x00, 0x00, 0xff } },
-    { "yellow",     { 0xff, 0xff, 0x00, 0xff } },
-    { "olive",      { 0x80, 0x80, 0x00, 0xff } },
-    { "lime",       { 0x00, 0xff, 0x00, 0xff } },
-    { "green",      { 0x00, 0x80, 0x00, 0xff } },
-    { "aqua",       { 0x00, 0xff, 0xff, 0xff } },
-    { "teal",       { 0x00, 0x80, 0x80, 0xff } },
-    { "blue",       { 0x00, 0x00, 0xff, 0xff } },
-    { "navy",       { 0x00, 0x00, 0x80, 0xff } },
-    { "fuchsia",    { 0xff, 0x00, 0xff, 0xff } },
-    { "purple",     { 0x80, 0x00, 0x80, 0xff } },
-} };
-
-
-//-----------------------------------------------------------------------------
-static const std::map<std::string, colour<4,uint8_t>> X11_COLOURS
-{
-    /* pink */
-    { "pink",                   { 0xff, 0xc0, 0xcb, 0xff } },
-    { "lightpink",              { 0xff, 0xb6, 0xc1, 0xff } },
-    { "hotpink",                { 0xff, 0x69, 0xb4, 0xff } },
-    { "deeppink",               { 0xff, 0x14, 0x93, 0xff } },
-    { "palevioletred",          { 0xdb, 0x70, 0x93, 0xff } },
-    { "mediumvioletred",        { 0xc7, 0x15, 0x85, 0xff } },
-
-    /* red */
-    { "lightsalmon",            { 0xff, 0xa0, 0x7a, 0xff } },
-    { "salmon",                 { 0xfa, 0x80, 0x72, 0xff } },
-    { "darksalmon",             { 0xe9, 0x96, 0x7a, 0xff } },
-    { "lightcoral",             { 0xf0, 0x80, 0x80, 0xff } },
-    { "indianred",              { 0xcd, 0x5c, 0x5c, 0xff } },
-    { "crimson",                { 0xdc, 0x14, 0x3c, 0xff } },
-    { "firebrick",              { 0xb2, 0x22, 0x22, 0xff } },
-    { "darkred",                { 0x8b, 0x00, 0x00, 0xff } },
-    { "red",                    { 0xff, 0x00, 0x00, 0xff } },
-
-    /* orange */
-    { "orangered",              { 0xff, 0x45, 0x00, 0xff } },
-    { "tomato",                 { 0xff, 0x63, 0x47, 0xff } },
-    { "coral",                  { 0xff, 0x7f, 0x50, 0xff } },
-    { "darkorange",             { 0xff, 0x8c, 0x00, 0xff } },
-    { "orange",                 { 0xff, 0xa5, 0x00, 0xff } },
-
-    /* yellow */
-    { "yellow",                 { 0xff, 0xff, 0x00, 0xff } },
-    { "lightyellow",            { 0xff, 0xff, 0xe0, 0xff } },
-    { "lemonchiffon",           { 0xff, 0xfa, 0xcd, 0xff } },
-    { "lightgoldenrodyellow",   { 0xfa, 0xfa, 0xd2, 0xff } },
-    { "papayawhip",             { 0xff, 0xef, 0xd5, 0xff } },
-    { "moccasin",               { 0xff, 0xe4, 0xb5, 0xff } },
-    { "peachpuff",              { 0xff, 0xda, 0xb9, 0xff } },
-    { "palegoldenrod",          { 0xee, 0xe8, 0xaa, 0xff } },
-    { "khaki",                  { 0xf0, 0xe6, 0x8c, 0xff } },
-    { "darkkhaki",              { 0xbd, 0xb7, 0x6b, 0xff } },
-    { "gold",                   { 0xff, 0xd7, 0x00, 0xff } },
-
-    /* brown */
-    { "cornsilk",               { 0xff, 0xf8, 0xdc, 0xff } },
-    { "blanchedalmond",         { 0xff, 0xeb, 0xcd, 0xff } },
-    { "bisque",                 { 0xff, 0xe4, 0xc4, 0xff } },
-    { "navajowhite",            { 0xff, 0xde, 0xad, 0xff } },
-    { "wheat",                  { 0xf5, 0xde, 0xb3, 0xff } },
-    { "burlywood",              { 0xde, 0xb8, 0x87, 0xff } },
-    { "tan",                    { 0xd2, 0xb4, 0x8c, 0xff } },
-    { "rosybrown",              { 0xbc, 0x8f, 0x8f, 0xff } },
-    { "sandybrown",             { 0xf4, 0xa4, 0x60, 0xff } },
-    { "goldenrod",              { 0xda, 0xa5, 0x20, 0xff } },
-    { "darkgoldenrod",          { 0xb8, 0x86, 0x0b, 0xff } },
-    { "peru",                   { 0xcd, 0x85, 0x3f, 0xff } },
-    { "chocolate",              { 0xd2, 0x69, 0x1e, 0xff } },
-    { "saddlebrown",            { 0x8b, 0x45, 0x13, 0xff } },
-    { "sienna",                 { 0xa0, 0x52, 0x2d, 0xff } },
-    { "brown",                  { 0xa5, 0x2a, 0x2a, 0xff } },
-    { "maroon",                 { 0x80, 0x00, 0x00, 0xff } },
-
-    /* green */
-    { "darkolivegreen",         { 0x55, 0x6b, 0x2f, 0xff } },
-    { "olive",                  { 0x80, 0x80, 0x00, 0xff } },
-    { "olivedrab",              { 0x6b, 0x8e, 0x23, 0xff } },
-    { "yellowgreen",            { 0x9a, 0xcd, 0x32, 0xff } },
-    { "limegreen",              { 0x32, 0xcd, 0x32, 0xff } },
-    { "lime",                   { 0x00, 0xff, 0x00, 0xff } },
-    { "lawngreen",              { 0x7c, 0xfc, 0x00, 0xff } },
-    { "chartreuse",             { 0x7f, 0xff, 0x00, 0xff } },
-    { "greenyellow",            { 0xad, 0xff, 0x2f, 0xff } },
-    { "springgreen",            { 0x00, 0xff, 0x7f, 0xff } },
-    { "mediumspringgreen",      { 0x00, 0xfa, 0x9a, 0xff } },
-    { "lightgreen",             { 0x90, 0xee, 0x90, 0xff } },
-    { "palegreen",              { 0x98, 0xfb, 0x98, 0xff } },
-    { "darkseagreen",           { 0x8f, 0xbc, 0x8f, 0xff } },
-    { "mediumseagreen",         { 0x3c, 0xb3, 0x71, 0xff } },
-    { "seagreen",               { 0x2e, 0x8b, 0x57, 0xff } },
-    { "forestgreen",            { 0x22, 0x8b, 0x22, 0xff } },
-    { "green",                  { 0x00, 0x80, 0x00, 0xff } },
-    { "darkgreen",              { 0x00, 0x64, 0x00, 0xff } },
-
-    /* cyan */
-    { "mediumaquamarine",       { 0x66, 0xcd, 0xaa, 0xff } },
-    { "aqua",                   { 0x00, 0xff, 0xff, 0xff } },
-    { "cyan",                   { 0x00, 0xff, 0xff, 0xff } },
-    { "lightcyan",              { 0xe0, 0xff, 0xff, 0xff } },
-    { "paleturquoise",          { 0xaf, 0xee, 0xee, 0xff } },
-    { "aquamarine",             { 0x7f, 0xff, 0xd4, 0xff } },
-    { "turquoise",              { 0x40, 0xe0, 0xd0, 0xff } },
-    { "mediumturquoise",        { 0x48, 0xd1, 0xcc, 0xff } },
-    { "darkturquoise",          { 0x00, 0xce, 0xd1, 0xff } },
-    { "lightseagreen",          { 0x20, 0xb2, 0xaa, 0xff } },
-    { "cadetblue",              { 0x5f, 0x9e, 0xa0, 0xff } },
-    { "darkcyan",               { 0x00, 0x8b, 0x8b, 0xff } },
-    { "teal",                   { 0x00, 0x80, 0x80, 0xff } },
-
-    /* blue */
-    { "lightsteelblue",         { 0xb0, 0xc4, 0xde, 0xff } },
-    { "powderblue",             { 0xb0, 0xe0, 0xe6, 0xff } },
-    { "lightblue",              { 0xad, 0xd8, 0xe6, 0xff } },
-    { "skyblue",                { 0x87, 0xce, 0xeb, 0xff } },
-    { "lightskyblue",           { 0x87, 0xce, 0xfa, 0xff } },
-    { "deepskyblue",            { 0x00, 0xbf, 0xff, 0xff } },
-    { "dodgerblue",             { 0x1e, 0x90, 0xff, 0xff } },
-    { "cornflowerblue",         { 0x64, 0x95, 0xed, 0xff } },
-    { "steelblue",              { 0x46, 0x82, 0xb4, 0xff } },
-    { "royalblue",              { 0x41, 0x69, 0xe1, 0xff } },
-    { "blue",                   { 0x00, 0x00, 0xff, 0xff } },
-    { "mediumblue",             { 0x00, 0x00, 0xcd, 0xff } },
-    { "darkblue",               { 0x00, 0x00, 0x8b, 0xff } },
-    { "navy",                   { 0x00, 0x00, 0x80, 0xff } },
-    { "midnightblue",           { 0x19, 0x19, 0x70, 0xff } },
-
-    /* purple */
-    { "lavender",               { 0xe6, 0xe6, 0xfa, 0xff } },
-    { "thistle",                { 0xd8, 0xbf, 0xd8, 0xff } },
-    { "plum",                   { 0xdd, 0xa0, 0xdd, 0xff } },
-    { "violet",                 { 0xee, 0x82, 0xee, 0xff } },
-    { "orchid",                 { 0xda, 0x70, 0xd6, 0xff } },
-    { "fuchsia",                { 0xff, 0x00, 0xff, 0xff } },
-    { "magenta",                { 0xff, 0x00, 0xff, 0xff } },
-    { "mediumorchid",           { 0xba, 0x55, 0xd3, 0xff } },
-    { "mediumpurple",           { 0x93, 0x70, 0xdb, 0xff } },
-    { "blueviolet",             { 0x8a, 0x2b, 0xe2, 0xff } },
-    { "darkviolet",             { 0x94, 0x00, 0xd3, 0xff } },
-    { "darkorchid",             { 0x99, 0x32, 0xcc, 0xff } },
-    { "darkmagenta",            { 0x8b, 0x00, 0x8b, 0xff } },
-    { "purple",                 { 0x80, 0x00, 0x80, 0xff } },
-    { "indigo",                 { 0x4b, 0x00, 0x82, 0xff } },
-    { "darkslateblue",          { 0x48, 0x3d, 0x8b, 0xff } },
-    { "rebeccapurple",          { 0x66, 0x33, 0x99, 0xff } },
-    { "slateblue",              { 0x6a, 0x5a, 0xcd, 0xff } },
-    { "mediumslateblue",        { 0x7b, 0x68, 0xee, 0xff } },
-
-    /* white */
-    { "white",                  { 0xff, 0xff, 0xff, 0xff } },
-    { "snow",                   { 0xff, 0xfa, 0xfa, 0xff } },
-    { "honeydew",               { 0xf0, 0xff, 0xf0, 0xff } },
-    { "mintcream",              { 0xf5, 0xff, 0xfa, 0xff } },
-    { "azure",                  { 0xf0, 0xff, 0xff, 0xff } },
-    { "aliceblue",              { 0xf0, 0xf8, 0xff, 0xff } },
-    { "ghostwhite",             { 0xf8, 0xf8, 0xff, 0xff } },
-    { "whitesmoke",             { 0xf5, 0xf5, 0xf5, 0xff } },
-    { "seashell",               { 0xff, 0xf5, 0xee, 0xff } },
-    { "beige",                  { 0xf5, 0xf5, 0xdc, 0xff } },
-    { "oldlace",                { 0xfd, 0xf5, 0xe6, 0xff } },
-    { "floralwhite",            { 0xff, 0xfa, 0xf0, 0xff } },
-    { "ivory",                  { 0xff, 0xff, 0xf0, 0xff } },
-    { "antiquewhite",           { 0xfa, 0xeb, 0xd7, 0xff } },
-    { "linen",                  { 0xfa, 0xf0, 0xe6, 0xff } },
-    { "lavenderblush",          { 0xff, 0xf0, 0xf5, 0xff } },
-    { "mistyrose",              { 0xff, 0xe4, 0xe1, 0xff } },
-
-    /* grey/black */
-    { "gainsboro",              { 0xdc, 0xdc, 0xdc, 0xff } },
-    { "lightgrey",              { 0xd3, 0xd3, 0xd3, 0xff } },
-    { "silver",                 { 0xc0, 0xc0, 0xc0, 0xff } },
-    { "darkgray",               { 0xa9, 0xa9, 0xa9, 0xff } },
-    { "gray",                   { 0x80, 0x80, 0x80, 0xff } },
-    { "dimgray",                { 0x69, 0x69, 0x69, 0xff } },
-    { "lightslategray",         { 0x77, 0x88, 0x99, 0xff } },
-    { "slategray",              { 0x70, 0x80, 0x90, 0xff } },
-    { "darkslategray",          { 0x2f, 0x4f, 0x4f, 0xff } },
-    { "black",                  { 0x00, 0x00, 0x00, 0xff } },
-};
-
-
-//-----------------------------------------------------------------------------
-template <size_t S, typename T>
-static colour<S,T>
-lookup_colour (const std::string &name,
-               const std::map<std::string,colour<4,uint8_t>> &map)
-{
-    std::string lower (name);
-    std::transform (lower.begin (), lower.end (), lower.begin (), tolower);
-
-    auto pos = map.find (lower);
-    if (pos == map.end ())
-        throw std::out_of_range (name);
-
-    static_assert (S <= 4, "cannot invent additional data");
-    return pos->second.template redim<S> ().template cast<T> ();
-}
-
-
-//-----------------------------------------------------------------------------
-template <size_t S, typename T>
-colour<S,T>
-colour<S,T>::from_html (const std::string &name)
-{
-    return lookup_colour<S,T> (name, HTML_COLOURS);
-}
-
-
-//-----------------------------------------------------------------------------
-template <size_t S, typename T>
-colour<S,T>
-colour<S,T>::from_x11 (const std::string &name)
-{
-    return lookup_colour<S,T> (name, X11_COLOURS);
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-colour3f
-util::rgb_to_hsv (colour3f rgb)
-{
-    // Calculate chroma
-    auto M = max (rgb);
-    auto m = min (rgb);
-    auto C = M - m;
-
-    // Undefined for zero chroma
-    if (almost_zero (C))
-        return { -1.f, 0.f, M };
-
-    // Calculate hue
-    float H = exactly_equal (rgb.r, M) ?     (rgb.g - rgb.b) :
-              exactly_equal (rgb.g, M) ? 2 + (rgb.b - rgb.r) :
-              exactly_equal (rgb.b, M) ? 4 + (rgb.r - rgb.g) :
-                                                           0 ;
-
-    H /=  C;
-    H *= 60;
-
-    if (H < 0)
-        H += 360;
-
-    // Calculate value
-    auto V = M;
-
-    // Calculate saturation
-    auto S = almost_zero (V) ? 0.f : C / V;
-
-    return { H, S, V };
-}
-
-
-//-----------------------------------------------------------------------------
-colour3f
-util::hsv_to_rgb (colour3f hsv)
-{
-    CHECK_GE (hsv.h,   0);
-    CHECK_LT (hsv.h, 360);
-    CHECK_GE (hsv.s,   0);
-    CHECK_LE (hsv.s,   1);
-    CHECK_GE (hsv.v,   0);
-    CHECK_LE (hsv.v,   1);
-
-    float C = hsv.v * hsv.s;
-    float H = hsv.h / 60;
-    float X = C * (1 - std::abs (std::fmod (H, 2.f) - 1));
-
-    // monochromatic'ish
-    if (almost_zero (hsv.s))
-        return colour3f { hsv.v };
-
-    colour3f rgb;
-
-    unsigned hex = (unsigned)H;
-    switch (hex) {
-    case 0: rgb = { C, X, 0 }; break;
-    case 1: rgb = { X, C, 0 }; break;
-    case 2: rgb = { 0, C, X }; break;
-    case 3: rgb = { 0, X, C }; break;
-    case 4: rgb = { X, 0, C }; break;
-    case 5: rgb = { C, 0, X }; break;
-    }
-
-    auto m = hsv.v - C;
-
-    return rgb + m;
-}
-
-
-///----------------------------------------------------------------------------
-/// Extract a colour object from a JSON node.
-#include "json/tree.hpp"
-
-namespace json::tree {
-    template <>
-    util::colour4f
-    io<util::colour4f>::deserialise (const node &root) {
-        return {
-            root[0].as<float> (),
-            root[1].as<float> (),
-            root[2].as<float> (),
-            root[3].as<float> (),
-        };
-    }
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-template <size_t S, typename T>
-std::ostream&
-util::operator<< (std::ostream &os, util::colour<S,T> c) {
-    os << "colour(";
-    for (size_t i = 0; i < S - 1; ++i)
-        os << +c[i] << ", ";
-    os << +c[S-1] << ")";
-    return os;
-}
-
-
-//-----------------------------------------------------------------------------
-template <size_t S, typename T>
-std::istream&
-util::operator>> (std::istream &is, util::colour<S,T> &c)
-{
-    std::array<
-        std::conditional_t<
-            sizeof(T) == 1,
-            uint16_t,
-            T
-        >,S
-    > v;
-
-    static_assert (S > 0, "current implementation requires strictly positive components");
-    char comma;
-
-    for (size_t i = 0; i < S - 1; ++i) {
-        is >> v[i] >> comma;
-
-        if (comma != ',' || is.eof ()) {
-            is.setstate (std::ios_base::failbit);
-            return is;
-        }
-    }
-
-    is >> v[S-1];
-
-    if (!std::is_same<T, typename decltype(v)::value_type>::value) {
-        if (std::any_of (std::cbegin (v),
-                         std::cend   (v),
-                         [] (auto i) {
-            return i > std::numeric_limits<T>::max ();
-        })) {
-            is.setstate (std::ios_base::failbit);
-            return is;
-        }
-    }
-
-    std::copy (std::cbegin (v),
-               std::cend   (v),
-               std::begin  (c));
-
-    return is;
-}
-
-template std::istream& util::operator>> (std::istream&, util::colour<3,uint8_t>&);
-
-///////////////////////////////////////////////////////////////////////////////
-#define INSTANTIATE_S_T(S,T)                            \
-template                                                \
-struct util::colour<S,T>;                               \
-                                                        \
-template                                                \
-std::ostream&                                           \
-util::operator<< (std::ostream&, util::colour<S,T>);    \
-                                                        \
-template                                                \
-const char*                                             \
-util::to_string<util::colour<S,T>> (void);
-
-
-//-----------------------------------------------------------------------------
-#define INSTANTIATE_S(S)    \
-INSTANTIATE_S_T(S,uint8_t)  \
-INSTANTIATE_S_T(S,float)    \
-INSTANTIATE_S_T(S,double)
-
-
-//-----------------------------------------------------------------------------
-INSTANTIATE_S(1)
-INSTANTIATE_S(3)
-INSTANTIATE_S(4)
diff --git a/colour.hpp b/colour.hpp
index 7bed5b15..7e49056d 100644
--- a/colour.hpp
+++ b/colour.hpp
@@ -11,7 +11,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
- * Copyright 2010-2015 Danny Robson <danny@nerdcruft.net>
+ * Copyright 2010-2017 Danny Robson <danny@nerdcruft.net>
  */
 
 #ifndef __UTIL_COLOUR_HPP
@@ -21,68 +21,94 @@
 #include "introspection.hpp"
 
 #include <ostream>
+#include <type_traits>
 
 namespace util {
-    /// An RGBA colour POD type.
-    template <size_t S, typename T>
-    struct colour : public coord::base<S,T,colour,coord::rgba,coord::hsv> {
-        using coord::base<S,T,util::colour,coord::rgba,coord::hsv>::base;
-        using base_t = coord::base<S,T,util::colour,coord::rgba,coord::hsv>;
+    /// An abstract colour POD type componsed of S components of type T.
+    ///
+    /// Not to be used directly, instead the use of derived types is required.
+    /// This exists purely to simplify generic colour code.
+    template <
+        size_t S,
+        typename T,
+        typename SelfT
+    >
+    struct colour : coord::base<S,T,SelfT> {
+        using coord::base<S,T,SelfT>::base;
 
-        // overloaded cast operator which assumes values are unit normalised
         template <typename U>
-        colour<S,U>
-        cast (void) const;
-
-        /// parse colours specified as "#AABBCCDD".
-        ///
-        /// * the leading hash is optional.
-        /// * all components must be 2 hex digits.
-        static colour parse_html (const char*);
-        static colour parse_html (const std::string&);
-
-        /// look up the name of a colour from those specified in
-        /// html/x11/etc specifications.
-        static colour from_html (const std::string &name);
-        static colour from_x11  (const std::string &name);
-
-        /// look up all the specifications and returns the colour from one
-        /// that matches. the search order is unspecified, so if you want a
-        /// known colour then try them first yourself.
-        static colour from_string (const std::string &name);
+        auto
+        cast (void) const
+        {
+            ::util::revalue_t<SelfT,U> ret;
+            std::transform (std::begin (*this),
+                            std::end   (*this),
+                            std::begin (ret),
+                            renormalise<T,U>);
+            return ret;
+        }
     };
 
-    // Convenience types
-    template <typename T> using colour1 = colour<1,T>;
-    template <typename T> using colour3 = colour<3,T>;
-    template <typename T> using colour4 = colour<4,T>;
-
-    typedef colour1<uint8_t> colour1u;
-    typedef colour3<uint8_t> colour3u;
-    typedef colour4<uint8_t> colour4u;
-
-    typedef colour1<float> colour1f;
-    typedef colour3<float> colour3f;
-    typedef colour4<float> colour4f;
-
-    // RGB/HSV conversions
-    colour3f rgb_to_hsv (colour3f);
-    colour3f hsv_to_rgb (colour3f);
-
-    // ostream/istream operators
-    template <size_t S, typename T>
-    std::ostream&
-    operator<< (std::ostream&, util::colour<S,T>);
-
-    template <size_t S, typename T>
-    std::istream&
-    operator>> (std::istream&, util::colour<S,T>&);
-
-    // type name introspection specialisation
-    template <size_t S, typename T>
-    struct type_name<colour<S,T>> {
-        static constexpr const char value[] = "colour";
+    template <typename T>
+    struct util::coord::store<1,T,srgba<1,T>> {
+        union { struct { T r; }; T data[1]; };
     };
+    template <typename T>
+    struct util::coord::store<2,T,srgba<2,T>> {
+        union { struct { T r, g; }; T data[2]; };
+    };
+    template <typename T>
+    struct util::coord::store<3,T,srgba<3,T>> {
+        union { struct { T r, g, b; }; T data[3]; };
+    };
+
+    template <typename T>
+    struct util::coord::store<4,T,srgba<4,T>> {
+        union { struct { T r, g, b, a; }; T data[4]; };
+    };
+
+    template <size_t S, typename T> struct srgba : colour<S,T,srgba<S,T>> {
+        using colour<S,T,srgba<S,T>>::colour;
+    };
+
+    using srgba3f = srgba<3,float>;
+    using srgba4f = srgba<4,float>;
+
+    template <size_t S, typename T> struct hsva  : colour<S,T,hsva<S,T>> {};
+
+    template <size_t S, typename T>
+    struct redim_type<
+        srgba<S,T>
+    > { template <size_t _S> using type = srgba<_S,T>; };
+
+    template <size_t S, typename T>
+    struct revalue_type<srgba<S,T>> {
+        template <typename _T>
+        using type = srgba<S,_T>;
+    };
+
+
+    template <typename> struct is_colour : public std::false_type {};
+    template <
+        size_t S,
+        typename T,
+        template <
+            size_t,
+            typename
+        > typename ColourT
+    > struct is_colour<ColourT<S,T>>
+    :std::conditional_t<
+        std::is_base_of_v<
+            colour<S,T,ColourT<S,T>>,
+            ColourT<S,T>
+        >,
+        std::true_type,
+        std::false_type
+    > {};
+
+
+    template <typename T>
+    constexpr auto is_colour_v = is_colour<T>::value;
 }
 
 #include "colour.ipp"
diff --git a/colour.ipp b/colour.ipp
index 37b8f2eb..0f334864 100644
--- a/colour.ipp
+++ b/colour.ipp
@@ -19,15 +19,3 @@
 #endif
 #define __UTIL_COLOUR_IPP
 
-template <size_t S, typename T>
-template <typename U>
-util::colour<S,U>
-util::colour<S,T>::cast (void) const
-{
-    colour<S,U> ret;
-    std::transform (this->begin (),
-                    this->end (),
-                    ret.begin (),
-                    renormalise<T,U>);
-    return ret;
-}
diff --git a/coord/base.hpp b/coord/base.hpp
index bc3c0d65..81065d44 100644
--- a/coord/base.hpp
+++ b/coord/base.hpp
@@ -17,44 +17,56 @@
 #ifndef __UTIL_COORD_BASE_HPP
 #define __UTIL_COORD_BASE_HPP
 
+#include "fwd.hpp"
+
 #include "init.hpp"
+#include "traits.hpp"
 #include "../maths.hpp"
 
 #include <algorithm>
 #include <cstdlib>
 #include <type_traits>
 
+
 namespace util::coord {
     /////////////////////////////////////////////////////////////////////////
+    // the base class for all coordinate-like types.
+    //
+    // SelfT should not be exposed as a template template directly because
+    // some types (eg, XYZ colours) do not conform to the same template
+    // parameters are others (eg, vector2f). ie, it does not make sense to
+    // allow redim, or type changing on some types so they just aren't exposed.
     template <
         size_t S,
         typename T,
-        template <size_t, typename> class KLASS,
-        typename ...tags
+        typename SelfT
     >
-    struct base : public init<S,T,tags...> {
+    struct base : public init<S,T,SelfT> {
         static_assert (S > 0);
         static_assert (std::is_arithmetic<T>::value);
+        static_assert (sizeof (init<S,T,SelfT>) == S * sizeof (T));
 
         using value_type = T;
         static constexpr size_t dimension = S;
         static constexpr size_t elements = S;
 
-        static constexpr size_t size (void) { return S; }
+        static constexpr auto size (void) { return S; }
 
         // constructors
-        using init<S,T,tags...>::init;
+        using init<S,T,SelfT>::init;
         base () = default;
 
         constexpr explicit base (T val)
         { std::fill (begin (), end (), val); }
 
-        constexpr base (const base<S,T,KLASS,tags...> &rhs) = default;
-        base& operator= (const base<S,T,KLASS,tags...> &rhs) = default;
+        constexpr base (const base<S,T,SelfT> &rhs) = default;
+        base& operator= (const base<S,T,SelfT> &rhs) = default;
 
         // element accessors
         T& operator[] (size_t i) { return this->data[i]; }
         constexpr const T& operator[] (size_t i) const { return this->data[i]; }
+        T& operator[] (int i) { return this->data[i]; }
+        constexpr const T& operator[] (int i) const { return this->data[i]; }
 
         auto cbegin (void) const { return std::cbegin (this->data); }
         auto cend   (void) const { return std::cend   (this->data); }
@@ -81,12 +93,28 @@ namespace util::coord {
             return k;
         }
 
+
+        //---------------------------------------------------------------------
+        template <
+            typename K,
+            typename = std::enable_if_t<is_coord_v<K>,void>
+        >
+        K as (void) const
+        {
+            static_assert (K::elements == elements);
+            K k;
+            std::copy (begin (), end (), k.begin ());
+            return k;
+        }
+
+
         //---------------------------------
         template <typename U>
-        KLASS<S,U>
+        auto
         cast (void) const
         {
-            KLASS<S,U> out;
+            typename revalue_type<SelfT>::template type<U> out;
+
             std::copy (std::cbegin (this->data),
                        std::cend   (this->data),
                        std::begin  (out.data));
@@ -95,11 +123,18 @@ namespace util::coord {
 
         ///////////////////////////////////////////////////////////////////////
         // redimension
-        template <size_t D>
-        KLASS<D,T>
+        template <
+            size_t D,
+            typename _sfinae = SelfT
+        >
+        std::enable_if_t<
+            has_redim_v<_sfinae>,
+            redim_t<_sfinae,D>
+        >
         redim (void) const
         {
-            KLASS<D,T> out;
+            redim_t<SelfT,D> out;
+
             std::copy_n (std::cbegin (this->data),
                          min (S, D),
                          std::begin  (out.data));
@@ -108,11 +143,14 @@ namespace util::coord {
 
 
         //---------------------------------------------------------------------
-        template<size_t D>
-        KLASS<D,T>
-        redim (const KLASS<D,T> fill) const
+        template<size_t D,typename _sfinae = SelfT>
+        std::enable_if_t<
+            has_redim_v<_sfinae>,
+            redim_t<_sfinae,D>
+        >
+        redim (const redim_t<_sfinae,D> fill) const
         {
-            KLASS<D,T> out;
+            redim_t<SelfT,D> out;
 
             static constexpr auto L1 = min (S, D);
             static constexpr auto L2 = D - L1;
@@ -128,11 +166,17 @@ namespace util::coord {
         }
 
         //---------------------------------------------------------------------
-        template <size_t D>
-        KLASS<D,T>
+        template <
+            size_t D,
+            typename _sfinae = SelfT
+        >
+        std::enable_if_t<
+            has_redim_v<_sfinae>,
+            redim_t<_sfinae,D>
+        >
         redim (T fill) const
         {
-            KLASS<D,T> out;
+            redim_t<SelfT,D> out;
 
             auto cursor = std::copy_n (std::cbegin (this->data),
                                        min (S, D),
@@ -144,5 +188,6 @@ namespace util::coord {
     };
 }
 
+#include "ops.hpp"
 
 #endif
diff --git a/coord/fwd.hpp b/coord/fwd.hpp
index e1c3347e..fcd41a8a 100644
--- a/coord/fwd.hpp
+++ b/coord/fwd.hpp
@@ -14,11 +14,20 @@
  * Copyright 2016 Danny Robson <danny@nerdcruft.net>
  */
 
-#ifndef __UTIL_COORD_FWD_HPP
-#define __UTIL_COORD_FWD_HPP
+#ifndef CRUFT_UTIL_COORD_FWD_HPP
+#define CRUFT_UTIL_COORD_FWD_HPP
+
+#include <cstddef>
 
 namespace util {
-    template <size_t,typename> struct colour;
+    namespace coord {
+        template <size_t S,typename T,typename ParentT> struct store;
+        template <size_t,typename,typename> struct init;
+        template <size_t,typename,typename> struct base;
+    }
+
+    template <size_t,typename> struct srgba;
+    template <size_t,typename> struct hsva;
     template <size_t,typename> struct extent;
     template <size_t,typename> struct point;
     template <size_t,typename> struct vector;
diff --git a/coord/init.hpp b/coord/init.hpp
index 5423e75b..478bcd0b 100644
--- a/coord/init.hpp
+++ b/coord/init.hpp
@@ -22,53 +22,53 @@
 #include <cstdlib>
 
 namespace util::coord {
-    template <size_t S, typename T, typename...>
+    template <size_t S, typename T, typename SelfT>
     struct init;
 
     //-------------------------------------------------------------------------
-    template <typename T, typename ...tags>
-    struct init<1,T,tags...> : public store<1,T,tags...>
+    template <typename T, typename SelfT>
+    struct init<1,T,SelfT> : public store<1,T,SelfT>
     {
-        using store<1,T,tags...>::store;
+        using store<1,T,SelfT>::store;
         constexpr init () = default;
         constexpr init (T v0):
-            store<1,T,tags...> ({v0})
+            store<1,T,SelfT> ({v0})
         { ; }
     };
 
 
     //-------------------------------------------------------------------------
-    template <typename T, typename ...tags>
-    struct init<2,T,tags...> : public store<2,T,tags...>
+    template <typename T, typename SelfT>
+    struct init<2,T,SelfT> : public store<2,T,SelfT>
     {
-        using store<2,T,tags...>::store;
+        using store<2,T,SelfT>::store;
         constexpr init () = default;
         constexpr init (T v0, T v1):
-            store<2,T,tags...> ({ v0, v1 })
+            store<2,T,SelfT> ({ v0, v1 })
         { ; }
     };
 
 
     //-------------------------------------------------------------------------
-    template <typename T, typename ...tags>
-    struct init<3,T,tags...> : public store<3,T,tags...>
+    template <typename T, typename SelfT>
+    struct init<3,T,SelfT> : public store<3,T,SelfT>
     {
-        using store<3,T,tags...>::store;
+        using store<3,T,SelfT>::store;
         constexpr init () = default;
         constexpr init (T v0, T v1, T v2):
-            store<3,T,tags...> ({v0, v1, v2})
+            store<3,T,SelfT> ({v0, v1, v2})
         { ; }
     };
 
 
     //-------------------------------------------------------------------------
-    template <typename T, typename ...tags>
-    struct init<4,T,tags...> : public store<4,T,tags...>
+    template <typename T, typename SelfT>
+    struct init<4,T,SelfT> : public store<4,T,SelfT>
     {
-        using store<4,T,tags...>::store;
+        using store<4,T,SelfT>::store;
         constexpr init () = default;
         constexpr init (T v0, T v1, T v2, T v3):
-            store<4,T,tags...> ({ v0, v1, v2, v3 })
+            store<4,T,SelfT> ({ v0, v1, v2, v3 })
         { ; }
     };
 }
diff --git a/coord/iostream.hpp b/coord/iostream.hpp
index c95b0d7f..2d1a4eac 100644
--- a/coord/iostream.hpp
+++ b/coord/iostream.hpp
@@ -24,8 +24,8 @@
 
 namespace util {
     template <
-        template <size_t,typename> class K,
-        size_t S,
+        template <std::size_t,typename> class K,
+        std::size_t S,
         typename T
     >
     std::ostream&
diff --git a/coord/names.hpp b/coord/names.hpp
deleted file mode 100644
index d34dec13..00000000
--- a/coord/names.hpp
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2015 Danny Robson <danny@nerdcruft.net>
- */
-
-#ifndef __UTIL_COORD_NAMES_HPP
-#define __UTIL_COORD_NAMES_HPP
-
-namespace util::coord {
-    ///////////////////////////////////////////////////////////////////////
-    // tags for accessor names
-    //
-    // colours
-    struct rgba { };
-    struct hsv  { };
-
-    // physical positions
-    struct xyzw { };
-
-    // texture coords
-    struct stpq { };
-
-    // physical dimensions
-    struct whd  { };
-
-    // quaternions
-    struct wxyz { };
-    struct abcd { };
-}
-
-#endif
diff --git a/coord/ops.hpp b/coord/ops.hpp
index 9d6a36ab..f5b52ef7 100644
--- a/coord/ops.hpp
+++ b/coord/ops.hpp
@@ -18,6 +18,7 @@
 #define __UTIL_COORDS_OPS
 
 #include "fwd.hpp"
+#include "traits.hpp"
 
 #include "../debug.hpp"
 #include "../maths.hpp"
@@ -28,245 +29,273 @@
 #include <cmath>
 #include <cstdlib>
 #include <iterator>
+#include <functional>
 
 namespace util {
-    ///////////////////////////////////////////////////////////////////////
-    // operation traits
-    namespace coord {
-        template <
-            template <size_t,typename> class A,
-            template <size_t,typename> class B
-        >
-        struct result { };
-
-        //-------------------------------------------------------------------------
-        template <> struct result<colour,colour> { template <size_t S, typename T> using type = colour<S,T>; };
-        template <> struct result<extent,extent> { template <size_t S, typename T> using type = extent<S,T>; };
-        template <> struct result<extent,vector> { template <size_t S, typename T> using type = extent<S,T>; };
-        template <> struct result<point,extent>  { template <size_t S, typename T> using type = point <S,T>; };
-        template <> struct result<point,vector>  { template <size_t S, typename T> using type = point <S,T>; };
-        template <> struct result<vector,point>  { template <size_t S, typename T> using type = point <S,T>; };
-        template <> struct result<vector,vector> { template <size_t S, typename T> using type = vector<S,T>; };
-
-        template <
-            template <size_t,typename> class A,
-            template <size_t,typename> class B
-        >
-        using result_t = typename result<A,B>::type;
-
-
-        //---------------------------------------------------------------------
-        template <template <size_t,typename> class K>
-        struct has_norm : public std::false_type { };
-
-        template <> struct has_norm<vector>     : public std::true_type { };
-
-        template <template <size_t,typename> class K>
-        constexpr auto has_norm_v = has_norm<K>::value;
-
-
-        //---------------------------------------------------------------------
-        template <template <size_t,typename> class K>
-        struct has_scalar_op : public std::false_type { };
-
-        template <> struct has_scalar_op<colour>     : public std::true_type { };
-        template <> struct has_scalar_op<extent>     : public std::true_type { };
-        template <> struct has_scalar_op<point>      : public std::true_type { };
-        template <> struct has_scalar_op<vector>     : public std::true_type { };
-
-        template <template <size_t,typename> class K>
-        constexpr auto has_scalar_op_v = has_scalar_op<K>::value;
-    }
-
-    template <class> struct is_coord : std::false_type { };
-
-    template <size_t S, typename T> struct is_coord<point<S,T>>      : std::true_type { };
-    template <size_t S, typename T> struct is_coord<extent<S,T>>     : std::true_type { };
-    template <size_t S, typename T> struct is_coord<vector<S,T>>     : std::true_type { };
-    template <size_t S, typename T> struct is_coord<colour<S,T>>     : std::true_type { };
-
-    template <class K>
-    constexpr bool
-    is_coord_v = is_coord<K>::value;
-
-
     ///////////////////////////////////////////////////////////////////////////
-    template <typename T>
-    constexpr
-    std::enable_if_t<is_coord_v<T>, std::size_t>
-    arity (void)
-    {
-        return T::dimension;
-    }
-
-
-    //-------------------------------------------------------------------------
-    template <typename T>
-    constexpr
-    std::enable_if_t<std::is_arithmetic<T>::value, std::size_t>
-    arity (void)
-    {
-        return 1;
-    }
-
-
-    ///////////////////////////////////////////////////////////////////////////
-    // vector operators
-#define ELEMENT_OP(OP)                                  \
-    template <                                          \
-        size_t S,                                       \
-        typename T,                                     \
-        typename U,                                     \
-        template <size_t,typename> class A,             \
-        template <size_t,typename> class B,             \
-        typename = std::enable_if_t<                    \
-            is_coord_v<A<S,T>> && is_coord_v<B<S,U>>,   \
-            void                                        \
-        >                                               \
-    >                                                   \
-    constexpr                                           \
-    auto                                                \
-    operator OP (A<S,T> a, B<S,U> b)                    \
-    {                                                   \
-        typename coord::result<A,B>::template type<     \
-            S,std::common_type_t<T,U>                   \
-        > out {};                                       \
-        for (size_t i = 0; i < S; ++i)                  \
-            out[i] = a[i] OP b[i];                      \
-        return out;                                     \
-    }                                                   \
-                                                        \
-    template <                                          \
-        size_t S,                                       \
-        typename T,                                     \
-        typename U,                                     \
-        template <size_t,typename> class A,             \
-        template <size_t,typename> class B,             \
-        typename = std::enable_if_t<                    \
-            is_coord_v<A<S,T>> &&                       \
-            is_coord_v<B<S,U>> &&                       \
-            std::is_same<                               \
-                std::common_type_t<T,U>, T              \
-            >::value,                                   \
-            void                                        \
-        >                                               \
-    >                                                   \
-    auto&                                               \
-    operator PASTE(OP,=) (A<S,T>& a, B<S,U> b)          \
-    {                                                   \
-        for (size_t i = 0; i < S; ++i)                  \
-            a[i] PASTE(OP,=) b[i];                      \
-        return a;                                       \
-    }
-
-    ELEMENT_OP(+)
-    ELEMENT_OP(-)
-    ELEMENT_OP(*)
-    ELEMENT_OP(/)
-    ELEMENT_OP(%)
-#undef ELEMENT_OP
-
-    ///////////////////////////////////////////////////////////////////////////
-    // scalar operators
-#define SCALAR_OP(OP)                                   \
-    template <                                          \
-        size_t S,                                       \
-        typename T,                                     \
-        typename U,                                     \
-        template <size_t,typename> class K,             \
-        typename = std::enable_if_t<                    \
-            coord::has_scalar_op_v<K>, void             \
-        >                                               \
-    >                                                   \
-    constexpr                                           \
-    auto                                                \
-    operator OP (U u, K<S,T> k)                         \
-    {                                                   \
-        K<S,std::common_type_t<T,U>> out{};             \
-                                                        \
-        for (size_t i = 0; i < S; ++i)                  \
-            out[i] = u OP k[i];                         \
-        return out;                                     \
-    }                                                   \
-                                                        \
-    template <                                          \
-        size_t S,                                       \
-        typename T,                                     \
-        typename U,                                     \
-        template <size_t,typename> class K,             \
-        typename = std::enable_if_t<                    \
-            coord::has_scalar_op_v<K>,void              \
-        >                                               \
-    >                                                   \
-    constexpr                                           \
-    auto                                                \
-    operator OP (K<S,T> k, U u)                         \
-    {                                                   \
-        K<S,std::common_type_t<T,U>> out {};            \
-                                                        \
-        for (size_t i = 0; i < S; ++i)                  \
-            out[i] = k[i] OP u;                         \
-        return out;                                     \
-    }
-
-    SCALAR_OP(+)
-    SCALAR_OP(-)
-    SCALAR_OP(*)
-    SCALAR_OP(/)
-    SCALAR_OP(%)
-
-#undef SCALAR_OP
-
-
-    //-------------------------------------------------------------------------
-    // scalar assignment operators.
+    // a templated functor that exposes arithmetic and assignment maths
+    // functions for vector-vector or vector-scalar operations.
     //
-    // we must check the operands/results do not need casting to store in the
-    // destination type to avoid silent errors accumulating.
-#define SCALAR_OP(OP)                                       \
-    template <                                              \
-        size_t S,                                           \
-        typename T,                                         \
-        typename U,                                         \
-        template <size_t,typename> class K,                 \
-        typename = std::enable_if_t<                        \
-            is_coord<K<S,T>>::value &&                      \
-            std::is_arithmetic<T>::value &&                 \
-            std::is_arithmetic<U>::value,                   \
-            void                                            \
-        >                                                   \
-    >                                                       \
-    std::enable_if_t<                                       \
-        std::is_same<                                       \
-            T,                                              \
-            std::common_type_t<T,U>                         \
-        >::value,                                           \
-        K<S,T>                                              \
-    >&                                                      \
-    operator OP (K<S,T> &k, U u)                            \
-    {                                                       \
-        for (size_t i = 0; i < S; ++i)                      \
-            k[i] OP u;                                      \
-                                                            \
-        return k;                                           \
+    // we implement the operations this way because it (somewhat) simplifies
+    // ambiguity resolution in the various operators we need to provide.
+    // eg, operator+(vec,vec) vs operator+(vec,int).
+    //
+    // it used to be directly implemented with a series of templated free
+    // functions when we could restrict the arguments more easily with quite
+    // specific template template parameters. but the introduction of
+    // coordinate types that do not expose size or type information as template
+    // parameters we can't rely on this mechanism anymore.
+    template <typename, typename,typename=void>
+    struct ops { };
+
+
+    //-------------------------------------------------------------------------
+    // vector operators
+    template <typename ValueA, typename ValueB>
+    struct ops<
+        ValueA,
+        ValueB,
+        std::enable_if_t<
+            is_coord_v<ValueA> &&
+            is_coord_v<ValueB> &&
+            arity<ValueA>::value == arity<ValueB>::value &&
+            std::is_same_v<
+                typename ValueA::value_type,
+                typename ValueB::value_type
+            >,
+            void
+        >
+    > {
+        template <typename OpT>
+        static constexpr auto
+        arithmetic (OpT op, ValueA a, ValueB b)
+        {
+            result_t<ValueA,ValueB> out {};
+            for (std::size_t i = 0; i < ValueA::elements; ++i)
+                out[i] = op (a[i], b[i]);
+            return out;
+        }
+
+        template <typename OpT>
+        static constexpr ValueA&
+        assignment (OpT op, ValueA &a, ValueB b)
+        {
+            for (std::size_t i = 0; i < ValueA::elements; ++i)
+                a[i] = op (a[i], b[i]);
+            return a;
+        }
+    };
+
+
+    //-------------------------------------------------------------------------
+    // vector-scalar operations
+    // 
+    // we allow scalar types which can be naturally promoted to the vector's
+    // value_type
+    template <
+        typename CoordT,
+        typename ScalarT
+    >
+    struct ops<
+        CoordT,
+        ScalarT,
+        std::enable_if_t<
+            has_scalar_op_v<CoordT> &&
+            is_coord_v<CoordT> &&
+            std::is_same_v<
+                typename CoordT::value_type,
+                std::common_type_t<
+                    typename CoordT::value_type,
+                    ScalarT
+                >
+            >,
+            void
+        >
+    > {
+        template <typename OpT>
+        static constexpr CoordT&
+        assignment (OpT &&op, CoordT &c, ScalarT s)
+        {
+            for (size_t i = 0; i < CoordT::elements; ++i)
+                c[i] = op (c[i], s);
+            return c;
+        }
+
+
+        template <typename OpT>
+        static constexpr CoordT
+        arithmetic (OpT &&op, CoordT c, ScalarT s)
+        {
+            CoordT out {};
+            for (size_t i = 0; i < CoordT::elements; ++i)
+                out[i] = op (c[i], s);
+            return out;
+        }
+    };
+
+
+    //-------------------------------------------------------------------------
+    // scalar-vector operations
+    template <typename ScalarT, typename CoordT>
+    struct ops<
+        ScalarT,
+        CoordT,
+        std::enable_if_t<
+            has_scalar_op_v<CoordT> &&
+            std::is_arithmetic_v<ScalarT> &&
+            std::is_same_v<ScalarT, typename CoordT::value_type>,
+            void
+        >
+    > {
+        template <typename OpT>
+        static constexpr CoordT
+        arithmetic (OpT op, ScalarT s, CoordT c)
+        {
+            CoordT out {};
+            for (size_t i = 0; i < CoordT::elements; ++i)
+                out[i] = op (s, c[i]);
+            return out;
+        }
+    };
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <
+        typename A,
+        typename B,
+        typename = std::enable_if_t<
+            (is_coord_v<std::decay_t<A>> || is_coord_v<std::decay_t<B>>) &&
+            (is_coord_v<std::decay_t<A>> || std::is_arithmetic_v<std::decay_t<A>>) &&
+            (is_coord_v<std::decay_t<B>> || std::is_arithmetic_v<std::decay_t<B>>)
+        >
+    >
+    constexpr auto
+    operator+ (A &&a, B &&b)
+    {
+        return ops<std::decay_t<A>,std::decay_t<B>>::template arithmetic (std::plus{}, a, b);
     }
 
-    SCALAR_OP(+=)
-    SCALAR_OP(-=)
-    SCALAR_OP(*=)
-    SCALAR_OP(/=)
-    SCALAR_OP(%=)
-#undef SCALAR_OP
+
+    template <
+        typename A,
+        typename B,
+        typename = std::enable_if_t<
+            (is_coord_v<std::decay_t<A>> || is_coord_v<std::decay_t<B>>) &&
+            (is_coord_v<std::decay_t<A>> || std::is_arithmetic_v<std::decay_t<A>>) &&
+            (is_coord_v<std::decay_t<B>> || std::is_arithmetic_v<std::decay_t<B>>)
+        >
+    >
+    constexpr auto
+    operator- (A &&a, B &&b)
+    {
+        return ops<std::decay_t<A>,std::decay_t<B>>::template arithmetic (std::minus{}, a, b);
+    }
+
+
+    template <
+        typename A,
+        typename B,
+        typename = std::enable_if_t<
+            (is_coord_v<std::decay_t<A>> || is_coord_v<std::decay_t<B>>) &&
+            (is_coord_v<std::decay_t<A>> || std::is_arithmetic_v<std::decay_t<A>>) &&
+            (is_coord_v<std::decay_t<B>> || std::is_arithmetic_v<std::decay_t<B>>)
+        >
+    >
+    constexpr auto
+    operator* (A &&a, B &&b)
+    {
+        return ops<std::decay_t<A>,std::decay_t<B>>::template arithmetic (std::multiplies{}, a, b);
+    }
+
+
+    template <
+        typename A,
+        typename B,
+        typename = std::enable_if_t<
+            (is_coord_v<std::decay_t<A>> || is_coord_v<std::decay_t<B>>) &&
+            (is_coord_v<std::decay_t<A>> || std::is_arithmetic_v<std::decay_t<A>>) &&
+            (is_coord_v<std::decay_t<B>> || std::is_arithmetic_v<std::decay_t<B>>)
+        >
+    >
+    constexpr auto
+    operator/ (A &&a, B &&b)
+    {
+        return ops<std::decay_t<A>,std::decay_t<B>>::template arithmetic (std::divides{}, a, b);
+    }
+
+
+    //-------------------------------------------------------------------------
+    template <
+        typename A,
+        typename B,
+        typename = std::enable_if_t<
+            (is_coord_v<std::decay_t<A>> || is_coord_v<std::decay_t<B>>) &&
+            (is_coord_v<std::decay_t<A>> || std::is_arithmetic_v<std::decay_t<A>>) &&
+            (is_coord_v<std::decay_t<B>> || std::is_arithmetic_v<std::decay_t<B>>)
+        >
+    >
+    constexpr auto
+    operator += (A &&a, B &&b)
+    {
+        return ops<std::decay_t<A>, std::decay_t<B>>::template assignment (std::plus{}, a, b);
+    }
+
+
+    template <
+        typename A,
+        typename B,
+        typename = std::enable_if_t<
+            (is_coord_v<std::decay_t<A>> || is_coord_v<std::decay_t<B>>) &&
+            (is_coord_v<std::decay_t<A>> || std::is_arithmetic_v<std::decay_t<A>>) &&
+            (is_coord_v<std::decay_t<B>> || std::is_arithmetic_v<std::decay_t<B>>)
+        >
+    >
+    constexpr auto
+    operator -= (A &&a, B &&b)
+    {
+        return ops<std::decay_t<A>, std::decay_t<B>>::template assignment (std::plus{}, a, b);
+    }
+
+
+    template <
+        typename A,
+        typename B,
+        typename = std::enable_if_t<
+            (is_coord_v<std::decay_t<A>> || is_coord_v<std::decay_t<B>>) &&
+            (is_coord_v<std::decay_t<A>> || std::is_arithmetic_v<std::decay_t<A>>) &&
+            (is_coord_v<std::decay_t<B>> || std::is_arithmetic_v<std::decay_t<B>>)
+        >
+    >
+    constexpr auto
+    operator *= (A &&a, B &&b)
+    {
+        return ops<std::decay_t<A>, std::decay_t<B>>::template assignment (std::plus{}, a, b);
+    }
+
+
+    template <
+        typename A,
+        typename B,
+        typename = std::enable_if_t<
+            (is_coord_v<std::decay_t<A>> || is_coord_v<std::decay_t<B>>) &&
+            (is_coord_v<std::decay_t<A>> || std::is_arithmetic_v<std::decay_t<A>>) &&
+            (is_coord_v<std::decay_t<B>> || std::is_arithmetic_v<std::decay_t<B>>)
+        >
+    >
+    constexpr auto
+    operator /= (A &&a, B &&b)
+    {
+        return ops<std::decay_t<A>, std::decay_t<B>>::template assignment (std::plus{}, a, b);
+    }
 
 
     ///////////////////////////////////////////////////////////////////////////
     // unary operators
-
 #define UNARY_OP(OP)                                \
     template <                                      \
-        size_t S,                                   \
+        std::size_t S,                              \
         typename T,                                 \
-        template <size_t,typename> class K,         \
+        template <std::size_t,typename> class K,    \
         typename = std::enable_if_t<                \
             is_coord_v<K<S,T>>, void                \
         >                                           \
@@ -277,7 +306,7 @@ namespace util {
     {                                               \
         K<S,decltype(OP std::declval<T> ())> out{}; \
                                                     \
-        for (size_t i = 0; i < S; ++i)              \
+        for (std::size_t i = 0; i < S; ++i)         \
             out[i] = OP k[i];                       \
                                                     \
         return out;                                 \
@@ -296,18 +325,17 @@ namespace util {
 
     /// elementwise equality operator
     template <
-        size_t S,
-        typename T,
-        template <size_t,typename> class K,
+        typename ValueT,
         typename = std::enable_if_t<
-            is_coord_v<K<S,T>>, void
+            is_coord_v<ValueT>, void
         >
     >
     constexpr
     bool
-    operator== (const K<S,T> a, const K<S,T> b)
+    operator== (const ValueT a, const ValueT b)
     {
-        bool (*predicate)(const T&, const T&) = almost_equal;
+        using value_type = typename ValueT::value_type;
+        bool (*predicate)(const value_type&, const value_type&) = almost_equal;
 
         return std::equal (std::cbegin (a),
                            std::cend   (a),
@@ -318,9 +346,9 @@ namespace util {
     ///------------------------------------------------------------------------
     /// elementwise inquality operator
     template <
-        size_t S,
+        std::size_t S,
         typename T,
-        template <size_t,typename> class K,
+        template <std::size_t,typename> class K,
         typename = std::enable_if_t<
             is_coord_v<K<S,T>>, void
         >
@@ -335,9 +363,9 @@ namespace util {
 
     //-------------------------------------------------------------------------
     template <
-        size_t S,
+        std::size_t S,
         typename T,
-        template <size_t,typename> class K,
+        template <std::size_t,typename> class K,
         typename = std::enable_if_t<
             is_coord_v<K<S,T>>, void
         >
@@ -359,7 +387,7 @@ namespace util {
 
     /// point-point subtraction giving a vector difference
     template <
-        size_t S,
+        std::size_t S,
         typename T,
         typename U
     >
@@ -368,7 +396,7 @@ namespace util {
     operator- (point<S,T> a, point<S,U> b)
     {
         vector<S,std::common_type_t<T,U>> out {};
-        for (size_t i = 0; i < S; ++i)
+        for (std::size_t i = 0; i < S; ++i)
             out[i] = a[i] - b[i];
         return out;
     }
@@ -376,7 +404,7 @@ namespace util {
 
     //-------------------------------------------------------------------------
     template <
-        size_t S,
+        std::size_t S,
         typename T,
         typename U,
         typename = std::enable_if_t<
@@ -394,7 +422,7 @@ namespace util {
 
     ///////////////////////////////////////////////////////////////////////////
     template <
-        size_t S,
+        std::size_t S,
         typename T
     >
     constexpr
@@ -402,18 +430,52 @@ namespace util {
     dot (const T (&a)[S], const T (&b)[S])
     {
         T sum = 0;
-        for (size_t i = 0; i < S; ++i)
+        for (std::size_t i = 0; i < S; ++i)
             sum += a[i] * b[i];
         return sum;
     }
 
 
+    template <
+        std::size_t S,
+        typename T,
+        typename K,
+        typename = std::enable_if_t<
+            is_coord_v<K> && std::is_same_v<typename K::value_type, T> && K::elements == S,
+            void
+        >
+    >
+    constexpr
+    T
+    dot (const T (&a)[S], K k)
+    {
+        return dot (a, k.data);
+    }
+
+
+    template <
+        std::size_t S,
+        typename T,
+        typename K,
+        typename = std::enable_if_t<
+            is_coord_v<K> && std::is_same_v<typename K::value_type, T> && K::elements == S,
+            void
+        >
+    >
+    constexpr
+    T
+    dot (K k, const T (&a)[S])
+    {
+        return dot (k.data, a);
+    }
+
+
     //-------------------------------------------------------------------------
     template <
-        size_t S,
+        std::size_t S,
         typename T,
-        template <size_t,typename> class A,
-        template <size_t,typename> class B,
+        template <std::size_t,typename> class A,
+        template <std::size_t,typename> class B,
         typename = std::enable_if_t<
             is_coord_v<A<S,T>> && is_coord_v<B<S,T>>, void
         >
@@ -428,9 +490,9 @@ namespace util {
 
     //-------------------------------------------------------------------------
     template <
-        size_t S,
+        std::size_t S,
         typename T,
-        template <size_t,typename> class K,
+        template <std::size_t,typename> class K,
         typename = std::enable_if_t<
             is_coord_v<K<S,T>>, void
         >
@@ -445,9 +507,9 @@ namespace util {
 
     //-------------------------------------------------------------------------
     template <
-        size_t S,
+        std::size_t S,
         typename T,
-        template <size_t,typename> class K,
+        template <std::size_t,typename> class K,
         typename = std::enable_if_t<
             is_coord_v<K<S,T>>, void
         >
@@ -462,14 +524,12 @@ namespace util {
 
     ///////////////////////////////////////////////////////////////////////////
     template <
-        size_t S,
-        typename T,
-        template <size_t,typename> class K,
-        typename = std::enable_if_t<coord::has_norm_v<K>,void>
+        typename K,
+        typename = std::enable_if_t<has_norm_v<K>,void>
     >
     constexpr
-    T
-    norm2 (const K<S,T> &k)
+    auto
+    norm2 (const K &k)
     {
         return dot (k, k);
     }
@@ -477,17 +537,15 @@ namespace util {
 
     //-------------------------------------------------------------------------
     template <
-        size_t S,
-        typename T,
-        template <size_t,typename> class K,
+        typename K,
         typename = std::enable_if_t<
-            coord::has_norm_v<K>,
+            has_norm_v<K>,
             void
         >
     >
     constexpr
-    T
-    norm (const K<S,T> &k)
+    auto
+    norm (const K &k)
     {
         return std::sqrt (norm2 (k));
     }
@@ -495,55 +553,47 @@ namespace util {
 
     //-------------------------------------------------------------------------
     template <
-        size_t S,
-        typename T,
-        template <size_t,typename> class K,
+        typename K,
         typename = std::enable_if_t<
-            coord::has_norm_v<K>,
+            has_norm_v<K>,
             void
         >
     >
     constexpr
-    K<S,T>
-    normalised (const K<S,T> &k)
+    auto
+    normalised (const K &k)
     {
-        auto n = norm (k);
-        CHECK_NEZ (n);
-
-        return k / n;
+        CHECK_NEZ (norm (k));
+        return k / norm (k);
     }
 
 
     //-------------------------------------------------------------------------
     template <
-        size_t S,
-        typename T,
-        template <size_t,typename> class K,
+        typename K,
         typename = std::enable_if_t<
-            coord::has_norm_v<K>,
+            has_norm_v<K>,
             void
         >
     >
     constexpr
     bool
-    is_normalised (const K<S,T> &k)
+    is_normalised (const K &k)
     {
-        return almost_equal (norm2 (k), T{1});
+        return almost_equal (norm2 (k), 1);
     }
 
 
     ///////////////////////////////////////////////////////////////////////////
     template <
-        size_t S,
-        typename T,
-        template <size_t,typename> class K,
+        typename K,
         typename = std::enable_if_t<
-            is_coord_v<K<S,T>>, void
+            is_coord_v<K>, void
         >
     >
     constexpr
-    K<S,T>
-    abs (K<S,T> k)
+    K
+    abs (K k)
     {
         for (auto &v: k)
             v = std::abs (v);
@@ -552,16 +602,14 @@ namespace util {
 
     ///////////////////////////////////////////////////////////////////////////
     template <
-        size_t S,
-        typename T,
-        template <size_t,typename> class K,
+        typename K,
         typename = std::enable_if_t<
-            is_coord_v<K<S,T>>, void
+            is_coord_v<K>, void
         >
     >
     constexpr
-    K<S,T>
-    pow (K<S,T> k)
+    K
+    pow (K k)
     {
         for (auto &v: k)
             v = pow (v);
@@ -571,9 +619,9 @@ namespace util {
     ///////////////////////////////////////////////////////////////////////////
     // root of sum of squares
     template <
-        size_t S,
+        std::size_t S,
         typename T,
-        template <size_t,typename> class K,
+        template <std::size_t,typename> class K,
         typename = std::enable_if_t<
             is_coord_v<K<S,T>>, void
         >
@@ -588,9 +636,9 @@ namespace util {
 
     ///////////////////////////////////////////////////////////////////////////
     template <
-        size_t S,
+        std::size_t S,
         typename T,
-        template <size_t,typename> class K,
+        template <std::size_t,typename> class K,
         typename = std::enable_if_t<
             is_coord_v<K<S,T>>, void
         >
@@ -611,9 +659,9 @@ namespace util {
     ///////////////////////////////////////////////////////////////////////////
     // trigonometric functions
     template <
-        size_t S,
+        std::size_t S,
         typename T,
-        template <size_t,typename> class K,
+        template <std::size_t,typename> class K,
         typename = std::enable_if_t<is_coord_v<K<S,T>>,void>
     >
     constexpr
@@ -633,9 +681,9 @@ namespace util {
 
     //-------------------------------------------------------------------------
     template <
-        size_t S,
+        std::size_t S,
         typename T,
-        template <size_t,typename> class K,
+        template <std::size_t,typename> class K,
         typename = std::enable_if_t<is_coord_v<K<S,T>>,void>
     >
     constexpr
@@ -658,9 +706,9 @@ namespace util {
 
     /// return a coord type containing the max element at each offset
     template <
-        size_t S,
+        std::size_t S,
         typename T,
-        template <size_t,typename> class K,
+        template <std::size_t,typename> class K,
         typename = std::enable_if_t<
             is_coord_v<K<S,T>>, void
         >
@@ -670,7 +718,7 @@ namespace util {
     min (K<S,T> a, K<S,T> b)
     {
         K<S,T> out {};
-        for (size_t i = 0; i < S; ++i)
+        for (std::size_t i = 0; i < S; ++i)
             out[i] = min (a[i], b[i]);
         return out;
     }
@@ -679,9 +727,9 @@ namespace util {
     ///------------------------------------------------------------------------
     // /return a coord type containing the max element at each offset
     template <
-        size_t S,
+        std::size_t S,
         typename T,
-        template <size_t,typename> class K,
+        template <std::size_t,typename> class K,
         typename = std::enable_if_t<
             is_coord_v<K<S,T>>, void
         >
@@ -691,7 +739,7 @@ namespace util {
     max (K<S,T> a, K<S,T> b)
     {
         K<S,T> out {};
-        for (size_t i = 0; i < S; ++i)
+        for (std::size_t i = 0; i < S; ++i)
             out[i] = max (a[i], b[i]);
         return out;
     }
@@ -699,9 +747,9 @@ namespace util {
 
     ///------------------------------------------------------------------------
     template <
-        size_t S,
+        std::size_t S,
         typename T,
-        template<size_t,typename> class K,
+        template<std::size_t,typename> class K,
         typename = std::enable_if_t<
             is_coord_v<K<S,T>>, void
         >
@@ -715,9 +763,9 @@ namespace util {
 
 
     template <
-        size_t S,
+        std::size_t S,
         typename T,
-        template<size_t,typename> class K,
+        template<std::size_t,typename> class K,
         typename = std::enable_if_t<
             is_coord_v<K<S,T>>, void
         >
@@ -732,9 +780,9 @@ namespace util {
 
     ///////////////////////////////////////////////////////////////////////////
     template <
-        size_t S,
+        std::size_t S,
         typename T,
-        template <size_t,typename> class K,
+        template <std::size_t,typename> class K,
         typename = std::enable_if_t<
             is_coord_v<K<S,T>>, void
         >
@@ -760,11 +808,11 @@ namespace util {
     ///////////////////////////////////////////////////////////////////////////
 #define VECTOR_OP(OP)                                       \
     template <                                              \
-        size_t S,                                           \
+        std::size_t S,                                      \
         typename T,                                         \
         typename U,                                         \
-        template <size_t,typename> class A,                 \
-        template <size_t,typename> class B,                 \
+        template <std::size_t,typename> class A,            \
+        template <std::size_t,typename> class B,            \
         typename = std::enable_if_t<                        \
             is_coord_v<A<S,T>> && is_coord_v<B<S,U>>, void  \
         >                                                   \
@@ -774,7 +822,7 @@ namespace util {
     operator OP (const A<S,T> a, const B<S,U> b)            \
     {                                                       \
         vector<S,bool> out {};                              \
-        for (size_t i = 0; i < S; ++i)                      \
+        for (std::size_t i = 0; i < S; ++i)                 \
             out[i] = a[i] OP b[i];                          \
         return out;                                         \
     }
@@ -789,24 +837,24 @@ namespace util {
 #undef VECTOR_OP
 
 
-#define SCALAR_OP(OP)                       \
-    template <                              \
-        size_t S,                           \
-        typename T,                         \
-        typename U,                         \
-        template <size_t,typename> class K, \
-        typename = std::enable_if_t<        \
-            is_coord_v<K<S,T>>, void        \
-        >                                   \
-    >                                       \
-    constexpr                               \
-    vector<S,bool>                          \
-    operator OP (const K<S,T> k, const U u) \
-    {                                       \
-        vector<S,bool> out {};              \
-        for (size_t i = 0; i < S; ++i)      \
-            out[i] = k[i] OP u;             \
-        return out;                         \
+#define SCALAR_OP(OP)                               \
+    template <                                      \
+        std::size_t S,                              \
+        typename T,                                 \
+        typename U,                                 \
+        template <std::size_t,typename> class K,    \
+        typename = std::enable_if_t<                \
+            is_coord_v<K<S,T>>, void                \
+        >                                           \
+    >                                               \
+    constexpr                                       \
+    vector<S,bool>                                  \
+    operator OP (const K<S,T> k, const U u)         \
+    {                                               \
+        vector<S,bool> out {};                      \
+        for (std::size_t i = 0; i < S; ++i)         \
+            out[i] = k[i] OP u;                     \
+        return out;                                 \
     }
 
     SCALAR_OP(<)
@@ -821,8 +869,8 @@ namespace util {
 
     //-------------------------------------------------------------------------
     template <
-        size_t S,
-        template <size_t,typename> class K,
+        std::size_t S,
+        template <std::size_t,typename> class K,
         typename = std::enable_if_t<
             is_coord_v<K<S,bool>>, void
         >
@@ -838,8 +886,8 @@ namespace util {
 
     //-------------------------------------------------------------------------
     template <
-        size_t S,
-        template <size_t,typename> class K,
+        std::size_t S,
+        template <std::size_t,typename> class K,
         typename = std::enable_if_t<
             is_coord_v<K<S,bool>>, void
         >
@@ -856,9 +904,9 @@ namespace util {
 
     ///////////////////////////////////////////////////////////////////////////
     template <
-        size_t S,
+        std::size_t S,
         typename T,
-        template<size_t,typename> class K,
+        template<std::size_t,typename> class K,
         typename = std::enable_if_t<
             is_coord_v<K<S,T>> && std::is_floating_point<T>::value, void
         >
@@ -886,11 +934,11 @@ namespace util {
     /// \tparam T underlying data type of the coordinate
     /// \tparam K coordinate data type to operate on
     template <
-        size_t I,
-        size_t S,
+        std::size_t I,
+        std::size_t S,
         typename T,
         template<
-        size_t,
+        std::size_t,
         typename
     > class K
     >
@@ -914,11 +962,11 @@ namespace util {
     /// \tparam T underlying data type of the coordinate
     /// \tparam K coordinate data type to operate on
     template <
-        size_t I,
-        size_t S,
+        std::size_t I,
+        std::size_t S,
         typename T,
         template<
-            size_t,
+            std::size_t,
             typename
         > class K
     >
@@ -946,10 +994,10 @@ namespace std {
     /// \tparam T data type
     /// \tparam K coordinate class
     template <
-        size_t S,
+        std::size_t S,
         typename T,
         template<
-            size_t,
+            std::size_t,
             typename
         > class K
     >
@@ -968,11 +1016,11 @@ namespace std {
     /// \tparam T data type for the coordinate
     /// \tparam K the underlying coordinate class
     template <
-        size_t I,
-        size_t S,
+        std::size_t I,
+        std::size_t S,
         typename T,
         template<
-            size_t,
+            std::size_t,
             typename
         > class K
     >
@@ -992,7 +1040,7 @@ namespace std {
 
 namespace std {
     template <
-        size_t S,
+        std::size_t S,
         typename T,
         template <
             std::size_t,typename
@@ -1003,9 +1051,9 @@ namespace std {
     > : public ::std::enable_if<
         ::util::is_coord_v<K<S,T>>
     > {
-        std::size_t
+        uint32_t
         operator() (K<S,T> k) const {
-            size_t v = 0xdeadbeef;
+            uint32_t v = 0xdeadbeef;
 
             for (auto t: k)
                 v = ::util::hash::mix (t, v);
diff --git a/coord/store.hpp b/coord/store.hpp
index a5bc4036..35d8224c 100644
--- a/coord/store.hpp
+++ b/coord/store.hpp
@@ -11,17 +11,18 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
- * Copyright 2015 Danny Robson <danny@nerdcruft.net>
+ * Copyright 2015-2017 Danny Robson <danny@nerdcruft.net>
  */
 
 #ifndef __UTIL_COORD_STORE_HPP
 #define __UTIL_COORD_STORE_HPP
 
-#include "names.hpp"
+#include "fwd.hpp"
 
+#include "../preprocessor.hpp"
 #include "../platform.hpp"
 
-#include <cstdlib>
+#include <cstddef>
 #include <type_traits>
 
 
@@ -55,156 +56,79 @@ namespace util::coord::detail {
 #define SIMD_ALIGN(S,T) alignas (util::coord::detail::alignment<T> (S))
 
 
-namespace util::coord {
-    ///////////////////////////////////////////////////////////////////////////
-    // Coordinate storage class.
-    //
-    // Types with trivially suitable arity are aligned appropriately to take
-    // advantage of native platform SIMD. eg, 4f types are aligned to 16 bytes
-    // on SSE platforms.
-    template <
-        size_t S,
-        typename T,
-        typename...
-    >
-    struct
-    SIMD_ALIGN(S,T)
-    store {
-        T data[S];
-    };
-
-
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename T>
-    struct store<3,T,rgba,hsv> {
-        union {
-            T data[3];
-            struct { T r,g,b; };
-            struct { T h,s,v; };
-        };
-    };
-
-
-    // Align on 16 bytes if the data is at least 16 bytes long. Prevents tiny
-    // types like colour4u requiring massive alignments, reduces internal
-    // fragmentation.
-    //
-    // TODO: expand this for other instruction sets. maybe switch on type.
-    template <typename T>
-    struct
-    SIMD_ALIGN(4,T)
-    store<4,T,rgba,hsv> {
-        union {
-            T data[4];
-            struct { T r,g,b,a; };
-            struct { T h,s,v;   };
-        };
-    };
-
-
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename T>
-    struct store<2,T,xyzw> {
-        union {
-            T data[2];
-            struct { T x,y; };
-        };
-    };
-
-
-    template <typename T>
-    struct store<3,T,xyzw> {
-        union {
-            T data[3];
-            struct { T x,y,z; };
-        };
-    };
-
-
-    // Align on 16 bytes if the data is at least 16 bytes long. Prevents tiny
-    // types like colour4u requiring massive alignments, reduces internal
-    // fragmentation.
-    //
-    // TODO: expand this for other instruction sets. maybe switch on type.
-    template <typename T>
-    struct
-    SIMD_ALIGN(4,T)
-    store<4,T,xyzw> {
-        union {
-            T data[4];
-            struct { T x,y,z,w; };
-        };
-    };
-
-
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename T>
-    struct store<2,T,xyzw,stpq> {
-        union {
-            T data[2];
-            struct { T x,y; };
-            struct { T s,t; };
-        };
-    };
-
-
-    template <typename T>
-    struct store<3,T,xyzw,stpq> {
-        union {
-            T data[3];
-            struct { T x,y,z; };
-            struct { T s,t,p; };
-        };
-    };
-
-
-    // Align on 16 bytes if the data is at least 16 bytes long. Prevents tiny
-    // types like colour4u requiring massive alignments, reduces internal
-    // fragmentation.
-    //
-    // TODO: expand this for other instruction sets. maybe switch on type.
-    template <typename T>
-    struct
-    SIMD_ALIGN(4,T)
-    store<4,T,xyzw,stpq> {
-        union {
-            T data[4];
-            struct { T x,y,z,w; };
-            struct { T s,t,p,q; };
-        };
-    };
-
-
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename T>
-    struct store<2,T,whd> {
-        union {
-            T data[2];
-            struct { T w,h; };
-        };
-    };
-
-
-    template <typename T>
-    struct store<3,T,whd> {
-        union {
-            T data[3];
-            struct { T w,h,d; };
-        };
-    };
-
-
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename T>
-    struct
-    SIMD_ALIGN(4,T)
-    store<4,T,wxyz,abcd> {
-        union {
-            T data[4];
-            struct { T w,x,y,z; };
-            struct { T a,b,c,d; };
-        };
-    };
+///////////////////////////////////////////////////////////////////////////////
+// defines the named member variables that a coordinate type is composed of
+#define DEFINE_COORD_STORE(TAG,...)             \
+namespace util::coord {                         \
+    template <typename T>                       \
+    struct store<                               \
+        VA_ARGS_COUNT(__VA_ARGS__),             \
+        T,                                      \
+        TAG                                     \
+    > {                                         \
+        union {                                 \
+            struct {                            \
+                T __VA_ARGS__;                  \
+            };                                  \
+            T data[VA_ARGS_COUNT(__VA_ARGS__)]; \
+        };                                      \
+    };                                          \
 }
 
+
+template <typename T>
+struct util::coord::store<1,T,::util::extent<1,T>> {
+    union { struct { T w; }; T data[1]; };
+};
+
+template <typename T>
+struct util::coord::store<2,T,::util::extent<2,T>> {
+    union { struct { T w, h; }; T data[2]; };
+};
+
+template <typename T>
+struct util::coord::store<3,T,::util::extent<3,T>> {
+    union { struct { T w, h, d; }; T data[3]; };
+};
+
+template <typename T>
+struct util::coord::store<1,T,::util::point<1,T>> {
+    union { struct { T x; }; T data[1]; };
+};
+
+template <typename T>
+struct util::coord::store<2,T,::util::point<2,T>> {
+    union { struct { T x, y; }; T data[2]; };
+};
+
+template <typename T>
+struct util::coord::store<3,T,::util::point<3,T>> {
+    union { struct { T x, y, z; }; T data[3]; };
+};
+
+template <typename T>
+struct util::coord::store<4,T,::util::point<4,T>> {
+    union { struct { T x, y, z, w; }; T data[4]; };
+};
+
+template <typename T>
+struct util::coord::store<1,T,::util::vector<1,T>> {
+    union { struct { T x; }; T data[1]; };
+};
+
+template <typename T>
+struct util::coord::store<2,T,::util::vector<2,T>> {
+    union { struct { T x, y; }; T data[2]; };
+};
+
+template <typename T>
+struct util::coord::store<3,T,::util::vector<3,T>> {
+    union { struct { T x, y, z; }; T data[3]; };
+};
+
+template <typename T>
+struct util::coord::store<4,T,::util::vector<4,T>> {
+    union { struct { T x, y, z, w; }; T data[4]; };
+};
+
 #endif
diff --git a/coord/traits.hpp b/coord/traits.hpp
new file mode 100644
index 00000000..861ea884
--- /dev/null
+++ b/coord/traits.hpp
@@ -0,0 +1,170 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2012-2017 Danny Robson <danny@nerdcruft.net>
+ */
+
+#ifndef CRUFT_UTIL_COORD_TRAITS_HPP
+#define CRUFT_UTIL_COORD_TRAITS_HPP
+
+#include "fwd.hpp"
+
+#include <cstddef>
+#include <type_traits>
+
+namespace util {
+    ///////////////////////////////////////////////////////////////////////
+    // operation traits
+    template <typename, typename>
+    struct result { };
+
+    //-------------------------------------------------------------------------
+    template <std::size_t S, typename T> struct result<srgba<S,T>,srgba<S,T>>   { using type = srgba<S,T>; };
+    template <std::size_t S, typename T> struct result<srgba<S,T>,vector<S,T>>   { using type = srgba<S,T>; };
+    template <std::size_t S, typename T> struct result<vector<S,T>,srgba<S,T>>   { using type = srgba<S,T>; };
+    template <std::size_t S, typename T> struct result<extent<S,T>,extent<S,T>> { using type = extent<S,T>; };
+    template <std::size_t S, typename T> struct result<extent<S,T>,vector<S,T>> { using type = extent<S,T>; };
+    template <std::size_t S, typename T> struct result<point<S,T>,extent<S,T>>  { using type = point <S,T>; };
+    template <std::size_t S, typename T> struct result<point<S,T>,vector<S,T>>  { using type = point <S,T>; };
+    template <std::size_t S, typename T> struct result<vector<S,T>,point<S,T>>  { using type = point <S,T>; };
+    template <std::size_t S, typename T> struct result<vector<S,T>,vector<S,T>> { using type = vector<S,T>; };
+
+    template <
+        typename A, typename B
+    >
+    using result_t = typename result<A,B>::type;
+
+
+    //---------------------------------------------------------------------
+    template <typename>
+    struct has_norm : public std::false_type { };
+
+    template <std::size_t S, typename T> struct has_norm<vector<S,T>> : public std::true_type { };
+
+    template <typename T>
+    constexpr auto has_norm_v = has_norm<T>::value;
+
+
+    //---------------------------------------------------------------------
+    template <typename T>
+    struct has_scalar_op : public std::false_type { };
+
+    template <std::size_t S, typename T> struct has_scalar_op<srgba<S,T>>  : public std::true_type { };
+    template <std::size_t S, typename T> struct has_scalar_op<extent<S,T>> : public std::true_type { };
+    template <std::size_t S, typename T> struct has_scalar_op<point<S,T>>  : public std::true_type { };
+    template <std::size_t S, typename T> struct has_scalar_op<vector<S,T>> : public std::true_type { };
+
+    template <typename T>
+    constexpr auto has_scalar_op_v = has_scalar_op<T>::value;
+
+
+    template <class> struct is_coord : std::false_type { };
+
+    template <typename T> struct is_coord<const T> : is_coord<T> {};
+    template <typename T> struct is_coord<T&> : is_coord<T> {};
+
+    template <std::size_t S, typename T> struct is_coord<point<S,T>>      : std::true_type { };
+    template <std::size_t S, typename T> struct is_coord<extent<S,T>>     : std::true_type { };
+    template <std::size_t S, typename T> struct is_coord<vector<S,T>>     : std::true_type { };
+    template <std::size_t S, typename T> struct is_coord<srgba<S,T>> : std::true_type { };
+
+    template <class K>
+    constexpr bool
+    is_coord_v = is_coord<K>::value;
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename T> struct has_redim : std::false_type {};
+
+
+    //---------------------------------------------------------------------
+    template <std::size_t S, typename T> struct has_redim< point<S,T>> : public std::true_type {};
+    template <std::size_t S, typename T> struct has_redim<vector<S,T>> : public std::true_type {};
+    template <std::size_t S, typename T> struct has_redim<extent<S,T>> : public std::true_type {};
+
+    //---------------------------------------------------------------------
+    template <typename T> constexpr auto has_redim_v = has_redim<T>::value;
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename> struct redim_type {};
+
+
+    //---------------------------------------------------------------------
+    template <std::size_t S, typename T> struct redim_type<point<S,T>>
+    { template <std::size_t _S> using type = point<_S,T>; };
+
+    template <std::size_t S, typename T> struct redim_type<vector<S,T>>
+    { template <std::size_t _S> using type = vector<_S,T>; };
+
+    template <std::size_t S, typename T> struct redim_type<extent<S,T>>
+    { template <std::size_t _S> using type = extent<_S,T>; };
+
+
+    //---------------------------------------------------------------------
+    template <
+        typename Self,
+        std::size_t S
+    >
+    using redim_t = typename redim_type<Self>::template type<S>;
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename> struct revalue_type {};
+
+
+    //-------------------------------------------------------------------------
+    template <std::size_t S, typename T>
+    struct revalue_type<point<S,T>> {
+        template <typename _T> using type = point<S,_T>;
+    };
+
+    template <std::size_t S, typename T>
+    struct revalue_type<vector<S,T>> {
+        template <typename _T> using type = vector<S,_T>;
+    };
+
+    template <std::size_t S, typename T>
+    struct revalue_type<extent<S,T>> {
+        template <typename _T> using type = extent<S,_T>;
+    };
+
+
+    //-------------------------------------------------------------------------
+    template <typename Self, typename T>
+    using revalue_t = typename revalue_type<Self>::template type<T>;
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename,typename=void> struct arity {};
+
+
+    template <typename T>
+    struct arity<T,std::enable_if_t<std::is_arithmetic_v<T>,void>
+    > :std::integral_constant<std::size_t, 1>
+    { };
+
+
+    template <typename T>
+    struct arity<
+        T,std::enable_if_t<is_coord_v<T>,void>
+    > :std::integral_constant<std::size_t,T::elements>
+    { };
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename T>
+    constexpr auto arity_v = arity<T>::value;
+}
+
+#endif
diff --git a/extent.cpp b/extent.cpp
index 5da4f70f..c6f97c06 100644
--- a/extent.cpp
+++ b/extent.cpp
@@ -187,9 +187,9 @@ namespace util::debug  {
 
 //-----------------------------------------------------------------------------
 #define INSTANTIATE_S_T(S,T)        \
-template struct util::extent<S,T>;  \
-template bool util::debug::is_valid (const extent<S,T>&); \
-template struct util::debug::validator<extent<S,T>>;
+template struct ::util::extent<S,T>;  \
+template bool ::util::debug::is_valid (const ::util::extent<S,T>&); \
+template struct ::util::debug::validator<::util::extent<S,T>>;
 
 #define INSTANTIATE(T)      \
 INSTANTIATE_S_T(1,T)        \
diff --git a/extent.hpp b/extent.hpp
index eeb804a6..076b381f 100644
--- a/extent.hpp
+++ b/extent.hpp
@@ -17,22 +17,24 @@
 #ifndef __UTIL_EXTENT_HPP
 #define __UTIL_EXTENT_HPP
 
+#include "coord/fwd.hpp"
 #include "coord/base.hpp"
 #include "vector.hpp"
 #include "point.hpp"
 
+#include <cstddef>
 
 namespace util {
     /**
-     * A pure two-dimensional size, without positioning
+     * A pure n-dimensional size, without positioning
      */
     template <size_t S, typename T>
-    struct extent : public coord::base<S,T,extent,coord::whd>
+    struct extent : public ::util::coord::base<S,T,::util::extent<S,T>>
     {
-        using coord::base<S,T,util::extent,coord::whd>::base;
+        using ::util::coord::base<S,T,::util::extent<S,T>>::base;
 
         extent () = default;
-        explicit extent (vector<S,T>);
+        explicit extent (::util::vector<S,T>);
 
         constexpr T    area  (void) const;
         constexpr T diameter (void) const;
@@ -42,25 +44,29 @@ namespace util {
         U aspect (void) const;
 
         template <typename U>
-        bool includes (util::point<S,U>) const;
+        bool includes (::util::point<S,U>) const;
 
-        extent expanded (vector<S,T>) const;
-        extent expanded (T) const;
-        extent contracted (vector<S,T>) const;
-        extent contracted (T) const;
+        ::util::extent<S,T> expanded (::util::vector<S,T>) const;
+        ::util::extent<S,T> expanded (T) const;
+        ::util::extent<S,T> contracted (::util::vector<S,T>) const;
+        ::util::extent<S,T> contracted (T) const;
 
         bool empty (void) const;
 
-        static constexpr extent max (void);
-        static constexpr extent min (void);
+        static constexpr ::util::extent<S,T> max (void);
+        static constexpr ::util::extent<S,T> min (void);
     };
 
     template <size_t S, typename T>
     struct extent_range {
     public:
-        struct iterator : public std::iterator<std::forward_iterator_tag, point<S,T>, size_t> {
+        struct iterator : public std::iterator<
+            std::forward_iterator_tag,
+            ::util::point<S,T>,
+            size_t
+        > {
         public:
-            iterator (extent<S,T>, util::point<S,T>);
+            iterator (::util::extent<S,T>, ::util::point<S,T>);
 
             point<S,T> operator* () const;
             iterator& operator++ (void);
diff --git a/geom/aabb.cpp b/geom/aabb.cpp
index 2aa1052a..26a7c4a0 100644
--- a/geom/aabb.cpp
+++ b/geom/aabb.cpp
@@ -83,92 +83,6 @@ AABB<S,T>::closest (point<S,T> q) const
 }
 
 
-///////////////////////////////////////////////////////////////////////////////
-template <size_t S, typename T>
-AABB<S,T>&
-AABB<S,T>::expand (util::vector<S,T> mag)
-{
-    p0 -= mag / T{2};
-    p1 += mag / T{2};
-
-    return *this;
-}
-
-
-//-----------------------------------------------------------------------------
-template <size_t S, typename T>
-AABB<S,T>&
-AABB<S,T>::expand (T t)
-{
-    return expand (vector<S,T> {t});
-}
-
-
-//-----------------------------------------------------------------------------
-template <size_t S, typename T>
-AABB<S,T>
-AABB<S,T>::expanded (vector<S,T> mag)
-{
-    auto ret = *this;
-    ret.expand (mag);
-    return ret;
-}
-
-
-//-----------------------------------------------------------------------------
-template <size_t S, typename T>
-AABB<S,T>
-AABB<S,T>::expanded (T t)
-{
-    return expanded (vector<S,T> {t});
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-template <size_t S, typename T>
-AABB<S,T>&
-AABB<S,T>::contract (util::vector<S,T> mag)
-{
-    // Avoid contracting magnitudes larger than our extent
-    auto diff = p1 - p0;
-    auto delta = min (diff, mag);
-
-    p0 += delta / T{2};
-    p1 -= delta / T{2};
-
-    return *this;
-}
-
-
-//-----------------------------------------------------------------------------
-template <size_t S, typename T>
-AABB<S,T>&
-AABB<S,T>::contract (T mag)
-{
-    return contract (util::vector<S,T> {mag});
-}
-
-
-//-----------------------------------------------------------------------------
-template <size_t S, typename T>
-AABB<S,T>
-AABB<S,T>::contracted (util::vector<S,T> mag) const
-{
-    AABB<S,T> res = *this;
-    res.contract (mag);
-    return res;
-}
-
-
-//-----------------------------------------------------------------------------
-template <size_t S, typename T>
-AABB<S,T>
-AABB<S,T>::contracted (T mag) const
-{
-    return contracted (vector<S,T> {mag});
-}
-
-
 //-----------------------------------------------------------------------------
 template <size_t S, typename T>
 void
diff --git a/geom/aabb.hpp b/geom/aabb.hpp
index 2c169d25..698ce899 100644
--- a/geom/aabb.hpp
+++ b/geom/aabb.hpp
@@ -36,16 +36,6 @@ namespace util::geom {
 
         point<S,T> closest (point<S,T>) const;
 
-        AABB<S,T>& expand (util::vector<S,T>);
-        AABB<S,T>& expand (T);
-        AABB<S,T>  expanded (util::vector<S,T>);
-        AABB<S,T>  expanded (T);
-
-        AABB<S,T>& contract (util::vector<S,T>);
-        AABB<S,T>& contract (T);
-        AABB<S,T>  contracted (util::vector<S,T>) const;
-        AABB<S,T>  contracted (T) const;
-
         void cover (point<S,T>);
 
         AABB<S,T> operator+ (vector<S,T>) const;
@@ -53,8 +43,8 @@ namespace util::geom {
 
         bool operator== (AABB) const;
 
-        point<S,T> p0;
-        point<S,T> p1;
+        ::util::point<S,T> p0;
+        ::util::point<S,T> p1;
     };
 
     typedef AABB<2,float> AABB2f;
diff --git a/geom/plane.cpp b/geom/plane.cpp
index 3ea53e49..2087664d 100644
--- a/geom/plane.cpp
+++ b/geom/plane.cpp
@@ -24,8 +24,7 @@ using util::geom::plane;
 
 ///////////////////////////////////////////////////////////////////////////////
 template <size_t S, typename T>
-plane<S,T>::plane (point<S,T>  _p,
-                   vector<S,T> _n):
+plane<S,T>::plane (point<S,T>  _p, vector<S,T> _n):
     p (_p),
     n (_n)
 {
diff --git a/geom/plane.hpp b/geom/plane.hpp
index e2cfe646..4cbe295d 100644
--- a/geom/plane.hpp
+++ b/geom/plane.hpp
@@ -23,11 +23,10 @@
 namespace util::geom {
     template <size_t S, typename T>
     struct plane {
-        plane (util::point<S,T> p,
-               util::vector<S,T> n);
+        plane (util::point<S,T>, util::vector<S,T>);
 
-        util::point<S,T> p;
-        util::vector<S,T> n;
+        ::util::point<S,T> p;
+        ::util::vector<S,T> n;
     };
 
 
diff --git a/hash/bsdsum.cpp b/hash/bsdsum.cpp
index 64c3bd22..f38258f1 100644
--- a/hash/bsdsum.cpp
+++ b/hash/bsdsum.cpp
@@ -48,9 +48,8 @@ bsdsum::update (const void *restrict data, size_t size) noexcept
 
 ///////////////////////////////////////////////////////////////////////////////
 void
-bsdsum::update (
-    const uint8_t *const restrict first,
-    const uint8_t *const restrict last) noexcept
+bsdsum::update (const uint8_t *const restrict first,
+                const uint8_t *const restrict last) noexcept
 {
     CHECK (first);
     CHECK (last);
diff --git a/maths.hpp b/maths.hpp
index 5ad376bc..61dc40c3 100644
--- a/maths.hpp
+++ b/maths.hpp
@@ -203,7 +203,7 @@ namespace util {
 
     ///////////////////////////////////////////////////////////////////////////
     template <typename T>
-    T
+    std::enable_if_t<std::is_arithmetic_v<T>, T>
     abs [[gnu::const]] (T t)
     {
         return t > 0 ? t : -t;
@@ -604,9 +604,9 @@ namespace util {
     //-------------------------------------------------------------------------
     /// Variadic maximum
     template <typename T>
-    constexpr T
+    constexpr std::enable_if_t<std::is_arithmetic_v<T>, T>
     max  (const T a)
-        { return a; }
+    { return a; }
 
 
     //-------------------------------------------------------------------------
diff --git a/matrix.cpp b/matrix.cpp
index dea7a429..cab7fa0c 100644
--- a/matrix.cpp
+++ b/matrix.cpp
@@ -27,7 +27,7 @@ using util::matrix;
 
 
 ///////////////////////////////////////////////////////////////////////////////
-template <size_t Rows, size_t Cols, typename T>
+template <std::size_t Rows, std::size_t Cols, typename T>
 matrix<Rows,Cols,T>&
 matrix<Rows,Cols,T>::invert (void)
 {
@@ -36,7 +36,7 @@ matrix<Rows,Cols,T>::invert (void)
 
 
 //-----------------------------------------------------------------------------
-//template <size_t S, typename T>
+//template <std::size_t S, typename T>
 //matrix<S,T>&
 //matrix<S,T>::invert_affine (void)
 //{
@@ -85,7 +85,7 @@ matrix<Rows,Cols,T>::invert (void)
 
 
 //-----------------------------------------------------------------------------
-template <size_t Rows, size_t Cols, typename T>
+template <std::size_t Rows, std::size_t Cols, typename T>
 T
 util::matrix<Rows,Cols,T>::determinant (void) const
 {
@@ -94,7 +94,7 @@ util::matrix<Rows,Cols,T>::determinant (void) const
 
 
 //-----------------------------------------------------------------------------
-template <size_t Rows, size_t Cols, typename T>
+template <std::size_t Rows, std::size_t Cols, typename T>
 util::matrix<Rows,Cols,T>
 util::matrix<Rows,Cols,T>::inverse (void) const
 {
@@ -103,14 +103,14 @@ util::matrix<Rows,Cols,T>::inverse (void) const
 
 
 ///////////////////////////////////////////////////////////////////////////////
-template <size_t Rows, size_t Cols, typename T>
+template <std::size_t Rows, std::size_t Cols, typename T>
 matrix<Cols,Rows,T>
 util::transposed (const matrix<Rows,Cols,T> &m)
 {
     util::matrix<Cols,Rows,T> res;
 
-    for (size_t y = 0; y < Rows; ++y)
-        for (size_t x = 0; x < Cols; ++x)
+    for (std::size_t y = 0; y < Rows; ++y)
+        for (std::size_t x = 0; x < Cols; ++x)
             res[y][x] = m[x][y];
 
     return res;
@@ -123,42 +123,14 @@ template util::matrix4f util::transposed (const matrix4f&);
 
 
 ///////////////////////////////////////////////////////////////////////////////
-template <size_t Rows, size_t Cols, typename T>
-util::vector<Rows,T>
-matrix<Rows,Cols,T>::operator* (const vector<Rows,T> &rhs) const
-{
-    vector<Rows,T> out;
-
-    for (size_t i = 0; i < Rows; ++i)
-        out[i] = dot (rhs, values[i]);
-
-    return out;
-}
-
-
-//-----------------------------------------------------------------------------
-template <size_t Rows, size_t Cols, typename T>
-util::point<Rows,T>
-matrix<Rows,Cols,T>::operator* (const point<Rows,T> &rhs) const
-{
-    point<Rows,T> out;
-
-    for (size_t i = 0; i < Rows; ++i)
-        out[i] = dot (rhs, values[i]);
-
-    return out;
-}
-
-
-//-----------------------------------------------------------------------------
-template <size_t Rows, size_t Cols, typename T>
+template <std::size_t Rows, std::size_t Cols, typename T>
 bool
 matrix<Rows,Cols,T>::is_affine (void) const
 {
     if (Rows != Cols)
         return false;
 
-    for (size_t i = 0; i < Rows - 1; ++i)
+    for (std::size_t i = 0; i < Rows - 1; ++i)
         if (!exactly_zero (values[Rows-1][i]))
             return false;
 
@@ -167,11 +139,11 @@ matrix<Rows,Cols,T>::is_affine (void) const
 
 
 //-----------------------------------------------------------------------------
-template <size_t Rows, size_t Cols, typename T>
+template <typename T>
 util::matrix4<T>
-matrix<Rows,Cols,T>::ortho (T left,   T right,
-                            T bottom, T top,
-                            T near,   T far)
+util::ortho (T left,   T right,
+             T bottom, T top,
+             T near,   T far)
 {
     CHECK_GT (far, near);
 
@@ -183,29 +155,29 @@ matrix<Rows,Cols,T>::ortho (T left,   T right,
     T tb = 2 / (top - bottom);
     T fn = 2 / (far - near);
 
-    return { {
+    return {{
         { rl,  0,  0, tx },
         {  0, tb,  0, ty },
         {  0,  0, fn, tz },
         {  0,  0,  0,  1 },
-    } };
+    }};
 }
 
 
 //-----------------------------------------------------------------------------
-template <size_t Rows, size_t Cols, typename T>
+template <typename T>
 util::matrix4<T>
-matrix<Rows, Cols,T>::ortho2D (T left  , T right,
-                               T bottom, T top)
+util::ortho2D (T left, T right,
+               T bottom, T top)
 {
     return ortho (left, right, bottom, top, -1, 1);
 }
 
 
 //-----------------------------------------------------------------------------
-template <size_t Rows, size_t Cols, typename T>
+template <typename T>
 util::matrix4<T>
-matrix<Rows,Cols,T>::perspective (T fov, T aspect, range<T> Z)
+util::perspective (T fov, T aspect, range<T> Z)
 {
     CHECK_GE (Z.lo, 0);
     CHECK_GE (Z.hi, 0);
@@ -234,11 +206,11 @@ matrix<Rows,Cols,T>::perspective (T fov, T aspect, range<T> Z)
 // Implemented for right handed world coordinates.
 //
 // Assumes 'up' is normalised.
-template <size_t Rows, size_t Cols, typename T>
+template <typename T>
 util::matrix4<T>
-matrix<Rows,Cols,T>::look_at (const util::point<3,T> eye,
-                              const util::point<3,T> centre,
-                              const util::vector<3,T> up)
+util::look_at (const util::point<3,T> eye,
+               const util::point<3,T> centre,
+               const util::vector<3,T> up)
 {
     CHECK (is_normalised (up));
 
@@ -253,23 +225,16 @@ matrix<Rows,Cols,T>::look_at (const util::point<3,T> eye,
         {   0,   0,   0, 1 },
     }};
 
-    return rot * util::matrix4<T>::translation (0-eye);
+    return rot * util::translation<T> (0-eye);
 }
 
+template util::matrix4f util::look_at (util::point3f, util::point3f, util::vector3f);
+
 
 //-----------------------------------------------------------------------------
-template <size_t Rows, size_t Cols, typename T>
+template <typename T>
 util::matrix4<T>
-matrix<Rows,Cols,T>::translation (util::vector<2,T> v)
-{
-    return translation ({v.x, v.y, 0});
-}
-
-
-//-----------------------------------------------------------------------------
-template <size_t Rows, size_t Cols, typename T>
-util::matrix4<T>
-matrix<Rows,Cols,T>::translation (util::vector<3,T> v)
+util::translation (util::vector<3,T> v)
 {
     return { {
         { 1.f, 0.f, 0.f, v.x },
@@ -280,18 +245,21 @@ matrix<Rows,Cols,T>::translation (util::vector<3,T> v)
 }
 
 
+template util::matrix4f util::translation (util::vector3f);
+
+
 //-----------------------------------------------------------------------------
-template <size_t Rows, size_t Cols, typename T>
+template <typename T>
 util::matrix4<T>
-matrix<Rows,Cols,T>::scale (T mag)
+util::scale (T mag)
 {
     return scale (vector<3,T> (mag));
 }
 
 //-----------------------------------------------------------------------------
-template <size_t Rows, size_t Cols, typename T>
+template <typename T>
 util::matrix4<T>
-matrix<Rows,Cols,T>::scale (util::vector<3,T> v)
+util::scale (util::vector<3,T> v)
 {
     return { {
         { v.x, 0.f, 0.f, 0.f },
@@ -303,9 +271,9 @@ matrix<Rows,Cols,T>::scale (util::vector<3,T> v)
 
 
 //-----------------------------------------------------------------------------
-template <size_t Rows, size_t Cols, typename T>
+template <typename T>
 util::matrix4<T>
-matrix<Rows,Cols,T>::rotation (T angle, util::vector<3,T> about)
+util::rotation (T angle, util::vector<3,T> about)
 {
     CHECK (is_normalised (about));
 
@@ -338,6 +306,7 @@ matrix<Rows,Cols,T>::rotation (T angle, util::vector<3,T> about)
     } };
 }
 
+template util::matrix4f util::rotation (float, util::vector3f);
 
 //-----------------------------------------------------------------------------
 template struct util::matrix<2,2,float>;
@@ -354,7 +323,7 @@ template struct util::matrix<4,4,double>;
 // Uses the algorithm from:
 //    "Extracting Euler Angles from a Rotation Matrix" by
 //    Mike Day, Insomniac Games.
-template <size_t Rows, size_t Cols, typename T>
+template <std::size_t Rows, std::size_t Cols, typename T>
 util::vector<3,T>
 util::to_euler (const matrix<Rows,Cols,T> &m)
 {
@@ -383,13 +352,13 @@ template util::vector<3,float> util::to_euler (const matrix<4,4,float>&);
 
 
 ///////////////////////////////////////////////////////////////////////////////
-template <size_t Rows, size_t Cols, typename T>
+template <std::size_t Rows, std::size_t Cols, typename T>
 std::ostream&
 util::operator<< (std::ostream &os, const matrix<Rows,Cols,T> &m)
 {
     os << "{ ";
 
-    for (size_t i = 0; i < Rows; ++i) {
+    for (std::size_t i = 0; i < Rows; ++i) {
         os << "{ ";
         std::copy_n (m[i], Cols, util::infix_iterator<float> (os, ", "));
         os << ((i == Rows - 1) ? " }" : " }, ");
diff --git a/matrix.hpp b/matrix.hpp
index e66cf5a7..ce2591fd 100644
--- a/matrix.hpp
+++ b/matrix.hpp
@@ -19,23 +19,43 @@
 
 #include "point.hpp"
 #include "range.hpp"
+#include "vector.hpp"
 
 #include <ostream>
 #include <cstdlib>
 
 namespace util {
-    template <size_t Rows, size_t Cols, typename T>
+    template <std::size_t Rows, std::size_t Cols, typename T>
     struct matrix {
         static constexpr auto rows = Rows;
         static constexpr auto cols = Cols;
 
-        T values[Rows][Cols];
+        constexpr matrix () noexcept = default;
+
+        constexpr matrix (const T(&_data)[Rows][Cols]) noexcept:
+            values {}
+        {
+            for (std::size_t r = 0; r < Rows; ++r)
+                for (std::size_t c = 0; c < Cols; ++c)
+                    values[r][c] = _data[r][c];
+        }
+
+
+        template <std::size_t S, typename SelfT>
+        constexpr matrix (const util::coord::base<S,T,SelfT> (&_data)[Rows]) noexcept
+        {
+            for (std::size_t r = 0; r < Rows; ++r)
+                for (std::size_t c = 0; c < Cols; ++c)
+                    values[r][c] = _data[r][c];
+        }
+
+        T values[rows][cols];
 
         // index operators return a pointer into the data array so that
         // multidimensional array syntax can be used transparently on this
         // type.
-        T* operator[] (size_t);
-        const T* operator[] (size_t) const;
+        constexpr auto& operator[] (std::size_t idx) { return values[idx]; }
+        constexpr const auto& operator[] (std::size_t idx) const { return values[idx]; }
 
         T* data (void);
         const T* data (void) const;
@@ -54,8 +74,18 @@ namespace util {
         matrix  inverse_affine (void) const;
         matrix& invert_affine  (void);
 
-        vector<Rows,T> operator* (const vector<Rows,T>&) const;
-        point<Rows,T>  operator* (const point<Rows,T> &) const;
+
+        template <typename VectorT>
+        std::enable_if_t<is_coord_v<VectorT>, VectorT>
+        operator* (const VectorT &rhs) const
+        {
+            VectorT out;
+
+            for (std::size_t i = 0; i < Rows; ++i)
+                out[i] = dot (rhs, values[i]);
+
+            return out;
+        }
 
         bool is_affine (void) const;
 
@@ -63,44 +93,44 @@ namespace util {
         matrix<Rows,Cols,U>
         cast (void) const;
 
-        // Perspective matrices
-        static matrix<4,4,T> ortho   (T left, T right, T bottom, T top, T near, T far);
-        static matrix<4,4,T> ortho2D (T left, T right, T bottom, T top);
-        static matrix<4,4,T> perspective (T fov, T aspect, range<T> Z);
-        static matrix<4,4,T> look_at (point<3,T> eye, point<3,T> target, vector<3,T> up);
-
-        // Affine matrices
-        static matrix<4,4,T> translation (util::vector<2,T>);
-        static matrix<4,4,T> translation (util::vector<3,T>);
-        static matrix<4,4,T> scale       (util::vector<3,T>);
-        static matrix<4,4,T> scale       (T);
-        static matrix<4,4,T> rotation    (T angle, util::vector<3,T> about);
-
         // Constant matrices
         static constexpr matrix identity ();
         static constexpr matrix zeroes ();
     };
 
 
+    // Perspective matrices
+    template <typename T> matrix<4,4,T> ortho (T left, T right, T bottom, T top, T near, T far);
+    template <typename T> matrix<4,4,T> ortho2D (T left, T right, T bottom, T top);
+    template <typename T> matrix<4,4,T> perspective (T fov, T aspect, range<T> Z);
+    template <typename T> matrix<4,4,T> look_at (point<3,T> eye, point<3,T> target, vector<3,T> up);
+
+    // Affine matrices
+    template <typename T> matrix<4,4,T> translation (util::vector<3,T>);
+    template <typename T> matrix<4,4,T> scale       (util::vector<3,T>);
+    template <typename T> matrix<4,4,T> scale       (T);
+    template <typename T> matrix<4,4,T> rotation    (T angle, util::vector<3,T> about);
+
+
     ///////////////////////////////////////////////////////////////////////////
     // Convert an affine rotation matrix to euler angles.
     //
     // Results are undefined if the matrix is not purely a rotation matrix,
     // or if the dimension is not 3x3 or 4x4.
-    template <size_t Rows, size_t Cols, typename T>
+    template <std::size_t Rows, std::size_t Cols, typename T>
     vector<3,T>
     to_euler (const matrix<Rows, Cols, T>&);
 
 
     ///////////////////////////////////////////////////////////////////////////
     // logical operations
-    template <size_t Rows, size_t Cols, typename T>
+    template <std::size_t Rows, std::size_t Cols, typename T>
     constexpr
     bool
     operator== (const matrix<Rows,Cols,T>&, const matrix<Rows,Cols,T>&);
 
 
-    template <size_t Rows, size_t Cols, typename T>
+    template <std::size_t Rows, std::size_t Cols, typename T>
     constexpr
     bool
     operator!= (const matrix<Rows,Cols,T>&, const matrix<Rows,Cols,T>&);
@@ -108,51 +138,95 @@ namespace util {
 
     ///////////////////////////////////////////////////////////////////////////
     // element operations
-    template <size_t Rows, size_t Cols, typename T>
+    template <std::size_t Rows, std::size_t Cols, typename T>
     constexpr
     matrix<Rows,Cols,T>
     operator+ (const matrix<Rows,Cols,T>&, const matrix<Rows,Cols,T>&);
 
-    template <size_t Rows, size_t Cols, typename T>
+    template <std::size_t Rows, std::size_t Cols, typename T>
     constexpr
     matrix<Rows,Cols,T>
     operator- (const matrix<Rows,Cols,T>&, const matrix<Rows,Cols,T>&);
 
 
+    template <std::size_t Rows, std::size_t Cols, typename T>
+    constexpr
+    matrix<Rows,Cols,T>
+    div (const matrix<Rows,Cols,T> &a, const matrix<Rows,Cols,T> &b)
+    {
+        matrix<Rows,Cols,T> out {};
+        for (std::size_t r = 0; r < Rows; ++r)
+            for (std::size_t c = 0; c < Cols; ++c)
+                out[r][c] = a[r][c] / b[r][c];
+        return out;
+    }
+
+
+    template <std::size_t Rows, std::size_t Cols, typename T>
+    constexpr T
+    max (const matrix<Rows,Cols,T> &m)
+    {
+        T val = m[0][0];
+        for (std::size_t r = 0; r < Rows; ++r)
+            for (std::size_t c = 0; c < Cols; ++c)
+                val = max (val, m[r][c]);
+        return val;
+    }
+
+
     ///////////////////////////////////////////////////////////////////////////
     // scalar operations
-    template <size_t R, size_t C, typename T> constexpr matrix<R,C,T> operator* (const matrix<R,C,T>&, T);
-    template <size_t R, size_t C, typename T> constexpr matrix<R,C,T> operator/ (const matrix<R,C,T>&, T);
-    template <size_t R, size_t C, typename T> constexpr matrix<R,C,T> operator+ (const matrix<R,C,T>&, T);
-    template <size_t R, size_t C, typename T> constexpr matrix<R,C,T> operator- (const matrix<R,C,T>&, T);
+    template <std::size_t R, std::size_t C, typename T> constexpr matrix<R,C,T> operator* (const matrix<R,C,T>&, T);
+    template <std::size_t R, std::size_t C, typename T> constexpr matrix<R,C,T> operator/ (const matrix<R,C,T>&, T);
+    template <std::size_t R, std::size_t C, typename T> constexpr matrix<R,C,T> operator+ (const matrix<R,C,T>&, T);
+    template <std::size_t R, std::size_t C, typename T> constexpr matrix<R,C,T> operator- (const matrix<R,C,T>&, T);
 
-    template <size_t R, size_t C, typename T> constexpr matrix<R,C,T> operator* (T, const matrix<R,C,T>&);
-    template <size_t R, size_t C, typename T> constexpr matrix<R,C,T> operator/ (T, const matrix<R,C,T>&);
-    template <size_t R, size_t C, typename T> constexpr matrix<R,C,T> operator+ (T, const matrix<R,C,T>&);
-    template <size_t R, size_t C, typename T> constexpr matrix<R,C,T> operator- (T, const matrix<R,C,T>&);
+    template <std::size_t R, std::size_t C, typename T> constexpr matrix<R,C,T> operator* (T, const matrix<R,C,T>&);
+    template <std::size_t R, std::size_t C, typename T> constexpr matrix<R,C,T> operator/ (T, const matrix<R,C,T>&);
+    template <std::size_t R, std::size_t C, typename T> constexpr matrix<R,C,T> operator+ (T, const matrix<R,C,T>&);
+    template <std::size_t R, std::size_t C, typename T> constexpr matrix<R,C,T> operator- (T, const matrix<R,C,T>&);
 
-    template <size_t R, size_t C, typename T> constexpr matrix<R,C,T>& operator*= (matrix<R,C,T>&, T);
-    template <size_t R, size_t C, typename T> constexpr matrix<R,C,T>& operator/= (matrix<R,C,T>&, T);
-    template <size_t R, size_t C, typename T> constexpr matrix<R,C,T>& operator+= (matrix<R,C,T>&, T);
-    template <size_t R, size_t C, typename T> constexpr matrix<R,C,T>& operator-= (matrix<R,C,T>&, T);
+    template <std::size_t R, std::size_t C, typename T> constexpr matrix<R,C,T>& operator*= (matrix<R,C,T>&, T);
+    template <std::size_t R, std::size_t C, typename T> constexpr matrix<R,C,T>& operator/= (matrix<R,C,T>&, T);
+    template <std::size_t R, std::size_t C, typename T> constexpr matrix<R,C,T>& operator+= (matrix<R,C,T>&, T);
+    template <std::size_t R, std::size_t C, typename T> constexpr matrix<R,C,T>& operator-= (matrix<R,C,T>&, T);
 
 
     ///////////////////////////////////////////////////////////////////////////
     // matrix operations
     template <
-        size_t R1, size_t C1,
-        size_t R2, size_t C2,
+        std::size_t R1, //int C1,
+        std::size_t RC, //int R2,
+        std::size_t C2,
         typename T
     >
     constexpr
     matrix<R1,C2,T>
-    operator* (const matrix<R1,C1,T>&, const matrix<R2,C2,T>&);
+    operator* (const matrix<R1,RC,T>&a, const matrix<RC,C2,T>&b)
+    {
+        matrix<R1,C2,T> res {};
+
+        // we use a column first iteration approach because otherwise we risk
+        // triggering clang#????
+        for (std::size_t c = 0; c < C2; ++c) {
+            for (std::size_t r = 0; r < R1; ++r) {
+                T accum {0};
+
+                for (std::size_t i = 0; i < RC; ++i)
+                    accum += a[r][i] * b[i][c];
+
+                res[r][c] = accum;
+            }
+        }
+
+        return res;
+    }
 
 
     //-------------------------------------------------------------------------
     template <
-        size_t R1, size_t C1,
-        size_t R2, size_t C2,
+        std::size_t R1, std::size_t C1,
+        std::size_t R2, std::size_t C2,
         typename T
     >
     constexpr
@@ -162,25 +236,25 @@ namespace util {
 
 
     ///////////////////////////////////////////////////////////////////////////
-    template <size_t Rows, size_t Cols, typename T>
+    template <std::size_t Rows, std::size_t Cols, typename T>
     T
     determinant (const matrix<Rows,Cols,T>&);
 
-    template <size_t Rows, size_t Cols, typename T>
+    template <std::size_t Rows, std::size_t Cols, typename T>
     matrix<Rows,Cols,T>
     inverse (const matrix<Rows,Cols,T>&);
 
-    template <size_t Rows, size_t Cols, typename T>
+    template <std::size_t Rows, std::size_t Cols, typename T>
     matrix<Cols,Rows,T>
     transposed (const matrix<Rows,Cols,T>&);
 
     ///////////////////////////////////////////////////////////////////////////
 
-    template <size_t Rows, size_t Cols, typename T>
+    template <std::size_t Rows, std::size_t Cols, typename T>
     matrix<Rows,Cols,T>
     abs (const matrix<Rows,Cols,T>&);
 
-    template <size_t Rows, size_t Cols, typename T>
+    template <std::size_t Rows, std::size_t Cols, typename T>
     constexpr
     T
     sum (const matrix<Rows,Cols,T>&);
@@ -190,8 +264,8 @@ namespace util {
     template <typename T> using matrix3 = matrix<3,3,T>;
     template <typename T> using matrix4 = matrix<4,4,T>;
 
-    template <size_t Rows, size_t Cols> using matrixf = matrix<Rows,Cols,float>;
-    template <size_t Rows, size_t Cols> using matrixd = matrix<Rows,Cols,double>;
+    template <std::size_t Rows, std::size_t Cols> using matrixf = matrix<Rows,Cols,float>;
+    template <std::size_t Rows, std::size_t Cols> using matrixd = matrix<Rows,Cols,double>;
 
     typedef matrix<2,2,float> matrix2f;
     typedef matrix<2,2,double> matrix2d;
@@ -204,7 +278,7 @@ namespace util {
 
 
     ///////////////////////////////////////////////////////////////////////////
-    template <size_t Rows, size_t Cols, typename T>
+    template <std::size_t Rows, std::size_t Cols, typename T>
     std::ostream& operator<< (std::ostream&, const matrix<Rows,Cols,T>&);
 }
 
diff --git a/matrix.ipp b/matrix.ipp
index 1f3f53f8..84907951 100644
--- a/matrix.ipp
+++ b/matrix.ipp
@@ -19,29 +19,30 @@
 #error
 #endif
 
+#include "matrix.hpp"
 #define __UTIL_MATRIX_IPP
 
 
 ///////////////////////////////////////////////////////////////////////////////
-template <size_t Rows, size_t Cols, typename T>
-T*
-util::matrix<Rows,Cols,T>::operator[] (size_t idx)
-{
-    return this->values[idx];
-}
+//template <std::size_t Rows, std::size_t Cols, typename T>
+//T*
+//util::matrix<Rows,Cols,T>::operator[] (int idx)
+//{
+//    return this->values[idx];
+//}
+//
+//
+////-----------------------------------------------------------------------------
+//template <std::size_t Rows, std::size_t Cols, typename T>
+//const T*
+//util::matrix<Rows,Cols,T>::operator[] (int idx) const
+//{
+//    return this->values[idx];
+//}
 
 
 //-----------------------------------------------------------------------------
-template <size_t Rows, size_t Cols, typename T>
-const T*
-util::matrix<Rows,Cols,T>::operator[] (size_t idx) const
-{
-    return this->values[idx];
-}
-
-
-//-----------------------------------------------------------------------------
-template <size_t Rows, size_t Cols, typename T>
+template <std::size_t Rows, std::size_t Cols, typename T>
 T*
 util::matrix<Rows,Cols,T>::data (void)
 {
@@ -50,7 +51,7 @@ util::matrix<Rows,Cols,T>::data (void)
 
 
 //-----------------------------------------------------------------------------
-template <size_t Rows, size_t Cols, typename T>
+template <std::size_t Rows, std::size_t Cols, typename T>
 const T*
 util::matrix<Rows,Cols,T>::data (void) const
 {
@@ -59,7 +60,7 @@ util::matrix<Rows,Cols,T>::data (void) const
 
 
 //-----------------------------------------------------------------------------
-template <size_t Rows, size_t Cols, typename T>
+template <std::size_t Rows, std::size_t Cols, typename T>
 const T*
 util::matrix<Rows,Cols,T>::begin (void) const
 {
@@ -68,7 +69,7 @@ util::matrix<Rows,Cols,T>::begin (void) const
 
 
 //-----------------------------------------------------------------------------
-template <size_t Rows, size_t Cols, typename T>
+template <std::size_t Rows, std::size_t Cols, typename T>
 const T*
 util::matrix<Rows,Cols,T>::end (void) const
 {
@@ -77,7 +78,7 @@ util::matrix<Rows,Cols,T>::end (void) const
 
 
 //-----------------------------------------------------------------------------
-template <size_t Rows, size_t Cols, typename T>
+template <std::size_t Rows, std::size_t Cols, typename T>
 const T*
 util::matrix<Rows,Cols,T>::cbegin (void) const
 {
@@ -86,7 +87,7 @@ util::matrix<Rows,Cols,T>::cbegin (void) const
 
 
 //-----------------------------------------------------------------------------
-template <size_t Rows, size_t Cols, typename T>
+template <std::size_t Rows, std::size_t Cols, typename T>
 const T*
 util::matrix<Rows,Cols,T>::cend (void) const
 {
@@ -95,7 +96,7 @@ util::matrix<Rows,Cols,T>::cend (void) const
 
 
 //-----------------------------------------------------------------------------
-template <size_t Rows, size_t Cols, typename T>
+template <std::size_t Rows, std::size_t Cols, typename T>
 T*
 util::matrix<Rows,Cols,T>::begin (void)
 {
@@ -104,7 +105,7 @@ util::matrix<Rows,Cols,T>::begin (void)
 
 
 //-----------------------------------------------------------------------------
-template <size_t Rows, size_t Cols, typename T>
+template <std::size_t Rows, std::size_t Cols, typename T>
 T*
 util::matrix<Rows,Cols,T>::end (void)
 {
@@ -113,7 +114,7 @@ util::matrix<Rows,Cols,T>::end (void)
 
 
 ///////////////////////////////////////////////////////////////////////////////
-template <size_t Rows, size_t Cols, typename T>
+template <std::size_t Rows, std::size_t Cols, typename T>
 template <typename U>
 util::matrix<Rows,Cols,U>
 util::matrix<Rows,Cols,T>::cast (void) const
@@ -126,7 +127,7 @@ util::matrix<Rows,Cols,T>::cast (void) const
 
 ///////////////////////////////////////////////////////////////////////////////
 #define MATRIX_ELEMENT_OP(OP)                                       \
-template <size_t Rows, size_t Cols, typename T>                     \
+template <std::size_t Rows, std::size_t Cols, typename T>                     \
 constexpr                                                           \
 util::matrix<Rows,Cols,T>                                           \
 util::operator OP (                                                 \
@@ -135,8 +136,8 @@ util::operator OP (                                                 \
 {                                                                   \
     util::matrix<Rows,Cols,T> res {};                               \
                                                                     \
-    for (size_t i = 0; i < a.rows; ++i)                             \
-        for (size_t j = 0; j < a.cols; ++j)                         \
+    for (std::size_t i = 0; i < a.rows; ++i)                             \
+        for (std::size_t j = 0; j < a.cols; ++j)                         \
             res[i][j] = a[i][j] OP b[i][j];                         \
                                                                     \
     return res;                                                     \
@@ -150,7 +151,7 @@ MATRIX_ELEMENT_OP(+)
 
 ///////////////////////////////////////////////////////////////////////////////
 #define MATRIX_SCALAR_OP(OP)                                        \
-template <size_t Rows, size_t Cols, typename T>                     \
+template <std::size_t Rows, std::size_t Cols, typename T>                     \
 constexpr                                                           \
 util::matrix<Rows,Cols,T>                                           \
 util::operator OP (const util::matrix<Rows,Cols,T> &m, const T t)   \
@@ -168,7 +169,7 @@ util::operator OP (const util::matrix<Rows,Cols,T> &m, const T t)   \
 }                                                                   \
                                                                     \
                                                                     \
-template <size_t Rows, size_t Cols, typename T>                     \
+template <std::size_t Rows, std::size_t Cols, typename T>                     \
 constexpr                                                           \
 util::matrix<Rows,Cols,T>                                           \
 util::operator OP (const T t, const util::matrix<Rows,Cols,T> &m)   \
@@ -177,7 +178,7 @@ util::operator OP (const T t, const util::matrix<Rows,Cols,T> &m)   \
 }                                                                   \
                                                                     \
                                                                     \
-template <size_t Rows, size_t Cols, typename T>                     \
+template <std::size_t Rows, std::size_t Cols, typename T>                     \
 constexpr                                                           \
 util::matrix<Rows,Cols,T>&                                          \
 util::operator OP##= (util::matrix<Rows,Cols,T> &m, T t)            \
@@ -202,40 +203,21 @@ MATRIX_SCALAR_OP(-)
 
 
 ///////////////////////////////////////////////////////////////////////////////
-template <
-    std::size_t R1, std::size_t C1,
-    std::size_t R2, std::size_t C2,
-    typename T
->
-constexpr
-util::matrix<R1,C2,T>
-util::operator* (const matrix<R1,C1,T> &a, const matrix<R2,C2,T> &b)
-{
-    static_assert (R2 == C1);
-
-    matrix<R1,C2,T> res {0};
-
-    for (size_t r = 0; r < R1; ++r)
-        for (size_t c = 0; c < C2; ++c)
-            for (size_t i = 0; i < R2; ++i)
-                res[r][c] += a[r][i] * b[i][c];
-
-    return res;
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-template <size_t Rows, size_t Cols, typename T>
+template <std::size_t Rows, std::size_t Cols, typename T>
 constexpr
 util::matrix<Rows,Cols,T>
 util::matrix<Rows,Cols,T>::zeroes (void)
 {
-    return {0};
+    util::matrix<Rows,Cols,T> ret {};
+    for (std::size_t r = 0; r < Rows; ++r)
+        for (std::size_t c = 0; c < Cols; ++c)
+            ret[r][c] = 0;
+    return ret;
 }
 
 
 ///////////////////////////////////////////////////////////////////////////////
-template <size_t Rows, size_t Cols, typename T>
+template <std::size_t Rows, std::size_t Cols, typename T>
 constexpr
 util::matrix<Rows,Cols,T>
 util::matrix<Rows,Cols,T>::identity (void)
@@ -243,14 +225,14 @@ util::matrix<Rows,Cols,T>::identity (void)
     static_assert (Rows == Cols);
 
     auto m = zeroes ();
-    for (size_t i = 0; i < Rows; ++i)
+    for (std::size_t i = 0; i < Rows; ++i)
         m[i][i] = 1;
     return m;
 }
 
 
 ///////////////////////////////////////////////////////////////////////////////
-template <size_t Rows, size_t Cols, typename T>
+template <std::size_t Rows, std::size_t Cols, typename T>
 constexpr
 bool
 util::operator== (const matrix<Rows,Cols,T> &a, const matrix<Rows,Cols,T> &b)
@@ -260,7 +242,7 @@ util::operator== (const matrix<Rows,Cols,T> &a, const matrix<Rows,Cols,T> &b)
 
 
 //-----------------------------------------------------------------------------
-template <size_t Rows, size_t Cols, typename T>
+template <std::size_t Rows, std::size_t Cols, typename T>
 constexpr
 bool
 util::operator!= (const matrix<Rows,Cols,T> &a, const matrix<Rows,Cols,T> &b)
@@ -270,7 +252,7 @@ util::operator!= (const matrix<Rows,Cols,T> &a, const matrix<Rows,Cols,T> &b)
 
 
 ///////////////////////////////////////////////////////////////////////////////
-template <size_t Rows, size_t Cols, typename T>
+template <std::size_t Rows, std::size_t Cols, typename T>
 util::matrix<Rows,Cols,T>
 util::abs (const util::matrix<Rows,Cols,T> &src)
 {
@@ -281,7 +263,7 @@ util::abs (const util::matrix<Rows,Cols,T> &src)
 
 
 ///////////////////////////////////////////////////////////////////////////////
-template <size_t Rows, size_t Cols, typename T>
+template <std::size_t Rows, std::size_t Cols, typename T>
 constexpr
 T
 util::sum (const util::matrix<Rows, Cols,T> &src)
diff --git a/matrix2.cpp b/matrix2.cpp
index 393066a4..bbe94e73 100644
--- a/matrix2.cpp
+++ b/matrix2.cpp
@@ -20,7 +20,7 @@ using util::matrix;
 
 
 ///////////////////////////////////////////////////////////////////////////////
-template <size_t Rows, size_t Cols, typename T>
+template <std::size_t Rows, std::size_t Cols, typename T>
 T
 util::determinant (const matrix<Rows,Cols,T> &m)
 {
@@ -34,16 +34,16 @@ template double util::determinant (const matrix<2,2,double>&);
 
 
 ///////////////////////////////////////////////////////////////////////////////
-template <size_t Rows, size_t Cols, typename T>
+template <std::size_t Rows, std::size_t Cols, typename T>
 matrix<Rows,Cols,T>
 util::inverse (const matrix<Rows,Cols,T> &m)
 {
     static_assert (Rows == 2 && Cols == 2);
 
-    return matrix<2,2,T> {
-         m[1][1], -m[0][1],
-        -m[1][0],  m[0][0]
-    } / determinant (m);
+    return matrix<2,2,T> {{
+        {  m[1][1], -m[0][1], },
+        { -m[1][0],  m[0][0], },
+    }} / determinant (m);
 }
 
 
diff --git a/matrix3.cpp b/matrix3.cpp
index d4398a20..123bb16b 100644
--- a/matrix3.cpp
+++ b/matrix3.cpp
@@ -20,7 +20,7 @@ using util::matrix;
 
 
 ///////////////////////////////////////////////////////////////////////////////
-template <size_t Rows, size_t Cols, typename T>
+template <std::size_t Rows, std::size_t Cols, typename T>
 T
 util::determinant (const matrix<Rows,Cols,T>& m)
 {
@@ -36,25 +36,25 @@ template double util::determinant (const matrix<3,3,double>&);
 
 
 //-----------------------------------------------------------------------------
-template <size_t Rows, size_t Cols, typename T>
+template <std::size_t Rows, std::size_t Cols, typename T>
 matrix<Rows,Cols,T>
 util::inverse (const matrix<Rows,Cols,T> &m)
 {
     static_assert (Rows == 3 && Cols == 3);
 
-    return matrix<3,3,T> {
-        m[1][1] * m[2][2] - m[2][1] * m[1][2],
-        m[0][2] * m[2][1] - m[0][1] * m[2][2],
-        m[0][1] * m[1][2] - m[0][2] * m[1][1],
+    return matrix<3,3,T> {{
+        { m[1][1] * m[2][2] - m[2][1] * m[1][2],
+          m[0][2] * m[2][1] - m[0][1] * m[2][2],
+          m[0][1] * m[1][2] - m[0][2] * m[1][1], },
 
-        m[1][2] * m[2][0] - m[1][0] * m[2][2],
-        m[0][0] * m[2][2] - m[0][2] * m[2][0],
-        m[1][0] * m[0][2] - m[0][0] * m[1][2],
+        { m[1][2] * m[2][0] - m[1][0] * m[2][2],
+          m[0][0] * m[2][2] - m[0][2] * m[2][0],
+          m[1][0] * m[0][2] - m[0][0] * m[1][2], },
 
-        m[1][0] * m[2][1] - m[2][0] * m[1][1],
-        m[2][0] * m[0][1] - m[0][0] * m[2][1],
-        m[0][0] * m[1][1] - m[1][0] * m[0][1],
-    } / determinant (m);
+        { m[1][0] * m[2][1] - m[2][0] * m[1][1],
+          m[2][0] * m[0][1] - m[0][0] * m[2][1],
+          m[0][0] * m[1][1] - m[1][0] * m[0][1], },
+    }} / determinant (m);
 }
 
 template util::matrix<3,3,float>  util::inverse (const matrix<3,3,float>&);
diff --git a/matrix4.cpp b/matrix4.cpp
index bbaca1be..a6fe6468 100644
--- a/matrix4.cpp
+++ b/matrix4.cpp
@@ -20,7 +20,7 @@ using util::matrix;
 
 
 //-----------------------------------------------------------------------------
-template <size_t Rows, size_t Cols, typename T>
+template <std::size_t Rows, std::size_t Cols, typename T>
 T
 util::determinant (const matrix<Rows,Cols,T> &m)
 {
@@ -45,30 +45,125 @@ template double util::determinant (const matrix<4,4,double>&);
 
 
 //-----------------------------------------------------------------------------
-template <size_t Rows, size_t Cols, typename T>
+template <std::size_t Rows, std::size_t Cols, typename T>
 matrix<Rows,Cols,T>
 util::inverse (const matrix<Rows,Cols,T> &m)
 {
     static_assert (Rows == 4 && Cols == 4);
 
-    return matrix<4,4,T> {
-        m[1][2]*m[2][3]*m[3][1] - m[1][3]*m[2][2]*m[3][1] + m[1][3]*m[2][1]*m[3][2] - m[1][1]*m[2][3]*m[3][2] - m[1][2]*m[2][1]*m[3][3] + m[1][1]*m[2][2]*m[3][3],
-        m[0][3]*m[2][2]*m[3][1] - m[0][2]*m[2][3]*m[3][1] - m[0][3]*m[2][1]*m[3][2] + m[0][1]*m[2][3]*m[3][2] + m[0][2]*m[2][1]*m[3][3] - m[0][1]*m[2][2]*m[3][3],
-        m[0][2]*m[1][3]*m[3][1] - m[0][3]*m[1][2]*m[3][1] + m[0][3]*m[1][1]*m[3][2] - m[0][1]*m[1][3]*m[3][2] - m[0][2]*m[1][1]*m[3][3] + m[0][1]*m[1][2]*m[3][3],
-        m[0][3]*m[1][2]*m[2][1] - m[0][2]*m[1][3]*m[2][1] - m[0][3]*m[1][1]*m[2][2] + m[0][1]*m[1][3]*m[2][2] + m[0][2]*m[1][1]*m[2][3] - m[0][1]*m[1][2]*m[2][3],
-        m[1][3]*m[2][2]*m[3][0] - m[1][2]*m[2][3]*m[3][0] - m[1][3]*m[2][0]*m[3][2] + m[1][0]*m[2][3]*m[3][2] + m[1][2]*m[2][0]*m[3][3] - m[1][0]*m[2][2]*m[3][3],
-        m[0][2]*m[2][3]*m[3][0] - m[0][3]*m[2][2]*m[3][0] + m[0][3]*m[2][0]*m[3][2] - m[0][0]*m[2][3]*m[3][2] - m[0][2]*m[2][0]*m[3][3] + m[0][0]*m[2][2]*m[3][3],
-        m[0][3]*m[1][2]*m[3][0] - m[0][2]*m[1][3]*m[3][0] - m[0][3]*m[1][0]*m[3][2] + m[0][0]*m[1][3]*m[3][2] + m[0][2]*m[1][0]*m[3][3] - m[0][0]*m[1][2]*m[3][3],
-        m[0][2]*m[1][3]*m[2][0] - m[0][3]*m[1][2]*m[2][0] + m[0][3]*m[1][0]*m[2][2] - m[0][0]*m[1][3]*m[2][2] - m[0][2]*m[1][0]*m[2][3] + m[0][0]*m[1][2]*m[2][3],
-        m[1][1]*m[2][3]*m[3][0] - m[1][3]*m[2][1]*m[3][0] + m[1][3]*m[2][0]*m[3][1] - m[1][0]*m[2][3]*m[3][1] - m[1][1]*m[2][0]*m[3][3] + m[1][0]*m[2][1]*m[3][3],
-        m[0][3]*m[2][1]*m[3][0] - m[0][1]*m[2][3]*m[3][0] - m[0][3]*m[2][0]*m[3][1] + m[0][0]*m[2][3]*m[3][1] + m[0][1]*m[2][0]*m[3][3] - m[0][0]*m[2][1]*m[3][3],
-        m[0][1]*m[1][3]*m[3][0] - m[0][3]*m[1][1]*m[3][0] + m[0][3]*m[1][0]*m[3][1] - m[0][0]*m[1][3]*m[3][1] - m[0][1]*m[1][0]*m[3][3] + m[0][0]*m[1][1]*m[3][3],
-        m[0][3]*m[1][1]*m[2][0] - m[0][1]*m[1][3]*m[2][0] - m[0][3]*m[1][0]*m[2][1] + m[0][0]*m[1][3]*m[2][1] + m[0][1]*m[1][0]*m[2][3] - m[0][0]*m[1][1]*m[2][3],
-        m[1][2]*m[2][1]*m[3][0] - m[1][1]*m[2][2]*m[3][0] - m[1][2]*m[2][0]*m[3][1] + m[1][0]*m[2][2]*m[3][1] + m[1][1]*m[2][0]*m[3][2] - m[1][0]*m[2][1]*m[3][2],
-        m[0][1]*m[2][2]*m[3][0] - m[0][2]*m[2][1]*m[3][0] + m[0][2]*m[2][0]*m[3][1] - m[0][0]*m[2][2]*m[3][1] - m[0][1]*m[2][0]*m[3][2] + m[0][0]*m[2][1]*m[3][2],
-        m[0][2]*m[1][1]*m[3][0] - m[0][1]*m[1][2]*m[3][0] - m[0][2]*m[1][0]*m[3][1] + m[0][0]*m[1][2]*m[3][1] + m[0][1]*m[1][0]*m[3][2] - m[0][0]*m[1][1]*m[3][2],
-        m[0][1]*m[1][2]*m[2][0] - m[0][2]*m[1][1]*m[2][0] + m[0][2]*m[1][0]*m[2][1] - m[0][0]*m[1][2]*m[2][1] - m[0][1]*m[1][0]*m[2][2] + m[0][0]*m[1][1]*m[2][2],
-    } / determinant (m);
+    return matrix<4,4,T> {{
+        {  m[1][2]*m[2][3]*m[3][1]
+          -m[1][3]*m[2][2]*m[3][1]
+          +m[1][3]*m[2][1]*m[3][2]
+          -m[1][1]*m[2][3]*m[3][2]
+          -m[1][2]*m[2][1]*m[3][3]
+          +m[1][1]*m[2][2]*m[3][3],
+
+           m[0][3]*m[2][2]*m[3][1]
+          -m[0][2]*m[2][3]*m[3][1]
+          -m[0][3]*m[2][1]*m[3][2]
+          +m[0][1]*m[2][3]*m[3][2]
+          +m[0][2]*m[2][1]*m[3][3]
+          -m[0][1]*m[2][2]*m[3][3],
+
+           m[0][2]*m[1][3]*m[3][1]
+          -m[0][3]*m[1][2]*m[3][1]
+          +m[0][3]*m[1][1]*m[3][2]
+          -m[0][1]*m[1][3]*m[3][2]
+          -m[0][2]*m[1][1]*m[3][3]
+          +m[0][1]*m[1][2]*m[3][3],
+
+           m[0][3]*m[1][2]*m[2][1]
+          -m[0][2]*m[1][3]*m[2][1]
+          -m[0][3]*m[1][1]*m[2][2]
+          +m[0][1]*m[1][3]*m[2][2]
+          +m[0][2]*m[1][1]*m[2][3]
+          -m[0][1]*m[1][2]*m[2][3], },
+
+        {  m[1][3]*m[2][2]*m[3][0]
+          -m[1][2]*m[2][3]*m[3][0]
+          -m[1][3]*m[2][0]*m[3][2]
+          +m[1][0]*m[2][3]*m[3][2]
+          +m[1][2]*m[2][0]*m[3][3]
+          -m[1][0]*m[2][2]*m[3][3],
+
+           m[0][2]*m[2][3]*m[3][0]
+          -m[0][3]*m[2][2]*m[3][0]
+          +m[0][3]*m[2][0]*m[3][2]
+          -m[0][0]*m[2][3]*m[3][2]
+          -m[0][2]*m[2][0]*m[3][3]
+          +m[0][0]*m[2][2]*m[3][3],
+
+           m[0][3]*m[1][2]*m[3][0]
+          -m[0][2]*m[1][3]*m[3][0]
+          -m[0][3]*m[1][0]*m[3][2]
+          +m[0][0]*m[1][3]*m[3][2]
+          +m[0][2]*m[1][0]*m[3][3]
+          -m[0][0]*m[1][2]*m[3][3],
+
+           m[0][2]*m[1][3]*m[2][0]
+          -m[0][3]*m[1][2]*m[2][0]
+          +m[0][3]*m[1][0]*m[2][2]
+          -m[0][0]*m[1][3]*m[2][2]
+          -m[0][2]*m[1][0]*m[2][3]
+          +m[0][0]*m[1][2]*m[2][3], },
+
+        {  m[1][1]*m[2][3]*m[3][0]
+          -m[1][3]*m[2][1]*m[3][0]
+          +m[1][3]*m[2][0]*m[3][1]
+          -m[1][0]*m[2][3]*m[3][1]
+          -m[1][1]*m[2][0]*m[3][3]
+          +m[1][0]*m[2][1]*m[3][3],
+
+           m[0][3]*m[2][1]*m[3][0]
+          -m[0][1]*m[2][3]*m[3][0]
+          -m[0][3]*m[2][0]*m[3][1]
+          +m[0][0]*m[2][3]*m[3][1]
+          +m[0][1]*m[2][0]*m[3][3]
+          -m[0][0]*m[2][1]*m[3][3],
+
+           m[0][1]*m[1][3]*m[3][0]
+          -m[0][3]*m[1][1]*m[3][0]
+          +m[0][3]*m[1][0]*m[3][1]
+          -m[0][0]*m[1][3]*m[3][1]
+          -m[0][1]*m[1][0]*m[3][3]
+          +m[0][0]*m[1][1]*m[3][3],
+
+           m[0][3]*m[1][1]*m[2][0]
+          -m[0][1]*m[1][3]*m[2][0]
+          -m[0][3]*m[1][0]*m[2][1]
+          +m[0][0]*m[1][3]*m[2][1]
+          +m[0][1]*m[1][0]*m[2][3]
+          -m[0][0]*m[1][1]*m[2][3], },
+
+        {  m[1][2]*m[2][1]*m[3][0]
+          -m[1][1]*m[2][2]*m[3][0]
+          -m[1][2]*m[2][0]*m[3][1]
+          +m[1][0]*m[2][2]*m[3][1]
+          +m[1][1]*m[2][0]*m[3][2]
+          -m[1][0]*m[2][1]*m[3][2],
+
+           m[0][1]*m[2][2]*m[3][0]
+          -m[0][2]*m[2][1]*m[3][0]
+          +m[0][2]*m[2][0]*m[3][1]
+          -m[0][0]*m[2][2]*m[3][1]
+          -m[0][1]*m[2][0]*m[3][2]
+          +m[0][0]*m[2][1]*m[3][2],
+
+           m[0][2]*m[1][1]*m[3][0]
+          -m[0][1]*m[1][2]*m[3][0]
+          -m[0][2]*m[1][0]*m[3][1]
+          +m[0][0]*m[1][2]*m[3][1]
+          +m[0][1]*m[1][0]*m[3][2]
+          -m[0][0]*m[1][1]*m[3][2],
+
+           m[0][1]*m[1][2]*m[2][0]
+          -m[0][2]*m[1][1]*m[2][0]
+          +m[0][2]*m[1][0]*m[2][1]
+          -m[0][0]*m[1][2]*m[2][1]
+          -m[0][1]*m[1][0]*m[2][2]
+          +m[0][0]*m[1][1]*m[2][2], }
+    }} / determinant (m);
 }
 
 template util::matrix<4,4,float>  util::inverse (const matrix<4,4,float>&);
diff --git a/point.hpp b/point.hpp
index 3bc78d59..aa23f077 100644
--- a/point.hpp
+++ b/point.hpp
@@ -28,9 +28,9 @@ namespace util {
     /// \tparam S number of dimensions
     /// \tparam T the underlying per-dimension datatype
     template <size_t S, typename T>
-    struct point : public coord::base<S,T,point,coord::xyzw>
+    struct point : public coord::base<S,T,point<S,T>>
     {
-        using coord::base<S,T,util::point,coord::xyzw>::base;
+        using coord::base<S,T,point<S,T>>::base;
 
         vector<S,T> to (point) const;
         vector<S,T> from (point) const;
diff --git a/quaternion.hpp b/quaternion.hpp
index 52eea91a..101f8699 100644
--- a/quaternion.hpp
+++ b/quaternion.hpp
@@ -17,7 +17,7 @@
 #ifndef __UTIL_QUATERNION_HPP
 #define __UTIL_QUATERNION_HPP
 
-#include "coord.hpp"
+#include "coord/traits.hpp"
 
 #include "vector.hpp"
 #include "matrix.hpp"
@@ -38,6 +38,8 @@ namespace util {
     struct quaternion {
         T w, x, y, z;
 
+        static constexpr std::size_t size (void) { return 4; }
+
         static quaternion angle_axis (T radians, vector<3,T> axis);
         static quaternion from_euler (vector<3,T>);
 
@@ -50,6 +52,12 @@ namespace util {
     };
 
 
+    template <typename T>
+    struct arity<quaternion<T>,void>
+    :std::integral_constant<std::size_t, 4>
+    { };
+
+
     ///////////////////////////////////////////////////////////////////////////
     template <typename T>
     vector3<T>
diff --git a/random.hpp b/random.hpp
index b2bbe4a5..0ecd56fc 100644
--- a/random.hpp
+++ b/random.hpp
@@ -17,6 +17,7 @@
 #ifndef __UTIL_RANDOM_HPP
 #define __UTIL_RANDOM_HPP
 
+#include <algorithm>
 #include <random>
 
 
@@ -45,6 +46,43 @@ namespace util::rand {
         std::uniform_int_distribution<size_t> dist (0, N-1);
         return t[dist (gen)];
     }
-}
+
+
+    //-------------------------------------------------------------------------
+    template <
+        typename T,
+        typename IteratorT,
+        typename GeneratorT = default_generator
+    >
+    void
+    uniform (T lo, T hi, IteratorT first, IteratorT last)
+    {
+        static_assert (std::is_same_v<T, typename std::iterator_traits<IteratorT>::value_type>);
+        auto &gen = thread_engine<GeneratorT> ();
+
+        static_assert (std::is_integral_v<T> || std::is_floating_point_v<T>);
+
+        if constexpr (std::is_integral_v<T>) {
+            std::generate (
+                first,
+                last,
+                [&gen, d = std::uniform_int_distribution<T> (lo, hi)]
+            {
+                return d (gen);
+            });
+        }
+
+        if constexpr (std::is_floating_point_v<T>) {
+            auto d = std::uniform_real_distribution<T> (lo, hi);
+            std::generate (
+                first,
+                last,
+                [&]
+            {
+                    return d (gen);
+            });
+        }
+    }
+};
 
 #endif
diff --git a/test/affine.cpp b/test/affine.cpp
index e27f542d..a7208972 100644
--- a/test/affine.cpp
+++ b/test/affine.cpp
@@ -6,6 +6,9 @@
 
 #include "coord/iostream.hpp"
 
+#include <array>
+
+
 ///////////////////////////////////////////////////////////////////////////////
 void
 test_matrix_identities (util::TAP::logger &tap)
@@ -15,16 +18,16 @@ test_matrix_identities (util::TAP::logger &tap)
     {
         util::point3f p { 1, 2, 3 };
 
-        auto m = util::matrix4f::translation (0-p);
+        auto m = util::translation (0-p);
         auto x = m * p.homog<4> ();
         tap.expect_eq (x, util::point4f {0,0,0,1}, "trivial translation to origin");
     }
 
     {
         util::point3f p {0};
-        auto m = util::matrix4f::rotation (1, { 1, 0, 0 }) *
-                 util::matrix4f::rotation (1, { 0, 1, 0 }) *
-                 util::matrix4f::rotation (1, { 0, 0, 1 });
+        auto m = util::rotation<float> (1, { 1, 0, 0 }) *
+                 util::rotation<float> (1, { 0, 1, 0 }) *
+                 util::rotation<float> (1, { 0, 0, 1 });
         auto x = m * p.homog<4> ();
 
         tap.expect_eq (x, util::point4f {0,0,0,1}, "trivial rotation at origin");
@@ -34,7 +37,7 @@ test_matrix_identities (util::TAP::logger &tap)
         util::point3f eye { 1, 2, 3 };
         util::point3f tgt { 0, 0, 0 };
 
-        auto m = util::matrix4f::look_at (eye, tgt, UP);
+        auto m = util::look_at (eye, tgt, UP);
         auto x = m * eye.homog<4> ();
         tap.expect_eq (x, util::point4f {0,0,0,1}, "look_at eye translation");
     }
@@ -43,7 +46,7 @@ test_matrix_identities (util::TAP::logger &tap)
         util::point3f eye { 1, 2, 3 };
         util::point3f tgt { 4, 5, 6 };
 
-        auto m = util::matrix4f::look_at (eye, tgt, UP);
+        auto m = util::look_at (eye, tgt, UP);
         auto x = m * eye.homog<4> ();
         tap.expect_eq (x, util::point4f {0,0,0,1}, "look_at eye translation with target");
     }
@@ -64,7 +67,7 @@ test_mq_axis (util::TAP::logger &tap)
     };
 
     for (auto t: TESTS) {
-        auto m = util::matrix4f::rotation (1, t.euler);
+        auto m = util::rotation<float> (1, t.euler);
         auto q = util::quaternionf::angle_axis (1, t.euler);
 
         auto diff = sum (abs (m - q.as_matrix ()));
@@ -78,27 +81,32 @@ void
 test_mq_euler (util::TAP::logger &tap)
 {
     static const struct {
-        util::vector3f euler;
+        float x, y, z;
         const char *msg;
     } TESTS[] = {
-        { { 0, 0, 0 }, "zeroes" },
-        { { 1, 0, 0 }, "x-axis" },
-        { { 0, 1, 0 }, "y-axis" },
-        { { 0, 0, 1 }, "z-axis" },
-        { { 1, 1, 1 }, "ones"   },
-        { { 9, 9, 9 }, "nines"  }
+        { 0, 0, 0, "zeroes" },
+        { 1, 0, 0, "x-axis" },
+        { 0, 1, 0, "y-axis" },
+        { 0, 0, 1, "z-axis" },
+        { 1, 1, 1, "ones"   },
+        { 9, 9, 9, "nines"  }
     };
 
     for (auto t: TESTS) {
-        auto m = util::matrix4f::rotation (t.euler[0], { 1, 0, 0 }) *
-                 util::matrix4f::rotation (t.euler[1], { 0, 1, 0 }) *
-                 util::matrix4f::rotation (t.euler[2], { 0, 0, 1 });
+        const auto mx = util::rotation<float> (t.x, {1,0,0});
+        const auto my = util::rotation<float> (t.y, {0,1,0});
+        const auto mz = util::rotation<float> (t.z, {0,0,1});
+        const auto  m = mx * my * mz;
+
         auto q = (
-            util::quaternionf::angle_axis (t.euler[0], { 1, 0, 0 }) *
-            util::quaternionf::angle_axis (t.euler[1], { 0, 1, 0 }) *
-            util::quaternionf::angle_axis (t.euler[2], { 0, 0, 1 })
+            util::quaternionf::angle_axis (t.x, { 1, 0, 0 }) *
+            util::quaternionf::angle_axis (t.y, { 0, 1, 0 }) *
+            util::quaternionf::angle_axis (t.z, { 0, 0, 1 })
         ).as_matrix ();
 
+        if (abs (m - q)[0])
+            exit (0);
+
         auto diff = util::sum (abs (m - q));
         tap.expect_le (diff, 1e-6f, "matrix-quaternion xyz euler rotations, %s", t.msg);
     }
diff --git a/test/colour.cpp b/test/colour.cpp
index 04ef6ce0..036afcc7 100644
--- a/test/colour.cpp
+++ b/test/colour.cpp
@@ -10,83 +10,11 @@ main (int, char**)
 
     // Check casting works between intergral and floating formats
     {
-        util::colour4f f (1);
-        util::colour<4,uint8_t> u (255);
+        util::srgba<4,float> f {1.f};
+        util::srgba<4,uint8_t> u {255};
         tap.expect_eq (f.cast<uint8_t> (), u, "cast float to u8");
         tap.expect_eq (u.cast<float> (), f, "cast u8 to float");
     }
 
-    // Check parsing is working
-    tap.expect_eq (
-        util::colour4u::parse_html ("#11223344"),
-        util::colour4u (0x11, 0x22, 0x33, 0x44),
-        "4-component html parsing with hash"
-    );
-
-    tap.expect_eq (
-        util::colour4u::parse_html ("11223344"),
-        util::colour4u (0x11, 0x22, 0x33, 0x44),
-        "4-component html parsing without hash"
-    );
-
-    tap.expect_eq (
-        util::colour1f::parse_html ("ff"),
-        util::colour1f (1.f),
-        "1-component html parsing"
-    );
-
-    tap.expect_eq (
-        util::colour3u::parse_html ("3399ff"),
-        util::colour3u (0x33, 0x99, 0xff),
-        "3-component html parsing"
-    );
-
-    tap.expect_throw<std::invalid_argument> (
-        [] () { util::colour1f::parse_html ("00112233"); },
-        "1-component parsing with 4-component format"
-    );
-
-    tap.expect_throw<std::invalid_argument> (
-        [] () { util::colour4f::parse_html ("00"); },
-        "4-component parsing with 1-component format"
-    );
-
-    tap.expect_throw<std::invalid_argument> (
-        [] () { util::colour4f::parse_html ("0011223"); },
-        "4-component parsing with one too few digits"
-    );
-
-
-    // Check lookups are working
-    tap.expect_eq (util::colour4f::from_html  ("white"), util::colour4f {1}, "HTML lookup");
-    tap.expect_eq ( util::colour4f::from_x11  ("white"), util::colour4f {1}, "X11 lookup");
-
-    // Check HSV conversions
-    {
-        // white: hue is undefined
-        auto white = util::rgb_to_hsv ({1,1,1});
-        tap.expect (util::exactly_zero (white.s) && util::exactly_equal (white.v, 1), "white hsv");
-
-        // black: hue is undefined
-        auto black = util::rgb_to_hsv ({0,0,0});
-        tap.expect (util::exactly_zero (black.s) && util::exactly_zero (black.v), "black hsv");
-
-        struct {
-            const char *name;
-            util::colour3f rgb;
-            util::colour3f hsv;
-        } TESTS[] = {
-            { "red",   { 1,     0,     0,    }, {   0, 1,     1,    } }, // red
-            { "green", { 0,     1,     0,    }, { 120, 1,     1,    } }, // green
-            { "blue",  { 0,     0,     1,    }, { 240, 1,     1,    } }, // blue
-            { "misc",  { 0.75f, 0.25f, 0.75f }, { 300, 2/3.f, 0.75f } },
-        };
-
-        for (auto i: TESTS) {
-            tap.expect_eq (util::rgb_to_hsv (i.rgb), i.hsv, "rgb-to-hsv %s", i.name);
-            tap.expect_eq (util::hsv_to_rgb (i.hsv), i.rgb, "hsv-to-rgb %s", i.name);
-        }
-    }
-
     return tap.status ();
 }
diff --git a/test/geom/aabb.cpp b/test/geom/aabb.cpp
index cbd5c43b..93d7403c 100644
--- a/test/geom/aabb.cpp
+++ b/test/geom/aabb.cpp
@@ -12,42 +12,5 @@ main (int, char**)
 {
     util::TAP::logger tap;
 
-    {
-        // Test contraction
-        AABB2f box {
-            { 2, 2 },
-            { 8, 8 }
-        };
-
-        box.contract (2.f);
-
-        tap.expect_eq<AABB2f, AABB2f> (box, { { 3, 3 }, { 7, 7 }}, "over contraction");
-    }
-
-    {
-        // Test expansion
-        AABB2f box {
-            { 2, 2 },
-            { 8, 8 }
-        };
-
-        box.expand (2.f);
-
-        tap.expect_eq<AABB2f, AABB2f> (box, { { 1, 1 }, { 9, 9 }}, "expansion");
-    }
-
-
-    {
-        // Ensure we don't wrap-around on unsigned position types when contracting
-        AABB2f small {
-            { 0, 0 },
-            { 1, 1 }
-        };
-
-        small.contract (10);
-
-        tap.expect_eq<AABB2f, AABB2f> (small, { { 0.5f, 0.5f }, { 0.5f, 0.5f }}, "unsigned over-contract");
-    }
-
     return tap.status ();
 }
diff --git a/test/point.cpp b/test/point.cpp
index 94e14438..4a1f4b85 100644
--- a/test/point.cpp
+++ b/test/point.cpp
@@ -34,6 +34,10 @@ main (void)
     }
 
     // Redim to higher dimension with fill
+    //
+    // HACK: This fails under GCC-7.1.0, and i'm not wasting any more time
+    // reducing this test case. it's _really_ template heavy.
+#if !(__GNUC_PREREQ (7, 1))
     {
         static const point4f FILL (1.f, 2.f, 3.f, 4.f);
         const point2f p (0.1f, 1.f);
@@ -48,6 +52,7 @@ main (void)
             "redim to higher with fill"
         );
     }
+#endif
 
     // Simple linking check for coord type casting. Relies on truncation.
     {
diff --git a/test/quaternion.cpp b/test/quaternion.cpp
index bcd89d4a..89362862 100644
--- a/test/quaternion.cpp
+++ b/test/quaternion.cpp
@@ -86,7 +86,7 @@ main (void)
             const auto &r = ROTATIONS[i];
 
             auto q = quaternionf::angle_axis  (r.mag, r.axis).as_matrix ();
-            auto m = util::matrix4f::rotation (r.mag, r.axis);
+            auto m = util::rotation<float> (r.mag, r.axis);
             auto diff = util::abs (q - m);
 
             tap.expect_lt (util::sum (diff), 1e-6f, "single basis rotation %zu", i);
@@ -97,7 +97,7 @@ main (void)
 
         for (auto r: ROTATIONS) {
             q = q.angle_axis (r.mag, r.axis) * q;
-            m = m.rotation (r.mag, r.axis) * m;
+            m = util::rotation<float> (r.mag, r.axis) * m;
         }
 
         auto diff = util::abs (q.as_matrix () - m);
diff --git a/test/string.cpp b/test/string.cpp
index 883c577b..37ba470a 100644
--- a/test/string.cpp
+++ b/test/string.cpp
@@ -6,8 +6,12 @@ int
 main (int, char**)
 {
     util::TAP::logger tap;
-    
-    const char csv[] = "\0,a,123,,this is a test,";
+
+    // the string_literal prefix is required to (easily) construct a string
+    // with an internal null character.
+    using namespace std::literals::string_literals;
+    const std::string csv = "\0,a,123,,this is a test,"s;
+
     const std::string values[] = {
         { "\0", 1 },
         { "a" },
@@ -17,8 +21,7 @@ main (int, char**)
         { "" }
     };
 
-    std::string str (std::cbegin (csv), std::cbegin (csv) + std::size (csv));
-    auto tok = util::make_tokeniser (str, ',');
+    auto tok = util::make_tokeniser (csv, ',');
     auto t_cursor = tok.cbegin ();
     auto v_cursor = std::cbegin (values);
 
diff --git a/vector.hpp b/vector.hpp
index bfeb6398..ff11aa9e 100644
--- a/vector.hpp
+++ b/vector.hpp
@@ -22,9 +22,9 @@
 
 namespace util {
     template <size_t S, typename T>
-    struct vector : public coord::base<S,T,vector,coord::xyzw,coord::stpq>
+    struct vector : public coord::base<S,T,vector<S,T>>
     {
-        using coord::base<S,T,util::vector,coord::xyzw,coord::stpq>::base;
+        using coord::base<S,T,vector<S,T>>::base;
 
         // representations
         template <size_t D> vector<D,T> homog (void) const;
diff --git a/view.cpp b/view.cpp
index 1a4d49a2..2f550025 100644
--- a/view.cpp
+++ b/view.cpp
@@ -24,7 +24,7 @@
 bool                                    \
 util::operator== (A a, B b)             \
 {                                       \
-    return a.size () == a.size () &&    \
+    return a.size () == b.size () &&    \
            std::equal (a.cbegin (),     \
                        a.cend (),       \
                        b.cbegin ());    \

From edde2af132bd67b286e2aee83873b23e648369c5 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Wed, 22 Nov 2017 17:10:27 +1100
Subject: [PATCH 04/56] cmake: bump for optimisation flags

---
 cmake | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cmake b/cmake
index 06bb32ff..65767470 160000
--- a/cmake
+++ b/cmake
@@ -1 +1 @@
-Subproject commit 06bb32ff00fc4b6d8581a2e91a17ddab5a1407d4
+Subproject commit 6576747031f4a7d82497d60663df83e54b75d088

From 59240ce83a633371f17773ec05d540bdd36b8dcf Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Fri, 24 Nov 2017 12:24:44 +1100
Subject: [PATCH 05/56] matrix: move implementation from ipp to hpp

---
 CMakeLists.txt  |   1 -
 matrix.hpp      | 163 ++++++++++++++++++++++++++++++++++-------
 matrix.ipp      | 188 ------------------------------------------------
 test/matrix.cpp |   7 ++
 4 files changed, 145 insertions(+), 214 deletions(-)
 delete mode 100644 matrix.ipp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3664382d..4f806b76 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -329,7 +329,6 @@ list (
     matrix3.cpp
     matrix4.cpp
     matrix.hpp
-    matrix.ipp
     memory/deleter.cpp
     memory/deleter.hpp
     nocopy.hpp
diff --git a/matrix.hpp b/matrix.hpp
index e3597214..fb5d702b 100644
--- a/matrix.hpp
+++ b/matrix.hpp
@@ -25,7 +25,11 @@
 #include <cstdlib>
 
 namespace util {
-    template <std::size_t Rows, std::size_t Cols, typename T>
+    template <
+        std::size_t Rows,
+        std::size_t Cols,
+        typename T
+    >
     struct matrix {
         static constexpr auto rows = Rows;
         static constexpr auto cols = Cols;
@@ -49,7 +53,7 @@ namespace util {
                     values[r][c] = _data[r][c];
         }
 
-        T values[rows][cols];
+        T values[Rows][Cols];
 
         ///////////////////////////////////////////////////////////////////////
         // index operators return a pointer into the data array so that
@@ -60,56 +64,56 @@ namespace util {
 
         //---------------------------------------------------------------------
         constexpr auto
-        data (void) noexcept
+        data (void)& noexcept
         {
             return begin ();
         }
 
         //---------------------------------------------------------------------
         constexpr auto
-        data (void) const noexcept
+        data (void) const& noexcept
         {
             return begin ();
         }
 
         //---------------------------------------------------------------------
         constexpr auto
-        begin (void) const noexcept
+        begin (void) const& noexcept
         {
             return &(*this)[0][0];
         }
 
         //---------------------------------------------------------------------
         constexpr auto
-        end (void) const noexcept
+        end (void) const& noexcept
         {
             return &(*this)[Rows][0];
         }
 
         //---------------------------------------------------------------------
         constexpr auto
-        begin (void) noexcept
+        begin (void)& noexcept
         {
             return &(*this)[0][0];
         }
 
         //---------------------------------------------------------------------
         constexpr auto
-        end (void) noexcept
+        end (void)& noexcept
         {
             return &(*this)[Rows][0];
         }
 
         //---------------------------------------------------------------------
         constexpr auto
-        cbegin (void) const noexcept
+        cbegin (void) const& noexcept
         {
             return begin ();
         }
 
         //---------------------------------------------------------------------
         constexpr auto
-        cend (void) const noexcept
+        cend (void) const& noexcept
         {
             return end ();
         }
@@ -146,14 +150,28 @@ namespace util {
         matrix<Rows,Cols,U>
         cast (void) const noexcept
         {
-            util::matrix<Rows,Cols,T> out;
+            matrix out;
             std::copy (cbegin (), cend (), std::begin (out));
             return out;
         }
 
         // Constant matrices
-        static constexpr matrix identity ();
-        static constexpr matrix zeroes ();
+        static constexpr
+        matrix identity (void) noexcept
+        {
+            auto m = zeroes ();
+            for (std::size_t i = 0; i < Rows; ++i)
+                m[i][i] = 1;
+            return m;
+        }
+
+        static constexpr
+        matrix zeroes (void) noexcept
+        {
+            matrix ret {};
+            std::fill (std::begin (ret), std::end (ret), T{0});
+            return ret;
+        }
     };
 
 
@@ -164,10 +182,10 @@ namespace util {
     template <typename T> matrix<4,4,T> look_at (point<3,T> eye, point<3,T> target, vector<3,T> up);
 
     // Affine matrices
-    template <typename T> matrix<4,4,T> translation (util::vector<3,T>);
-    template <typename T> matrix<4,4,T> scale       (util::vector<3,T>);
+    template <typename T> matrix<4,4,T> translation (vector<3,T>);
+    template <typename T> matrix<4,4,T> scale       (vector<3,T>);
     template <typename T> matrix<4,4,T> scale       (T);
-    template <typename T> matrix<4,4,T> rotation    (T angle, util::vector<3,T> about);
+    template <typename T> matrix<4,4,T> rotation    (T angle, vector<3,T> about);
 
 
     ///////////////////////////////////////////////////////////////////////////
@@ -185,13 +203,20 @@ namespace util {
     template <std::size_t Rows, std::size_t Cols, typename T>
     constexpr
     bool
-    operator== (const matrix<Rows,Cols,T>&, const matrix<Rows,Cols,T>&);
+    operator== (const matrix<Rows,Cols,T> &a, const matrix<Rows,Cols,T> &b)
+    {
+        return std::equal (std::cbegin (a), std::cend (a), std::cbegin (b));
+    }
 
 
+    //-------------------------------------------------------------------------
     template <std::size_t Rows, std::size_t Cols, typename T>
     constexpr
     bool
-    operator!= (const matrix<Rows,Cols,T>&, const matrix<Rows,Cols,T>&);
+    operator!= (const matrix<Rows,Cols,T> &a, const matrix<Rows,Cols,T> &b)
+    {
+        return !(a == b);
+    }
 
 
     ///////////////////////////////////////////////////////////////////////////
@@ -302,24 +327,112 @@ namespace util {
     T
     determinant (const matrix<Rows,Cols,T>&);
 
+
+    //-------------------------------------------------------------------------
     template <std::size_t Rows, std::size_t Cols, typename T>
     matrix<Rows,Cols,T>
     inverse (const matrix<Rows,Cols,T>&);
 
+
+    //-------------------------------------------------------------------------
     template <std::size_t Rows, std::size_t Cols, typename T>
     matrix<Cols,Rows,T>
     transposed (const matrix<Rows,Cols,T>&);
 
-    ///////////////////////////////////////////////////////////////////////////
 
+    ///////////////////////////////////////////////////////////////////////////
     template <std::size_t Rows, std::size_t Cols, typename T>
     matrix<Rows,Cols,T>
-    abs (const matrix<Rows,Cols,T>&);
+    abs (const matrix<Rows,Cols,T> &src)
+    {
+        matrix<Rows,Cols,T> dst;
+        std::transform (std::cbegin (src), std::cend (src), std::begin (dst), util::abs<T>);
+        return dst;
+    }
+
 
     template <std::size_t Rows, std::size_t Cols, typename T>
-    constexpr
-    T
-    sum (const matrix<Rows,Cols,T>&);
+    constexpr T
+    sum (const matrix<Rows,Cols,T> &src)
+    {
+        return sum (std::cbegin (src), std::cend (src));
+    }
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    #define MATRIX_ELEMENT_OP(OP)                                       \
+    template <std::size_t Rows, std::size_t Cols, typename T>           \
+    constexpr                                                           \
+    matrix<Rows,Cols,T>                                                 \
+    operator OP (                                                       \
+        const matrix<Rows,Cols,T> &a,                                   \
+        const matrix<Rows,Cols,T> &b)                                   \
+    {                                                                   \
+        matrix<Rows,Cols,T> res {};                                     \
+                                                                        \
+        for (std::size_t i = 0; i < a.rows; ++i)                        \
+            for (std::size_t j = 0; j < a.cols; ++j)                    \
+                res[i][j] = a[i][j] OP b[i][j];                         \
+                                                                        \
+        return res;                                                     \
+    }
+
+    MATRIX_ELEMENT_OP(-)
+    MATRIX_ELEMENT_OP(+)
+
+    #undef MATRIX_ELEMENT_OP
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    #define MATRIX_SCALAR_OP(OP)                                        \
+    template <std::size_t Rows, std::size_t Cols, typename T>           \
+    constexpr                                                           \
+    matrix<Rows,Cols,T>                                                 \
+    operator OP (const matrix<Rows,Cols,T> &m, const T t)               \
+    {                                                                   \
+        matrix<Rows,Cols,T> res {};                                     \
+                                                                        \
+        std::transform (                                                \
+            std::cbegin (m),                                            \
+            std::cend   (m),                                            \
+            std::begin  (res),                                          \
+            [&t] (auto x) { return x OP t; }                            \
+        );                                                              \
+                                                                        \
+        return res;                                                     \
+    }                                                                   \
+                                                                        \
+                                                                        \
+    template <std::size_t Rows, std::size_t Cols, typename T>           \
+    constexpr                                                           \
+    matrix<Rows,Cols,T>                                                 \
+    operator OP (const T t, const matrix<Rows,Cols,T> &m)               \
+    {                                                                   \
+        return m OP t;                                                  \
+    }                                                                   \
+                                                                        \
+                                                                        \
+    template <std::size_t Rows, std::size_t Cols, typename T>           \
+    constexpr                                                           \
+    matrix<Rows,Cols,T>&                                                \
+    operator OP##= (matrix<Rows,Cols,T> &m, T t)                        \
+    {                                                                   \
+        std::transform (                                                \
+            std::cbegin (m),                                            \
+            std::cend   (m),                                            \
+            std::begin  (m),                                            \
+            [&t] (auto x) { return x OP t; }                            \
+        );                                                              \
+                                                                        \
+        return m;                                                       \
+    }
+
+    MATRIX_SCALAR_OP(*)
+    MATRIX_SCALAR_OP(/)
+    MATRIX_SCALAR_OP(+)
+    MATRIX_SCALAR_OP(-)
+
+    #undef MATRIX_SCALAR_OP
 
 
     ///////////////////////////////////////////////////////////////////////////
@@ -342,8 +455,8 @@ namespace util {
     ///////////////////////////////////////////////////////////////////////////
     template <std::size_t Rows, std::size_t Cols, typename T>
     std::ostream& operator<< (std::ostream&, const matrix<Rows,Cols,T>&);
+
+
 }
 
-#include "matrix.ipp"
-
 #endif
diff --git a/matrix.ipp b/matrix.ipp
deleted file mode 100644
index 9fc75048..00000000
--- a/matrix.ipp
+++ /dev/null
@@ -1,188 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2011-2015 Danny Robson <danny@nerdcruft.net>
- */
-
-
-#ifdef __UTIL_MATRIX_IPP
-#error
-#endif
-
-#include "matrix.hpp"
-#define __UTIL_MATRIX_IPP
-
-
-///////////////////////////////////////////////////////////////////////////////
-//template <std::size_t Rows, std::size_t Cols, typename T>
-//T*
-//util::matrix<Rows,Cols,T>::operator[] (int idx)
-//{
-//    return this->values[idx];
-//}
-//
-//
-////-----------------------------------------------------------------------------
-//template <std::size_t Rows, std::size_t Cols, typename T>
-//const T*
-//util::matrix<Rows,Cols,T>::operator[] (int idx) const
-//{
-//    return this->values[idx];
-//}
-
-
-///////////////////////////////////////////////////////////////////////////////
-#define MATRIX_ELEMENT_OP(OP)                                       \
-template <std::size_t Rows, std::size_t Cols, typename T>                     \
-constexpr                                                           \
-util::matrix<Rows,Cols,T>                                           \
-util::operator OP (                                                 \
-    const util::matrix<Rows,Cols,T> &a,                             \
-    const util::matrix<Rows,Cols,T> &b)                             \
-{                                                                   \
-    util::matrix<Rows,Cols,T> res {};                               \
-                                                                    \
-    for (std::size_t i = 0; i < a.rows; ++i)                             \
-        for (std::size_t j = 0; j < a.cols; ++j)                         \
-            res[i][j] = a[i][j] OP b[i][j];                         \
-                                                                    \
-    return res;                                                     \
-}
-
-MATRIX_ELEMENT_OP(-)
-MATRIX_ELEMENT_OP(+)
-
-#undef MATRIX_ELEMENT_OP
-
-
-///////////////////////////////////////////////////////////////////////////////
-#define MATRIX_SCALAR_OP(OP)                                        \
-template <std::size_t Rows, std::size_t Cols, typename T>                     \
-constexpr                                                           \
-util::matrix<Rows,Cols,T>                                           \
-util::operator OP (const util::matrix<Rows,Cols,T> &m, const T t)   \
-{                                                                   \
-    util::matrix<Rows,Cols,T> res {};                               \
-                                                                    \
-    std::transform (                                                \
-        std::cbegin (m),                                            \
-        std::cend   (m),                                            \
-        std::begin  (res),                                          \
-        [&t] (auto x) { return x OP t; }                            \
-    );                                                              \
-                                                                    \
-    return res;                                                     \
-}                                                                   \
-                                                                    \
-                                                                    \
-template <std::size_t Rows, std::size_t Cols, typename T>                     \
-constexpr                                                           \
-util::matrix<Rows,Cols,T>                                           \
-util::operator OP (const T t, const util::matrix<Rows,Cols,T> &m)   \
-{                                                                   \
-    return m OP t;                                                  \
-}                                                                   \
-                                                                    \
-                                                                    \
-template <std::size_t Rows, std::size_t Cols, typename T>                     \
-constexpr                                                           \
-util::matrix<Rows,Cols,T>&                                          \
-util::operator OP##= (util::matrix<Rows,Cols,T> &m, T t)            \
-{                                                                   \
-    std::transform (                                                \
-        std::cbegin (m),                                            \
-        std::cend   (m),                                            \
-        std::begin  (m),                                            \
-        [&t] (auto x) { return x OP t; }                            \
-    );                                                              \
-                                                                    \
-    return m;                                                       \
-}
-
-
-MATRIX_SCALAR_OP(*)
-MATRIX_SCALAR_OP(/)
-MATRIX_SCALAR_OP(+)
-MATRIX_SCALAR_OP(-)
-
-#undef MATRIX_SCALAR_OP
-
-
-///////////////////////////////////////////////////////////////////////////////
-template <std::size_t Rows, std::size_t Cols, typename T>
-constexpr
-util::matrix<Rows,Cols,T>
-util::matrix<Rows,Cols,T>::zeroes (void)
-{
-    util::matrix<Rows,Cols,T> ret {};
-    for (std::size_t r = 0; r < Rows; ++r)
-        for (std::size_t c = 0; c < Cols; ++c)
-            ret[r][c] = 0;
-    return ret;
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-template <std::size_t Rows, std::size_t Cols, typename T>
-constexpr
-util::matrix<Rows,Cols,T>
-util::matrix<Rows,Cols,T>::identity (void)
-{
-    static_assert (Rows == Cols);
-
-    auto m = zeroes ();
-    for (std::size_t i = 0; i < Rows; ++i)
-        m[i][i] = 1;
-    return m;
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-template <std::size_t Rows, std::size_t Cols, typename T>
-constexpr
-bool
-util::operator== (const matrix<Rows,Cols,T> &a, const matrix<Rows,Cols,T> &b)
-{
-    return std::equal (std::cbegin (a), std::cend (a), std::cbegin (b));
-}
-
-
-//-----------------------------------------------------------------------------
-template <std::size_t Rows, std::size_t Cols, typename T>
-constexpr
-bool
-util::operator!= (const matrix<Rows,Cols,T> &a, const matrix<Rows,Cols,T> &b)
-{
-    return !(a == b);
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-template <std::size_t Rows, std::size_t Cols, typename T>
-util::matrix<Rows,Cols,T>
-util::abs (const util::matrix<Rows,Cols,T> &src)
-{
-    util::matrix<Rows,Cols,T> dst;
-    std::transform (std::cbegin (src), std::cend (src), std::begin (dst), util::abs<T>);
-    return dst;
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-template <std::size_t Rows, std::size_t Cols, typename T>
-constexpr
-T
-util::sum (const util::matrix<Rows, Cols,T> &src)
-{
-    return sum (std::cbegin (src), std::cend (src));
-}
diff --git a/test/matrix.cpp b/test/matrix.cpp
index 0e077098..40e8d94d 100644
--- a/test/matrix.cpp
+++ b/test/matrix.cpp
@@ -15,6 +15,13 @@ main (void)
 {
     util::TAP::logger tap;
 
+    // a quick check to make sure this function is actually provided
+    tap.expect_eq (sum (util::matrix4f::zeroes ()), 0.f, "zero matrix sums to zero");
+
+
+    // trivial check for matrix summation. useful to sanity test some
+    // alignment constraints if run under a tool like memorysanitizer or
+    // valgrind.
     static constexpr util::matrix4f SEQ { {
         {  1,  2,  3,  4 },
         {  5,  6,  7,  8 },

From a8088d03cd983fe8e32dc50d0a7c302956f41452 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Fri, 24 Nov 2017 13:08:56 +1100
Subject: [PATCH 06/56] matrix: use vector for the row storage

---
 coord/base.hpp  | 17 ++++++++++----
 coord/ops.hpp   | 15 +++++-------
 matrix.cpp      |  2 +-
 matrix.hpp      | 61 ++++++++++++++++++++++++++++++-------------------
 test/affine.cpp |  3 ---
 test/matrix.cpp |  4 ++--
 6 files changed, 59 insertions(+), 43 deletions(-)

diff --git a/coord/base.hpp b/coord/base.hpp
index c2ff6ced..736741ad 100644
--- a/coord/base.hpp
+++ b/coord/base.hpp
@@ -73,13 +73,20 @@ namespace util::coord {
         }
 
         constexpr base (const base<S,T,SelfT> &rhs) = default;
-        base& operator= (const base<S,T,SelfT> &rhs) = default;
+        base& operator= (const base<S,T,SelfT> &rhs)& = default;
+        base& operator= (const T t)&
+        {
+            for (auto v: *this)
+                v = t;
+            return *this;
+        }
 
         // element accessors
-        T& operator[] (size_t i) { return this->data[i]; }
-        constexpr const T& operator[] (size_t i) const { return this->data[i]; }
-        T& operator[] (int i) { return this->data[i]; }
-        constexpr const T& operator[] (int i) const { return this->data[i]; }
+        constexpr T& operator[] (size_t i)& noexcept { return this->data[i]; }
+        constexpr T& operator[] (int i)& noexcept { return this->data[i]; }
+
+        constexpr const T& operator[] (size_t i) const& noexcept { return this->data[i]; }
+        constexpr const T& operator[] (int i) const& noexcept { return this->data[i]; }
 
         auto cbegin (void) const { return std::cbegin (this->data); }
         auto cend   (void) const { return std::cend   (this->data); }
diff --git a/coord/ops.hpp b/coord/ops.hpp
index a3967d12..1ca9e3f8 100644
--- a/coord/ops.hpp
+++ b/coord/ops.hpp
@@ -609,19 +609,16 @@ namespace util {
 
     //-------------------------------------------------------------------------
     template <
-        std::size_t S,
-        typename T,
-        template <std::size_t,typename> class A,
-        template <std::size_t,typename> class B,
+        typename A,
+        typename B,
         typename = std::enable_if_t<
-            is_coord_v<A<S,T>> && is_coord_v<B<S,T>>, void
+            is_coord_v<A> && is_coord_v<B>, void
         >
     >
-    constexpr
-    T
-    dot (A<S,T> a, B<S,T> b)
+    constexpr auto
+    dot (A a, B b)
     {
-        return dot<S,T> (a.data, b.data);
+        return dot (a.data, b.data);
     }
 
 
diff --git a/matrix.cpp b/matrix.cpp
index de04b8ef..d95f51df 100644
--- a/matrix.cpp
+++ b/matrix.cpp
@@ -352,7 +352,7 @@ util::operator<< (std::ostream &os, const matrix<Rows,Cols,T> &m)
 
     for (std::size_t i = 0; i < Rows; ++i) {
         os << "{ ";
-        std::copy_n (m[i], Cols, util::infix_iterator<float> (os, ", "));
+        std::copy (std::cbegin (m[i]), std::cend (m[i]), util::infix_iterator<float> (os, ", "));
         os << ((i == Rows - 1) ? " }" : " }, ");
     }
 
diff --git a/matrix.hpp b/matrix.hpp
index fb5d702b..d8b65063 100644
--- a/matrix.hpp
+++ b/matrix.hpp
@@ -34,17 +34,25 @@ namespace util {
         static constexpr auto rows = Rows;
         static constexpr auto cols = Cols;
 
+        using row_t = util::vector<Cols,T>;
+
+
+        ///////////////////////////////////////////////////////////////////////
         constexpr matrix () noexcept = default;
 
+
+        //---------------------------------------------------------------------
         constexpr matrix (const T(&_data)[Rows][Cols]) noexcept:
             values {}
         {
+            static_assert (sizeof (*this) == sizeof (T) * Rows * Cols);
             for (std::size_t r = 0; r < Rows; ++r)
                 for (std::size_t c = 0; c < Cols; ++c)
                     values[r][c] = _data[r][c];
         }
 
 
+        //---------------------------------------------------------------------
         template <std::size_t S, typename SelfT>
         constexpr matrix (const util::coord::base<S,T,SelfT> (&_data)[Rows]) noexcept
         {
@@ -53,55 +61,54 @@ namespace util {
                     values[r][c] = _data[r][c];
         }
 
-        T values[Rows][Cols];
 
         ///////////////////////////////////////////////////////////////////////
         // index operators return a pointer into the data array so that
         // multidimensional array syntax can be used transparently on this
         // type.
-        constexpr auto& operator[] (std::size_t idx) { return values[idx]; }
-        constexpr const auto& operator[] (std::size_t idx) const { return values[idx]; }
+        constexpr row_t& operator[] (std::size_t idx)& { return values[idx]; }
+        constexpr const row_t& operator[] (std::size_t idx) const& { return values[idx]; }
 
         //---------------------------------------------------------------------
-        constexpr auto
+        constexpr row_t*
         data (void)& noexcept
         {
-            return begin ();
+            return &values[0];
         }
 
         //---------------------------------------------------------------------
-        constexpr auto
+        constexpr const row_t*
         data (void) const& noexcept
         {
-            return begin ();
+            return &values[0];
         }
 
         //---------------------------------------------------------------------
         constexpr auto
         begin (void) const& noexcept
         {
-            return &(*this)[0][0];
-        }
-
-        //---------------------------------------------------------------------
-        constexpr auto
-        end (void) const& noexcept
-        {
-            return &(*this)[Rows][0];
+            return data ();
         }
 
         //---------------------------------------------------------------------
         constexpr auto
         begin (void)& noexcept
         {
-            return &(*this)[0][0];
+            return data ();
         }
 
         //---------------------------------------------------------------------
-        constexpr auto
+        constexpr row_t*
         end (void)& noexcept
         {
-            return &(*this)[Rows][0];
+            return &values[Rows];
+        }
+
+        //---------------------------------------------------------------------
+        constexpr const row_t*
+        end (void) const& noexcept
+        {
+            return &values[Rows];
         }
 
         //---------------------------------------------------------------------
@@ -138,8 +145,8 @@ namespace util {
         {
             VectorT out;
 
-            for (std::size_t i = 0; i < Rows; ++i)
-                out[i] = dot (rhs, values[i]);
+            for (std::size_t r = 0; r < Rows; ++r)
+                out[r] = dot (rhs, values[r]);
 
             return out;
         }
@@ -169,9 +176,13 @@ namespace util {
         matrix zeroes (void) noexcept
         {
             matrix ret {};
-            std::fill (std::begin (ret), std::end (ret), T{0});
+            std::fill (std::begin (ret), std::end (ret), row_t{0});
             return ret;
         }
+
+
+    private:
+        row_t values[Rows];
     };
 
 
@@ -346,7 +357,8 @@ namespace util {
     abs (const matrix<Rows,Cols,T> &src)
     {
         matrix<Rows,Cols,T> dst;
-        std::transform (std::cbegin (src), std::cend (src), std::begin (dst), util::abs<T>);
+        for (size_t r = 0; r < Rows; ++r)
+            dst[r] = abs (src[r]);
         return dst;
     }
 
@@ -355,7 +367,10 @@ namespace util {
     constexpr T
     sum (const matrix<Rows,Cols,T> &src)
     {
-        return sum (std::cbegin (src), std::cend (src));
+        util::vector<Rows,T> accum {};
+        for (size_t r = 0; r < Rows; ++r)
+            accum[r] = sum (src[r]);
+        return sum (accum);
     }
 
 
diff --git a/test/affine.cpp b/test/affine.cpp
index a7208972..b68e2ef4 100644
--- a/test/affine.cpp
+++ b/test/affine.cpp
@@ -104,9 +104,6 @@ test_mq_euler (util::TAP::logger &tap)
             util::quaternionf::angle_axis (t.z, { 0, 0, 1 })
         ).as_matrix ();
 
-        if (abs (m - q)[0])
-            exit (0);
-
         auto diff = util::sum (abs (m - q));
         tap.expect_le (diff, 1e-6f, "matrix-quaternion xyz euler rotations, %s", t.msg);
     }
diff --git a/test/matrix.cpp b/test/matrix.cpp
index 40e8d94d..dc962a71 100644
--- a/test/matrix.cpp
+++ b/test/matrix.cpp
@@ -112,9 +112,9 @@ main (void)
         for (size_t r = 0; r < m.rows; ++r)
             for (size_t c = 0; c < m.cols; ++c)
                 if (r == c)
-                    success = success && util::almost_equal (m.values[r][c], 1.f);
+                    success = success && util::almost_equal (m[r][c], 1.f);
                 else
-                    success = success && util::almost_equal (m.values[r][c], 0.f);
+                    success = success && util::almost_equal (m[r][c], 0.f);
 
         tap.expect (success, "identity inversion");
     }

From a0b0863d61ecebf2c49efb2fd53625c4e702d529 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Fri, 24 Nov 2017 17:18:43 +1100
Subject: [PATCH 07/56] coord: use new template form in ostream operators

---
 coord/iostream.hpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/coord/iostream.hpp b/coord/iostream.hpp
index 52709f32..d31fa9d4 100644
--- a/coord/iostream.hpp
+++ b/coord/iostream.hpp
@@ -17,6 +17,7 @@
 #ifndef CRUFT_UTIL_IOSTREAM
 #define CRUFT_UTIL_IOSTREAM
 
+#include "./traits.hpp"
 #include "../iterator.hpp"
 
 #include <cstddef>
@@ -25,17 +26,16 @@
 
 namespace util {
     template <
-        template <std::size_t,typename> class K,
-        std::size_t S,
-        typename T
+        typename K,
+        typename = std::enable_if_t<is_coord_v<K>,void>
     >
     std::ostream&
-    operator<< (std::ostream &os, const K<S,T> &k)
+    operator<< (std::ostream &os, const K &k)
     {
         os << "[";
         std::transform (std::cbegin (k),
                         std::cend   (k),
-                        infix_iterator<T> (os, ", "),
+                        infix_iterator<typename K::value_type> (os, ", "),
                         [] (auto i) { return +i; });
         os << "]";
 

From c1036d8337ccc6dfb020c07089aaf57196547fae Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Fri, 24 Nov 2017 17:19:04 +1100
Subject: [PATCH 08/56] matrix: use vector ostream operator

---
 matrix.cpp | 21 ---------------------
 matrix.hpp | 19 ++++++++++++++-----
 2 files changed, 14 insertions(+), 26 deletions(-)

diff --git a/matrix.cpp b/matrix.cpp
index d95f51df..26ec35a7 100644
--- a/matrix.cpp
+++ b/matrix.cpp
@@ -342,24 +342,3 @@ util::to_euler (const matrix<Rows,Cols,T> &m)
 template util::vector<3,float> util::to_euler (const matrix<3,3,float>&);
 template util::vector<3,float> util::to_euler (const matrix<4,4,float>&);
 
-
-///////////////////////////////////////////////////////////////////////////////
-template <std::size_t Rows, std::size_t Cols, typename T>
-std::ostream&
-util::operator<< (std::ostream &os, const matrix<Rows,Cols,T> &m)
-{
-    os << "{ ";
-
-    for (std::size_t i = 0; i < Rows; ++i) {
-        os << "{ ";
-        std::copy (std::cbegin (m[i]), std::cend (m[i]), util::infix_iterator<float> (os, ", "));
-        os << ((i == Rows - 1) ? " }" : " }, ");
-    }
-
-    return os << " }";
-}
-
-
-//-----------------------------------------------------------------------------
-template std::ostream& util::operator<< (std::ostream&, const matrix<4,4,float>&);
-template std::ostream& util::operator<< (std::ostream&, const matrix<4,4,double>&);
diff --git a/matrix.hpp b/matrix.hpp
index d8b65063..48a7d8f5 100644
--- a/matrix.hpp
+++ b/matrix.hpp
@@ -20,9 +20,10 @@
 #include "point.hpp"
 #include "range.hpp"
 #include "vector.hpp"
+#include "iterator.hpp"
 
-#include <ostream>
 #include <cstdlib>
+#include <ostream>
 
 namespace util {
     template <
@@ -469,9 +470,17 @@ namespace util {
 
     ///////////////////////////////////////////////////////////////////////////
     template <std::size_t Rows, std::size_t Cols, typename T>
-    std::ostream& operator<< (std::ostream&, const matrix<Rows,Cols,T>&);
-
-
-}
+    std::ostream&
+    operator<< (std::ostream &os, const matrix<Rows,Cols,T> &m)
+    {
+        os << '[';
+        std::copy (
+            std::cbegin (m),
+            std::cend   (m),
+            util::infix_iterator<decltype(m[0])> (os, ", ")
+        );
+        return os << ']';
+    }
+};
 
 #endif

From b4175e45930e849a057ed24d57a385ef391fd5e5 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Fri, 15 Dec 2017 18:57:10 +1100
Subject: [PATCH 09/56] uri: add more data fields

we now provide more fine grained field extraction from URIs, focusing
primarily on the utility of URLs.
---
 test/uri.cpp     | 155 +++++++++++++++++++++++++++++++++++++++++------
 test/version.cpp |  17 +++---
 uri.cpp.rl       |  84 +++++++++++++++++++------
 uri.hpp          |  56 ++++++++++++++---
 4 files changed, 261 insertions(+), 51 deletions(-)

diff --git a/test/uri.cpp b/test/uri.cpp
index 0f6e2367..7055c203 100644
--- a/test/uri.cpp
+++ b/test/uri.cpp
@@ -10,32 +10,149 @@ main (void)
 
     static const struct {
         const char *src;
+
         const char *scheme;
+        const char *hierarchical;
         const char *authority;
+        const char *user;
+        const char *host;
+        const char *port;
         const char *path;
         const char *query;
         const char *fragment;
     } GOOD[] = {
-        { "ftp://ftp.is.co.za/rfc/rfc1808.txt",                     "ftp",      "ftp.is.co.za",     "/rfc/rfc1808.txt", "", "" },
-        { "http://www.ietf.org/rfc/rfc2396.txt",                    "http",     "www.ietf.org",     "/rfc/rfc2396.txt", "", "" },
-        { "ldap://[2001:db8::7]/c=GB?objectClass?one",              "ldap",     "[2001:db8::7]",    "/c=GB", "objectClass?one", "" },
-        { "mailto:John.Doe@example.com",                            "mailto",   "",                 "John.Doe@example.com", "", "" },
-        { "news:comp.infosystems.www.servers.unix",                 "news",     "",                 "comp.infosystems.www.servers.unix", "", "" },
-        { "tel:+1-816-555-1212",                                    "tel",      "",                 "+1-816-555-1212", "", "" },
-        { "telnet://192.0.2.16:80/",                                "telnet",   "192.0.2.16:80",    "/", "", "" },
-        { "urn:oasis:names:specification:docbook:dtd:xml:4.1.2",    "urn",      "",                 "oasis:names:specification:docbook:dtd:xml:4.1.2", "", "" },
+        // examples from rfc3986
+        {
+            .src = "ftp://ftp.is.co.za/rfc/rfc1808.txt",
+
+            .scheme = "ftp",
+            .hierarchical = "ftp.is.co.za/rfc/rfc1808.txt",
+            .authority = "ftp.is.co.za",
+            .user = "",
+            .host = "ftp.is.co.za",
+            .port = "",
+            .path = "/rfc/rfc1808.txt",
+            .query = "",
+            .fragment = "" },
+        {
+            .src = "http://www.ietf.org/rfc/rfc2396.txt",
+
+            .scheme = "http",
+            .hierarchical = "www.ietf.org/rfc/rfc2396.txt",
+            .authority = "www.ietf.org",
+            .user = "",
+            .host = "www.ietf.org",
+            .port = "",
+            .path = "/rfc/rfc2396.txt",
+            .query = "",
+            .fragment = "" },
+
+        {
+            .src = "ldap://[2001:db8::7]/c=GB?objectClass?one",
+
+            .scheme = "ldap",
+            .hierarchical = "[2001:db8::7]/c=GB",
+            .authority = "[2001:db8::7]",
+            .user = "",
+            .host = "[2001:db8::7]",
+            .port = "",
+            .path = "/c=GB",
+            .query = "objectClass?one",
+            .fragment = "" },
+
+        {
+            .src = "mailto:John.Doe@example.com",
+
+            .scheme= "mailto",
+            .hierarchical = "John.Doe@example.com",
+            .authority= "",
+            .user = "",
+            .host = "",
+            .port = "",
+            .path= "John.Doe@example.com",
+            .query= "",
+            .fragment= "" },
+
+        {
+            .src  = "news:comp.infosystems.www.servers.unix",
+            .scheme= "news",
+            .hierarchical = "comp.infosystems.www.servers.unix",
+            .authority= "",
+            .user = "",
+            .host = "",
+            .port = "",
+            .path= "comp.infosystems.www.servers.unix",
+            .query= "",
+            .fragment= "" },
+
+        {
+            .src  = "tel:+1-816-555-1212",
+
+            .scheme= "tel",
+            .hierarchical = "+1-816-555-1212",
+            .authority= "",
+            .user = "",
+            .host = "",
+            .port = "",
+            .path= "+1-816-555-1212",
+            .query= "",
+            .fragment= "" },
+
+        {
+            .src  = "telnet://192.0.2.16:80/",
+
+            .scheme= "telnet",
+            .hierarchical = "192.0.2.16:80/",
+            .authority= "192.0.2.16:80",
+            .user = "",
+            .host = "192.0.2.16",
+            .port = "80",
+            .path= "/",
+            .query= "",
+            .fragment= "" },
+
+        {
+            .src  = "urn:oasis:names:specification:docbook:dtd:xml:4.1.2",
+
+            .scheme= "urn",
+            .hierarchical = "oasis:names:specification:docbook:dtd:xml:4.1.2",
+            .authority= "",
+            .user = "",
+            .host = "",
+            .port = "",
+            .path= "oasis:names:specification:docbook:dtd:xml:4.1.2",
+            .query= "",
+            .fragment= "" },
+
+
+        // a case with all possible components
+        {
+            .src = "https://user:password@example.com:80/path/to?foo=bar#fragment",
+
+            .scheme = "https",
+            .hierarchical = "user:password@example.com:80/path/to",
+            .authority = "user:password@example.com:80",
+            .user = "user:password",
+            .host = "example.com",
+            .port = "80",
+            .path = "/path/to",
+            .query = "foo=bar",
+            .fragment = "fragment" },
     };
 
-    for (auto i: GOOD) {
-        tap.expect_nothrow ([i] (void) { util::uri foo (i.src); }, "nothrow parsing '%s'", i.src);
+    for (auto t: GOOD) {
+        tap.expect_nothrow ([t] (void) { util::uri foo (t.src); }, "nothrow parsing '%s'", t.src);
+        util::uri u (t.src);
 
-        util::uri u (i.src);
-
-        tap.expect (std::equal (u.get (util::uri::SCHEME).begin (), u.get (util::uri::SCHEME).end (), i.scheme),            "extracting scheme for '%s'", i.src);
-        tap.expect (std::equal (u.get (util::uri::AUTHORITY).begin (), u.get (util::uri::AUTHORITY).end (), i.authority),   "extracting authority '%s'", i.src);
-        tap.expect (std::equal (u.get (util::uri::PATH).begin (), u.get (util::uri::PATH).end (), i.path),                  "extracting path '%s'", i.src);
-        tap.expect (std::equal (u.get (util::uri::QUERY).begin (), u.get (util::uri::QUERY).end (), i.query),               "extracting query '%s'", i.src);
-        tap.expect (std::equal (u.get (util::uri::FRAGMENT).begin (), u.get (util::uri::FRAGMENT).end (), i.fragment),      "extracting fragment '%s'", i.src);
+        tap.expect (equal (u.scheme (), t.scheme), "scheme for '%s'", t.src);
+        tap.expect (equal (u.heirarchical (), t.hierarchical), "hierarchical for '%s'", t.src);
+        tap.expect (equal (u.authority (), t.authority), "authority for '%s'", t.src);
+        tap.expect (equal (u.host (), t.host), "host for '%s'", t.src);
+        tap.expect (equal (u.user (), t.user), "user for '%s'", t.src);
+        tap.expect (equal (u.port (), t.port), "port for '%s'", t.src);
+        tap.expect (equal (u.path (), t.path), "path for '%s'", t.src);
+        tap.expect (equal (u.query (), t.query), "query for '%s'", t.src);
+        tap.expect (equal (u.fragment (), t.fragment), "fragment for '%s'", t.src);
     }
 
     static const char* BAD[] = {
@@ -43,7 +160,9 @@ main (void)
     };
 
     for (auto i: BAD)
-        tap.expect_throw<util::uri::parse_error> ([i] (void) { util::uri foo (i); }, "throw parsing '%s'", i);
+        tap.expect_throw<util::uri::parse_error> (
+            [i] (void) { util::uri foo (i); }, "throw parsing '%s'", i
+    );
 
 
     return tap.status ();
diff --git a/test/version.cpp b/test/version.cpp
index f8abf25c..9c2b1d29 100644
--- a/test/version.cpp
+++ b/test/version.cpp
@@ -43,23 +43,26 @@ static const struct {
 };
 
 
-///////////////////////////////////////////////////////////////////////////////
+//-----------------------------------------------------------------------------
 int
 main () {
 
     util::TAP::logger tap;
 
-    for (const auto &i: PARSE_TESTS) {
-        util::version v (i.str);
+    for (const auto &t: PARSE_TESTS) {
+        util::version v (t.str);
 
-        tap.expect (std::equal (v.begin (), v.end (), i.parts) && v.release == i.release, "%s", i.msg);
+        bool parts = std::equal (v.begin (), v.end (), t.parts);
+        bool release = v.release == t.release;
+
+        tap.expect (parts && release, "%s", t.msg);
     }
 
 
     for (const auto &t: CMP_TESTS) {
-        bool eq = t.a == t.b,
-             lt = t.a <  t.b,
-             gt = t.a >  t.b;
+        const bool eq = t.a == t.b;
+        const bool lt = t.a <  t.b;
+        const bool gt = t.a >  t.b;
 
         tap.expect (t.eq == eq, "%s: equality", t.msg);
         tap.expect (t.lt == lt, "%s: less-than", t.msg);
diff --git a/uri.cpp.rl b/uri.cpp.rl
index a5f02f23..a60f6f3c 100644
--- a/uri.cpp.rl
+++ b/uri.cpp.rl
@@ -20,6 +20,7 @@
 #include "uri.hpp"
 
 #include "debug.hpp"
+#include "iterator.hpp"
 
 #include <algorithm>
 #include <iostream>
@@ -32,19 +33,31 @@
     action success {__success = true; }
     action failure {__success = false; }
 
-    action scheme_begin { m_views[SCHEME] = { p, nullptr }; }
+    action scheme_begin { m_views[SCHEME] = { p, p }; }
     action scheme_end   { m_views[SCHEME] = { m_views[SCHEME].begin (), p }; }
 
-    action authority_begin { m_views[AUTHORITY] = { p, nullptr}; }
+    action hier_begin { m_views[HIERARCHICAL] = { p, p }; }
+    action hier_end   { m_views[HIERARCHICAL] = { m_views[HIERARCHICAL].begin (), p }; }
+
+    action user_begin { m_views[USER] = { p, p }; }
+    action user_end   { m_views[USER] = { m_views[USER].begin (), p }; }
+
+    action host_begin { m_views[HOST] = { p, p }; }
+    action host_end   { m_views[HOST] = { m_views[HOST].begin (), p }; }
+
+    action port_begin { m_views[PORT] = { p, p }; }
+    action port_end   { m_views[PORT] = { m_views[PORT].begin (), p }; }
+
+    action authority_begin { m_views[AUTHORITY] = { p, p}; }
     action authority_end   { m_views[AUTHORITY] = { m_views[AUTHORITY].begin (), p }; }
 
-    action path_begin { m_views[PATH] = { p, nullptr}; }
+    action path_begin { m_views[PATH] = { p, p}; }
     action path_end   { m_views[PATH] = { m_views[PATH].begin (), p }; }
 
-    action query_begin { m_views[QUERY] = { p, nullptr}; }
+    action query_begin { m_views[QUERY] = { p, p}; }
     action query_end   { m_views[QUERY] = { m_views[QUERY].begin (), p }; }
 
-    action fragment_begin { m_views[FRAGMENT] = { p, nullptr}; }
+    action fragment_begin { m_views[FRAGMENT] = { p, p}; }
     action fragment_end   { m_views[FRAGMENT] = { m_views[FRAGMENT].begin (), p }; }
 
     ## Characters
@@ -100,9 +113,18 @@
     reserved = gen_delim | sub_delim;
 
     ## Authority
-    port = digit*;
-    host = ip_literal | ipv4address | reg_name;
-    userinfo = (unreserved | pct_encoded | sub_delim | ':')*;
+    port = (
+        digit*
+    ) >port_begin %port_end;
+
+    host = (
+        ip_literal | ipv4address | reg_name
+    ) >host_begin %host_end;
+
+    userinfo = (
+        (unreserved | pct_encoded | sub_delim | ':')*
+    ) >user_begin %user_end;
+
     authority = (
         (userinfo '@')? host (':' port)?
     ) >authority_begin %authority_end;
@@ -122,12 +144,13 @@
     ) >fragment_begin %fragment_end;
 
     ## URI types
-    hier_part =
-          '//' authority path_abempty  >path_begin %path_end
-        | path_absolute  >path_begin %path_end
+    hier_part = (
+          '//' (authority path_abempty  >path_begin %path_end) >hier_begin %hier_end
+    ) | (
+          path_absolute  >path_begin %path_end
         | path_rootless  >path_begin %path_end
         | path_empty     >path_begin %path_end
-    ;
+    ) >hier_begin %hier_end;
 
     uri = scheme ':' hier_part ('?' query)? ('#' fragment);
 
@@ -175,7 +198,17 @@ static const util::view<const char*> NULL_VIEW { nullptr, nullptr };
 
 //-----------------------------------------------------------------------------
 util::uri::uri (std::string &&_value):
-    m_views {NULL_VIEW, NULL_VIEW, NULL_VIEW, NULL_VIEW, NULL_VIEW},
+    m_views {
+        NULL_VIEW,
+        NULL_VIEW,
+        NULL_VIEW,
+        NULL_VIEW,
+        NULL_VIEW,
+        NULL_VIEW,
+        NULL_VIEW,
+        NULL_VIEW,
+        NULL_VIEW
+    },
     m_value (std::move (_value))
 {
     const char *p   = m_value.data ();
@@ -196,7 +229,7 @@ util::uri::uri (std::string &&_value):
 
 //-----------------------------------------------------------------------------
 util::view<const char*>
-util::uri::get (util::uri::component c)
+util::uri::get (util::uri::component c) const
 {
     CHECK_NEQ (c, NUM_COMPONENTS);
     return m_views[c];
@@ -264,16 +297,21 @@ util::uri::percent_decode (view<const char*> s)
 }
 
 
+
 //-----------------------------------------------------------------------------
 std::ostream&
 util::operator<< (std::ostream &os, util::uri::component c)
 {
     switch (c) {
-        case util::uri::SCHEME:     return os << "SCHEME";
-        case util::uri::AUTHORITY:  return os << "AUTHORITY";
-        case util::uri::PATH:       return os << "PATH";
-        case util::uri::QUERY:      return os << "QUERY";
-        case util::uri::FRAGMENT:   return os << "FRAGMENT";
+        case util::uri::SCHEME:         return os << "SCHEME";
+        case util::uri::HIERARCHICAL:   return os << "HIERARCHICAL";
+        case util::uri::AUTHORITY:      return os << "AUTHORITY";
+        case util::uri::USER:           return os << "USER";
+        case util::uri::HOST:           return os << "HOST";
+        case util::uri::PORT:           return os << "PORT";
+        case util::uri::PATH:           return os << "PATH";
+        case util::uri::QUERY:          return os << "QUERY";
+        case util::uri::FRAGMENT:       return os << "FRAGMENT";
 
         case util::uri::NUM_COMPONENTS:
             unreachable ();
@@ -281,3 +319,11 @@ util::operator<< (std::ostream &os, util::uri::component c)
 
     unreachable ();
 }
+
+
+//-----------------------------------------------------------------------------
+std::ostream&
+util::operator<< (std::ostream &os, const util::uri &val)
+{
+    return os << '[' << util::make_infix (val.components ()) << ']';
+}
diff --git a/uri.hpp b/uri.hpp
index 92f4749a..f8ff25f1 100644
--- a/uri.hpp
+++ b/uri.hpp
@@ -11,20 +11,33 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
- * Copyright 2015 Danny Robson <danny@nerdcruft.net>
+ * Copyright 2015, 2017 Danny Robson <danny@nerdcruft.net>
  */
 
 
-#ifndef __UTIL_URI_HPP
-#define __UTIL_URI_HPP
+#ifndef CRUFT_UTIL_URI_HPP
+#define CRUFT_UTIL_URI_HPP
 
 #include "view.hpp"
 
+#include <array>
 #include <string>
 #include <stdexcept>
 
 
 namespace util {
+    // parsing of rfc3986 uniform resource identifiers
+    //
+    // does not currently perform normalisation (scheme or protocol),
+    // comparison, or other associated operations. though these should be
+    // added in the future.
+    //
+    // note that the parsed results may not always conform to expectations
+    // for some protocols. eg, mailto identifiers are complex to parse
+    // reliably and would require a specialised parser to be reliable.
+    //
+    // not all fields will be present for all protocols (or all instances of
+    // any given protocol). eg, the "tel" is unlikely to have port numbers.
     class uri {
     public:
         explicit uri (std::string &&);
@@ -34,25 +47,54 @@ namespace util {
         class parse_error : public std::runtime_error
         { using runtime_error::runtime_error; };
 
+
+        // URI:     'https://user:password@example.com:80/path/to?foo=bar#fragment'
+        //
+        // SCHEME:          'https'
+        // HIERARCHICAL:    'user:password@example.com:80/path/to'
+        // AUTHORITY:       'user:password@example.com:80'
+        // USER:            'user:password'
+        // HOST:            'example.com'
+        // PORT:            '80'
+        // PATH:            '/path/to'
+        // QUERY:           'foo=bar'
+        // FRAGMENT:        'fragment'
         enum component {
             SCHEME,
-            AUTHORITY,
-            PATH,
+            HIERARCHICAL,
+                AUTHORITY,
+                    USER,
+                    HOST,
+                    PORT,
+                PATH,
             QUERY,
             FRAGMENT,
 
             NUM_COMPONENTS
         };
 
-        view<const char*> get (component);
+        view<const char*> get (component) const;
+
+        view<const char*> scheme (void) const { return get (SCHEME); }
+        view<const char*> heirarchical (void) const { return get (HIERARCHICAL); }
+        view<const char*> authority (void) const { return get (AUTHORITY); }
+        view<const char*> user (void) const { return get (USER); }
+        view<const char*> host (void) const { return get (HOST); }
+        view<const char*> port (void) const { return get (PORT); }
+        view<const char*> path (void) const { return get (PATH); }
+        view<const char*> query (void) const { return get (QUERY); }
+        view<const char*> fragment (void) const { return get (FRAGMENT); }
+
+        auto components (void) const noexcept { return m_views; }
 
         static std::string percent_decode (view<const char*>);
 
     private:
-        view<const char*> m_views[NUM_COMPONENTS];
+        std::array<view<const char*>, NUM_COMPONENTS> m_views;
         std::string m_value;
     };
 
+    std::ostream& operator<< (std::ostream&, const uri&);
     std::ostream& operator<< (std::ostream&, uri::component);
 }
 

From 60a76703264fec9db2b3cf36e09361b9366f7d28 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Fri, 15 Dec 2017 18:58:33 +1100
Subject: [PATCH 10/56] view: delegate constructors where feasible

this will allow us to reduce code duplication for sanity checks at
construction time.
---
 view.hpp | 16 +++++-----------
 1 file changed, 5 insertions(+), 11 deletions(-)

diff --git a/view.hpp b/view.hpp
index 831c9ee3..371cc920 100644
--- a/view.hpp
+++ b/view.hpp
@@ -49,8 +49,7 @@ namespace util {
         //---------------------------------------------------------------------
         constexpr
         view (const view &rhs) noexcept:
-            m_begin (rhs.m_begin),
-            m_end   (rhs.m_end)
+            view (rhs.m_begin, rhs.m_end)
         { ; }
 
 
@@ -60,19 +59,15 @@ namespace util {
         // class as a base for unique owning pointers without exposing
         // begin/end to them directly.
         constexpr view (view &&rhs) noexcept:
-            view (IteratorT{}, IteratorT{})
-        {
-            std::swap (m_begin, rhs.m_begin);
-            std::swap (m_end,   rhs.m_end);
-        }
+            view (std::move (rhs.m_begin), std::move (rhs.m_end))
+        { ; }
 
 
         //---------------------------------------------------------------------
         template <typename ContainerT>
         constexpr explicit
         view (ContainerT &klass):
-            m_begin (std::begin (klass)),
-            m_end   (std::end   (klass))
+            view (std::begin (klass), std::end (klass))
         { ; }
 
 
@@ -80,8 +75,7 @@ namespace util {
         template <typename ContainerT>
         constexpr explicit
         view (const ContainerT &klass):
-            m_begin (std::begin (klass)),
-            m_end   (std::end   (klass))
+            view (std::begin (klass), std::end (klass))
         { ; }
 
 

From 2ead13a063ba2da819c80a16da70dadcbfde81b2 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Mon, 18 Dec 2017 14:50:10 +1100
Subject: [PATCH 11/56] parse: use views over explit begin/end pairs

---
 parse.cpp |  4 ++--
 parse.hpp | 12 ++++++------
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/parse.cpp b/parse.cpp
index fcd2036d..97b8e01a 100644
--- a/parse.cpp
+++ b/parse.cpp
@@ -69,9 +69,9 @@ c_fparse (const char *first, const char *last)
 #define C_PARSE(T, KLASS) \
 template <> \
 T \
-util::parse<T> (const char *first, const char *last) \
+util::parse<T> (util::view<const char *> str) \
 { \
-    return c_ ## KLASS ## parse<T> (first, last); \
+    return c_ ## KLASS ## parse<T> (std::cbegin (str), std::cend (str)); \
 }
 
 
diff --git a/parse.hpp b/parse.hpp
index b03b5ee1..829e49ea 100644
--- a/parse.hpp
+++ b/parse.hpp
@@ -17,6 +17,8 @@
 #ifndef CRUFT_UTIL_PARSE_HPP
 #define CRUFT_UTIL_PARSE_HPP
 
+#include "view.hpp"
+
 #include <cstring>
 #include <string>
 #include <iterator>
@@ -28,16 +30,14 @@ namespace util {
     ///
     /// throws std::invalid_argument when the type cannot be parsed.
     template <typename T>
-    T
-    parse (const char *first, const char *last);
+    T parse (util::view<const char *>);
 
 
     //-------------------------------------------------------------------------
     template <typename T>
-    T
-    parse (const char *str)
+    T parse (const char *str)
     {
-        return parse<T> (str, str + strlen (str));
+        return parse<T> (make_view (str));
     }
 
 
@@ -46,7 +46,7 @@ namespace util {
     T
     parse (const std::string &str)
     {
-        return parse<T> (std::cbegin (str), std::cend (str));
+        return parse<T> (make_view (str));
     }
 }
 

From 77c88438d440effe16695df1dc2f18c301807bbe Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Mon, 18 Dec 2017 15:46:52 +1100
Subject: [PATCH 12/56] except: move posix/win32 exceptions to own units

---
 CMakeLists.txt             |   6 +-
 backtrace_stackwalk.cpp    |   3 +-
 backtrace_win32.cpp        |   3 +-
 debug_win32.cpp            |   3 +-
 except.cpp                 | 202 -------------------------------------
 except.hpp                 |  97 ------------------
 exe_linux.cpp              |   4 +-
 exe_win32.cpp              |   3 +-
 io.cpp                     |  31 +++---
 io_posix.cpp               |   7 +-
 io_win32.cpp               |   7 +-
 library_win32.cpp          |   4 +-
 memory/buffer/circular.cpp |  10 +-
 memory/buffer/paged.cpp    |  14 +--
 memory/system.cpp          |   8 +-
 posix/dir.cpp              |   6 +-
 posix/dir.ipp              |   6 +-
 posix/fd.cpp               |  16 +--
 posix/map.cpp              |  10 +-
 win32/registry.cpp         |   9 +-
 20 files changed, 73 insertions(+), 376 deletions(-)
 delete mode 100644 except.cpp
 delete mode 100644 except.hpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 4f806b76..1252a745 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -80,6 +80,8 @@ list (
     posix/dir.cpp
     posix/dir.hpp
     posix/dir.ipp
+    posix/except.cpp
+    posix/except.hpp
     posix/fd.cpp
     posix/fd.hpp
 )
@@ -120,6 +122,8 @@ if (WINDOWS)
         library_win32.hpp
         library_win32.cpp
         time_win32.cpp
+        win32/except.cpp
+        win32/except.hpp
         win32/handle.cpp
         win32/handle.hpp
         win32/registry.hpp
@@ -201,8 +205,6 @@ list (
     debug.ipp
     endian.cpp
     endian.hpp
-    except.cpp
-    except.hpp
     exe.hpp
     extent.cpp
     extent.hpp
diff --git a/backtrace_stackwalk.cpp b/backtrace_stackwalk.cpp
index 2cd14020..a1535d0f 100644
--- a/backtrace_stackwalk.cpp
+++ b/backtrace_stackwalk.cpp
@@ -19,6 +19,7 @@
 #include "debug.hpp"
 #include "except.hpp"
 #include "types.hpp"
+#include "win32/error.hpp"
 
 #include <windows.h>
 #include <dbghelp.h>
@@ -66,7 +67,7 @@ backtrace::backtrace ()
                           SymGetModuleBase64,
                           nullptr))
         {
-            util::win32_error::throw_code ();
+            util::win32::error::throw_code ();
         }
 
         // we've read the bottom of the stack
diff --git a/backtrace_win32.cpp b/backtrace_win32.cpp
index 378ac7c6..5ed8aee8 100644
--- a/backtrace_win32.cpp
+++ b/backtrace_win32.cpp
@@ -17,6 +17,7 @@
 
 #include "backtrace.hpp"
 
+#include "win32/error.hpp"
 #include "win32/handle.hpp"
 #include "debug.hpp"
 #include "except.hpp"
@@ -33,7 +34,7 @@ debug::backtrace::backtrace (void)
 
     auto process = GetCurrentProcess();
     if (!SymInitialize (process, NULL, TRUE))
-        util::win32_error::throw_code ();
+        util::win32::error::throw_code ();
 
     while (true) {
         auto res = CaptureStackBackTrace (1, m_frames.size (), m_frames.data (), NULL);
diff --git a/debug_win32.cpp b/debug_win32.cpp
index bc785ed0..5e97fd0e 100644
--- a/debug_win32.cpp
+++ b/debug_win32.cpp
@@ -19,6 +19,7 @@
 #include "except.hpp"
 #include "log.hpp"
 #include "except.hpp"
+#include "win32/error.hpp"
 
 #include <windows.h>
 #include <iostream>
@@ -49,7 +50,7 @@ prepare_debugger (void)
 {
     if (nullptr == LoadLibrary("exchndl.dll")) {
         auto code = GetLastError ();
-        LOG_WARNING("Emergency debugger not loaded: %s", util::win32_error::code_string (code));
+        LOG_WARNING("Emergency debugger not loaded: %s", util::win32::error::code_string (code));
     }
 }
 
diff --git a/except.cpp b/except.cpp
deleted file mode 100644
index 11887d50..00000000
--- a/except.cpp
+++ /dev/null
@@ -1,202 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2010 Danny Robson <danny@nerdcruft.net>
- */
-
-#include "except.hpp"
-
-#include "debug.hpp"
-#include "platform.hpp"
-
-#include <cstring>
-#include <cerrno>
-
-using util::errno_error;
-
-
-///////////////////////////////////////////////////////////////////////////////
-/// Construct an errno_error from a given error value. The error value MUST signal an error at
-/// construction time.
-errno_error::errno_error (int _code):
-    runtime_error (strerror (_code)),
-    m_code (_code)
-{
-    CHECK_NEQ (_code, 0);
-}
-
-
-///----------------------------------------------------------------------------
-/// Construct an errno_error from the current value of errno. errno MUST signal an error at
-/// construction time.
-errno_error::errno_error ():
-    errno_error (last_code ())
-{
-    CHECK_NEQ (m_code, 0);
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-int
-errno_error::last_code (void)
-{
-    return errno;
-}
-
-
-//-----------------------------------------------------------------------------
-int
-errno_error::code (void) const
-{
-    return m_code;
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-/// Throw an errno_error exception if errno currently signals an error.
-void
-errno_error::try_code (void)
-{
-    try_code (last_code ());
-}
-
-
-///----------------------------------------------------------------------------
-/// Throw an errno_error exception if 'code' represents an error.
-void
-errno_error::try_code (int code)
-{
-    if (__builtin_expect (code != 0, false))
-        throw errno_error(code);
-}
-
-
-///----------------------------------------------------------------------------
-void
-errno_error::throw_code (void)
-{
-    throw_code (last_code ());
-}
-
-
-///----------------------------------------------------------------------------
-void
-errno_error::throw_code (int code)
-{
-    CHECK_NEQ (code, 0);
-    throw errno_error (code);
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-#if defined(PLATFORM_WIN32)
-
-using util::win32_error;
-
-
-//-----------------------------------------------------------------------------
-win32_error::win32_error (DWORD _code):
-    runtime_error (code_string (_code)),
-    m_code (_code)
-{
-    CHECK_NEQ (m_code, (DWORD)ERROR_SUCCESS);
-}
-
-
-//-----------------------------------------------------------------------------
-win32_error::win32_error (void):
-    win32_error (last_code ())
-{ ; }
-
-
-///////////////////////////////////////////////////////////////////////////////
-DWORD
-win32_error::code (void) const
-{
-    return m_code;
-}
-
-
-//-----------------------------------------------------------------------------
-DWORD
-win32_error::last_code (void)
-{
-    return GetLastError ();
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-void
-win32_error::try_code (void)
-{
-    try_code (last_code ());
-}
-
-
-//-----------------------------------------------------------------------------
-void
-win32_error::try_code (DWORD id)
-{
-    if (__builtin_expect (id != ERROR_SUCCESS, false))
-        throw_code (id);
-}
-
-
-//-----------------------------------------------------------------------------
-void
-win32_error::throw_code (void)
-{
-    throw_code (last_code ());
-}
-
-
-//-----------------------------------------------------------------------------
-void
-win32_error::throw_code (DWORD code)
-{
-    CHECK_NEQ (code, (DWORD)ERROR_SUCCESS);
-    throw win32_error (code);
-}
-
-
-//-----------------------------------------------------------------------------
-std::string
-win32_error::code_string (void)
-{
-    return code_string (last_code ());
-}
-
-
-//-----------------------------------------------------------------------------
-std::string
-win32_error::code_string (DWORD code)
-{
-    char message[256];
-
-    auto res = FormatMessage (
-        FORMAT_MESSAGE_FROM_SYSTEM,
-        NULL,
-        code,
-        MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
-        message,
-        std::size (message),
-        NULL
-    );
-
-    if (res == 0) {
-        win32_error::throw_code ();
-    }
-
-    return std::string (message, message + res);
-}
-#endif
diff --git a/except.hpp b/except.hpp
deleted file mode 100644
index 2d33203b..00000000
--- a/except.hpp
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2010 Danny Robson <danny@nerdcruft.net>
- */
-
-
-#ifndef __EXCEPT_HPP
-#define __EXCEPT_HPP
-
-#include "platform.hpp"
-
-#include <stdexcept>
-
-namespace util {
-    class input_error : public std::runtime_error {
-        public:
-            explicit input_error (const std::string &_what):
-                    runtime_error (_what)
-            { ; }
-    };
-
-
-    class output_error : public std::runtime_error {
-        public:
-            explicit output_error (const std::string &_what):
-                runtime_error (_what)
-            { ; }
-    };
-
-
-    class unavailable_error : public std::runtime_error {
-        public:
-            explicit unavailable_error (const std::string &_what):
-                    runtime_error (_what)
-            { ; }
-    };
-
-
-    /// An exception class used for reporting errors signalled by errno.
-    class errno_error : public std::runtime_error {
-    public:
-        explicit errno_error (int code);
-        errno_error ();
-
-        int code (void) const;
-        static int last_code (void);
-
-        static void try_code (void);
-        static void try_code (int code);
-
-        static void throw_code [[gnu::noreturn]] (void);
-        static void throw_code [[gnu::noreturn]] (int code);
-
-    private:
-        int m_code;
-    };
-}
-
-#if defined(PLATFORM_WIN32)
-#include <windows.h>
-
-namespace  util {
-    class win32_error : public std::runtime_error {
-    public:
-        explicit win32_error (DWORD _code);
-        win32_error ();
-
-        DWORD code (void) const;
-        static DWORD last_code (void);
-
-        static void try_code (void);
-        static void try_code (DWORD);
-
-        static void throw_code [[gnu::noreturn]] (void);
-        static void throw_code [[gnu::noreturn]] (DWORD);
-
-        static std::string code_string (void);
-        static std::string code_string (DWORD);
-
-    private:
-        DWORD m_code;
-    };
-}
-#endif
-
-#endif
diff --git a/exe_linux.cpp b/exe_linux.cpp
index 6a29de99..78e5ff86 100644
--- a/exe_linux.cpp
+++ b/exe_linux.cpp
@@ -16,8 +16,8 @@
 
 #include "exe.hpp"
 
-#include "except.hpp"
 #include "cast.hpp"
+#include "posix/except.hpp"
 
 #include <vector>
 #include <experimental/filesystem>
@@ -39,7 +39,7 @@ util::image_path (void)
 retry:
     const auto written = readlink (PROC_SELF, resolved.data (), resolved.size ());
     if (written < 0)
-        errno_error::throw_code ();
+        posix::error::throw_code ();
 
     if (sign_cast<size_t> (written) == resolved.size ()) {
         resolved.resize (resolved.size () * 2);
diff --git a/exe_win32.cpp b/exe_win32.cpp
index b67f69d9..b28abae1 100644
--- a/exe_win32.cpp
+++ b/exe_win32.cpp
@@ -17,6 +17,7 @@
 #include "exe.hpp"
 
 #include "except.hpp"
+#incldue "win32/except.hpp"
 
 #include <experimental/filesystem>
 #include <vector>
@@ -32,7 +33,7 @@ util::image_path (void)
 retry:
         const auto written = GetModuleFileName (nullptr, resolved.data (), resolved.size ());
         if (written == 0)
-            win32_error::throw_code ();
+            win32::error::throw_code ();
 
         if (written == resolved.size ()) {
             resolved.resize (resolved.size () * 2);
diff --git a/io.cpp b/io.cpp
index 218e3a10..11d7714c 100644
--- a/io.cpp
+++ b/io.cpp
@@ -17,8 +17,8 @@
 #include "io.hpp"
 
 #include "debug.hpp"
-#include "except.hpp"
 #include "cast.hpp"
+#include "posix/except.hpp"
 
 #include <cstdio>
 #include <fcntl.h>
@@ -44,12 +44,9 @@ util::slurp (const std::experimental::filesystem::path &path)
     posix::fd out (path, O_RDONLY | O_BINARY);
 
     // Calculate the total file size
-    off_t size = lseek (out, 0, SEEK_END);
-    if (size == (off_t)-1)
-        throw errno_error();
+    off_t size = posix::error::try_value (lseek (out, 0, SEEK_END));
 
-    if (lseek (out, 0, SEEK_SET) == (off_t)-1)
-        throw errno_error ();
+    posix::error::try_value (lseek (out, 0, SEEK_SET));
 
     // Allocate a buffer, and keep reading until it's full.
     std::vector<T> buffer (size);
@@ -59,9 +56,10 @@ util::slurp (const std::experimental::filesystem::path &path)
     T *cursor = buffer.data ();
 
     while (remaining) {
-        ssize_t consumed = ::read (out, cursor, remaining);
-        if (consumed == -1)
-            throw errno_error();
+        ssize_t consumed = posix::error::try_value(
+            ::read (out, cursor, remaining)
+        );
+
         CHECK_GT (        consumed, 0);
         CHECK_LE ((size_t)consumed, remaining);
 
@@ -89,13 +87,10 @@ util::slurp (FILE *stream)
     );
 
     // find how much data is in this file
-    const int desc = fileno (stream);
-    if (desc < 0)
-        errno_error::throw_code ();
+    const int desc = util::posix::error::try_value (fileno (stream));
 
     struct stat meta;
-    if (fstat (desc, &meta) < 0)
-        errno_error::throw_code ();
+    posix::error::try_value (fstat (desc, &meta));
 
     std::vector<T> buf;
 
@@ -144,9 +139,7 @@ util::write (const posix::fd &out,
     size_t remaining = bytes;
 
     while (remaining) {
-        ssize_t consumed = ::write (out, cursor, remaining);
-        if (consumed < 0)
-            errno_error::throw_code ();
+        ssize_t consumed = posix::error::try_value (::write (out, cursor, remaining));
 
         remaining -= sign_cast<size_t> (consumed);
         cursor    += sign_cast<size_t> (consumed);
@@ -198,7 +191,7 @@ scoped_cwd::scoped_cwd ()
     m_original.resize (16);
     while (getcwd (&m_original[0], m_original.size ()) == nullptr && errno == ERANGE)
         m_original.resize (m_original.size () * 2);
-    errno_error::try_code ();
+    posix::error::try_code ();
 }
 
 
@@ -206,7 +199,7 @@ scoped_cwd::scoped_cwd ()
 scoped_cwd::~scoped_cwd ()
 {
     if (!chdir (m_original.c_str ()))
-        errno_error::throw_code ();
+        posix::error::throw_code ();
 }
 
 
diff --git a/io_posix.cpp b/io_posix.cpp
index b5455e67..e865c8af 100644
--- a/io_posix.cpp
+++ b/io_posix.cpp
@@ -18,8 +18,8 @@
 
 #include "cast.hpp"
 #include "debug.hpp"
-#include "except.hpp"
 #include "posix/fd.hpp"
+#include "posix/except.hpp"
 
 #include <sys/stat.h>
 
@@ -38,13 +38,12 @@ mapped_file::mapped_file (const std::experimental::filesystem::path &path,
 mapped_file::mapped_file (const ::util::posix::fd &src, int mflags)
 {
     struct stat meta;
-    if (fstat (src, &meta) < 0)
-        throw errno_error ();
+    ::util::posix::error::try_value (fstat (src, &meta));
 
     m_size = sign_cast<size_t> (meta.st_size);
     m_data = (uint8_t *)mmap (NULL, m_size, mflags, MAP_SHARED, src, 0);
     if (m_data == MAP_FAILED)
-        throw errno_error ();
+        ::util::posix::error::throw_code ();
 }
 
 
diff --git a/io_win32.cpp b/io_win32.cpp
index bd08b1a2..c83de38e 100644
--- a/io_win32.cpp
+++ b/io_win32.cpp
@@ -18,6 +18,7 @@
 
 #include "debug.hpp"
 #include "except.hpp"
+#include "win32/error.hpp"
 
 #include <windows.h>
 
@@ -94,11 +95,11 @@ mapped_file::mapped_file (::util::win32::handle &&src,
     // hell. Try not to collapse, but instead bail with a null mapping and
     // pray the user doesn't do something stupid with the result.
     if (!m_mapping) {
-        auto err = win32_error::last_code ();
+        auto err = win32::error::last_code ();
         if (err == ERROR_FILE_INVALID && m_size == 0)
             return;
 
-        win32_error::throw_code (err);
+        win32::error::throw_code (err);
     }
 
     auto view = MapViewOfFile (
@@ -109,7 +110,7 @@ mapped_file::mapped_file (::util::win32::handle &&src,
     );
 
     if (!view)
-        win32_error::throw_code ();
+        win32::error::throw_code ();
 
     m_data.reset (
         static_cast<unsigned char*> (view)
diff --git a/library_win32.cpp b/library_win32.cpp
index 7397f8b3..3a4af1f0 100644
--- a/library_win32.cpp
+++ b/library_win32.cpp
@@ -16,7 +16,7 @@
 
 #include "library_win32.hpp"
 
-#include "except.hpp"
+#include "win32/except.hpp"
 
 using util::detail::win32::library;
 
@@ -26,7 +26,7 @@ library::library (const std::experimental::filesystem::path &path):
     m_handle (LoadLibraryA (path.c_str ()))
 {
     if (!m_handle)
-        win32_error::throw_code ();
+        win32::error::throw_code ();
 }
 
 
diff --git a/memory/buffer/circular.cpp b/memory/buffer/circular.cpp
index b7ce6209..cd447e20 100644
--- a/memory/buffer/circular.cpp
+++ b/memory/buffer/circular.cpp
@@ -16,12 +16,12 @@
 
 #include "circular.hpp"
 
-#include "../system.hpp"
 #include "../../debug.hpp"
-#include "../../except.hpp"
 #include "../../maths.hpp"
+#include "../../posix/except.hpp"
 #include "../../raii.hpp"
 #include "../../random.hpp"
+#include "../system.hpp"
 
 #include <unistd.h>
 #include <sys/mman.h>
@@ -84,14 +84,14 @@ circular::circular (size_t bytes)
 
     // embiggen to the desired size
     if (ftruncate (fd, bytes))
-        errno_error::throw_code ();
+        posix::error::throw_code ();
 
     // pre-allocate a sufficiently large virtual memory block. it doesn't
     // matter much what flags we use because we'll just be overwriting it
     // shortly.
     m_begin = reinterpret_cast<char*> (mmap (nullptr, bytes * 2, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0));
     if (MAP_FAILED == m_begin)
-        errno_error::throw_code ();
+        posix::error::throw_code ();
 
     // preemptively setup an unmapping object in case the remapping fails
     util::scoped_function unmapper ([this, bytes] (void) { munmap (m_begin, bytes); });
@@ -105,7 +105,7 @@ circular::circular (size_t bytes)
     m_end   = reinterpret_cast<char*> (mmap (m_begin + bytes, bytes, prot, flag, fd, 0));
 
     if (m_begin == MAP_FAILED || m_end == MAP_FAILED)
-        errno_error::throw_code ();
+        posix::error::throw_code ();
 
     // all went well, disarm the failsafe
     unmapper.clear ();
diff --git a/memory/buffer/paged.cpp b/memory/buffer/paged.cpp
index 2494a978..28bc141f 100644
--- a/memory/buffer/paged.cpp
+++ b/memory/buffer/paged.cpp
@@ -16,11 +16,11 @@
 
 #include "paged.hpp"
 
-#include "../system.hpp"
-#include "../../except.hpp"
+#include "../../cast.hpp"
 #include "../../maths.hpp"
 #include "../../pointer.hpp"
-#include "../../cast.hpp"
+#include "../../posix/except.hpp"
+#include "../system.hpp"
 
 #include <sys/mman.h>
 
@@ -37,7 +37,7 @@ paged::paged (size_t bytes, size_t _window):
     );
 
     if (m_begin == MAP_FAILED)
-        errno_error::throw_code ();
+        posix::error::throw_code ();
 
     // remap the initial window with read/write permissions
     m_cursor = m_begin + round_up (min (m_window, bytes), pagesize ());
@@ -45,7 +45,7 @@ paged::paged (size_t bytes, size_t _window):
                             m_cursor - m_begin,
                             PROT_READ | PROT_WRITE,
                             MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0))
-        errno_error::throw_code ();
+        posix::error::throw_code ();
 
     // record the nominal end address
     m_end = m_begin + round_up (bytes, pagesize ());
@@ -110,7 +110,7 @@ paged::commit (char *cursor)
                             PROT_READ | PROT_WRITE,
                             MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS,
                             -1, 0))
-        errno_error::throw_code ();
+        posix::error::throw_code ();
 
     m_cursor = cursor;
 }
@@ -137,7 +137,7 @@ paged::release (char *desired)
                             PROT_NONE,
                             MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS,
                             -1, 0))
-        errno_error::throw_code ();
+        posix::error::throw_code ();
 
     m_cursor = desired;
 }
diff --git a/memory/system.cpp b/memory/system.cpp
index acf4eefb..dcd365af 100644
--- a/memory/system.cpp
+++ b/memory/system.cpp
@@ -16,8 +16,8 @@
 
 #include "system.hpp"
 
-#include "../except.hpp"
 #include "../cast.hpp"
+#include "../posix/except.hpp"
 
 #include <unistd.h>
 
@@ -28,11 +28,7 @@ util::memory::pagesize (void)
     static size_t val;
 
     if (!val) {
-        auto res = sysconf (_SC_PAGE_SIZE);
-        if (res == -1)
-            errno_error::throw_code ();
-
-        val = sign_cast<unsigned long> (res);
+        val = sign_cast<unsigned long> (posix::error::try_value (sysconf (_SC_PAGE_SIZE)));
     }
 
     return val;
diff --git a/posix/dir.cpp b/posix/dir.cpp
index e8e3fce6..36f37570 100644
--- a/posix/dir.cpp
+++ b/posix/dir.cpp
@@ -16,7 +16,7 @@
 
 #include "dir.hpp"
 
-#include "../except.hpp"
+#include "except.hpp"
 
 using util::posix::dir;
 
@@ -26,14 +26,14 @@ dir::dir (const std::experimental::filesystem::path &p):
     m_handle (::opendir (p.c_str ()))
 {
     if (!m_handle)
-        errno_error::throw_code ();
+        error::throw_code ();
 }
 
 
 //-----------------------------------------------------------------------------
 dir::~dir ()
 {
-    errno_error::try_code (closedir (m_handle));
+    error::try_code (closedir (m_handle));
 }
 
 
diff --git a/posix/dir.ipp b/posix/dir.ipp
index 80508cfd..a2e05053 100644
--- a/posix/dir.ipp
+++ b/posix/dir.ipp
@@ -14,7 +14,7 @@
  * Copyright 2015-2016 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "../except.hpp"
+#include "except.hpp"
 
 #include <cerrno>
 
@@ -29,7 +29,7 @@ util::posix::dir::scan(std::function<void(const std::experimental::filesystem::p
     for (dirent *cursor; errno = 0, cursor = readdir (m_handle); )
         cb (cursor->d_name, args...);
 
-    errno_error::try_code ();
+    error::try_code ();
 }
 
 
@@ -43,5 +43,5 @@ util::posix::dir::scan (void (*cb) (const std::experimental::filesystem::path&,
     for (dirent *cursor; errno = 0, cursor = readdir (m_handle); )
         cb (cursor->d_name, args...);
 
-    errno_error::try_code ();
+    error::try_code ();
 }
diff --git a/posix/fd.cpp b/posix/fd.cpp
index 9bee1779..8bfa6427 100644
--- a/posix/fd.cpp
+++ b/posix/fd.cpp
@@ -16,7 +16,7 @@
 
 #include "fd.hpp"
 
-#include "../except.hpp"
+#include "except.hpp"
 
 #include <sys/stat.h>
 #include <fcntl.h>
@@ -36,7 +36,7 @@ fd::fd (const std::experimental::filesystem::path &path, int flags, mode_t mode)
     m_fd (::open (path.c_str (), flags, mode))
 {
     if (m_fd < 0)
-        errno_error::throw_code ();
+        error::throw_code ();
 }
 
 
@@ -68,7 +68,7 @@ fd::dup (int _fd)
 {
     auto res = ::dup (_fd);
     if (res < 0)
-        errno_error::throw_code ();
+        error::throw_code ();
 
     return fd (res);
 }
@@ -81,7 +81,7 @@ fd::~fd ()
         return;
 
     if (close (m_fd))
-        errno_error::throw_code ();
+        error::throw_code ();
 }
 
 
@@ -91,7 +91,7 @@ fd::stat (void) const
 {
     struct stat buf;
     if (fstat (m_fd, &buf))
-        errno_error::throw_code ();
+        error::throw_code ();
     return buf;
 }
 
@@ -102,7 +102,7 @@ fd::read (void *buffer, size_t count)
 {
     auto res = ::read (m_fd, buffer, count);
     if (res == -1)
-        errno_error::throw_code ();
+        error::throw_code ();
     return res;
 }
 
@@ -112,7 +112,7 @@ fd::write (const void *buffer, size_t count)
 {
     auto res = ::write (m_fd, buffer, count);
     if (res == -1)
-        errno_error::throw_code ();
+        error::throw_code ();
     return res;
 }
 
@@ -123,7 +123,7 @@ fd::lseek (off_t offset, int whence)
 {
     auto res = ::lseek (m_fd, offset, whence);
     if (res == -1)
-        errno_error::throw_code ();
+        error::throw_code ();
     return res;
 }
 
diff --git a/posix/map.cpp b/posix/map.cpp
index 5fe86c21..c5da1d11 100644
--- a/posix/map.cpp
+++ b/posix/map.cpp
@@ -16,7 +16,7 @@
 
 #include "map.hpp"
 
-#include "../except.hpp"
+#include "posix/except.hpp"
 
 using util::posix::map;
 
@@ -27,7 +27,7 @@ map::map (size_t size, int prot, int flags):
     m_size (size)
 {
     if (MAP_FAILED == m_addr)
-        ::util::errno_error::throw_code ();
+        ::util::posix::error::throw_code ();
 }
 
 
@@ -37,7 +37,7 @@ map::map (size_t size, int prot, int flags, const fd &src, off_t offset):
     m_size (size)
 {
     if (MAP_FAILED == m_addr)
-        ::util::errno_error::throw_code ();
+        ::util::posix::error::throw_code ();
 }
 
 
@@ -57,7 +57,7 @@ map::~map ()
         return;
 
     if (munmap (m_addr, m_size))
-        ::util::errno_error::throw_code ();
+        ::util::posix::error::throw_code ();
 }
 
 
@@ -136,5 +136,5 @@ map::resize (size_t newsize, resize_t op)
 
     auto res = mremap (m_addr, m_size, newsize, flags);
     if (res == MAP_FAILED)
-        ::util::errno_error::throw_code ();
+        ::util::posix::error::throw_code ();
 }
diff --git a/win32/registry.cpp b/win32/registry.cpp
index 039ad346..b21c3b05 100644
--- a/win32/registry.cpp
+++ b/win32/registry.cpp
@@ -16,6 +16,7 @@
 
 #include "registry.hpp"
 
+#include "error.hpp"
 #include "../debug.hpp"
 #include "../except.hpp"
 
@@ -50,7 +51,7 @@ template <> constexpr DWORD restrict_to_id<std::string> (void) { return RRF_RT_R
 key::key (HKEY root, const char *child, REGSAM rights)
 {
     auto err = RegOpenKeyEx (root, child, 0, rights, &m_handle);
-    win32_error::try_code (err);
+    win32::error::try_code (err);
 }
 
 
@@ -58,7 +59,7 @@ key::key (HKEY root, const char *child, REGSAM rights)
 key::~key ()
 {
     auto err = RegCloseKey (m_handle);
-    win32_error::try_code (err);
+    win32::error::try_code (err);
 }
 
 
@@ -72,7 +73,7 @@ key::data (const char *name) const
     DWORD size = sizeof (value);
 
     auto err = RegGetValue (m_handle, name, &value, restrict_to_id<T> (), nullptr, &value, &size);
-    win32_error::try_code (err);
+    win32::error::try_code (err);
 
     return value;
 }
@@ -92,7 +93,7 @@ key::values (void) const
         if (ERROR_NO_MORE_ITEMS == err)
             return all;
         if (ERROR_SUCCESS != err)
-            win32_error::throw_code (err);
+            win32::error::throw_code (err);
 
         CHECK_GT (size, 0u);
         name.resize (size - 1);

From c22a5a2a078a91fc858e6d5a0a9d14c538576ea6 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Mon, 18 Dec 2017 15:57:43 +1100
Subject: [PATCH 13/56] posix/fd: prefer error::try_value over explicit checks

---
 posix/fd.cpp | 39 +++++++++++++++------------------------
 1 file changed, 15 insertions(+), 24 deletions(-)

diff --git a/posix/fd.cpp b/posix/fd.cpp
index 8bfa6427..c322b77a 100644
--- a/posix/fd.cpp
+++ b/posix/fd.cpp
@@ -33,11 +33,8 @@ fd::fd (const std::experimental::filesystem::path &path, int flags):
 
 //-----------------------------------------------------------------------------
 fd::fd (const std::experimental::filesystem::path &path, int flags, mode_t mode):
-    m_fd (::open (path.c_str (), flags, mode))
-{
-    if (m_fd < 0)
-        error::throw_code ();
-}
+    m_fd (error::try_value (::open (path.c_str (), flags, mode)))
+{ ; }
 
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -66,11 +63,9 @@ fd::dup (void) const
 fd
 fd::dup (int _fd)
 {
-    auto res = ::dup (_fd);
-    if (res < 0)
-        error::throw_code ();
-
-    return fd (res);
+    return fd {
+        error::try_value (::dup (_fd))
+    };
 }
 
 
@@ -80,8 +75,7 @@ fd::~fd ()
     if (m_fd < 0)
         return;
 
-    if (close (m_fd))
-        error::throw_code ();
+    error::try_code (close (m_fd));
 }
 
 
@@ -100,20 +94,18 @@ fd::stat (void) const
 ssize_t
 fd::read (void *buffer, size_t count)
 {
-    auto res = ::read (m_fd, buffer, count);
-    if (res == -1)
-        error::throw_code ();
-    return res;
+    return error::try_value (
+        ::read (m_fd, buffer, count)
+    );
 }
 
 //-----------------------------------------------------------------------------
 ssize_t
 fd::write (const void *buffer, size_t count)
 {
-    auto res = ::write (m_fd, buffer, count);
-    if (res == -1)
-        error::throw_code ();
-    return res;
+    return error::try_value (
+        ::write (m_fd, buffer, count)
+    );
 }
 
 
@@ -121,10 +113,9 @@ fd::write (const void *buffer, size_t count)
 off_t
 fd::lseek (off_t offset, int whence)
 {
-    auto res = ::lseek (m_fd, offset, whence);
-    if (res == -1)
-        error::throw_code ();
-    return res;
+    return error::try_value (
+        ::lseek (m_fd, offset, whence)
+    );
 }
 
 

From abfc3c787865a394864eb250c9087ffb516615d6 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Mon, 18 Dec 2017 15:46:52 +1100
Subject: [PATCH 14/56] except: move posix/win32 exceptions to own units

---
 posix/except.cpp |  99 +++++++++++++++++++++++++++++++++++++++
 posix/except.hpp |  55 ++++++++++++++++++++++
 win32/except.cpp | 119 +++++++++++++++++++++++++++++++++++++++++++++++
 win32/except.hpp |  47 +++++++++++++++++++
 4 files changed, 320 insertions(+)
 create mode 100644 posix/except.cpp
 create mode 100644 posix/except.hpp
 create mode 100644 win32/except.cpp
 create mode 100644 win32/except.hpp

diff --git a/posix/except.cpp b/posix/except.cpp
new file mode 100644
index 00000000..40b73638
--- /dev/null
+++ b/posix/except.cpp
@@ -0,0 +1,99 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2010, 2017,
+ *     Danny Robson <danny@nerdcruft.net>
+ */
+
+#include "except.hpp"
+
+#include "../debug.hpp"
+
+#include <cstring>
+
+using util::posix::error;
+
+
+///////////////////////////////////////////////////////////////////////////////
+/// Construct an exception object from a given error value.
+///
+/// The error value MUST be an error at construction time.
+error::error (int _code):
+    std::runtime_error (::strerror (_code)),
+    m_code (_code)
+{
+    CHECK_NEQ (_code, 0);
+}
+
+
+///----------------------------------------------------------------------------
+/// Construct an exception object from the current value of errno.
+///
+/// errno MUST signal an error at construction time.
+error::error ():
+    error (last_code ())
+{
+    CHECK_NEQ (m_code, 0);
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+int
+error::last_code (void)
+{
+    return errno;
+}
+
+
+//-----------------------------------------------------------------------------
+int
+error::code (void) const
+{
+    return m_code;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+/// Throw an exception object if errno currently signals an error.
+void
+error::try_code (void)
+{
+    try_code (last_code ());
+}
+
+
+///----------------------------------------------------------------------------
+/// Throw an exception object if 'code' represents an error.
+void
+error::try_code (int code)
+{
+    if (__builtin_expect (code != 0, false))
+        throw error (code);
+}
+
+
+///----------------------------------------------------------------------------
+void
+error::throw_code (void)
+{
+    throw_code (last_code ());
+}
+
+
+///----------------------------------------------------------------------------
+void
+error::throw_code (int code)
+{
+    CHECK_NEQ (code, 0);
+    throw error (code);
+}
diff --git a/posix/except.hpp b/posix/except.hpp
new file mode 100644
index 00000000..a9a6ce8e
--- /dev/null
+++ b/posix/except.hpp
@@ -0,0 +1,55 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2010, 2017,
+ *     Danny Robson <danny@nerdcruft.net>
+ */
+
+#ifndef CRUFT_UTIL_POSIX_EXCEPT_HPP
+#define CRUFT_UTIL_POSIX_EXCEPT_HPP
+
+#include <stdexcept>
+
+namespace util::posix {
+    /// An exception class used for reporting errors signalled by errno.
+    ///
+    /// Ideally this would be named `errno' but that symbol is permitted to
+    /// be a macro and significantly complicates symbol resolution either way.
+    class error : public std::runtime_error {
+    public:
+        explicit error (int code);
+        error ();
+
+        int code (void) const;
+        static int last_code (void);
+
+        static void try_code (void);
+        static void try_code (int code);
+
+        static void throw_code [[gnu::noreturn]] (void);
+        static void throw_code [[gnu::noreturn]] (int code);
+
+        template <typename T>
+        static T try_value (T value)
+        {
+            if (value < 0)
+                throw_code ();
+            return value;
+        }
+
+    private:
+        int m_code;
+    };
+}
+
+#endif
diff --git a/win32/except.cpp b/win32/except.cpp
new file mode 100644
index 00000000..9b92673c
--- /dev/null
+++ b/win32/except.cpp
@@ -0,0 +1,119 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2010, 2017
+ *     Danny Robson <danny@nerdcruft.net>
+ */
+
+#include "except.hpp"
+
+#include "../debug.hpp"
+
+using util::win32::error;
+
+
+///////////////////////////////////////////////////////////////////////////////
+error::error (DWORD _code):
+    runtime_error (code_string (_code)),
+    m_code (_code)
+{
+    CHECK_NEQ (m_code, (DWORD)ERROR_SUCCESS);
+}
+
+
+//-----------------------------------------------------------------------------
+error::error (void):
+    error (last_code ())
+{ ; }
+
+
+///////////////////////////////////////////////////////////////////////////////
+DWORD
+error::code (void) const
+{
+    return m_code;
+}
+
+
+//-----------------------------------------------------------------------------
+DWORD
+error::last_code (void)
+{
+    return GetLastError ();
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+void
+error::try_code (void)
+{
+    try_code (last_code ());
+}
+
+
+//-----------------------------------------------------------------------------
+void
+error::try_code (DWORD id)
+{
+    if (__builtin_expect (id != ERROR_SUCCESS, false))
+        throw_code (id);
+}
+
+
+//-----------------------------------------------------------------------------
+void
+error::throw_code (void)
+{
+    throw_code (last_code ());
+}
+
+
+//-----------------------------------------------------------------------------
+void
+error::throw_code (DWORD code)
+{
+    CHECK_NEQ (code, (DWORD)ERROR_SUCCESS);
+    throw error (code);
+}
+
+
+//-----------------------------------------------------------------------------
+std::string
+error::code_string (void)
+{
+    return code_string (last_code ());
+}
+
+
+//-----------------------------------------------------------------------------
+std::string
+error::code_string (DWORD code)
+{
+    char message[256];
+
+    auto res = FormatMessage (
+        FORMAT_MESSAGE_FROM_SYSTEM,
+        NULL,
+        code,
+        MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
+        message,
+        std::size (message),
+        NULL
+    );
+
+    if (res == 0) {
+        error::throw_code ();
+    }
+
+    return std::string (message, message + res);
+}
diff --git a/win32/except.hpp b/win32/except.hpp
new file mode 100644
index 00000000..5d43ac82
--- /dev/null
+++ b/win32/except.hpp
@@ -0,0 +1,47 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2010, 2017
+ *     Danny Robson <danny@nerdcruft.net>
+ */
+
+#ifndef CRUFT_UTIL_WIN32_EXCEPT_HPP
+#define CRUFT_UTIL_WIN32_EXCEPT_HPP
+
+#include <stdexcept>
+#include <windows.h>
+
+namespace util::win32 {
+    class error : public std::runtime_error {
+    public:
+        explicit error (DWORD _code);
+        error ();
+
+        DWORD code (void) const;
+        static DWORD last_code (void);
+
+        static void try_code (void);
+        static void try_code (DWORD);
+
+        static void throw_code [[gnu::noreturn]] (void);
+        static void throw_code [[gnu::noreturn]] (DWORD);
+
+        static std::string code_string (void);
+        static std::string code_string (DWORD);
+
+    private:
+        DWORD m_code;
+    };
+}
+
+#endif

From e48aebb50354ea9bf04218ebcde9d5bd9e357718 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 19 Dec 2017 18:10:05 +1100
Subject: [PATCH 15/56] io: remove lvalue write function

writing arbitrary lvalues is incredibly dangerous if we don't have total
coverage of suitable overloads. eg, we have accidentally written string
objects to file descriptors.

instead we prefer byte/char views which the user can create as desired.
there's a little more cognitive overhead here, but it's substantially
less dangerous in casual usage.
---
 io.hpp | 14 +++++++++++---
 io.ipp |  9 ---------
 2 files changed, 11 insertions(+), 12 deletions(-)

diff --git a/io.hpp b/io.hpp
index 886f5988..f1e402d5 100644
--- a/io.hpp
+++ b/io.hpp
@@ -46,11 +46,19 @@ namespace util {
     //-------------------------------------------------------------------------
     void write (const posix::fd&, const void *restrict data, size_t bytes);
 
-    template <typename T>
-    void write (const posix::fd&, const T &data);
+    inline void
+    write (const posix::fd &dst, util::view<const char*> data)
+    {
+        write (dst, std::data (data), std::size (data));
+    }
+
 
     template <typename T>
-    void write (const posix::fd&, const T *restrict first, const T *restrict last);
+    void write (const posix::fd &_fd, const T &data)
+    {
+        return write (_fd, make_view (data));
+    }
+
 
     //-------------------------------------------------------------------------
     class indenter : public std::streambuf {
diff --git a/io.ipp b/io.ipp
index ab598bc0..0dc00ebb 100644
--- a/io.ipp
+++ b/io.ipp
@@ -23,15 +23,6 @@
 #endif
 
 namespace util {
-    //-------------------------------------------------------------------------
-    template <typename T>
-    void
-    write (const posix::fd &_fd, const T &data)
-    {
-        write (_fd, &data, sizeof (T));
-    }
-
-
     //-------------------------------------------------------------------------
     template <typename T>
     void

From bfcd63ec654e8705ac968befe53ca3a348a09c5b Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 19 Dec 2017 18:12:01 +1100
Subject: [PATCH 16/56] posix/fd: add read overloads that take char/byte views

---
 posix/fd.cpp |  9 +++++++++
 posix/fd.hpp | 11 +++++++++--
 2 files changed, 18 insertions(+), 2 deletions(-)

diff --git a/posix/fd.cpp b/posix/fd.cpp
index c322b77a..8044c8f2 100644
--- a/posix/fd.cpp
+++ b/posix/fd.cpp
@@ -99,8 +99,17 @@ fd::read (void *buffer, size_t count)
     );
 }
 
+
 //-----------------------------------------------------------------------------
 ssize_t
+fd::read (util::view<char *> dst)
+{
+    return read (std::data (dst), std::size (dst));
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+ssize_t
 fd::write (const void *buffer, size_t count)
 {
     return error::try_value (
diff --git a/posix/fd.hpp b/posix/fd.hpp
index 05e00cf2..3c1192c2 100644
--- a/posix/fd.hpp
+++ b/posix/fd.hpp
@@ -11,12 +11,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
- * Copyright 2016 Danny Robson <danny@nerdcruft.net>
+ * Copyright 2017 Danny Robson <danny@nerdcruft.net>
  */
 
 #ifndef __CRUFT_UTIL_POSIX_FD_HPP
 #define __CRUFT_UTIL_POSIX_FD_HPP
 
+#include "../view.hpp"
+
 #include <sys/types.h>
 #include <sys/stat.h>
 
@@ -52,8 +54,13 @@ namespace util::posix {
         struct ::stat stat (void) const;
 
         //---------------------------------------------------------------------
-        [[gnu::warn_unused_result]] ssize_t read  (      void *buf, size_t count);
+        [[gnu::warn_unused_result]] ssize_t read (void *buf, size_t count);
+        [[gnu::warn_unused_result]] ssize_t read (util::view<char*>);
+        [[gnu::warn_unused_result]] ssize_t read (util::view<std::byte*>);
+
         [[gnu::warn_unused_result]] ssize_t write (const void *buf, size_t count);
+        [[gnu::warn_unused_result]] ssize_t write (util::view<const char*>);
+        [[gnu::warn_unused_result]] ssize_t write (util::view<const std::byte*>);
 
         //---------------------------------------------------------------------
         [[gnu::warn_unused_result]] off_t lseek (off_t offset, int whence);

From 36902f1476f72c57cb27542fbba1138e27728265 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 19 Dec 2017 18:12:35 +1100
Subject: [PATCH 17/56] parse: add specialisation for int

---
 parse.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/parse.cpp b/parse.cpp
index 97b8e01a..7b00458a 100644
--- a/parse.cpp
+++ b/parse.cpp
@@ -84,3 +84,12 @@ C_PARSE(unsigned long long, i)
 C_PARSE(float, f)
 C_PARSE(double, f)
 C_PARSE(long double, f)
+
+
+template <>
+int
+util::parse<int> (util::view<const char*> str)
+{
+    auto intermediate = util::parse<long> (str);
+    return trunc_cast<int> (intermediate);
+}

From e61c4f6e988a96109e9d8a55e994ab6f44be3634 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 19 Dec 2017 18:13:03 +1100
Subject: [PATCH 18/56] view: add constructors from nullptr_t

---
 view.hpp | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

diff --git a/view.hpp b/view.hpp
index 371cc920..ae7efe39 100644
--- a/view.hpp
+++ b/view.hpp
@@ -56,13 +56,25 @@ namespace util {
         //---------------------------------------------------------------------
         // technically we could get away without explicitly defining a move
         // constructor here, but by nulling rhs we can more easily use this
-        // class as a base for unique owning pointers without exposing
-        // begin/end to them directly.
+        // class as a base for unique owning pointers without exposing the
+        // begin/end data members to them directly.
         constexpr view (view &&rhs) noexcept:
             view (std::move (rhs.m_begin), std::move (rhs.m_end))
         { ; }
 
 
+        //---------------------------------------------------------------------
+        // allow null construction of views where IteratorT is constructible
+        // from nullptr_t
+        //
+        // ideally we would avoid exposing this as it promotes use of nulls but
+        // it simplifies construction of views that are data members of classes
+        // when we may not immediately know the values we should contain.
+        constexpr view (std::nullptr_t) noexcept:
+            view {nullptr,nullptr}
+        { ; }
+
+
         //---------------------------------------------------------------------
         template <typename ContainerT>
         constexpr explicit

From 62d5dfcf648f3ea982331c7d83044070cde9ef5c Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 19 Dec 2017 18:13:32 +1100
Subject: [PATCH 19/56] view: add container/view equality operators

---
 view.hpp | 36 ++++++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)

diff --git a/view.hpp b/view.hpp
index ae7efe39..a5405c68 100644
--- a/view.hpp
+++ b/view.hpp
@@ -309,6 +309,42 @@ namespace util {
     }
 
 
+    //-------------------------------------------------------------------------
+    template <typename IteratorT, typename ContainerT>
+    constexpr bool
+    operator== (const ContainerT &a, const view<IteratorT> &b)
+    {
+        return make_view (a) == b;
+    }
+
+
+    //-------------------------------------------------------------------------
+    template <typename IteratorT, typename ContainerT>
+    constexpr bool
+    operator!= (const ContainerT &b, const view<IteratorT> &a)
+    {
+        return !(a == b);
+    }
+
+
+    //-------------------------------------------------------------------------
+    template <typename IteratorT, typename ContainerT>
+    constexpr bool
+    operator== (const view<IteratorT> &a, const ContainerT &b)
+    {
+        return a == make_view (b);
+    }
+
+
+    //-------------------------------------------------------------------------
+    template <typename IteratorT, typename ContainerT>
+    constexpr bool
+    operator!= (const view<IteratorT> &a, const ContainerT &b)
+    {
+        return !(a == b);
+    }
+
+
     //-------------------------------------------------------------------------
     // equality operations for string-like views against std::strings
     bool equal (const std::string&, view<const char*>);

From 17f1ca8f936e8346d4115877364bdb0af29e8336 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 19 Dec 2017 18:13:49 +1100
Subject: [PATCH 20/56] view: add char-view less-than operator

---
 view.hpp | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/view.hpp b/view.hpp
index a5405c68..647f36bd 100644
--- a/view.hpp
+++ b/view.hpp
@@ -345,6 +345,28 @@ namespace util {
     }
 
 
+    ///////////////////////////////////////////////////////////////////////////
+    /// a basic stringlike comparison operator that behaves as
+    /// std::string::compare would.
+    ///
+    /// provided so that the common case of stringlike views can be used in a
+    /// std::map and similar without a great deal of work.
+    inline bool
+    operator< (util::view<const char*> a, util::view<const char*> b)
+    {
+        const auto la = std::size (a);
+        const auto lb = std::size (b);
+
+        const auto res = strncmp (
+            std::data (a),
+            std::data (b),
+            util::min (la, lb)
+        );
+
+        return res < 0 || la < lb;
+    }
+
+
     //-------------------------------------------------------------------------
     // equality operations for string-like views against std::strings
     bool equal (const std::string&, view<const char*>);

From cd69bb684aa5cac3c5aef29d7b5bb54b6485297e Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Wed, 20 Dec 2017 12:29:40 +1100
Subject: [PATCH 21/56] json: use ragel optimisation flags

---
 CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 1252a745..e0d4dacb 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -26,7 +26,7 @@ endif()
 
 
 ###############################################################################
-RAGEL_TARGET(json-flat json/flat.cpp.rl ${CMAKE_CURRENT_BINARY_DIR}/json/flat.cpp)
+RAGEL_TARGET(json-flat json/flat.cpp.rl ${CMAKE_CURRENT_BINARY_DIR}/json/flat.cpp COMPILE_FLAGS -G2)
 RAGEL_TARGET(uri uri.cpp.rl ${CMAKE_CURRENT_BINARY_DIR}/uri.cpp)
 RAGEL_TARGET(version version.cpp.rl ${CMAKE_CURRENT_BINARY_DIR}/version.cpp)
 

From 202c22eee8cfe9dcd0aca428453c71eae4f895c6 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Wed, 20 Dec 2017 12:31:52 +1100
Subject: [PATCH 22/56] view: simplify logical comparator implementation

we remove some duplicate and specific logical comparator specialisations
and instead rely on a base view/view comparator implementation by way of
make_view.
---
 test/string.cpp |  2 +-
 test/uri.cpp    | 18 +++++-----
 test/view.cpp   | 39 +++++++++++++++++++---
 view.cpp        | 26 ---------------
 view.hpp        | 87 +++++++++++++++++++++----------------------------
 5 files changed, 81 insertions(+), 91 deletions(-)

diff --git a/test/string.cpp b/test/string.cpp
index 29050814..cce00832 100644
--- a/test/string.cpp
+++ b/test/string.cpp
@@ -30,7 +30,7 @@ main (int, char**)
     };
 
     for (const auto &[tok, expected]: util::zip (util::make_tokeniser (csv, ','), TESTS))
-        tap.expect (equal (tok, expected.value), "%s", expected.message);
+        tap.expect_eq (tok, expected.value, "%s", expected.message);
 
     return tap.status ();
 }
diff --git a/test/uri.cpp b/test/uri.cpp
index 7055c203..474b489a 100644
--- a/test/uri.cpp
+++ b/test/uri.cpp
@@ -144,15 +144,15 @@ main (void)
         tap.expect_nothrow ([t] (void) { util::uri foo (t.src); }, "nothrow parsing '%s'", t.src);
         util::uri u (t.src);
 
-        tap.expect (equal (u.scheme (), t.scheme), "scheme for '%s'", t.src);
-        tap.expect (equal (u.heirarchical (), t.hierarchical), "hierarchical for '%s'", t.src);
-        tap.expect (equal (u.authority (), t.authority), "authority for '%s'", t.src);
-        tap.expect (equal (u.host (), t.host), "host for '%s'", t.src);
-        tap.expect (equal (u.user (), t.user), "user for '%s'", t.src);
-        tap.expect (equal (u.port (), t.port), "port for '%s'", t.src);
-        tap.expect (equal (u.path (), t.path), "path for '%s'", t.src);
-        tap.expect (equal (u.query (), t.query), "query for '%s'", t.src);
-        tap.expect (equal (u.fragment (), t.fragment), "fragment for '%s'", t.src);
+        tap.expect_eq (u.scheme (), t.scheme, "scheme for '%s'", t.src);
+        tap.expect_eq (u.heirarchical (), t.hierarchical, "hierarchical for '%s'", t.src);
+        tap.expect_eq (u.authority (), t.authority, "authority for '%s'", t.src);
+        tap.expect_eq (u.host (), t.host, "host for '%s'", t.src);
+        tap.expect_eq (u.user (), t.user, "user for '%s'", t.src);
+        tap.expect_eq (u.port (), t.port, "port for '%s'", t.src);
+        tap.expect_eq (u.path (), t.path, "path for '%s'", t.src);
+        tap.expect_eq (u.query (), t.query, "query for '%s'", t.src);
+        tap.expect_eq (u.fragment (), t.fragment, "fragment for '%s'", t.src);
     }
 
     static const char* BAD[] = {
diff --git a/test/view.cpp b/test/view.cpp
index 72f9bf85..0e9d6266 100644
--- a/test/view.cpp
+++ b/test/view.cpp
@@ -1,6 +1,10 @@
 #include "tap.hpp"
 #include "view.hpp"
-    
+
+#include <algorithm>
+
+
+///////////////////////////////////////////////////////////////////////////////
 int
 main (int, char**)
 {
@@ -9,10 +13,35 @@ main (int, char**)
     const std::string s = "this is a test string";
     const std::string t = "not the same string";
 
-    tap.expect (equal (s, util::make_view(s)), "string/view equality");
-    tap.expect (!equal (s, util::make_view(t)), "string/view inequality");
-    tap.expect (equal (s.data (), util::make_view (s)), "c-str/view equality");
-    tap.expect (equal (s, util::view<const char*> (&*s.cbegin (), &*s.cend ())), "string/pointer-view equality");
+    tap.expect_eq  (s, util::make_view(s), "string/view equality");
+    tap.expect_neq (s, util::make_view(t), "string/view inequality");
+    tap.expect_eq  (s.data (), util::make_view (s), "c-str/view equality");
+    tap.expect_eq  (
+        s,
+        util::view<const char*> (&*s.cbegin (), &*s.cend ()),
+        "string/pointer-view equality");
+
+    {
+        // comparator tests
+        static const struct {
+            util::view<const char*> a;
+            util::view<const char*> b;
+            bool less;
+        } TESTS[] = {
+            { "b", "b", false },
+            { "b", "a", false },
+            { "b", "c", true  },
+            { "foo", "bar", false },
+            { "bar", "foo", true },
+            { "banana", "banana", false },
+            { "banana", "banan",  false },
+            { "banan",  "banana", true  },
+        };
+
+        tap.expect (std::all_of (std::begin (TESTS), std::end (TESTS), [] (const auto &x) {
+            return (x.a < x.b) == x.less;
+        }), "comparator less-than");
+    };
 
     return tap.status ();
 }
diff --git a/view.cpp b/view.cpp
index 2ae62997..82464485 100644
--- a/view.cpp
+++ b/view.cpp
@@ -20,32 +20,6 @@
 #include <iterator>
 
 
-///////////////////////////////////////////////////////////////////////////////
-#define EQUALITY(A,B)                   \
-bool                                    \
-util::equal (A a, B b)                  \
-{                                       \
-    return a.size () == b.size () &&    \
-           std::equal (a.cbegin (),     \
-                       a.cend (),       \
-                       b.cbegin ());    \
-}
-
-
-//-----------------------------------------------------------------------------
-EQUALITY(const std::string&, view<const char*>)
-EQUALITY(const std::string&, view<char*>)
-EQUALITY(const std::string&, view<std::string::const_iterator>)
-EQUALITY(const std::string&, view<std::string::iterator>)
-
-EQUALITY(view<const char*>,  const std::string&)
-EQUALITY(view<char*>,        const std::string&)
-EQUALITY(view<std::string::const_iterator>, const std::string&)
-EQUALITY(view<std::string::iterator>, const std::string&)
-
-#undef EQUALITY
-
-
 ///////////////////////////////////////////////////////////////////////////////
 namespace util {
 #define OSTREAM(A)                                                          \
diff --git a/view.hpp b/view.hpp
index 647f36bd..8bcad97a 100644
--- a/view.hpp
+++ b/view.hpp
@@ -46,6 +46,12 @@ namespace util {
         { ; }
 
 
+        //---------------------------------------------------------------------
+        template <std::size_t N, typename ValueT>
+        view (const ValueT(&value)[N]):
+            view (std::begin (value), std::end (value))
+        { ; }
+
         //---------------------------------------------------------------------
         constexpr
         view (const view &rhs) noexcept:
@@ -291,55 +297,50 @@ namespace util {
 
 
     ///////////////////////////////////////////////////////////////////////////
-    template <typename IteratorT>
+    template <typename IteratorA, typename IteratorB>
     constexpr bool
-    operator== (const view<IteratorT> &a, const view<IteratorT> &b)
+    operator== (const view<IteratorA> &a, const view<IteratorB> &b)
     {
-        return std::cbegin (a) == std::cbegin (b) &&
-               std::cend   (a) == std::cend   (b);
+        return a.size () == b.size () &&
+               std::equal (std::begin (a), std::end (a), std::begin (b));
     }
 
 
     //-------------------------------------------------------------------------
-    template <typename IteratorT>
+    // defer equality to the view/view operator by way of make_view
+    template <typename IteratorT, typename ValueT>
     constexpr bool
-    operator!= (const view<IteratorT> &a, const view<IteratorT> &b)
-    {
-        return !(a == b);
-    }
-
-
-    //-------------------------------------------------------------------------
-    template <typename IteratorT, typename ContainerT>
-    constexpr bool
-    operator== (const ContainerT &a, const view<IteratorT> &b)
-    {
-        return make_view (a) == b;
-    }
-
-
-    //-------------------------------------------------------------------------
-    template <typename IteratorT, typename ContainerT>
-    constexpr bool
-    operator!= (const ContainerT &b, const view<IteratorT> &a)
-    {
-        return !(a == b);
-    }
-
-
-    //-------------------------------------------------------------------------
-    template <typename IteratorT, typename ContainerT>
-    constexpr bool
-    operator== (const view<IteratorT> &a, const ContainerT &b)
+    operator== (const view<IteratorT> &a, const ValueT &b)
     {
         return a == make_view (b);
     }
 
 
     //-------------------------------------------------------------------------
-    template <typename IteratorT, typename ContainerT>
+    // reverse the arguments and forward to the above operator. we formumlate
+    // equality this way to avoid implementing the operator twice for each
+    // weird case.
+    template <typename IteratorT, typename ValueT>
     constexpr bool
-    operator!= (const view<IteratorT> &a, const ContainerT &b)
+    operator== (const ValueT &a, const view<IteratorT> &b)
+    {
+        return b == a;
+    }
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename IteratorT, typename ValueT>
+    constexpr bool
+    operator!= (const util::view<IteratorT> &a, const ValueT &b)
+    {
+        return !(a == b);
+    }
+
+
+    //-------------------------------------------------------------------------
+    template <typename IteratorT, typename ValueT>
+    constexpr bool
+    operator!= (const ValueT &a, const util::view<IteratorT> &b)
     {
         return !(a == b);
     }
@@ -363,24 +364,10 @@ namespace util {
             util::min (la, lb)
         );
 
-        return res < 0 || la < lb;
+        return res < 0 || (res == 0 && la < lb);
     }
 
 
-    //-------------------------------------------------------------------------
-    // equality operations for string-like views against std::strings
-    bool equal (const std::string&, view<const char*>);
-    bool equal (const std::string&, view<char*>);
-    bool equal (const std::string&, view<std::string::const_iterator>);
-    bool equal (const std::string&, view<std::string::iterator>);
-
-
-    bool equal (view<const char*>,                 const std::string&);
-    bool equal (view<char*>,                       const std::string&);
-    bool equal (view<std::string::const_iterator>, const std::string&);
-    bool equal (view<std::string::iterator>,       const std::string&);
-
-
     ///////////////////////////////////////////////////////////////////////////
     template <typename IteratorT>
     std::ostream&

From d0d5ae549e4811ed2ed274edc722bf591a567e28 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Wed, 20 Dec 2017 12:45:05 +1100
Subject: [PATCH 23/56] uri: extract grammar into contained ragel file

this will allow us to reference the grammar from other grammars, eg http
parsing.
---
 CMakeLists.txt |   2 +-
 abnf.rl        |  67 +++++++++++++++++++++++
 rfc3986.rl     | 140 +++++++++++++++++++++++++++++++++++++++++++++++++
 uri.cpp.rl     | 114 ++--------------------------------------
 4 files changed, 213 insertions(+), 110 deletions(-)
 create mode 100644 abnf.rl
 create mode 100644 rfc3986.rl

diff --git a/CMakeLists.txt b/CMakeLists.txt
index e0d4dacb..87c0a627 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -27,7 +27,7 @@ endif()
 
 ###############################################################################
 RAGEL_TARGET(json-flat json/flat.cpp.rl ${CMAKE_CURRENT_BINARY_DIR}/json/flat.cpp COMPILE_FLAGS -G2)
-RAGEL_TARGET(uri uri.cpp.rl ${CMAKE_CURRENT_BINARY_DIR}/uri.cpp)
+RAGEL_TARGET(uri uri.cpp.rl ${CMAKE_CURRENT_BINARY_DIR}/uri.cpp COMPILE_FLAGS -G2)
 RAGEL_TARGET(version version.cpp.rl ${CMAKE_CURRENT_BINARY_DIR}/version.cpp)
 
 
diff --git a/abnf.rl b/abnf.rl
new file mode 100644
index 00000000..86903cdc
--- /dev/null
+++ b/abnf.rl
@@ -0,0 +1,67 @@
+void foo (void) { }
+
+%%{
+
+machine rfc5234;
+
+###############################################################################
+# RFC5234 ABNF core rules
+
+# ; A-Z / a-z
+ALPHA =  0x41..0x5A | 0x61..0x7A;
+BIT   =  '0' | '1';
+
+# any 7-bit US-ASCII character, excluding NUL
+CHAR  = 0x01..0x7F;
+
+# carriage return
+CR = 0x0D;
+
+# linefeed
+LF = 0x0A;
+
+# Internet standard newline
+CRLF = CR LF;
+
+# controls
+CTL = 0x00..0x1F | 0x7F;
+
+# 0-9
+DIGIT = 0x30..0x39;
+
+# " (Double Quote)
+DQUOTE = 0x22;
+
+HEXDIG = DIGIT | 'A'..'F';
+
+# horizontal tab
+HTAB = 0x09;
+
+SP = 0x20;
+
+# white space
+WSP =  SP | HTAB;
+
+# Use of this linear-white-space rule permits lines containing only white space
+# that are no longer legal in mail headers and have caused interoperability
+# problems in other contexts.
+#
+# Do not use when defining mail headers and use with caution in other contexts.
+LWSP = (WSP | CRLF WSP)*;
+
+# 8 bits of data
+OCTET = any; #0x00..0xFF;
+
+# visible (printing) characters
+VCHAR = 0x21..0x7E;
+
+    write data;
+
+}%%
+
+int main () {
+
+
+    %%write init;
+    %%write exec;
+}
diff --git a/rfc3986.rl b/rfc3986.rl
new file mode 100644
index 00000000..c11abd0f
--- /dev/null
+++ b/rfc3986.rl
@@ -0,0 +1,140 @@
+%%{
+    machine rfc3986;
+
+    #action trace;
+    #action success;
+    #action failure;
+
+    #action scheme_begin;
+    #action scheme_end;
+    #action hier_begin;
+    #action hier_end;
+    #action user_begin;
+    #action user_end;
+    #action host_begin;
+    #action host_end;
+    #action port_begin;
+    #action port_end;
+    #action authority_begin;
+    #action authority_end;
+    #action path_begin;
+    #action path_end;
+    #action query_begin;
+    #action query_end;
+    #action fragment_begin;
+    #action fragment_end;
+
+    #action uri_begin;
+    #action uri_end;
+
+    ## Characters
+    unreserved = alpha | digit | "-" | "." | "_" | "~";
+    pct_encoded = '%' xdigit xdigit;
+    gen_delim = ":" | "/" | "?" | "#" | "[" | "]" | "@";
+    sub_delim = "!" | "$" | "&" | "'" | "(" | ")" | "*" | "+" | "," | ";" | "=";
+    pchar = unreserved | pct_encoded | sub_delim | ':' | '@';
+
+    ## Atoms
+    reg_name = (unreserved | pct_encoded | sub_delim)*;
+
+    ## IP-address
+    ## Note: The address grammar is embedded in the RFC so we embed it too
+    dec_octet = digit | [1-9] digit | '1' digit{2} | '2' [0-4] digit | '25' [0-5];
+
+    ipv4address = dec_octet '.' dec_octet '.' dec_octet '.' dec_octet;
+
+    h16  =  xdigit{1,4};
+    ls32 = (h16 ":" h16) | ipv4address;
+
+    ipv6address =
+                                      (h16 ":"){6} ls32
+        |                        "::" (h16 ":"){5} ls32
+        | (                h16)? "::" (h16 ":"){4} ls32
+        | ((h16 ":"){0,1}  h16)? "::" (h16 ":"){3} ls32
+        | ((h16 ":"){0,2}  h16)? "::" (h16 ":"){2} ls32
+        | ((h16 ":"){0,3}  h16)? "::" (h16 ":"){1} ls32
+        | ((h16 ":"){0,4}  h16)? "::"              ls32
+        | ((h16 ":"){0,5}  h16)? "::"              h16
+        | ((h16 ":"){0,6}  h16)? "::"
+    ;
+
+    ipvfuture = 'v' xdigit{1,} '.' (unreserved | sub_delim | ':'){1,};
+    ip_literal = '[' (ipv6address | ipvfuture) ']';
+
+    ## Segments
+    segment = pchar*;
+    segment_nz = pchar{1,};
+    segment_nz_nc = (unreserved | pct_encoded | sub_delim | '@'){1,};
+
+    ## Paths
+    path_abempty = ('/' segment)*;
+    path_absolute = '/' (segment_nz ('/' segment)*)?;
+    path_noscheme = segment_nz_nc ('/' segment)*;
+    path_rootless = segment_nz ('/' segment)*;
+    path_empty = '0' pchar;
+
+    path = (
+        path_abempty | path_absolute | path_noscheme | path_rootless | path_empty
+    );
+
+    reserved = gen_delim | sub_delim;
+
+    ## Authority
+    port = (
+        digit*
+    ) >port_begin %port_end;
+
+    host = (
+        ip_literal | ipv4address | reg_name
+    ) >host_begin %host_end;
+
+    userinfo = (
+        (unreserved | pct_encoded | sub_delim | ':')*
+    ) >user_begin %user_end;
+
+    authority = (
+        (userinfo '@')? host (':' port)?
+    ) >authority_begin %authority_end;
+
+
+    ## URI components
+    scheme = (
+        alpha (alpha | digit | '+' | '-' | '.')*
+    ) >scheme_begin %scheme_end;
+
+    query = (
+        (pchar | '/' | '?')*
+    ) >query_begin %query_end;
+
+    fragment = (
+        (pchar | '/' | '?')*
+    ) >fragment_begin %fragment_end;
+
+    ## URI types
+    hier_part = (
+          '//' (authority path_abempty  >path_begin %path_end) >hier_begin %hier_end
+    ) | (
+          path_absolute  >path_begin %path_end
+        | path_rootless  >path_begin %path_end
+        | path_empty     >path_begin %path_end
+    ) >hier_begin %hier_end;
+
+    uri = scheme ':' hier_part ('?' query)? ('#' fragment);
+
+    relative_part =
+          '//' authority path_abempty  >path_begin %path_end
+        | path_absolute  >path_begin %path_end
+        | path_noscheme  >path_begin %path_end
+        | path_empty     >path_begin %path_end
+    ;
+
+    relative_ref = relative_part ('?' query)? ('#' fragment);
+
+    uri_reference = uri | relative_ref;
+
+    absolute_uri = scheme ':' hier_part ('?' query)?;
+
+    URI = (
+        absolute_uri | uri_reference
+    ) >uri_begin %uri_end;
+}%%
diff --git a/uri.cpp.rl b/uri.cpp.rl
index a60f6f3c..a7485727 100644
--- a/uri.cpp.rl
+++ b/uri.cpp.rl
@@ -27,7 +27,7 @@
 
 
 %%{
-    machine uri;
+    machine impl;
 
     action trace { if (0) std::cerr << *p; }
     action success {__success = true; }
@@ -60,116 +60,12 @@
     action fragment_begin { m_views[FRAGMENT] = { p, p}; }
     action fragment_end   { m_views[FRAGMENT] = { m_views[FRAGMENT].begin (), p }; }
 
-    ## Characters
-    unreserved = alpha | digit | "-" | "." | "_" | "~";
-    pct_encoded = '%' xdigit xdigit;
-    gen_delim = ":" | "/" | "?" | "#" | "[" | "]" | "@";
-    sub_delim = "!" | "$" | "&" | "'" | "(" | ")" | "*" | "+" | "," | ";" | "=";
-    pchar = unreserved | pct_encoded | sub_delim | ':' | '@';
+    action uri_begin {}
+    action uri_end {}
 
-    ## Atoms
-    reg_name = (unreserved | pct_encoded | sub_delim)*;
+    include rfc3986 'rfc3986.rl';
 
-    ## IP-address
-    ## Note: The address grammar is embedded in the RFC so we embed it too
-    dec_octet = digit | [1-9] digit | '1' digit{2} | '2' [0-4] digit | '25' [0-5];
-
-    ipv4address = dec_octet '.' dec_octet '.' dec_octet '.' dec_octet;
-
-    h16  =  xdigit{1,4};
-    ls32 = (h16 ":" h16) | ipv4address;
-
-    ipv6address =
-                                      (h16 ":"){6} ls32
-        |                        "::" (h16 ":"){5} ls32
-        | (                h16)? "::" (h16 ":"){4} ls32
-        | ((h16 ":"){0,1}  h16)? "::" (h16 ":"){3} ls32
-        | ((h16 ":"){0,2}  h16)? "::" (h16 ":"){2} ls32
-        | ((h16 ":"){0,3}  h16)? "::" (h16 ":"){1} ls32
-        | ((h16 ":"){0,4}  h16)? "::"              ls32
-        | ((h16 ":"){0,5}  h16)? "::"              h16
-        | ((h16 ":"){0,6}  h16)? "::"
-    ;
-
-    ipvfuture = 'v' xdigit{1,} '.' (unreserved | sub_delim | ':'){1,};
-    ip_literal = '[' (ipv6address | ipvfuture) ']';
-
-    ## Segments
-    segment = pchar*;
-    segment_nz = pchar{1,};
-    segment_nz_nc = (unreserved | pct_encoded | sub_delim | '@'){1,};
-
-    ## Paths
-    path_abempty = ('/' segment)*;
-    path_absolute = '/' (segment_nz ('/' segment)*)?;
-    path_noscheme = segment_nz_nc ('/' segment)*;
-    path_rootless = segment_nz ('/' segment)*;
-    path_empty = '0' pchar;
-
-    path = (
-        path_abempty | path_absolute | path_noscheme | path_rootless | path_empty
-    );
-
-    reserved = gen_delim | sub_delim;
-
-    ## Authority
-    port = (
-        digit*
-    ) >port_begin %port_end;
-
-    host = (
-        ip_literal | ipv4address | reg_name
-    ) >host_begin %host_end;
-
-    userinfo = (
-        (unreserved | pct_encoded | sub_delim | ':')*
-    ) >user_begin %user_end;
-
-    authority = (
-        (userinfo '@')? host (':' port)?
-    ) >authority_begin %authority_end;
-
-
-    ## URI components
-    scheme = (
-        alpha (alpha | digit | '+' | '-' | '.')*
-    ) >scheme_begin %scheme_end;
-
-    query = (
-        (pchar | '/' | '?')*
-    ) >query_begin %query_end;
-
-    fragment = (
-        (pchar | '/' | '?')*
-    ) >fragment_begin %fragment_end;
-
-    ## URI types
-    hier_part = (
-          '//' (authority path_abempty  >path_begin %path_end) >hier_begin %hier_end
-    ) | (
-          path_absolute  >path_begin %path_end
-        | path_rootless  >path_begin %path_end
-        | path_empty     >path_begin %path_end
-    ) >hier_begin %hier_end;
-
-    uri = scheme ':' hier_part ('?' query)? ('#' fragment);
-
-    relative_part = 
-          '//' authority path_abempty  >path_begin %path_end
-        | path_absolute  >path_begin %path_end
-        | path_noscheme  >path_begin %path_end
-        | path_empty     >path_begin %path_end
-    ;
-
-    relative_ref = relative_part ('?' query)? ('#' fragment);
-
-    uri_reference = uri | relative_ref;
-
-    absolute_uri = scheme ':' hier_part ('?' query)?;
-
-    URI := (
-        absolute_uri | uri_reference
-    )
+    impl := URI
     %success
     $!failure
     $trace;

From cfe1185621c42a08c9a9dcc050f0d784054c5722 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Fri, 22 Dec 2017 12:33:29 +1100
Subject: [PATCH 24/56] maths: move log2 into header for constexpr

---
 maths.cpp | 21 ---------------------
 maths.hpp | 11 +++++++++--
 2 files changed, 9 insertions(+), 23 deletions(-)

diff --git a/maths.cpp b/maths.cpp
index ec39ea19..cc3493e3 100644
--- a/maths.cpp
+++ b/maths.cpp
@@ -31,27 +31,6 @@ template uint32_t util::log2up (uint32_t);
 template uint64_t util::log2up (uint64_t);
 
 
-///////////////////////////////////////////////////////////////////////////////
-template <typename T>
-T
-util::log2 (T v)
-{
-    static_assert (std::is_integral<T>::value,
-                   "log2 is only implemented for integers");
-
-    T l = 0;
-    while (v >>= 1)
-        ++l;
-
-    return l;
-}
-
-template uint8_t  util::log2 (uint8_t);
-template uint16_t util::log2 (uint16_t);
-template uint32_t util::log2 (uint32_t);
-template uint64_t util::log2 (uint64_t);
-
-
 ///////////////////////////////////////////////////////////////////////////////
 template const float  util::PI<float>;
 template const double util::PI<double>;
diff --git a/maths.hpp b/maths.hpp
index d6aa3f19..24ad136b 100644
--- a/maths.hpp
+++ b/maths.hpp
@@ -242,8 +242,15 @@ namespace util {
     //-----------------------------------------------------------------------------
     // Logarithms
     template <typename T>
-    T
-    log2  (T val);
+    constexpr
+    std::enable_if_t<std::is_integral_v<T>, T>
+    log2 (T val)
+    {
+        T tally = 0;
+        while (val >>= 1)
+            ++tally;
+        return tally;
+    }
 
 
     //-------------------------------------------------------------------------

From 8d317fd41e586882d594b955821e7f79a110781a Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Fri, 22 Dec 2017 12:34:25 +1100
Subject: [PATCH 25/56] view: allow multiple iterator types

---
 view.hpp | 32 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/view.hpp b/view.hpp
index 8bcad97a..263e6afd 100644
--- a/view.hpp
+++ b/view.hpp
@@ -29,18 +29,18 @@
 #include <stdexcept>
 
 namespace util {
-    template <typename IteratorT>
+    template <typename IteratorA, typename IteratorB = IteratorA>
     struct view {
     public:
         //---------------------------------------------------------------------
         using value_type = typename std::iterator_traits<
-            remove_restrict_t<IteratorT>
+            remove_restrict_t<IteratorA>
         >::value_type;
 
 
         //---------------------------------------------------------------------
         constexpr
-        view (const IteratorT &first, const IteratorT &last) noexcept:
+        view (const IteratorA &first, const IteratorB &last) noexcept:
             m_begin (first),
             m_end   (last)
         { ; }
@@ -114,24 +114,24 @@ namespace util {
             m_begin = rhs.m_begin;
             m_end = rhs.m_end;
 
-            rhs.m_begin = IteratorT{};
-            rhs.m_end = IteratorT{};
+            rhs.m_begin = IteratorA{};
+            rhs.m_end = IteratorB{};
 
             return *this;
         };
 
 
         ///////////////////////////////////////////////////////////////////////
-        constexpr IteratorT begin (void) noexcept { return m_begin; }
-        constexpr IteratorT end   (void) noexcept { return m_end;   }
+        constexpr IteratorA begin (void) noexcept { return m_begin; }
+        constexpr IteratorB end   (void) noexcept { return m_end;   }
 
         //---------------------------------------------------------------------
-        constexpr const IteratorT begin (void) const noexcept { return cbegin (); }
-        constexpr const IteratorT end   (void) const noexcept { return cend   (); }
+        constexpr const IteratorA begin (void) const noexcept { return cbegin (); }
+        constexpr const IteratorB end   (void) const noexcept { return cend   (); }
 
         //---------------------------------------------------------------------
-        constexpr const IteratorT cbegin (void) const noexcept { return m_begin; }
-        constexpr const IteratorT cend   (void) const noexcept { return m_end;   }
+        constexpr const IteratorA cbegin (void) const noexcept { return m_begin; }
+        constexpr const IteratorB cend   (void) const noexcept { return m_end;   }
 
         //---------------------------------------------------------------------
         auto data (void)       { return begin (); }
@@ -181,8 +181,8 @@ namespace util {
 
     private:
         ///////////////////////////////////////////////////////////////////////
-        IteratorT m_begin;
-        IteratorT m_end;
+        IteratorA m_begin;
+        IteratorB m_end;
     };
 
 
@@ -230,11 +230,11 @@ namespace util {
 
 
     //-------------------------------------------------------------------------
-    template <typename IteratorT>
+    template <typename IteratorA, typename IteratorB>
     auto
-    make_view (IteratorT first, IteratorT last)
+    make_view (IteratorA first, IteratorB last)
     {
-        return view<IteratorT> {first, last};
+        return view<IteratorA, IteratorB> {first, last};
     }
 
     //-------------------------------------------------------------------------

From 02d3b4dd6448245c9e0e9e5146671c1e25ab58b6 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Fri, 22 Dec 2017 12:34:56 +1100
Subject: [PATCH 26/56] iterator: add unequal_iterator

unequal_iterator is a forward iterator that never successfully compares
for equality with other types. useful as the end iterator when one has
an output iterator as the begin iterator of a view.
---
 iterator.hpp | 78 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 78 insertions(+)

diff --git a/iterator.hpp b/iterator.hpp
index c288e7af..0d4428e3 100644
--- a/iterator.hpp
+++ b/iterator.hpp
@@ -438,6 +438,84 @@ namespace util {
         discard_iterator  operator++ (int) { return *this; }
         discard_iterator& operator*  (   ) { return *this; }
     };
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    /// an iterator that can be infinitely incremented but never assigned.
+    ///
+    /// useful for iterator ranges where the begin iterator is an output
+    /// iterator and hence never reaches an end point (and where we don't want
+    /// to engineer the client code to account for this).
+    template <
+        typename ValueT,
+        typename CategoryT,
+        typename DistanceT,
+        typename PointerT,
+        typename ReferenceT
+    >
+    struct unequal_iterator {
+        using value_type = ValueT;
+        using iterator_category = CategoryT;
+        using difference_type = DistanceT;
+        using pointer = PointerT;
+        using reference = ReferenceT;
+
+        unequal_iterator& operator++ (   ) { return *this; }
+        unequal_iterator  operator++ (int) { return *this; }
+    };
+
+
+    //-------------------------------------------------------------------------
+    template <typename ContainerT>
+    auto
+    make_unequal_iterator (const ContainerT&)
+    {
+        using t = typename std::iterator_traits<typename ContainerT::iterator>;
+
+        return unequal_iterator<
+            typename t::value_type,
+            typename t::iterator_category,
+            typename t::difference_type,
+            typename t::pointer,
+            typename t::reference
+        > {};
+    };
+
+
+    //-------------------------------------------------------------------------
+    template <
+        typename OtherT,
+
+        typename ValueT,
+        typename CategoryT,
+        typename DistanceT,
+        typename PointerT,
+        typename ReferenceT>
+    constexpr bool
+    operator== (
+        const unequal_iterator<ValueT,CategoryT,DistanceT,PointerT,ReferenceT>&,
+        const OtherT&
+    ) {
+        return false;
+    }
+
+
+    //-------------------------------------------------------------------------
+    template <
+        typename OtherT,
+
+        typename ValueT,
+        typename CategoryT,
+        typename DistanceT,
+        typename PointerT,
+        typename ReferenceT>
+    constexpr bool
+    operator== (
+        const OtherT&,
+        const unequal_iterator<ValueT,CategoryT,DistanceT,PointerT,ReferenceT>&
+    ) {
+        return false;
+    }
 };
 
 #endif

From e43791374662d8c59a2bf5db70754a76eb777555 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Fri, 22 Dec 2017 12:37:04 +1100
Subject: [PATCH 27/56] encode/base: add initial base64 experiments

---
 CMakeLists.txt       |   3 +
 encode/base.cpp      |  18 ++++
 encode/base.hpp      | 247 +++++++++++++++++++++++++++++++++++++++++++
 test/encode/base.cpp |  91 ++++++++++++++++
 4 files changed, 359 insertions(+)
 create mode 100644 encode/base.cpp
 create mode 100644 encode/base.hpp
 create mode 100644 test/encode/base.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 87c0a627..69492a43 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -203,6 +203,8 @@ list (
     debug.cpp
     debug.hpp
     debug.ipp
+    encode/base.cpp
+    encode/base.hpp
     endian.cpp
     endian.hpp
     exe.hpp
@@ -498,6 +500,7 @@ if (TESTS)
         crypto/tea
         crypto/xtea
         crypto/xxtea
+        encode/base
         endian
         exe
         extent
diff --git a/encode/base.cpp b/encode/base.cpp
new file mode 100644
index 00000000..abbc2e79
--- /dev/null
+++ b/encode/base.cpp
@@ -0,0 +1,18 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2017 Danny Robson <danny@nerdcruft.net>
+ */
+
+#include "base.hpp"
+
diff --git a/encode/base.hpp b/encode/base.hpp
new file mode 100644
index 00000000..65c2c132
--- /dev/null
+++ b/encode/base.hpp
@@ -0,0 +1,247 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2017 Danny Robson <danny@nerdcruft.net>
+ */
+
+#ifndef CRUFT_UTIL_BASE64_HPP
+#define CRUFT_UTIL_BASE64_HPP
+
+#include "../view.hpp"
+
+#include "../debug.hpp"
+
+#include <cstdint>
+#include <array>
+
+
+namespace util::encode {
+    ///////////////////////////////////////////////////////////////////////////
+    template <int Size>
+    struct alphabet {
+        static const char enc[Size];
+        static const uint8_t dec[256];
+    };
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <>
+    const char alphabet<64>::enc[64] = {
+        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+        'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+        'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
+        'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/',
+    };
+
+
+    //-------------------------------------------------------------------------
+    template <>
+    const uint8_t alphabet<64>::dec[256] = {
+           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 0x3E,    0,    0,    0, 0x3F,
+        0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D,    0,    0,    0,    0,    0,    0,
+           0, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E,
+        0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19,    0,    0,    0,    0,    0,
+           0, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
+        0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33,    0,    0,    0,    0,    0,
+           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    };
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <>
+    const char alphabet<32>::enc[32] {
+        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+        'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+        '2', '3', '4', '5', '6', '7',
+    };
+
+
+    //-------------------------------------------------------------------------
+    template <>
+    const uint8_t alphabet<32>::dec[256] = {
+           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+           0,    0, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,    0,    0,    0,    0,    0,    0,    0,    0,
+           0, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
+        0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19,    0,    0,    0,    0,    0,
+           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0
+    };
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <>
+    const char alphabet<16>::enc[16] {
+        '0', '1', '2', '3', '4', '5', '6', '7',
+        '8', '9', 'A', 'B', 'C', 'D', 'E', 'F',
+    };
+
+    template <>
+    const uint8_t alphabet<16>::dec[256] = {
+           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,    0,    0,    0,    0,    0,    0,
+           0, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0
+    };
+
+
+    //-------------------------------------------------------------------------
+    template <int Size> constexpr auto enc_v = alphabet<Size>::enc;
+    template <int Size> constexpr auto dec_v = alphabet<Size>::dec;
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    /// rfc4648 base16, base32, and base64 encoding
+    template <int Size>
+    struct base {
+        static constexpr auto symbol_bits = log2 (Size);
+        static constexpr auto group_bits = std::lcm (symbol_bits, 8);
+        static constexpr auto group_symbols = group_bits / symbol_bits;
+        static constexpr auto group_bytes = group_bits / 8;
+
+        static constexpr uint_fast32_t mask = (1<<symbol_bits)-1;
+
+
+        template <typename InputT, typename OutputT>
+        static OutputT
+        encode (OutputT dst, const util::view<InputT> src)
+        {
+            // convert whole groups of symbols while we have enough bytes remaining
+            auto cursor = std::cbegin (src);
+            for (size_t i = 0, last = std::size (src) / group_bytes; i != last; ++i) {
+                auto tally = std::accumulate (
+                    cursor, cursor + group_bytes,
+                    uint_fast32_t {0},
+                    [] (auto a, auto b) { return a << 8 | b; }
+                );
+
+                cursor += group_bytes;
+
+                for (int j = group_symbols - 1; j >= 0; --j)
+                    *dst++ = enc_v<Size>[tally >> (j * symbol_bits) & mask];
+            }
+
+            // we don't need to pad the output so we can early exit
+            if (cursor == std::cend (src))
+                return dst;
+
+            // accumulate the remaining bits and pad to a multiple of the
+            // output group length
+            auto tally = std::accumulate (
+                cursor,
+                std::cend (src),
+                uint_fast32_t {0},
+                [] (auto a, auto b) { return a << 8 | b; }
+            );
+
+            auto input_remain = std::cend (src) - cursor;
+            tally <<= symbol_bits - input_remain * 8 % symbol_bits;
+
+            // write each of the remaining symbols
+            auto output_remain = (input_remain * 8 + symbol_bits - 1) / symbol_bits;
+            for (auto i = output_remain - 1; i >= 0; --i)
+                *dst++ = enc_v<Size>[tally >> (i * symbol_bits) & mask];
+
+            // pad the output to the symbol group size with '=' characters
+            auto fill = (group_bytes - input_remain) * 8 / symbol_bits;
+            return std::fill_n (dst, fill, '=');
+        }
+
+
+        //---------------------------------------------------------------------
+        template <typename InputT, typename OutputT>
+        static OutputT
+        decode (OutputT dst, util::view<InputT> src)
+        {
+            if (src.empty ())
+                return dst;
+
+            if (src.size () % group_symbols)
+                throw std::invalid_argument ("base-encoded strings must be a proper multiple of symbols");
+
+            union {
+                uint_fast32_t num;
+                uint8_t bytes[group_bytes];
+            };
+
+            const bool padded = src.end ()[-1] == '=';
+            auto cursor = std::cbegin (src);
+            for (size_t i = 0, last = std::size (src) / group_symbols - padded?1:0;
+                i != last;
+                 ++i)
+            {
+                num = std::accumulate (
+                    cursor, cursor + group_symbols,
+                    uint_fast32_t {0},
+                    [] (auto a, auto b) { return a << symbol_bits | dec_v<Size>[b]; }
+                );
+
+                cursor += group_symbols;
+
+                dst = std::copy (std::crbegin (bytes), std::crend (bytes), dst);
+            }
+
+            if (cursor != std::end (src)) {
+                auto last = std::find (cursor, std::cend (src), '=');
+                num = std::accumulate (
+                    cursor, last,
+                    uint_fast32_t{0},
+                    [] (auto a, auto b) { return a << symbol_bits | dec_v<Size>[b]; }
+                );
+
+                auto symbols = last - cursor;
+                auto bits = symbols * symbol_bits;
+                auto shift = bits%8;
+                num >>= shift;
+
+                for (auto i = bits / 8; i; )
+                    *dst++ = bytes[--i];
+            }
+
+            return dst;
+        }
+    };
+};
+
+#endif
diff --git a/test/encode/base.cpp b/test/encode/base.cpp
new file mode 100644
index 00000000..621da75b
--- /dev/null
+++ b/test/encode/base.cpp
@@ -0,0 +1,91 @@
+#include "../../tap.hpp"
+
+#include "../../encode/base.hpp"
+#include "../../iterator.hpp"
+
+
+///////////////////////////////////////////////////////////////////////////////
+static constexpr char input[] = "foobar";
+
+
+//-----------------------------------------------------------------------------
+// test vectors from rfc4648
+template <int Size>
+struct output { static const char *value[std::size (input)]; };
+
+//-----------------------------------------------------------------------------
+template <>
+const char* output<64>::value[] = {
+    "", "Zg==", "Zm8=", "Zm9v", "Zm9vYg==", "Zm9vYmE=", "Zm9vYmFy",
+};
+
+
+template <>
+const char* output<32>::value[]  {
+    "", "MY======", "MZXQ====", "MZXW6===", "MZXW6YQ=", "MZXW6YTB", "MZXW6YTBOI======"
+};
+
+
+#if 0
+template <>
+const char* output<32h>::value[] {
+    "", "CO======", "CPNG====", "CPNMU===", "CPNMUOG=", "CPNMUOJ1", "CPNMUOJ1E8======",
+}
+#endif
+
+
+//-----------------------------------------------------------------------------
+template <>
+const char *output<16>::value[] = {
+    "", "66", "666F", "666F6F", "666F6F62", "666F6F6261", "666F6F626172"
+};
+
+
+//-----------------------------------------------------------------------------
+template <int Size>
+const auto output_v = output<Size>::value;
+
+
+///////////////////////////////////////////////////////////////////////////////
+template <int Size>
+void
+test_size (util::TAP::logger &tap)
+{
+    for (unsigned i = 0; i < std::size (input); ++i) {
+        const auto fragment = util::make_view (input, input + i);
+
+        std::string encoded;
+
+        util::encode::base<Size>::encode (
+            std::back_inserter (encoded),
+            fragment
+        );
+
+        tap.expect_eq (encoded, output_v<Size>[i],
+            "%! character base%! encode; '%!' is '%!'", i, Size, encoded, output_v<Size>[i]
+        );
+
+
+        std::string decoded;
+        util::encode::base<Size>::decode (
+            std::back_inserter (decoded),
+            util::make_view (encoded)
+        );
+
+        tap.expect_eq (decoded, fragment, "%! character base%! decode, '%!'", i, Size, decoded);
+    }
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+int
+main ()
+{
+    util::TAP::logger tap;
+
+    test_size<16> (tap);
+    test_size<32> (tap);
+    test_size<64> (tap);
+
+    return tap.status ();
+}
\ No newline at end of file

From d80855aedfc474e55e321631626ba80a1bbf29f1 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Fri, 22 Dec 2017 18:34:00 +1100
Subject: [PATCH 28/56] posix/except: add exception class for EAI_* codes

---
 posix/except.cpp | 38 ++++++++++++++++++++++++++++++++++++++
 posix/except.hpp | 15 ++++++++++++++-
 2 files changed, 52 insertions(+), 1 deletion(-)

diff --git a/posix/except.cpp b/posix/except.cpp
index 40b73638..ef416417 100644
--- a/posix/except.cpp
+++ b/posix/except.cpp
@@ -97,3 +97,41 @@ error::throw_code (int code)
     CHECK_NEQ (code, 0);
     throw error (code);
 }
+
+
+///////////////////////////////////////////////////////////////////////////////
+using util::posix::eai;
+
+#include <netdb.h>
+
+
+//-----------------------------------------------------------------------------
+eai::eai (int code):
+    runtime_error (gai_strerror (code)),
+    m_code (code)
+{ ; }
+
+
+//-----------------------------------------------------------------------------
+int
+eai::code (void) const
+{
+    return m_code;
+}
+
+
+//-----------------------------------------------------------------------------
+void
+eai::try_code (int code)
+{
+    if (code)
+        throw_code (code);
+}
+
+
+//-----------------------------------------------------------------------------
+void
+eai::throw_code (int code)
+{
+    throw eai { code };
+}
diff --git a/posix/except.hpp b/posix/except.hpp
index a9a6ce8e..44380baf 100644
--- a/posix/except.hpp
+++ b/posix/except.hpp
@@ -50,6 +50,19 @@ namespace util::posix {
     private:
         int m_code;
     };
-}
+
+
+    class eai : public std::runtime_error {
+    public:
+        explicit eai (int code);
+        int code (void) const;
+
+        static void try_code (int);
+        static void throw_code [[gnu::noreturn]] (int);
+
+    private:
+        int m_code;
+    };
+};
 
 #endif

From a6af7a8657a6211190f35977ccd3e819cccf6c20 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Fri, 22 Dec 2017 18:34:30 +1100
Subject: [PATCH 29/56] posix/fd: add explicit native conversion function

---
 posix/fd.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/posix/fd.hpp b/posix/fd.hpp
index 3c1192c2..55aa4783 100644
--- a/posix/fd.hpp
+++ b/posix/fd.hpp
@@ -67,6 +67,7 @@ namespace util::posix {
 
         ///////////////////////////////////////////////////////////////////////
         operator int (void) const;
+        int native (void) { return m_fd; }
 
     private:
         int m_fd;

From d1649d4acf3508067d4717d099b137925cb03751 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Fri, 22 Dec 2017 18:35:47 +1100
Subject: [PATCH 30/56] uri: remove componentwise ostream operator

componentwise output was a surprising behaviour for what is sometimes a
string-like object. users can elect to write the entire string via all()
or the components manually as required.
---
 uri.cpp.rl | 8 --------
 uri.hpp    | 1 -
 2 files changed, 9 deletions(-)

diff --git a/uri.cpp.rl b/uri.cpp.rl
index a7485727..79d15d6a 100644
--- a/uri.cpp.rl
+++ b/uri.cpp.rl
@@ -215,11 +215,3 @@ util::operator<< (std::ostream &os, util::uri::component c)
 
     unreachable ();
 }
-
-
-//-----------------------------------------------------------------------------
-std::ostream&
-util::operator<< (std::ostream &os, const util::uri &val)
-{
-    return os << '[' << util::make_infix (val.components ()) << ']';
-}
diff --git a/uri.hpp b/uri.hpp
index f8ff25f1..ddba7198 100644
--- a/uri.hpp
+++ b/uri.hpp
@@ -94,7 +94,6 @@ namespace util {
         std::string m_value;
     };
 
-    std::ostream& operator<< (std::ostream&, const uri&);
     std::ostream& operator<< (std::ostream&, uri::component);
 }
 

From cb9e9afcd382474dbc8c6cf14bfd4e0cf516e81a Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Fri, 22 Dec 2017 18:37:11 +1100
Subject: [PATCH 31/56] uri: add an `all' accessor for the entire string

---
 uri.hpp | 20 +++++++++++---------
 1 file changed, 11 insertions(+), 9 deletions(-)

diff --git a/uri.hpp b/uri.hpp
index ddba7198..efee4747 100644
--- a/uri.hpp
+++ b/uri.hpp
@@ -75,15 +75,17 @@ namespace util {
 
         view<const char*> get (component) const;
 
-        view<const char*> scheme (void) const { return get (SCHEME); }
-        view<const char*> heirarchical (void) const { return get (HIERARCHICAL); }
-        view<const char*> authority (void) const { return get (AUTHORITY); }
-        view<const char*> user (void) const { return get (USER); }
-        view<const char*> host (void) const { return get (HOST); }
-        view<const char*> port (void) const { return get (PORT); }
-        view<const char*> path (void) const { return get (PATH); }
-        view<const char*> query (void) const { return get (QUERY); }
-        view<const char*> fragment (void) const { return get (FRAGMENT); }
+        auto all (void) const { return util::make_view (m_value); }
+
+        auto scheme (void) const { return get (SCHEME); }
+        auto heirarchical (void) const { return get (HIERARCHICAL); }
+        auto authority (void) const { return get (AUTHORITY); }
+        auto user (void) const { return get (USER); }
+        auto host (void) const { return get (HOST); }
+        auto port (void) const { return get (PORT); }
+        auto path (void) const { return get (PATH); }
+        auto query (void) const { return get (QUERY); }
+        auto fragment (void) const { return get (FRAGMENT); }
 
         auto components (void) const noexcept { return m_views; }
 

From ce64396da45622dcac4cfa790b4a8fa2dcce0d0a Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Fri, 22 Dec 2017 18:38:30 +1100
Subject: [PATCH 32/56] posix/socket: add a convenience wrapper for sockets

---
 CMakeLists.txt   |   2 +
 posix/socket.cpp | 123 +++++++++++++++++++++++++++++++++++++++++++++++
 posix/socket.hpp |  60 +++++++++++++++++++++++
 3 files changed, 185 insertions(+)
 create mode 100644 posix/socket.cpp
 create mode 100644 posix/socket.hpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 69492a43..f7895cb8 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -84,6 +84,8 @@ list (
     posix/except.hpp
     posix/fd.cpp
     posix/fd.hpp
+    posix/socket.cpp
+    posix/socket.hpp
 )
 
 
diff --git a/posix/socket.cpp b/posix/socket.cpp
new file mode 100644
index 00000000..24f8d297
--- /dev/null
+++ b/posix/socket.cpp
@@ -0,0 +1,123 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2017 Danny Robson <danny@nerdcruft.net>
+ */
+
+#include "socket.hpp"
+
+#include "except.hpp"
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+
+using util::posix::socket;
+
+
+///////////////////////////////////////////////////////////////////////////////
+class lookup {
+public:
+    lookup (const util::view<const char*> host, int port):
+        m_addresses (nullptr, freeaddrinfo)
+    {
+        struct ::addrinfo hints {};
+        hints.ai_family = AF_UNSPEC;
+        hints.ai_socktype = SOCK_STREAM;
+
+        const struct {
+            std::string host;
+            std::string port;
+        } strings {
+            .host = std::string (std::begin (host), std::end (host)),
+            .port = std::to_string (port)
+        };
+
+        addrinfo* _addresses;
+        util::posix::eai::try_code (
+            getaddrinfo (
+                strings.host.c_str (),
+                strings.port.c_str (),
+                &hints,
+                &_addresses
+            )
+        );
+
+        m_addresses.reset (_addresses);
+    };
+
+    auto begin (void) const { return m_addresses.get (); }
+    auto end   (void) const { return nullptr; }
+
+private:
+    std::unique_ptr<addrinfo[],void(*)(addrinfo*)> m_addresses;
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+static util::posix::fd
+connect_host (const util::view<const char*> host, int port)
+{
+    for (const auto &info: lookup { host, port }) {
+        util::posix::fd sock {
+            socket (info.ai_family, info.ai_socktype, info.ai_protocol)
+        };
+        if (sock == -1)
+            continue;
+
+        if (connect (sock, info.ai_addr, info.ai_addrlen))
+            continue;
+
+        return sock;
+    }
+
+    throw std::runtime_error ("unable to connect");
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+socket::socket (int domain, int type):
+    socket (domain, type, 0)
+{ ; }
+
+
+//-----------------------------------------------------------------------------
+socket::socket (int domain, int type, int protocol):
+    fd (::socket (domain, type, protocol))
+{ ; }
+
+
+//-----------------------------------------------------------------------------
+socket::socket (util::view<const char*> host, int port):
+    fd (connect_host (host, port))
+{ ; }
+
+
+//-----------------------------------------------------------------------------
+socket::~socket ()
+{ ; }
+
+
+///////////////////////////////////////////////////////////////////////////////
+void
+socket::connect (util::view<const char*> host, int port)
+{
+    for (const auto &info: lookup { host, port }) {
+        if (!::connect (*this, info.ai_addr, info.ai_addrlen))
+            return;
+    }
+
+    throw std::runtime_error ("unable to reconnect");
+}
diff --git a/posix/socket.hpp b/posix/socket.hpp
new file mode 100644
index 00000000..ab1ef1c1
--- /dev/null
+++ b/posix/socket.hpp
@@ -0,0 +1,60 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2017 Danny Robson <danny@nerdcruft.net>
+ */
+
+#ifndef CRUFT_UTIL_POSIX_SOCKET_HPP
+#define CRUFT_UTIL_POSIX_SOCKET_HPP
+
+#include "fd.hpp"
+
+#include "except.hpp"
+
+#include <sys/types.h>
+#include <sys/socket.h>
+
+
+namespace util::posix {
+     class socket : public fd {
+     public:
+         socket (int domain, int type);
+         socket (int domain, int type, int protocol);
+
+         socket (util::view<const char*> host, int port);
+
+         void connect (util::view<const char*> host, int port);
+
+         // the destructor is provided so that we can operate more cleanly on
+         // win32 where we must call closesocket instead of the normal close.
+         // because windows...
+         ~socket ();
+
+         void shutdown ();
+
+         template <typename ValueT>
+         void setoption (int _level, int _name, const ValueT &_value)
+         {
+            error::try_code (
+                setsockopt (
+                    native (),
+                    _level,
+                    _name,
+                    &_value, sizeof (_value)
+                )
+            );
+         }
+     };
+};
+
+#endif

From ac685cfdd2e6ce2d19f14c3b46fd6ede75e4214b Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 26 Dec 2017 17:24:42 +1100
Subject: [PATCH 33/56] io: expose file-object variant of draining write

---
 io.hpp | 27 +++++++++++++++++++++++++--
 1 file changed, 25 insertions(+), 2 deletions(-)

diff --git a/io.hpp b/io.hpp
index f1e402d5..8582748b 100644
--- a/io.hpp
+++ b/io.hpp
@@ -43,9 +43,11 @@ namespace util {
     std::vector<T> slurp (FILE *);
 
 
-    //-------------------------------------------------------------------------
+    ///////////////////////////////////////////////////////////////////////////
     void write (const posix::fd&, const void *restrict data, size_t bytes);
 
+
+    //-------------------------------------------------------------------------
     inline void
     write (const posix::fd &dst, util::view<const char*> data)
     {
@@ -53,6 +55,7 @@ namespace util {
     }
 
 
+    //-------------------------------------------------------------------------
     template <typename T>
     void write (const posix::fd &_fd, const T &data)
     {
@@ -60,7 +63,27 @@ namespace util {
     }
 
 
-    //-------------------------------------------------------------------------
+    ///------------------------------------------------------------------------
+    /// writes all data from the provided view into the file-like-object
+    ///
+    /// writing will continually iterate until the entire buffer has been
+    /// dispatched so as to avoid issues with partial writes. will block until
+    /// such time as the entire buffer has written.
+    ///
+    /// an exception may be thrown in the event forward progress is impossible.
+    /// in this event the progress may not be reported to the caller. in the
+    /// future an exception member variable may expose the information.
+    template <typename DstT, typename IteratorA, typename IteratorB>
+    void
+    write (DstT &dst, util::view<IteratorA, IteratorB> src)
+    {
+        for (auto cursor = src.begin (); cursor != src.end (); ) {
+            cursor = dst.write (view{cursor, src.end ()});
+        }
+    }
+
+
+    ///////////////////////////////////////////////////////////////////////////
     class indenter : public std::streambuf {
     protected:
         std::streambuf* m_dest;

From fe979fc2a94216e46fa13ef4ca54c238741ed1e7 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 26 Dec 2017 17:25:58 +1100
Subject: [PATCH 34/56] fd: add reset and release methods

---
 posix/fd.cpp | 36 +++++++++++++++++++++++++++++++++---
 posix/fd.hpp |  7 +++++++
 2 files changed, 40 insertions(+), 3 deletions(-)

diff --git a/posix/fd.cpp b/posix/fd.cpp
index 8044c8f2..f6415801 100644
--- a/posix/fd.cpp
+++ b/posix/fd.cpp
@@ -94,13 +94,43 @@ fd::stat (void) const
 ssize_t
 fd::read (void *buffer, size_t count)
 {
-    return error::try_value (
-        ::read (m_fd, buffer, count)
-    );
+    error::try_value (::close (m_fd));
+    m_fd = -1;
 }
 
 
 //-----------------------------------------------------------------------------
+void
+fd::reset (void)
+{
+    if (m_fd >= 0) {
+        close ();
+        m_fd = -1;
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+void
+fd::reset (int rhs)
+{
+    if (m_fd >= 0)
+        close ();
+    m_fd = rhs;
+}
+
+
+//-----------------------------------------------------------------------------
+int
+fd::release (void)
+{
+    int tmp = m_fd;
+    m_fd = -1;
+    return tmp;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
 ssize_t
 fd::read (util::view<char *> dst)
 {
diff --git a/posix/fd.hpp b/posix/fd.hpp
index 55aa4783..e74abb43 100644
--- a/posix/fd.hpp
+++ b/posix/fd.hpp
@@ -53,6 +53,13 @@ namespace util::posix {
         ///////////////////////////////////////////////////////////////////////
         struct ::stat stat (void) const;
 
+
+        ///////////////////////////////////////////////////////////////////////
+        void close (void);
+        void reset (int);
+        void reset (void);
+        int release (void);
+
         //---------------------------------------------------------------------
         [[gnu::warn_unused_result]] ssize_t read (void *buf, size_t count);
         [[gnu::warn_unused_result]] ssize_t read (util::view<char*>);

From 39894b5619a963a0d046c934a001ef8e5a05d035 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 26 Dec 2017 17:26:53 +1100
Subject: [PATCH 35/56] fd: add read/write methods for views

---
 posix/fd.cpp | 35 +++++++++++++++++++++++++++--------
 posix/fd.hpp | 35 ++++++++++++++++++++++++++++++-----
 2 files changed, 57 insertions(+), 13 deletions(-)

diff --git a/posix/fd.cpp b/posix/fd.cpp
index f6415801..e2e79d03 100644
--- a/posix/fd.cpp
+++ b/posix/fd.cpp
@@ -45,6 +45,25 @@ fd::fd (fd &&rhs):
 }
 
 
+//-----------------------------------------------------------------------------
+fd&
+fd::operator= (fd &&rhs)
+{
+    close ();
+    std::swap (m_fd, rhs.m_fd);
+    return *this;
+}
+
+
+//-----------------------------------------------------------------------------
+fd&
+fd::operator= (int rhs)
+{
+    reset (rhs);
+    return *this;
+}
+
+
 ///////////////////////////////////////////////////////////////////////////////
 fd::fd (int _fd):
     m_fd (_fd)
@@ -74,8 +93,7 @@ fd::~fd ()
 {
     if (m_fd < 0)
         return;
-
-    error::try_code (close (m_fd));
+    close ();
 }
 
 
@@ -84,15 +102,14 @@ struct ::stat
 fd::stat (void) const
 {
     struct stat buf;
-    if (fstat (m_fd, &buf))
-        error::throw_code ();
+    error::try_value (fstat (m_fd, &buf));
     return buf;
 }
 
 
 ///////////////////////////////////////////////////////////////////////////////
-ssize_t
-fd::read (void *buffer, size_t count)
+void
+fd::close (void)
 {
     error::try_value (::close (m_fd));
     m_fd = -1;
@@ -132,9 +149,11 @@ fd::release (void)
 
 ///////////////////////////////////////////////////////////////////////////////
 ssize_t
-fd::read (util::view<char *> dst)
+fd::read (void *buffer, size_t count)
 {
-    return read (std::data (dst), std::size (dst));
+    return error::try_value (
+        ::read (m_fd, buffer, count)
+    );
 }
 
 
diff --git a/posix/fd.hpp b/posix/fd.hpp
index e74abb43..c5ca7228 100644
--- a/posix/fd.hpp
+++ b/posix/fd.hpp
@@ -34,6 +34,8 @@ namespace util::posix {
         fd (const std::experimental::filesystem::path &path, int flags, mode_t);
 
         fd (fd &&);
+        fd& operator= (fd &&);
+        fd& operator= (int);
 
         // The int constructor steals the fd. So don't pass in something that
         // you don't want closed at destruct time. This should really only be
@@ -62,16 +64,39 @@ namespace util::posix {
 
         //---------------------------------------------------------------------
         [[gnu::warn_unused_result]] ssize_t read (void *buf, size_t count);
-        [[gnu::warn_unused_result]] ssize_t read (util::view<char*>);
-        [[gnu::warn_unused_result]] ssize_t read (util::view<std::byte*>);
-
         [[gnu::warn_unused_result]] ssize_t write (const void *buf, size_t count);
-        [[gnu::warn_unused_result]] ssize_t write (util::view<const char*>);
-        [[gnu::warn_unused_result]] ssize_t write (util::view<const std::byte*>);
+
+
+        //---------------------------------------------------------------------
+        template <typename IteratorA, typename IteratorB>
+        [[gnu::warn_unused_result]]
+        std::enable_if_t<
+            sizeof (typename std::iterator_traits<IteratorA>::value_type) == 1,
+            IteratorA
+        >
+        read (util::view<IteratorA, IteratorB> dst)
+        {
+            return dst.begin () + read (&*std::data (dst), std::size (dst));
+        }
+
+
+        //---------------------------------------------------------------------
+        template <typename IteratorA, typename IteratorB>
+        [[gnu::warn_unused_result]]
+        std::enable_if_t<
+            sizeof (typename std::iterator_traits<IteratorA>::value_type) == 1,
+            IteratorA
+        >
+        write (util::view<IteratorA, IteratorB> src)
+        {
+            return src.begin () + write (&*std::data (src), std::size (src));
+        }
+
 
         //---------------------------------------------------------------------
         [[gnu::warn_unused_result]] off_t lseek (off_t offset, int whence);
 
+
         ///////////////////////////////////////////////////////////////////////
         operator int (void) const;
         int native (void) { return m_fd; }

From a979b253f5e3b06bf11ee1e9c7743e0e6aead7a9 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 26 Dec 2017 17:27:36 +1100
Subject: [PATCH 36/56] socket: correctly iterate over lookup entries

---
 posix/socket.cpp | 28 +++++++++++++++++++++++++---
 posix/socket.hpp | 11 +++++++++--
 2 files changed, 34 insertions(+), 5 deletions(-)

diff --git a/posix/socket.cpp b/posix/socket.cpp
index 24f8d297..1eeffce0 100644
--- a/posix/socket.cpp
+++ b/posix/socket.cpp
@@ -62,7 +62,7 @@ public:
     auto end   (void) const { return nullptr; }
 
 private:
-    std::unique_ptr<addrinfo[],void(*)(addrinfo*)> m_addresses;
+    std::unique_ptr<addrinfo,void(*)(addrinfo*)> m_addresses;
 };
 
 
@@ -88,6 +88,12 @@ connect_host (const util::view<const char*> host, int port)
 
 
 ///////////////////////////////////////////////////////////////////////////////
+socket::socket (int _fd):
+    fd (_fd)
+{ ; }
+
+
+//-----------------------------------------------------------------------------
 socket::socket (int domain, int type):
     socket (domain, type, 0)
 { ; }
@@ -110,12 +116,28 @@ socket::~socket ()
 { ; }
 
 
+//-----------------------------------------------------------------------------
+socket::socket (socket &&rhs):
+    fd (std::move (rhs))
+{ ; }
+
+
+//-----------------------------------------------------------------------------
+class socket&
+socket::operator= (socket &&rhs)
+{
+    fd::operator= (std::move (rhs));
+    return *this;
+}
+
+
 ///////////////////////////////////////////////////////////////////////////////
 void
 socket::connect (util::view<const char*> host, int port)
 {
-    for (const auto &info: lookup { host, port }) {
-        if (!::connect (*this, info.ai_addr, info.ai_addrlen))
+    const lookup l { host, port };
+    for (auto cursor = l.begin (); cursor != l.end (); cursor = cursor->ai_next) {
+        if (!::connect (*this, cursor->ai_addr, cursor->ai_addrlen))
             return;
     }
 
diff --git a/posix/socket.hpp b/posix/socket.hpp
index ab1ef1c1..289d112e 100644
--- a/posix/socket.hpp
+++ b/posix/socket.hpp
@@ -28,24 +28,31 @@
 namespace util::posix {
      class socket : public fd {
      public:
+         explicit socket (int _fd);
+
          socket (int domain, int type);
          socket (int domain, int type, int protocol);
 
          socket (util::view<const char*> host, int port);
 
-         void connect (util::view<const char*> host, int port);
+         socket (const socket&) = delete;
+         socket& operator= (const socket&) = delete;
+
+         socket (socket &&rhs);
+         socket& operator= (socket &&);
 
          // the destructor is provided so that we can operate more cleanly on
          // win32 where we must call closesocket instead of the normal close.
          // because windows...
          ~socket ();
 
+         void connect (util::view<const char*> host, int port);
          void shutdown ();
 
          template <typename ValueT>
          void setoption (int _level, int _name, const ValueT &_value)
          {
-            error::try_code (
+            error::try_value (
                 setsockopt (
                     native (),
                     _level,

From 14d3169c2676de7e21b63421693fb8dc58a33f60 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 26 Dec 2017 17:28:00 +1100
Subject: [PATCH 37/56] rfc3986: don't enforce actions for rules

some users may not care about actions for the top level rules so we
shouldn't enforce them.
---
 rfc3986.rl | 2 +-
 uri.cpp.rl | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/rfc3986.rl b/rfc3986.rl
index c11abd0f..b8da3e5b 100644
--- a/rfc3986.rl
+++ b/rfc3986.rl
@@ -136,5 +136,5 @@
 
     URI = (
         absolute_uri | uri_reference
-    ) >uri_begin %uri_end;
+    );
 }%%
diff --git a/uri.cpp.rl b/uri.cpp.rl
index 79d15d6a..759f4153 100644
--- a/uri.cpp.rl
+++ b/uri.cpp.rl
@@ -65,7 +65,7 @@
 
     include rfc3986 'rfc3986.rl';
 
-    impl := URI
+    impl := URI >uri_begin %uri_end
     %success
     $!failure
     $trace;

From dc51fa2ed0cabaa1f8dd5f4e351cea4a0fc6f8be Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 26 Dec 2017 17:29:32 +1100
Subject: [PATCH 38/56] view: char constructor shouldn't include null
 characters

---
 test/view.cpp |  5 +++++
 view.hpp      | 10 ++++++++++
 2 files changed, 15 insertions(+)

diff --git a/test/view.cpp b/test/view.cpp
index 0e9d6266..e0f99ec8 100644
--- a/test/view.cpp
+++ b/test/view.cpp
@@ -10,6 +10,11 @@ main (int, char**)
 {
     util::TAP::logger tap;
 
+    tap.expect_eq (
+        std::size (util::make_view ("foo")), 3u,
+        "character array view does not include trailing null"
+    );
+
     const std::string s = "this is a test string";
     const std::string t = "not the same string";
 
diff --git a/view.hpp b/view.hpp
index 263e6afd..db47cd56 100644
--- a/view.hpp
+++ b/view.hpp
@@ -46,6 +46,16 @@ namespace util {
         { ; }
 
 
+        //---------------------------------------------------------------------
+        // explicitly cater for the char array case so that we don't
+        // accidentally include the trailing null in the data.
+        template <std::size_t N>
+        view (const char (&value)[N]):
+            view (std::begin (value), std::begin (value) + N - 1)
+        {
+            static_assert (N > 0);
+        }
+
         //---------------------------------------------------------------------
         template <std::size_t N, typename ValueT>
         view (const ValueT(&value)[N]):

From a67069a33369bd7ec17670eeb4d60c78c5a22dbd Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 26 Dec 2017 17:30:41 +1100
Subject: [PATCH 39/56] view: move ostream operator into header

---
 view.cpp | 32 +-------------------------------
 view.hpp | 20 ++++++++++++++++----
 2 files changed, 17 insertions(+), 35 deletions(-)

diff --git a/view.cpp b/view.cpp
index 82464485..32d84bed 100644
--- a/view.cpp
+++ b/view.cpp
@@ -11,37 +11,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
- * Copyright 2016-2017 Danny Robson <danny@nerdcruft.net>
+ * Copyright 2017 Danny Robson <danny@nerdcruft.net>
  */
 
 #include "view.hpp"
-
-#include <algorithm>
-#include <iterator>
-
-
-///////////////////////////////////////////////////////////////////////////////
-namespace util {
-#define OSTREAM(A)                                                          \
-    template <>                                                             \
-    std::ostream&                                                           \
-    operator<< (std::ostream &os, view<A> a) {                              \
-        std::copy (a.cbegin (),                                             \
-                   std::find (a.cbegin (), a.cend (), '\0'),                \
-                   std::ostream_iterator<decltype(a)::value_type> (os));    \
-                                                                            \
-        return os;                                                          \
-    }
-
-    OSTREAM(const char*)
-    OSTREAM(char*)
-    OSTREAM(  signed char*)
-    OSTREAM(unsigned char*)
-    OSTREAM(const   signed char*)
-    OSTREAM(const unsigned char*)
-    OSTREAM(std::string::const_iterator)
-    OSTREAM(std::string::iterator)
-
-#undef OSTREAM
-}
-
diff --git a/view.hpp b/view.hpp
index db47cd56..c21c7e92 100644
--- a/view.hpp
+++ b/view.hpp
@@ -27,6 +27,7 @@
 #include <string>
 #include <cstring>
 #include <stdexcept>
+#include <iterator>
 
 namespace util {
     template <typename IteratorA, typename IteratorB = IteratorA>
@@ -356,6 +357,21 @@ namespace util {
     }
 
 
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename IteratorT>
+    std::ostream&
+    operator<< (std::ostream &os, view<IteratorT> val)
+    {
+        std::copy (
+            std::cbegin (val),
+            std::cend (val),
+            std::ostream_iterator<typename decltype(val)::value_type> (os)
+        );
+
+        return os;
+    }
+
+
     ///////////////////////////////////////////////////////////////////////////
     /// a basic stringlike comparison operator that behaves as
     /// std::string::compare would.
@@ -378,10 +394,6 @@ namespace util {
     }
 
 
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename IteratorT>
-    std::ostream&
-    operator<< (std::ostream&, view<IteratorT>);
 }
 
 

From e1a41c64de5a3ef72e544a54b77f706d2201a4c2 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 26 Dec 2017 17:31:17 +1100
Subject: [PATCH 40/56] view: add increment and decrement methods

---
 view.hpp | 37 +++++++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/view.hpp b/view.hpp
index c21c7e92..5a1d34d9 100644
--- a/view.hpp
+++ b/view.hpp
@@ -172,6 +172,43 @@ namespace util {
             return view { m_begin, m_begin + count };
         };
 
+
+        //---------------------------------------------------------------------
+        // returns a view that has the same end iterator, but the provided
+        // begin iterator.
+        //
+        // the new begin iterator must be reachable by incrementing the current
+        // begin iterator but lie before reaching the end iterator. ie, in the
+        // middle.
+        //
+        // useful for resizing views after options which incrementally consume
+        // the referenced data.
+        [[gnu::warn_unused_result]] constexpr auto
+        increment (IteratorA _begin) const
+        {
+            return view { _begin, m_end };
+        }
+
+
+        //---------------------------------------------------------------------
+        [[gnu::warn_unused_result]] constexpr auto
+        increment (int count) const
+        {
+            IteratorA next;
+            std::advance (next, count);
+            return increment (next);
+        }
+
+
+        //---------------------------------------------------------------------
+        template <typename IteratorC>
+        [[gnu::warn_unused_result]] constexpr auto
+        decrement (IteratorC _end)
+        {
+            return view { m_begin, _end };
+        };
+
+
         ///////////////////////////////////////////////////////////////////////
         constexpr value_type&
         operator[] (size_t idx)& noexcept

From 1123cfe4094f2bf5d6a4d8708358db852ee5c78c Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 26 Dec 2017 17:31:40 +1100
Subject: [PATCH 41/56] view: add unused_result warning to redim

---
 view.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/view.hpp b/view.hpp
index 5a1d34d9..4f65c063 100644
--- a/view.hpp
+++ b/view.hpp
@@ -163,7 +163,7 @@ namespace util {
         }
 
         //---------------------------------------------------------------------
-        constexpr auto
+        [[gnu::warn_unused_result]] constexpr auto
         redim (int count) const
         {
             CHECK_GT (count, 0);

From 9704387fdcabf6c8107cc6bc9ff1284f8e33a3cf Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 26 Dec 2017 17:32:06 +1100
Subject: [PATCH 42/56] view: use auto return type for indexing

---
 view.hpp | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/view.hpp b/view.hpp
index 4f65c063..b74c77a6 100644
--- a/view.hpp
+++ b/view.hpp
@@ -210,7 +210,7 @@ namespace util {
 
 
         ///////////////////////////////////////////////////////////////////////
-        constexpr value_type&
+        constexpr auto&
         operator[] (size_t idx)& noexcept
         {
             auto it = begin ();
@@ -219,7 +219,7 @@ namespace util {
         }
 
         //---------------------------------------------------------------------
-        constexpr const value_type&
+        constexpr auto&
         operator[] (size_t idx) const& noexcept
         {
             auto it = begin ();
@@ -343,7 +343,6 @@ namespace util {
     view<CharT*>
     make_view (std::basic_string<CharT,TraitsT,AllocT>&&) = delete;
 
-
     ///////////////////////////////////////////////////////////////////////////
     template <typename IteratorA, typename IteratorB>
     constexpr bool

From d86c8b5b2b3d822fe2245d00b5424e7c6304ef54 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 26 Dec 2017 17:33:06 +1100
Subject: [PATCH 43/56] uri: define more constructors

---
 uri.cpp.rl | 15 ++++++++++++---
 uri.hpp    |  3 ++-
 2 files changed, 14 insertions(+), 4 deletions(-)

diff --git a/uri.cpp.rl b/uri.cpp.rl
index 759f4153..ad188a3c 100644
--- a/uri.cpp.rl
+++ b/uri.cpp.rl
@@ -25,7 +25,10 @@
 #include <algorithm>
 #include <iostream>
 
+using util::uri;
 
+
+///////////////////////////////////////////////////////////////////////////////
 %%{
     machine impl;
 
@@ -83,12 +86,18 @@ util::uri::uri (const char *str):
 
 
 //-----------------------------------------------------------------------------
-util::uri::uri (const char *first, const char *last):
-    uri (std::string (first, last))
+uri::uri (util::view<const char *> _value):
+    uri (std::string (_value.begin (), _value.end ()))
 { ; }
 
 
-///////////////////////////////////////////////////////////////////////////////
+//-----------------------------------------------------------------------------
+uri::uri (const std::string &_value):
+    uri (std::string (_value))
+{ ; }
+
+
+//-----------------------------------------------------------------------------
 static const util::view<const char*> NULL_VIEW { nullptr, nullptr };
 
 
diff --git a/uri.hpp b/uri.hpp
index efee4747..dc12910e 100644
--- a/uri.hpp
+++ b/uri.hpp
@@ -41,8 +41,9 @@ namespace util {
     class uri {
     public:
         explicit uri (std::string &&);
+        explicit uri (const std::string&);
         explicit uri (const char *str);
-        uri (const char *first, const char *last);
+        explicit uri (util::view<const char *>);
 
         class parse_error : public std::runtime_error
         { using runtime_error::runtime_error; };

From d8f3469987c532bee21dc131d1847c178e1b65cb Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 26 Dec 2017 17:33:24 +1100
Subject: [PATCH 44/56] uri: move component queries entirely into header

---
 uri.cpp.rl |  9 ---------
 uri.hpp    | 29 +++++++++++++++++------------
 2 files changed, 17 insertions(+), 21 deletions(-)

diff --git a/uri.cpp.rl b/uri.cpp.rl
index ad188a3c..8ea4c7ff 100644
--- a/uri.cpp.rl
+++ b/uri.cpp.rl
@@ -132,15 +132,6 @@ util::uri::uri (std::string &&_value):
 }
 
 
-//-----------------------------------------------------------------------------
-util::view<const char*>
-util::uri::get (util::uri::component c) const
-{
-    CHECK_NEQ (c, NUM_COMPONENTS);
-    return m_views[c];
-}
-
-
 //-----------------------------------------------------------------------------
 static uint8_t
 hex_to_uint (char c)
diff --git a/uri.hpp b/uri.hpp
index dc12910e..cb3af52c 100644
--- a/uri.hpp
+++ b/uri.hpp
@@ -74,21 +74,26 @@ namespace util {
             NUM_COMPONENTS
         };
 
-        view<const char*> get (component) const;
+        view<const char*>
+        get (component c) const&
+        {
+            CHECK_LIMIT (c, 0, NUM_COMPONENTS);
+            return m_views[c];
+        }
 
-        auto all (void) const { return util::make_view (m_value); }
+        util::view<const char*> all (void) const& { return util::make_view (m_value); }
 
-        auto scheme (void) const { return get (SCHEME); }
-        auto heirarchical (void) const { return get (HIERARCHICAL); }
-        auto authority (void) const { return get (AUTHORITY); }
-        auto user (void) const { return get (USER); }
-        auto host (void) const { return get (HOST); }
-        auto port (void) const { return get (PORT); }
-        auto path (void) const { return get (PATH); }
-        auto query (void) const { return get (QUERY); }
-        auto fragment (void) const { return get (FRAGMENT); }
+        util::view<const char*> scheme (void) const& { return get (SCHEME); }
+        util::view<const char*> heirarchical (void) const& { return get (HIERARCHICAL); }
+        util::view<const char*> authority (void) const& { return get (AUTHORITY); }
+        util::view<const char*> user (void) const& { return get (USER); }
+        util::view<const char*> host (void) const& { return get (HOST); }
+        util::view<const char*> port (void) const& { return get (PORT); }
+        util::view<const char*> path (void) const& { return get (PATH); }
+        util::view<const char*> query (void) const& { return get (QUERY); }
+        util::view<const char*> fragment (void) const& { return get (FRAGMENT); }
 
-        auto components (void) const noexcept { return m_views; }
+        auto components (void) const& noexcept { return m_views; }
 
         static std::string percent_decode (view<const char*>);
 

From 27a93c078062af8c8fbcc5302432bb5385471c1c Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Thu, 28 Dec 2017 17:48:21 +1100
Subject: [PATCH 45/56] traits: add is_contiguous query for containers

---
 test/traits.cpp  |  8 ++++++++
 types/traits.hpp | 20 ++++++++++++++++++++
 2 files changed, 28 insertions(+)

diff --git a/test/traits.cpp b/test/traits.cpp
index 90d5e4bc..7f87b278 100644
--- a/test/traits.cpp
+++ b/test/traits.cpp
@@ -1,6 +1,8 @@
 #include <cruft/util/tap.hpp>
 #include <cruft/util/types/traits.hpp>
 
+#include <list>
+
 
 ///////////////////////////////////////////////////////////////////////////////
 template <typename FuncT>
@@ -56,4 +58,10 @@ main (void)
                 "complex function type");
 
     tap.expect (!has_return_type<int>::value, "integer is not applicable to func_traits");
+
+
+    tap.expect (is_contiguous_v<std::vector<char>>, "vector is contiguous");
+    tap.expect (is_contiguous_v<std::array<char,4>>, "array is contiguous");
+    tap.expect (!is_contiguous_v<std::list<char>>, "list is not contiguous");
+    return tap.status ();
 }
\ No newline at end of file
diff --git a/types/traits.hpp b/types/traits.hpp
index fbde1c3d..14cfd55e 100644
--- a/types/traits.hpp
+++ b/types/traits.hpp
@@ -270,4 +270,24 @@ template <std::size_t N, typename FuncT>
 using nth_argument_t = typename nth_argument<N, FuncT>::type;
 
 
+///////////////////////////////////////////////////////////////////////////////
+#include <string>
+#include <array>
+#include <vector>
+
+template <typename T>
+struct is_contiguous : public std::false_type {};
+
+template <typename CharT, typename Traits, typename Allocator>
+struct is_contiguous<std::basic_string<CharT, Traits, Allocator>> : public std::true_type {};
+
+template <typename T, std::size_t N>
+struct is_contiguous<std::array<T,N>>: public std::true_type {};
+
+template <typename T, typename Allocator>
+struct is_contiguous<std::vector<T,Allocator>>: public std::true_type {};
+
+template <typename T>
+constexpr auto is_contiguous_v = is_contiguous<T>::value;
+
 #endif

From f94be34ae4c1863a9fea295927d9743cf9fcf709 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Thu, 28 Dec 2017 17:49:18 +1100
Subject: [PATCH 46/56] view: add more constructor variants

---
 view.hpp | 184 ++++++++++++++++++++++++++++++++++++++++---------------
 1 file changed, 134 insertions(+), 50 deletions(-)

diff --git a/view.hpp b/view.hpp
index b74c77a6..8384b869 100644
--- a/view.hpp
+++ b/view.hpp
@@ -30,23 +30,47 @@
 #include <iterator>
 
 namespace util {
-    template <typename IteratorA, typename IteratorB = IteratorA>
+    template <typename BeginT, typename EndT = BeginT>
     struct view {
     public:
         //---------------------------------------------------------------------
         using value_type = typename std::iterator_traits<
-            remove_restrict_t<IteratorA>
+            remove_restrict_t<BeginT>
         >::value_type;
 
 
         //---------------------------------------------------------------------
         constexpr
-        view (const IteratorA &first, const IteratorB &last) noexcept:
+        view (const BeginT &first, const EndT &last) noexcept:
             m_begin (first),
             m_end   (last)
         { ; }
 
 
+        //---------------------------------------------------------------------
+        template <typename CountT, typename = std::enable_if_t<std::is_integral_v<CountT>,void>>
+        view (
+            const BeginT &_begin,
+            CountT _size
+        ):
+            view (_begin, _begin + _size)
+        { ; }
+
+
+        //---------------------------------------------------------------------
+        template <
+            typename ValueT,
+            typename = std::enable_if_t<
+                std::is_same_v<BeginT, const ValueT*> &&
+                std::is_same_v<EndT, const ValueT*>
+            >
+        >
+        view (const view<ValueT*,ValueT*> &rhs):
+            m_begin (rhs.begin ()),
+            m_end   (rhs.end   ())
+        { ; }
+
+
         //---------------------------------------------------------------------
         // explicitly cater for the char array case so that we don't
         // accidentally include the trailing null in the data.
@@ -93,18 +117,40 @@ namespace util {
 
 
         //---------------------------------------------------------------------
-        template <typename ContainerT>
+        template <typename CharT, typename Traits, typename Allocator>
+        view (std::basic_string<CharT,Traits,Allocator> &val):
+            view (std::data (val), std::data (val) + std::size (val))
+        { ; }
+
+
+        //---------------------------------------------------------------------
+        // non-contigous containers should use their begin/end iterators
+        // directly
+        template <
+            typename ContainerT,
+            typename std::enable_if_t<!is_contiguous_v<ContainerT>,ContainerT*> = nullptr
+        >
         constexpr explicit
-        view (ContainerT &klass):
+        view (
+            ContainerT &klass
+        ):
             view (std::begin (klass), std::end (klass))
         { ; }
 
 
         //---------------------------------------------------------------------
-        template <typename ContainerT>
+        // contiguous containers are often used with pointers to their contents
+        // for other operations so we directly construct them using pointers to
+        // their data for user convenience.
+        template <
+            typename ContainerT,
+            typename std::enable_if_t<is_contiguous_v<ContainerT>,ContainerT*> = nullptr
+        >
         constexpr explicit
-        view (const ContainerT &klass):
-            view (std::begin (klass), std::end (klass))
+        view (
+            ContainerT &klass
+        ):
+            view (std::data (klass), std::data (klass) + std::size (klass))
         { ; }
 
 
@@ -125,29 +171,30 @@ namespace util {
             m_begin = rhs.m_begin;
             m_end = rhs.m_end;
 
-            rhs.m_begin = IteratorA{};
-            rhs.m_end = IteratorB{};
+            rhs.m_begin = BeginT{};
+            rhs.m_end = EndT{};
 
             return *this;
         };
 
 
         ///////////////////////////////////////////////////////////////////////
-        constexpr IteratorA begin (void) noexcept { return m_begin; }
-        constexpr IteratorB end   (void) noexcept { return m_end;   }
+        constexpr BeginT begin (void) noexcept { return m_begin; }
+        constexpr EndT end   (void) noexcept { return m_end;   }
 
         //---------------------------------------------------------------------
-        constexpr const IteratorA begin (void) const noexcept { return cbegin (); }
-        constexpr const IteratorB end   (void) const noexcept { return cend   (); }
+        constexpr const BeginT begin (void) const noexcept { return cbegin (); }
+        constexpr const EndT end   (void) const noexcept { return cend   (); }
 
         //---------------------------------------------------------------------
-        constexpr const IteratorA cbegin (void) const noexcept { return m_begin; }
-        constexpr const IteratorB cend   (void) const noexcept { return m_end;   }
+        constexpr const BeginT cbegin (void) const noexcept { return m_begin; }
+        constexpr const EndT cend   (void) const noexcept { return m_end;   }
 
         //---------------------------------------------------------------------
         auto data (void)       { return begin (); }
         auto data (void) const { return begin (); }
 
+
         ///////////////////////////////////////////////////////////////////////
         constexpr bool
         empty (void) const noexcept
@@ -174,40 +221,34 @@ namespace util {
 
 
         //---------------------------------------------------------------------
-        // returns a view that has the same end iterator, but the provided
-        // begin iterator.
-        //
-        // the new begin iterator must be reachable by incrementing the current
-        // begin iterator but lie before reaching the end iterator. ie, in the
-        // middle.
-        //
-        // useful for resizing views after options which incrementally consume
-        // the referenced data.
-        [[gnu::warn_unused_result]] constexpr auto
-        increment (IteratorA _begin) const
+        util::view<BeginT,EndT>
+        operator- (util::view<BeginT,BeginT> prefix) const
         {
-            return view { _begin, m_end };
+            CHECK_EQ (prefix.begin (), begin ());
+            return { prefix.end (), end () };
         }
 
 
-        //---------------------------------------------------------------------
-        [[gnu::warn_unused_result]] constexpr auto
-        increment (int count) const
+        ///////////////////////////////////////////////////////////////////////
+        template <
+            typename ValueT,
+            typename = std::enable_if_t<
+                std::is_pointer_v<BeginT> &&
+                    sizeof (*std::declval<BeginT> ()) == sizeof (ValueT)
+                ,
+                void
+            >
+        >
+        view<ValueT*>
+        cast (void) const
         {
-            IteratorA next;
-            std::advance (next, count);
-            return increment (next);
+            return {
+                reinterpret_cast<ValueT*> (m_begin),
+                reinterpret_cast<ValueT*> (m_end)
+            };
         }
 
 
-        //---------------------------------------------------------------------
-        template <typename IteratorC>
-        [[gnu::warn_unused_result]] constexpr auto
-        decrement (IteratorC _end)
-        {
-            return view { m_begin, _end };
-        };
-
 
         ///////////////////////////////////////////////////////////////////////
         constexpr auto&
@@ -229,11 +270,51 @@ namespace util {
 
     private:
         ///////////////////////////////////////////////////////////////////////
-        IteratorA m_begin;
-        IteratorB m_end;
+        BeginT m_begin;
+        EndT m_end;
     };
 
 
+    //-------------------------------------------------------------------------
+    template <typename ValueT, std::size_t N>
+    view (const ValueT(&)[N]) -> view<const ValueT*,const ValueT*>;
+
+
+    //-------------------------------------------------------------------------
+    template <
+        typename IteratorT,
+        typename SizeT,
+        typename = std::enable_if_t<
+            std::is_integral_v<SizeT>,void
+        >
+    >
+    view (IteratorT, SizeT) -> view<IteratorT,IteratorT>;
+
+
+    //-------------------------------------------------------------------------
+    template <
+        typename ContainerT,
+        typename = std::enable_if_t<is_contiguous_v<ContainerT>, void>
+    >
+    view (ContainerT&) -> view<
+        typename ContainerT::value_type*,
+        typename ContainerT::value_type*
+    >;
+
+
+    //-------------------------------------------------------------------------
+    template <
+        typename ContainerT,
+        typename = std::enable_if_t<!is_contiguous_v<ContainerT>, void>
+    >
+    view (ContainerT&) -> view<
+        decltype (std::begin (std::declval<ContainerT> ())),
+        decltype (std::end   (std::declval<ContainerT> ()))
+    >;
+
+
+
+
     ///////////////////////////////////////////////////////////////////////////
     template <typename ValueT, size_t N>
     auto
@@ -273,16 +354,17 @@ namespace util {
     auto
     make_cview (const ContainerT &t)
     {
-        return util::view<decltype(std::cbegin (t))> { std::cbegin (t), std::cend (t) };
+        return make_view (t);
+        //return util::view<decltype(std::cbegin (t))> { std::cbegin (t), std::cend (t) };
     }
 
 
     //-------------------------------------------------------------------------
-    template <typename IteratorA, typename IteratorB>
+    template <typename BeginT, typename EndT>
     auto
-    make_view (IteratorA first, IteratorB last)
+    make_view (BeginT first, EndT last)
     {
-        return view<IteratorA, IteratorB> {first, last};
+        return view<BeginT, EndT> {first, last};
     }
 
     //-------------------------------------------------------------------------
@@ -300,6 +382,7 @@ namespace util {
         return { str, str + strlen (str) };
     }
 
+
     //-------------------------------------------------------------------------
     inline
     view<char*> make_view (char *str)
@@ -343,10 +426,11 @@ namespace util {
     view<CharT*>
     make_view (std::basic_string<CharT,TraitsT,AllocT>&&) = delete;
 
+
     ///////////////////////////////////////////////////////////////////////////
-    template <typename IteratorA, typename IteratorB>
+    template <typename BeginT, typename EndT>
     constexpr bool
-    operator== (const view<IteratorA> &a, const view<IteratorB> &b)
+    operator== (const view<BeginT> &a, const view<EndT> &b)
     {
         return a.size () == b.size () &&
                std::equal (std::begin (a), std::end (a), std::begin (b));

From f2fa90d0430e2dbf7dffd0e1704b586890ccbb40 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Thu, 28 Dec 2017 17:49:58 +1100
Subject: [PATCH 47/56] io: return views from write wrappers

---
 io.hpp | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/io.hpp b/io.hpp
index 8582748b..4ed8a543 100644
--- a/io.hpp
+++ b/io.hpp
@@ -49,7 +49,7 @@ namespace util {
 
     //-------------------------------------------------------------------------
     inline void
-    write (const posix::fd &dst, util::view<const char*> data)
+    write (const posix::fd &dst, util::view<const uint8_t*> data)
     {
         write (dst, std::data (data), std::size (data));
     }
@@ -74,12 +74,13 @@ namespace util {
     /// in this event the progress may not be reported to the caller. in the
     /// future an exception member variable may expose the information.
     template <typename DstT, typename IteratorA, typename IteratorB>
-    void
-    write (DstT &dst, util::view<IteratorA, IteratorB> src)
+    util::view<IteratorA,IteratorB>
+    write (DstT &dst, const util::view<IteratorA, IteratorB> src)
     {
-        for (auto cursor = src.begin (); cursor != src.end (); ) {
-            cursor = dst.write (view{cursor, src.end ()});
-        }
+        auto remain = src;
+        while (!remain.empty ())
+            remain = src - dst.write (remain);
+        return src;
     }
 
 

From 59b21e67dd7b3aca60c21d46ed8262415392a4c0 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Sat, 30 Dec 2017 13:38:11 +1100
Subject: [PATCH 48/56] time: more inline implementation into the header

---
 CMakeLists.txt |  1 -
 time.hpp       | 30 ++++++++++++++++++++----------
 time.ipp       | 28 ----------------------------
 3 files changed, 20 insertions(+), 39 deletions(-)
 delete mode 100644 time.ipp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index f7895cb8..20729385 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -400,7 +400,6 @@ list (
     term.hpp
     time.cpp
     time.hpp
-    time.ipp
     tuple.cpp
     tuple.hpp
     typeidx.cpp
diff --git a/time.hpp b/time.hpp
index 60c12b1a..24ffed5a 100644
--- a/time.hpp
+++ b/time.hpp
@@ -25,15 +25,24 @@
 
 
 namespace util {
-    // ------------------------------------------------------------------------
+    ///////////////////////////////////////////////////////////////////////////
     uintmax_t nanoseconds (void);
 
-    template <typename T>
-    void sleep (std::chrono::duration<T,std::nano>);
 
+    //-------------------------------------------------------------------------
+    template <typename T>
+    void sleep (std::chrono::duration<T,std::nano> dt)
+    {
+        auto nano = std::chrono::duration_cast<std::chrono::nanoseconds> (dt);
+        sleep (nano.count ());
+    }
+
+
+    //-------------------------------------------------------------------------
     void sleep (uint64_t ns);
 
-    // ------------------------------------------------------------------------
+
+    ///////////////////////////////////////////////////////////////////////////
     class delta_clock {
         public:
             delta_clock ();
@@ -46,7 +55,8 @@ namespace util {
             } time;
     };
 
-    // ------------------------------------------------------------------------
+
+    ///////////////////////////////////////////////////////////////////////////
     class period_query {
         public:
             explicit period_query (float seconds);
@@ -60,7 +70,8 @@ namespace util {
             } m_time;
     };
 
-    // ------------------------------------------------------------------------
+
+    ///////////////////////////////////////////////////////////////////////////
     class rate_limiter {
         public:
             explicit rate_limiter (unsigned rate);
@@ -72,7 +83,8 @@ namespace util {
             unsigned m_target;
     };
 
-    // ------------------------------------------------------------------------
+
+    ///////////////////////////////////////////////////////////////////////////
     class polled_duration {
         public:
             polled_duration (std::string name, uint64_t interval);
@@ -90,6 +102,4 @@ namespace util {
     };
 }
 
-#include "time.ipp"
-
-#endif // __UTIL_TIME_HPP
+#endif
diff --git a/time.ipp b/time.ipp
deleted file mode 100644
index a1c1604b..00000000
--- a/time.ipp
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2016 Danny Robson <danny@nerdcruft.net>
- */
-
-#ifndef __UTIL_TIME_IPP
-#define __UTIL_TIME_IPP
-
-template <typename T>
-void
-util::sleep (std::chrono::duration<T,std::nano> dt)
-{
-    auto nano = std::chrono::duration_cast<std::chrono::nanoseconds> (dt);
-    sleep (nano.count ());
-}
-
-#endif

From dd69da09c35a2a8f0b68d8ad6251f10f2e046dbb Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Sat, 30 Dec 2017 13:39:12 +1100
Subject: [PATCH 49/56] m/b/circular: template based on data type

---
 memory/buffer/circular.cpp | 32 ++++++++++++++++++++++----------
 memory/buffer/circular.hpp | 19 +++++++++++--------
 2 files changed, 33 insertions(+), 18 deletions(-)

diff --git a/memory/buffer/circular.cpp b/memory/buffer/circular.cpp
index cd447e20..822c4afb 100644
--- a/memory/buffer/circular.cpp
+++ b/memory/buffer/circular.cpp
@@ -54,7 +54,8 @@ tmpname (std::string &str, size_t length)
 
 
 ///////////////////////////////////////////////////////////////////////////////
-circular::circular (size_t bytes)
+template <typename ValueT>
+circular<ValueT>::circular (size_t bytes)
 {
     bytes = max (bytes, sizeof (value_type));
     bytes = round_up (bytes, pagesize ());
@@ -89,7 +90,9 @@ circular::circular (size_t bytes)
     // pre-allocate a sufficiently large virtual memory block. it doesn't
     // matter much what flags we use because we'll just be overwriting it
     // shortly.
-    m_begin = reinterpret_cast<char*> (mmap (nullptr, bytes * 2, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0));
+    m_begin = reinterpret_cast<ValueT*> (
+        mmap (nullptr, bytes * 2, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0)
+    );
     if (MAP_FAILED == m_begin)
         posix::error::throw_code ();
 
@@ -101,8 +104,8 @@ circular::circular (size_t bytes)
     auto prot = PROT_READ | PROT_WRITE;
     auto flag = MAP_FIXED | MAP_SHARED;
 
-    m_begin = reinterpret_cast<char*> (mmap (m_begin,         bytes, prot, flag, fd, 0));
-    m_end   = reinterpret_cast<char*> (mmap (m_begin + bytes, bytes, prot, flag, fd, 0));
+    m_begin = reinterpret_cast<ValueT*> (mmap (m_begin,         bytes, prot, flag, fd, 0));
+    m_end   = reinterpret_cast<ValueT*> (mmap (m_begin + bytes, bytes, prot, flag, fd, 0));
 
     if (m_begin == MAP_FAILED || m_end == MAP_FAILED)
         posix::error::throw_code ();
@@ -113,7 +116,8 @@ circular::circular (size_t bytes)
 
 
 //-----------------------------------------------------------------------------
-circular::~circular ()
+template <typename ValueT>
+circular<ValueT>::~circular ()
 {
     auto res = munmap (m_begin, 2 * (m_end - m_begin));
     (void)res;
@@ -122,24 +126,32 @@ circular::~circular ()
 
 
 ///////////////////////////////////////////////////////////////////////////////
-char*
-circular::begin (void)&
+template <typename ValueT>
+ValueT*
+circular<ValueT>::begin (void)&
 {
     return m_begin;
 }
 
 
 //-----------------------------------------------------------------------------
-char*
-circular::end (void)&
+template <typename ValueT>
+ValueT*
+circular<ValueT>::end (void)&
 {
     return m_end;
 }
 
 
 ///////////////////////////////////////////////////////////////////////////////
+template <typename ValueT>
 size_t
-circular::size (void) const
+circular<ValueT>::size (void) const
 {
     return m_end - m_begin;
 }
+
+
+///////////////////////////////////////////////////////////////////////////////
+template class util::memory::buffer::circular<char>;
+template class util::memory::buffer::circular<uint8_t>;
diff --git a/memory/buffer/circular.hpp b/memory/buffer/circular.hpp
index 387cb9c2..36dcf6af 100644
--- a/memory/buffer/circular.hpp
+++ b/memory/buffer/circular.hpp
@@ -23,9 +23,12 @@ namespace util::memory::buffer {
     // buffer size is advisory and will likely depend on page size. the user
     // must check the size after creation if this field is important for
     // their usage.
+    template <typename ValueT>
     class circular {
     public:
-        using value_type = char;
+        using value_type = ValueT;
+        using iterator = value_type*;
+        using const_iterator = const value_type*;
 
         explicit circular (size_t bytes);
         ~circular ();
@@ -35,19 +38,19 @@ namespace util::memory::buffer {
         circular& operator= (const circular&) = delete;
         circular& operator= (circular&&) = delete;
 
-        char& operator[] (size_t)&;
-        const char& operator[] (size_t) const&;
+        value_type& operator[] (size_t)&;
+        const value_type& operator[] (size_t) const&;
 
-        char* begin (void)&;
-        char* end   (void)&;
+        iterator begin (void)&;
+        iterator end   (void)&;
 
-        const char* begin (void) const&;
-        const char* end   (void) const&;
+        const_iterator begin (void) const&;
+        const_iterator end   (void) const&;
 
         size_t size (void) const;
 
     private:
-        char *m_begin, *m_end;
+        value_type *m_begin, *m_end;
 
     };
 }

From 52aa37dbf7efe2dafa9c4e2cb4f557891f454196 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Sat, 30 Dec 2017 13:39:42 +1100
Subject: [PATCH 50/56] m/b/circular: add pointer rebalancing operation

---
 memory/buffer/circular.cpp | 29 +++++++++++++++++++++++++++++
 memory/buffer/circular.hpp |  9 +++++++++
 2 files changed, 38 insertions(+)

diff --git a/memory/buffer/circular.cpp b/memory/buffer/circular.cpp
index 822c4afb..3642f619 100644
--- a/memory/buffer/circular.cpp
+++ b/memory/buffer/circular.cpp
@@ -152,6 +152,35 @@ circular<ValueT>::size (void) const
 }
 
 
+//-----------------------------------------------------------------------------
+template <typename ValueT>
+typename circular<ValueT>::iterator
+circular<ValueT>::constrain (iterator cursor)
+{
+    CHECK_LIMIT (cursor, m_begin, m_begin + 2 * size ());
+
+    return m_begin + (cursor - m_begin) % size ();
+}
+
+
+//-----------------------------------------------------------------------------
+template <typename ValueT>
+util::view<typename circular<ValueT>::iterator>
+circular<ValueT>::constrain (util::view<iterator> window)
+{
+    CHECK_LIMIT (window.begin (), m_begin, m_begin + 2 * size ());
+    CHECK_LIMIT (window.end   (), m_begin, m_begin + 2 * size ());
+
+    auto first = window.begin ();
+    auto last  = first + window.size ();
+    util::view res { first, last };
+
+    CHECK_EQ (res.size (), window.size ());
+    CHECK_LE (res.begin (), res.end ());
+    return res;
+}
+
+
 ///////////////////////////////////////////////////////////////////////////////
 template class util::memory::buffer::circular<char>;
 template class util::memory::buffer::circular<uint8_t>;
diff --git a/memory/buffer/circular.hpp b/memory/buffer/circular.hpp
index 36dcf6af..f37785ab 100644
--- a/memory/buffer/circular.hpp
+++ b/memory/buffer/circular.hpp
@@ -17,6 +17,8 @@
 #ifndef __UTIL_MEMORY_BUFFER_CIRCULAR_HPP
 #define __UTIL_MEMORY_BUFFER_CIRCULAR_HPP
 
+#include "../../view.hpp"
+
 #include <cstddef>
 
 namespace util::memory::buffer {
@@ -49,6 +51,13 @@ namespace util::memory::buffer {
 
         size_t size (void) const;
 
+        /// rebases the pointer so that it points to within the first
+        /// repetition of the data buffer.
+        iterator constrain (iterator);
+        /// rebases a pair of pointers so they fall within a contiguous span of
+        /// the data buffer.
+        util::view<iterator> constrain (util::view<iterator>);
+
     private:
         value_type *m_begin, *m_end;
 

From 0f450b5b1c9390d194c11f5e8d61b44b53f9cb45 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Sat, 30 Dec 2017 13:40:04 +1100
Subject: [PATCH 51/56] p/socket: correctly iterate through name lookups

---
 posix/socket.cpp | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/posix/socket.cpp b/posix/socket.cpp
index 1eeffce0..c659e82c 100644
--- a/posix/socket.cpp
+++ b/posix/socket.cpp
@@ -58,6 +58,7 @@ public:
         m_addresses.reset (_addresses);
     };
 
+    // TODO: use a wrapper that supports the increment operator
     auto begin (void) const { return m_addresses.get (); }
     auto end   (void) const { return nullptr; }
 
@@ -70,7 +71,9 @@ private:
 static util::posix::fd
 connect_host (const util::view<const char*> host, int port)
 {
-    for (const auto &info: lookup { host, port }) {
+    lookup l {host,port};
+    for (auto _info = l.begin (); _info; _info = _info->ai_next) {
+        auto &info = *_info;
         util::posix::fd sock {
             socket (info.ai_family, info.ai_socktype, info.ai_protocol)
         };

From dc010d87becd0ee6265594ba8a2e77e7b1b34c20 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Sat, 30 Dec 2017 13:40:37 +1100
Subject: [PATCH 52/56] view: add yet more constructors

---
 view.hpp | 123 +++++++++++++++++++++++++++++++++----------------------
 1 file changed, 73 insertions(+), 50 deletions(-)

diff --git a/view.hpp b/view.hpp
index 8384b869..6b4fedae 100644
--- a/view.hpp
+++ b/view.hpp
@@ -48,7 +48,12 @@ namespace util {
 
 
         //---------------------------------------------------------------------
-        template <typename CountT, typename = std::enable_if_t<std::is_integral_v<CountT>,void>>
+        // cosntruction from pointer/size represenations for ease of use with
+        // legacy C code.
+        template <
+            typename CountT,
+            typename = std::enable_if_t<std::is_integral_v<CountT>,void>
+        >
         view (
             const BeginT &_begin,
             CountT _size
@@ -58,11 +63,12 @@ namespace util {
 
 
         //---------------------------------------------------------------------
+        // implicit conversion from pointer views to const pointer views
         template <
             typename ValueT,
             typename = std::enable_if_t<
                 std::is_same_v<BeginT, const ValueT*> &&
-                std::is_same_v<EndT, const ValueT*>
+                std::is_same_v<EndT,   const ValueT*>
             >
         >
         view (const view<ValueT*,ValueT*> &rhs):
@@ -76,21 +82,51 @@ namespace util {
         // accidentally include the trailing null in the data.
         template <std::size_t N>
         view (const char (&value)[N]):
-            view (std::begin (value), std::begin (value) + N - 1)
+            view {std::begin (value), std::begin (value) + N - 1}
         {
             static_assert (N > 0);
         }
 
+
+        //---------------------------------------------------------------------
+        view (const char *str):
+            view { str, str + strlen (str) }
+        { ; }
+
+
+        //---------------------------------------------------------------------
+        view (char *str):
+            view (str, str + strlen (str))
+        { ; }
+
+
+        //---------------------------------------------------------------------
+        template <std::size_t N>
+        view (char (&value)[N]):
+            view {std::begin (value), std::begin (value) + N - 1}
+        {
+            static_assert (N > 0);
+        }
+
+
         //---------------------------------------------------------------------
         template <std::size_t N, typename ValueT>
         view (const ValueT(&value)[N]):
-            view (std::begin (value), std::end (value))
+            view {std::begin (value), std::end (value)}
         { ; }
 
+
+        //---------------------------------------------------------------------
+        template <std::size_t N, typename ValueT>
+        view (ValueT(&value)[N]):
+            view {std::begin (value), std::end (value)}
+        { ; }
+
+
         //---------------------------------------------------------------------
         constexpr
         view (const view &rhs) noexcept:
-            view (rhs.m_begin, rhs.m_end)
+            view {rhs.m_begin, rhs.m_end}
         { ; }
 
 
@@ -100,7 +136,7 @@ namespace util {
         // class as a base for unique owning pointers without exposing the
         // begin/end data members to them directly.
         constexpr view (view &&rhs) noexcept:
-            view (std::move (rhs.m_begin), std::move (rhs.m_end))
+            view {std::move (rhs.m_begin), std::move (rhs.m_end)}
         { ; }
 
 
@@ -124,33 +160,23 @@ namespace util {
 
 
         //---------------------------------------------------------------------
-        // non-contigous containers should use their begin/end iterators
-        // directly
-        template <
-            typename ContainerT,
-            typename std::enable_if_t<!is_contiguous_v<ContainerT>,ContainerT*> = nullptr
-        >
-        constexpr explicit
-        view (
-            ContainerT &klass
-        ):
-            view (std::begin (klass), std::end (klass))
+        template <typename CharT, typename Traits, typename Allocator>
+        view (const std::basic_string<CharT,Traits,Allocator> &val):
+            view (std::data (val), std::data (val) + std::size (val))
         { ; }
 
 
         //---------------------------------------------------------------------
-        // contiguous containers are often used with pointers to their contents
-        // for other operations so we directly construct them using pointers to
-        // their data for user convenience.
-        template <
-            typename ContainerT,
-            typename std::enable_if_t<is_contiguous_v<ContainerT>,ContainerT*> = nullptr
-        >
-        constexpr explicit
-        view (
-            ContainerT &klass
-        ):
-            view (std::data (klass), std::data (klass) + std::size (klass))
+        template <typename ValueT, typename AllocatorT>
+        view (const std::vector<ValueT,AllocatorT> &rhs):
+            view (std::data (rhs), std::data (rhs) + std::size (rhs))
+        { ; }
+
+
+        //---------------------------------------------------------------------
+        template <typename ValueT, typename AllocatorT>
+        view (std::vector<ValueT,AllocatorT> &rhs):
+            view (std::data (rhs), std::data (rhs) + std::size (rhs))
         { ; }
 
 
@@ -280,6 +306,12 @@ namespace util {
     view (const ValueT(&)[N]) -> view<const ValueT*,const ValueT*>;
 
 
+    //-------------------------------------------------------------------------
+    view (const char*) -> view<const char*>;
+
+    view (char*) -> view<char*>;
+
+
     //-------------------------------------------------------------------------
     template <
         typename IteratorT,
@@ -291,28 +323,19 @@ namespace util {
     view (IteratorT, SizeT) -> view<IteratorT,IteratorT>;
 
 
-    //-------------------------------------------------------------------------
-    template <
-        typename ContainerT,
-        typename = std::enable_if_t<is_contiguous_v<ContainerT>, void>
-    >
-    view (ContainerT&) -> view<
-        typename ContainerT::value_type*,
-        typename ContainerT::value_type*
-    >;
+    template <typename CharT, typename Traits, typename Allocator>
+    view (std::basic_string<CharT,Traits,Allocator> &) -> view<typename Allocator::pointer>;
 
 
-    //-------------------------------------------------------------------------
-    template <
-        typename ContainerT,
-        typename = std::enable_if_t<!is_contiguous_v<ContainerT>, void>
-    >
-    view (ContainerT&) -> view<
-        decltype (std::begin (std::declval<ContainerT> ())),
-        decltype (std::end   (std::declval<ContainerT> ()))
-    >;
+    template <typename CharT, typename Traits, typename Allocator>
+    view (const std::basic_string<CharT,Traits,Allocator> &) -> view<typename Allocator::const_pointer>;
+
+    template <typename ValueT, typename AllocatorT>
+    view (std::vector<ValueT,AllocatorT>&) -> view<typename AllocatorT::pointer>;
 
 
+    template <typename ValueT, typename AllocatorT>
+    view (const std::vector<ValueT,AllocatorT>&) -> view<typename AllocatorT::const_pointer>;
 
 
     ///////////////////////////////////////////////////////////////////////////
@@ -478,13 +501,13 @@ namespace util {
 
 
     ///////////////////////////////////////////////////////////////////////////
-    template <typename IteratorT>
+    template <typename BeginT, typename EndT>
     std::ostream&
-    operator<< (std::ostream &os, view<IteratorT> val)
+    operator<< (std::ostream &os, view<BeginT, EndT> val)
     {
         std::copy (
             std::cbegin (val),
-            std::cend (val),
+            std::cend   (val),
             std::ostream_iterator<typename decltype(val)::value_type> (os)
         );
 

From ed7ab6cb9efb29a22636c1a5319617257a176792 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Mon, 1 Jan 2018 13:40:34 +1100
Subject: [PATCH 53/56] debug: add validate specialisation for pointers

---
 debug.hpp | 51 +++++++++++++++++++++++++++++++++++++++++++++------
 1 file changed, 45 insertions(+), 6 deletions(-)

diff --git a/debug.hpp b/debug.hpp
index 20dfbd45..8911dec4 100644
--- a/debug.hpp
+++ b/debug.hpp
@@ -427,36 +427,72 @@ namespace util::debug {
     void init (void);
 
 
+    ///////////////////////////////////////////////////////////////////////////
+    // returns true if an instance of type `T' appears to be in a valid state.
+    //
+    // written as a struct rather than a function so that behaviour may be
+    // arbitrarily specialised. all users are free to specialise this struct
+    // with an user types.
+    //
+    // all specialisations must be safe to call on arbitrary data without
+    // exceptions or faults as this mechanism is used to control some
+    // debugging paths which themselves are the configuration points for
+    // throwing/logging/etc behaviour.
     template <typename T>
     struct validator {
-        static bool is_valid (const T&);
+        static bool is_valid (const T&) noexcept;
     };
 
 
+    //-------------------------------------------------------------------------
     template <typename T>
-    bool is_valid (const T &t)
-    { return validator<T>::is_valid (t); }
+    bool is_valid (const T &t) noexcept
+    {
+        return validator<T>::is_valid (t);
+    }
 
 
+    //-------------------------------------------------------------------------
     template <
         template<size_t, typename...> class T,
         size_t S,
         typename ...Args
     >
     struct validator<T<S,Args...>> {
-        static bool is_valid (const T<S,Args...>&);
+        static bool is_valid (const T<S,Args...>&) noexcept;
     };
 
 
+    //-------------------------------------------------------------------------
     template <
         template<size_t,typename...> class T,
         size_t S,
         typename ...Args
     >
-    bool is_valid (const T<S,Args...> &v)
-    { return validator<T<S,Args...>>::is_valid (v); }
+    bool is_valid (const T<S,Args...> &v) noexcept
+    {
+        return validator<T<S,Args...>>::is_valid (v);
+    }
 
 
+    //-------------------------------------------------------------------------
+    // forwarding validator from a pointer type to a reference type.
+    //
+    // null pointers are assumed to be invalid
+    template <typename T>
+    struct validator<T*> {
+        static bool is_valid (const T *val) noexcept
+        {
+            return val && ::util::debug::is_valid (*val);
+        }
+    };
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    // asserts that an instance of type `T' is in a valid state.
+    //
+    // behaviour will be controlled by NDEBUG and other assertion machinery and
+    // so may be optimised out entirely in optimised builds.
     template <typename T>
     void sanity (const T &t)
     {
@@ -465,6 +501,7 @@ namespace util::debug {
     }
 
 
+    //-------------------------------------------------------------------------
     template <
         template<typename...> class T,
         typename ...Args
@@ -477,6 +514,8 @@ namespace util::debug {
 }
 
 
+
+
 #include "debug.ipp"
 
 

From 4bd693a7991d83539ceb80f4e7f3436f24f549f3 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Mon, 1 Jan 2018 15:45:56 +1100
Subject: [PATCH 54/56] maths: allow any integral exponent for pow()

---
 bezier3.cpp              |  4 ++--
 cmdopt.cpp               | 12 ++++++------
 maths.hpp                | 16 ++++++++++++----
 test/roots/bisection.cpp |  6 +++---
 4 files changed, 23 insertions(+), 15 deletions(-)

diff --git a/bezier3.cpp b/bezier3.cpp
index 0721b924..d9262b82 100644
--- a/bezier3.cpp
+++ b/bezier3.cpp
@@ -30,10 +30,10 @@ namespace util {
         CHECK_GE (t, 0);
         CHECK_LE (t, 1);
 
-        auto v0 =     pow  (1 - t, 3)  * m_points[0];
+        auto v0 =     pow  (1 - t, 3u) * m_points[0];
         auto v1 = 3 * pow2 (1 - t) * t * m_points[1];
         auto v2 = 3 * pow2 (1 - t) * t * m_points[2];
-        auto v3 =     pow  (t, 3)      * m_points[3];
+        auto v3 =     pow  (t,     3u) * m_points[3];
 
         return {
             v0.x + v1.x + v2.x + v3.x,
diff --git a/cmdopt.cpp b/cmdopt.cpp
index 875d9d27..402d8baf 100644
--- a/cmdopt.cpp
+++ b/cmdopt.cpp
@@ -192,27 +192,27 @@ suffix_to_multiplier (char c)
     switch (c) {
     case 'e':
     case 'E':
-        return util::pow (1024UL, 6);
+        return util::pow (1024UL, 6u);
 
     case 'p':
     case 'P':
-        return util::pow (1024UL, 5);
+        return util::pow (1024UL, 5u);
 
     case 't':
     case 'T':
-        return util::pow (1024UL, 4);
+        return util::pow (1024UL, 4u);
 
     case 'g':
     case 'G':
-        return util::pow (1024UL, 3);
+        return util::pow (1024UL, 3u);
 
     case 'm':
     case 'M':
-        return util::pow (1024UL, 2);
+        return util::pow (1024UL, 2u);
 
     case 'k':
     case 'K':
-        return util::pow (1024UL, 1);
+        return util::pow (1024UL, 1u);
 
     default:
         const char str[2] = { c, '\0' };
diff --git a/maths.hpp b/maths.hpp
index 24ad136b..8088a3ff 100644
--- a/maths.hpp
+++ b/maths.hpp
@@ -221,11 +221,19 @@ namespace util {
 
 
     ///////////////////////////////////////////////////////////////////////////
-    template <typename T>
-    constexpr T
-    pow [[gnu::const]] (T x, unsigned y)
+    template <
+        typename BaseT,
+        typename ExponentT,
+        typename = std::enable_if_t<
+            std::is_unsigned_v<ExponentT>,
+            void
+        >
+    >
+    constexpr BaseT
+    pow [[gnu::const]] (BaseT base, ExponentT exponent)
     {
-        return y == 0 ? T{1} : x * pow (x, y - 1);
+        assert (exponent >= 0);
+        return exponent == 0 ? BaseT{1} : base * pow (base, exponent - 1);
     }
 
 
diff --git a/test/roots/bisection.cpp b/test/roots/bisection.cpp
index f0e763b7..81402655 100644
--- a/test/roots/bisection.cpp
+++ b/test/roots/bisection.cpp
@@ -8,9 +8,9 @@ using util::pow;
 
 
 constexpr float order2 (float x) { return x * x + 3 * x - 7.f; }
-constexpr float order4 (float x) { return   10 * pow (x, 4u)
-                                          -270 * pow (x, 2u)
-                                          -140 * pow (x, 1u)
+constexpr float order4 (float x) { return   10 * util::pow (x, 4u)
+                                          -270 * util::pow (x, 2u)
+                                          -140 * util::pow (x, 1u)
                                           +1200; }
 
 struct {

From 9fbfba580ae57781dc62afe4373509c8941ef8b0 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Mon, 1 Jan 2018 15:46:29 +1100
Subject: [PATCH 55/56] maths: allow digits10 for 64 bit integers

---
 maths.hpp      | 27 +++++++++++++++++++++++----
 test/maths.cpp |  4 ++++
 2 files changed, 27 insertions(+), 4 deletions(-)

diff --git a/maths.hpp b/maths.hpp
index 8088a3ff..809bdae9 100644
--- a/maths.hpp
+++ b/maths.hpp
@@ -341,11 +341,29 @@ namespace util {
     }
 
 
-    //-----------------------------------------------------------------------------
-    constexpr
-    unsigned
-    digits10 (uint32_t v) noexcept
+    //-------------------------------------------------------------------------
+    template <
+        typename NumericT,
+        typename = std::enable_if_t<
+            std::is_integral_v<NumericT>,
+            void
+        >
+    >
+    constexpr auto
+    digits10 (NumericT v) noexcept
     {
+        // cascading conditionals are faster, but it's super annoying to write
+        // out for arbitrarily sized types so we use this base case unti
+        // there's actually a performance reason to use another algorithm.
+        int tally = 0;
+        do {
+            v /= 10;
+            ++tally;
+        } while (v);
+
+        return tally;
+
+        /*
         return (v >= 1000000000) ? 10 :
                (v >=  100000000) ?  9 :
                (v >=   10000000) ?  8 :
@@ -356,6 +374,7 @@ namespace util {
                (v >=        100) ?  3 :
                (v >=         10) ?  2 :
                                     1;
+        */
     }
 
 
diff --git a/test/maths.cpp b/test/maths.cpp
index be27388a..f34947fc 100644
--- a/test/maths.cpp
+++ b/test/maths.cpp
@@ -159,6 +159,10 @@ main (void)
     tap.expect_eq (util::min (-2, 0, 2), -2, "variadic min");
     tap.expect_eq (util::max (-2, 0, 2),  2, "variadic max");
 
+    tap.expect_eq (util::digits10( 0), 1, "digits10, 0");
+    tap.expect_eq (util::digits10( 1), 1, "digits10, 1");
+    tap.expect_eq (util::digits10(10), 2, "digits10, 10");
+
     tap.expect_eq (util::pow2 (4u), 16u, "pow2");
 
     static const float POS_ZERO =  1.f / numeric_limits<float>::infinity ();

From 2af828e82dd237b28cb8838b1665c42ae5dd3794 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Mon, 1 Jan 2018 15:47:41 +1100
Subject: [PATCH 56/56] time: add iso8601 parsing

---
 CMakeLists.txt        |   6 +-
 test/time/8601.cpp    |  52 ++++++++++++
 time/parse.hpp        |  38 +++++++++
 time/parse8601.cpp.rl | 179 ++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 274 insertions(+), 1 deletion(-)
 create mode 100644 test/time/8601.cpp
 create mode 100644 time/parse.hpp
 create mode 100644 time/parse8601.cpp.rl

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 20729385..d74a97d5 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -29,6 +29,7 @@ endif()
 RAGEL_TARGET(json-flat json/flat.cpp.rl ${CMAKE_CURRENT_BINARY_DIR}/json/flat.cpp COMPILE_FLAGS -G2)
 RAGEL_TARGET(uri uri.cpp.rl ${CMAKE_CURRENT_BINARY_DIR}/uri.cpp COMPILE_FLAGS -G2)
 RAGEL_TARGET(version version.cpp.rl ${CMAKE_CURRENT_BINARY_DIR}/version.cpp)
+RAGEL_TARGET(parse8601 time/parse8601.cpp.rl ${CMAKE_CURRENT_BINARY_DIR}/time/parse8601.cpp)
 
 
 ###############################################################################
@@ -400,6 +401,8 @@ list (
     term.hpp
     time.cpp
     time.hpp
+    time/parse.hpp
+    time/parse8601.cpp
     tuple.cpp
     tuple.hpp
     typeidx.cpp
@@ -550,8 +553,9 @@ if (TESTS)
         string
         stringid
         strongdef
-        tuple
+        time/8601
         traits
+        tuple
         typeidx
         uri
         utf8
diff --git a/test/time/8601.cpp b/test/time/8601.cpp
new file mode 100644
index 00000000..465082bc
--- /dev/null
+++ b/test/time/8601.cpp
@@ -0,0 +1,52 @@
+#include "tap.hpp"
+
+#include "time/parse.hpp"
+
+
+int
+main (int, char**)
+{
+    util::TAP::logger tap;
+
+    static const char* BAD[] = {
+        "",
+        "foo"
+    };
+
+    for (const auto &t: BAD) {
+        tap.expect_throw<std::invalid_argument> (
+            [t] () { util::time::iso8601::parse (t); },
+            "invalid timestamp '%s'", t
+        );
+    }
+
+    using namespace std::chrono_literals;
+
+    static const struct {
+        const char *string;
+        std::chrono::nanoseconds value;
+        const char *message;
+    } DECODE[] = {
+        { "1970-01-01T00:00:00Z",               0s, "UNIX epoch" },
+        { "1970-01-01T01:01:00+01:01",          0s, "UNIX epoch, +offset" },
+        { "1985-04-12T23:20:50.52Z",    482196050520ms, "fractional UTC time" },
+        { "2000-02-28T01:00:00Z",       951699600s, "leap year, pre-29th" },
+        { "2000-02-29T01:00:00Z",       951786000s, "leap year, on-29th" },
+        { "2000-03-01T01:00:00Z",       951872400s, "leap year, post-29th" },
+        { "1990-12-31T23:59:60Z",       662688000s, "1990 leap second in UTC" },
+        { "1990-12-31T15:59:60-08:00",  662688000s, "1990 leap second in PST" },
+    };
+
+    for (const auto &t: DECODE) {
+        auto val = util::time::iso8601::parse (t.string);
+        tap.expect_eq (val, t.value, "%s", t.message);
+    }
+
+    tap.expect_eq (
+        util::time::iso8601::parse ("1996-12-19T16:39:57-08:00"),
+        util::time::iso8601::parse ("1996-12-20T00:39:57Z"),
+        "timezone equivalence"
+    );
+
+    return tap.status ();
+}
\ No newline at end of file
diff --git a/time/parse.hpp b/time/parse.hpp
new file mode 100644
index 00000000..75cfa4d0
--- /dev/null
+++ b/time/parse.hpp
@@ -0,0 +1,38 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2017 Danny Robson <danny@nerdcruft.net>
+ */
+
+#ifndef CRUFT_UTIL_TIME_PARSE_HPP
+#define CRUFT_UTIL_TIME_PARSE_HPP
+
+#include "../view.hpp"
+
+#include <chrono>
+#include <ratio>
+
+namespace util::time::iso8601 {
+    /// parse ISO8601 formatted datetime strings
+    ///
+    /// returns nanoseconds since the UNIX epoch (excluding leap seconds).
+    ///
+    /// recognises fractional seconds up to the numeric limits of
+    /// std::chrono::nanoseconds.
+    ///
+    /// may throw on improperly formatted strings or unrepresentable values.
+    std::chrono::nanoseconds
+    parse (util::view<const char*>);
+}
+
+#endif
diff --git a/time/parse8601.cpp.rl b/time/parse8601.cpp.rl
new file mode 100644
index 00000000..3c15aecb
--- /dev/null
+++ b/time/parse8601.cpp.rl
@@ -0,0 +1,179 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2017 Danny Robson <danny@nerdcruft.net>
+ */
+
+#include "time/parse.hpp"
+#include "posix/except.hpp"
+
+#include <stdexcept>
+#include <iostream>
+
+
+///////////////////////////////////////////////////////////////////////////////
+%%{
+    # based off rfc3339 rather than iso8601 because the former is public
+
+    machine iso8601;
+
+    date_fullyear = digit{4};
+    date_month    = digit{2};
+    date_mday     = digit{2};
+
+    time_hour     = digit{2};
+    time_minute   = digit{2};
+    time_second   = digit{2};
+
+    time_secfrac  = '.' digit{1,} ${ frac *= 10; frac += fc - '0'; };
+    time_numoffset = ('+' %{dir=1;} | '-' %{dir=-1;})
+                         time_hour   ${ offset.tm_hour *= 10; offset.tm_hour += fc - '0'; }
+                     ':' time_minute ${ offset.tm_min  *= 10; offset.tm_min  += fc - '0'; };
+    time_offset    = 'Z' | time_numoffset;
+
+    partial_time =     time_hour    ${ parts.tm_hour *= 10; parts.tm_hour += fc - '0'; }
+                   ':' time_minute  ${ parts.tm_min  *= 10; parts.tm_min  += fc - '0'; }
+                   ':' time_second  ${ parts.tm_sec  *= 10; parts.tm_sec  += fc - '0'; }
+                       time_secfrac?;
+
+    full_date =     date_fullyear ${ parts.tm_year *= 10; parts.tm_year += fc - '0'; }
+                '-' date_month    ${ parts.tm_mon  *= 10; parts.tm_mon  += fc - '0'; }
+                '-' date_mday     ${ parts.tm_mday *= 10; parts.tm_mday += fc - '0'; };
+
+    full_time = partial_time time_offset;
+
+    date_time := (
+        full_date 'T' full_time
+    )
+    >{ success = false; }
+    %{ success = true;  };
+
+    write data;
+}%%
+
+
+///////////////////////////////////////////////////////////////////////////////
+template <>
+bool
+util::debug::validator<tm>::is_valid (const tm &val) noexcept
+{
+    // we don't test tm_year anywhere here because there isn't a valid range
+    // for years, only that they are expressed as offsets from 1900;
+    return val.tm_sec  >= 0 && val.tm_sec  <=  60 &&
+           val.tm_min  >= 0 && val.tm_min  <   60 &&
+           val.tm_hour >= 0 && val.tm_hour <   24 &&
+           val.tm_mday >  0 && val.tm_mday <=  31 &&
+           val.tm_mon  >= 0 && val.tm_mon  <   12 &&
+           val.tm_wday >= 0 && val.tm_wday <    7 &&
+           val.tm_yday >= 0 && val.tm_yday <= 365;
+}
+
+
+//-----------------------------------------------------------------------------
+std::ostream&
+operator<< (std::ostream &os, const tm&)
+{
+    return os << "{}";
+}
+
+
+//-----------------------------------------------------------------------------
+std::chrono::seconds
+to_epoch (const tm &t)
+{
+    // TODO: it's assumed the user isn't passing in oddities like 36 months or
+    // similar. in the future we can account for this
+    CHECK_SANITY (t);
+
+
+    constexpr int
+    cumulative_days [12] = {
+        0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334
+    };
+
+    constexpr int epoch_year = 1970;
+    const int year = 1900 + t.tm_year;
+
+    // find the number of days since 1970. careful of leap years.
+    time_t secs;
+    secs  = (year - epoch_year) * 365 + cumulative_days[t.tm_mon % 12];
+    secs += (year - epoch_year + epoch_year %   4) /   4;
+    secs -= (year - epoch_year + epoch_year % 100) / 100;
+    secs += (year - epoch_year + epoch_year % 400) / 400;
+
+    const bool is_leap_year = (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0));
+    if (is_leap_year && t.tm_mon < 2)
+        secs--;
+
+    secs += t.tm_mday - 1;
+
+    // hours
+    secs *= 24;
+    secs += t.tm_hour;
+
+    // minutes
+    secs *= 60;
+    secs += t.tm_min;
+
+    // seconds
+    secs *= 60;
+    secs += t.tm_sec;
+
+    if (t.tm_isdst)
+        secs -= 60 * 60;
+
+    return std::chrono::seconds {secs};
+}
+
+
+
+//-----------------------------------------------------------------------------
+std::chrono::nanoseconds
+util::time::iso8601::parse (util::view<const char*> str)
+{
+    int cs;
+    const char *p   = std::begin (str);
+    const char *pe  = std::end    (str);
+    const char *eof = pe;
+
+    bool success = false;
+
+    int dir = 0;
+    int64_t frac = 0;
+    struct tm parts, offset;
+    memset (&parts, 0, sizeof (parts));
+    memset (&offset, 0, sizeof (offset));
+
+    %%write init;
+    %%write exec;
+
+    if (!success)
+        throw std::invalid_argument ("invalid date string");
+
+    parts.tm_year -= 1900;
+    parts.tm_mon  -= 1;
+
+    // compute the timezone offset
+    std::chrono::seconds diff {
+        dir * (offset.tm_hour * 60 * 60 + offset.tm_min * 60)
+    };
+
+    // fractional part
+    auto nano_digits = util::digits10 (std::nano::den-1);
+    auto frac_digits = util::digits10 (frac);
+    auto shift = util::pow (10, unsigned(nano_digits - frac_digits));
+
+    // sum the time_t, timezone offset, and fractional components
+    return to_epoch (parts) - diff + std::chrono::nanoseconds (frac * shift);
+}
+