diff --git a/CMakeLists.txt b/CMakeLists.txt
index d96e4af4..15dd0327 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -26,11 +26,11 @@ endif()
 
 
 ###############################################################################
-RAGEL_TARGET(json-flat json/flat.cpp.rl ${CMAKE_CURRENT_BINARY_DIR}/json/flat.cpp)
-RAGEL_TARGET(uri uri.cpp.rl ${CMAKE_CURRENT_BINARY_DIR}/uri.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 COMPILE_FLAGS -G2)
 RAGEL_TARGET(version version.cpp.rl ${CMAKE_CURRENT_BINARY_DIR}/version.cpp)
 RAGEL_TARGET(format.cpp format.cpp.rl ${CMAKE_CURRENT_BINARY_DIR}/format.cpp)
-
+RAGEL_TARGET(parse8601 time/parse8601.cpp.rl ${CMAKE_CURRENT_BINARY_DIR}/time/parse8601.cpp)
 include_directories(${CMAKE_CURRENT_SOURCE_DIR})
 
 
@@ -76,16 +76,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 (
@@ -93,8 +83,12 @@ list (
     posix/dir.cpp
     posix/dir.hpp
     posix/dir.ipp
+    posix/except.cpp
+    posix/except.hpp
     posix/fd.cpp
     posix/fd.hpp
+    posix/socket.cpp
+    posix/socket.hpp
 )
 
 
@@ -133,6 +127,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
@@ -194,9 +190,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
@@ -212,10 +208,10 @@ list (
     debug.cpp
     debug.hpp
     debug.ipp
+    encode/base.cpp
+    encode/base.hpp
     endian.cpp
     endian.hpp
-    except.cpp
-    except.hpp
     exe.hpp
     extent.cpp
     extent.hpp
@@ -341,7 +337,6 @@ list (
     matrix3.cpp
     matrix4.cpp
     matrix.hpp
-    matrix.ipp
     memory/deleter.cpp
     memory/deleter.hpp
     nocopy.hpp
@@ -406,7 +401,8 @@ list (
     term.hpp
     time.cpp
     time.hpp
-    time.ipp
+    time/parse.hpp
+    time/parse8601.cpp
     tuple.cpp
     tuple.hpp
     typeidx.cpp
@@ -453,7 +449,20 @@ DEPENDS
 
 ###############################################################################
 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})
 
 
 ###############################################################################
@@ -461,6 +470,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 ()
 
 
@@ -494,6 +504,7 @@ if (TESTS)
         crypto/tea
         crypto/xtea
         crypto/xxtea
+        encode/base
         endian
         exe
         extent
@@ -542,8 +553,9 @@ if (TESTS)
         string
         stringid
         strongdef
-        tuple
+        time/8601
         traits
+        tuple
         typeidx
         uri
         utf8
@@ -556,6 +568,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 ()
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/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/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 16be21dd..f9ca676a 100644
--- a/alloc/arena.hpp
+++ b/alloc/arena.hpp
@@ -68,6 +68,6 @@ namespace util::alloc {
     };
 }
 
-#include "./arena.ipp"
+#include "arena.ipp"
 
 #endif
diff --git a/alloc/raw/affix.cpp b/alloc/raw/affix.cpp
index 7f5f681a..b9159357 100644
--- a/alloc/raw/affix.cpp
+++ b/alloc/raw/affix.cpp
@@ -14,7 +14,7 @@
  * Copyright 2015 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./affix.hpp"
+#include "affix.hpp"
 
 using util::alloc::raw::affix;
 
diff --git a/alloc/raw/linear.cpp b/alloc/raw/linear.cpp
index 30501b0d..801aa9fb 100644
--- a/alloc/raw/linear.cpp
+++ b/alloc/raw/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/raw/malloc.cpp b/alloc/raw/malloc.cpp
index 4901c92a..86eb5238 100644
--- a/alloc/raw/malloc.cpp
+++ b/alloc/raw/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/raw/null.cpp b/alloc/raw/null.cpp
index c885f6e9..cc3ce234 100644
--- a/alloc/raw/null.cpp
+++ b/alloc/raw/null.cpp
@@ -15,7 +15,7 @@
  */
 
 
-#include "./null.hpp"
+#include "null.hpp"
 
 #include "../../debug.hpp"
 
diff --git a/alloc/raw/stack.cpp b/alloc/raw/stack.cpp
index 1f297e2c..d525c906 100644
--- a/alloc/raw/stack.cpp
+++ b/alloc/raw/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..50b75a57 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>
@@ -77,7 +77,7 @@ namespace util::ascii {
 
     //-------------------------------------------------------------------------
     constexpr inline
-    unsigned
+    uint8_t
     from_hex (char c)
     {
         return c >= '0' && c <= '9' ? (c - '0'     ) :
diff --git a/backtrace_execinfo.cpp b/backtrace_execinfo.cpp
index 40176d78..c7d4b2f8 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..a1535d0f 100644
--- a/backtrace_stackwalk.cpp
+++ b/backtrace_stackwalk.cpp
@@ -14,11 +14,12 @@
  * 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 "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 ae5470a0..5ed8aee8 100644
--- a/backtrace_win32.cpp
+++ b/backtrace_win32.cpp
@@ -15,11 +15,12 @@
  *      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/error.hpp"
+#include "win32/handle.hpp"
+#include "debug.hpp"
+#include "except.hpp"
 
 #include <cstdlib>
 #include <windows.h>
@@ -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/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..d9262b82 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"
 
@@ -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/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..402d8baf 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>
@@ -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/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 f8a0fd7c..84f31749 100644
--- a/colour.cpp
+++ b/colour.cpp
@@ -14,454 +14,45 @@
  * 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 <array>
-#include <map>
-
-///////////////////////////////////////////////////////////////////////////////
-using util::colour;
-using util::colour3f;
-using util::colour4f;
+#include "ascii.hpp"
+#include "parse.hpp"
 
 
 ///////////////////////////////////////////////////////////////////////////////
-template <size_t S, typename T>
-colour<S,T>
-colour<S,T>::parse_html (const char *fmt)
+static util::srgba4f
+parse_hex (util::view<const char*> str)
 {
-    // ensure the format is the correct length
-    auto len = strlen (fmt);
+    if (str.size () != strlen ("#012345"))
+        throw std::invalid_argument ("expected length of 7");
 
-    switch (len) {
-    case 1 + 2 * S:
-        if (*fmt != '#')
-            throw std::invalid_argument ("missing leading hash");
-        ++fmt;
-        break;
+    if (str[0] != '#')
+        throw std::invalid_argument ("expected leading '#'");
 
-    case 2 * S:
-        break;
-
-    default:
-        throw std::invalid_argument ("format is the wrong length");
+    if (!util::ascii::is_hex (str[1]) ||
+        !util::ascii::is_hex (str[2]) ||
+        !util::ascii::is_hex (str[3]) ||
+        !util::ascii::is_hex (str[4]) ||
+        !util::ascii::is_hex (str[5]) ||
+        !util::ascii::is_hex (str[6]))
+    {
+        throw std::invalid_argument ("expected hex digits");
     }
 
-    // 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]);
+    uint8_t r = util::ascii::from_hex (str[1]) << 4u | util::ascii::from_hex (str[2]);
+    uint8_t g = util::ascii::from_hex (str[3]) << 4u | util::ascii::from_hex (str[4]);
+    uint8_t b = util::ascii::from_hex (str[5]) << 4u | util::ascii::from_hex (str[6]);
 
-        res[i] = (a << 4u) | b;
-    }
-
-    return res.template cast<T> ();
+    return util::srgba<4,uint8_t> { r, g, b, 255 }.template cast<float> ();
 }
 
 
+
 ///////////////////////////////////////////////////////////////////////////////
-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
+template <>
+util::srgba4f
+util::parse<util::srgba4f> (util::view<const char*> str)
 {
-    /* 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)
-{
-    return os << "[ " << util::make_infix (util::numeric_view (c), ", ") << ']';
-}
-
-
-//-----------------------------------------------------------------------------
-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,uint16_t) \
-INSTANTIATE_S_T(S,float)    \
-INSTANTIATE_S_T(S,double)
-
-
-//-----------------------------------------------------------------------------
-INSTANTIATE_S(1)
-INSTANTIATE_S(3)
-INSTANTIATE_S(4)
+    return parse_hex (str);
+}
\ No newline at end of file
diff --git a/colour.hpp b/colour.hpp
index 7bed5b15..3c7273eb 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,98 @@
 #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>;
+
+    using srgba3u = srgba<3,uint8_t>;
+    using srgba4u = srgba<4,uint8_t>;
+
+    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 2afb74bd..41c370d6 100644
--- a/coord/base.hpp
+++ b/coord/base.hpp
@@ -17,36 +17,46 @@
 #ifndef CRUFT_UTIL_COORD_BASE_HPP
 #define CRUFT_UTIL_COORD_BASE_HPP
 
-#include "init.hpp"
+#include "fwd.hpp"
 
-#include "./ops.hpp"
+#include "ops.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 <
         std::size_t S,
         typename T,
-        template <std::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 self_t = SelfT;
         using value_type = T;
         static constexpr std::size_t dimension = S;
         static constexpr std::size_t elements = S;
 
         /// returns the number of elements we contain
-        static constexpr std::size_t size (void) { return S; }
+        static constexpr auto size (void) { return S; }
 
-        // inherit the fancy elementwise constructors from `init'.
-        using init<S,T,tags...>::init;
+        // constructors
+        using init<S,T,SelfT>::init;
 
         /// constructs, but does not initialise, the data.
         ///
@@ -63,12 +73,21 @@ namespace util::coord {
                 this->data[i] = fill;
         }
 
-        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;
+        base& operator= (const T t)&
+        {
+            for (auto v: *this)
+                v = t;
+            return *this;
+        }
 
         // element accessors
-        T& operator[] (std::size_t i) { return this->data[i]; }
-        constexpr const T& operator[] (std::size_t 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); }
@@ -95,12 +114,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));
@@ -113,14 +148,21 @@ namespace util::coord {
         ///
         /// explicitly does not allow a fill parameter given it can't be used
         /// when reducing dimensions.
-        template <std::size_t D>
+        template <
+            size_t D,
+            typename _sfinae = SelfT
+        >
         std::enable_if_t<
-            D <= S, KLASS<D,T>
+            has_redim_v<_sfinae>,
+            redim_t<_sfinae,D>
         >
         redim (void) const
         {
-            KLASS<D,T> out;
-            std::copy_n (cbegin (), D, std::begin  (out.data));
+            redim_t<SelfT,D> out;
+
+            std::copy_n (std::cbegin (this->data),
+                         min (S, D),
+                         std::begin  (out.data));
             return out;
         }
 
@@ -132,13 +174,14 @@ namespace util::coord {
         ///
         /// explicitly requires a fill parameter so that we avoid undefined
         /// values.
-        template <std::size_t D>
+        template<size_t D,typename _sfinae = SelfT>
         std::enable_if_t<
-            (D > S), KLASS<D,T>
+            has_redim_v<_sfinae>,
+            redim_t<_sfinae,D>
         >
-        redim (const KLASS<D,T> fill) const
+        redim (const redim_t<_sfinae,D> fill) const
         {
-            KLASS<D,T> out;
+            redim_t<SelfT,D> out;
 
             auto next = std::copy (cbegin (), cend (), std::begin (out));
             std::copy (std::cbegin (fill) + S, std::cend (fill), next);
@@ -151,13 +194,17 @@ namespace util::coord {
         ///
         /// explicitly requires a fill parameter so that we avoid undefined
         /// values.
-        template <std::size_t D>
+        template <
+            size_t D,
+            typename _sfinae = SelfT
+        >
         std::enable_if_t<
-            (D > S), KLASS<D,T>
+            has_redim_v<_sfinae>,
+            redim_t<_sfinae,D>
         >
         redim (T fill) const
         {
-            KLASS<D,T> out;
+            redim_t<SelfT,D> out;
 
             auto next = std::copy (cbegin (), cend (), std::begin (out));
             std::fill (next, std::end (out), fill);
@@ -172,7 +219,7 @@ namespace util::coord {
         /// it's ugly as sin, but simplifies some situations where we don't
         /// want a temporary.
         template <std::size_t ...Indices>
-        KLASS<sizeof...(Indices),T>
+        constexpr auto
         indices (void) const
         {
             static_assert (
@@ -180,11 +227,11 @@ namespace util::coord {
                 "indices must fall within the defined range for the type"
             );
 
-            return KLASS<sizeof...(Indices),T> { this->data[Indices]... };
+            return redim_t<SelfT,sizeof...(Indices)> {
+                this->data[Indices]...
+            };
         }
     };
 }
 
-#include "../vector.hpp"
-
 #endif
diff --git a/coord/fwd.hpp b/coord/fwd.hpp
index 3aecbc39..af80ae0f 100644
--- a/coord/fwd.hpp
+++ b/coord/fwd.hpp
@@ -20,10 +20,17 @@
 #include <cstddef>
 
 namespace util {
-    template <std::size_t,typename> struct colour;
-    template <std::size_t,typename> struct extent;
-    template <std::size_t,typename> struct point;
-    template <std::size_t,typename> struct vector;
+    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;
 }
 
 #endif
diff --git a/coord/init.hpp b/coord/init.hpp
index 68d5555f..04aa12a6 100644
--- a/coord/init.hpp
+++ b/coord/init.hpp
@@ -22,53 +22,53 @@
 #include <cstddef>
 
 namespace util::coord {
-    template <std::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 explicit init (T v0):
-            store<1,T,tags...> ({v0})
+        constexpr init (T 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 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 << "]";
 
diff --git a/coord/names.hpp b/coord/names.hpp
deleted file mode 100644
index d8c9c294..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 CRUFT_UTIL_COORD_NAMES_HPP
-#define CRUFT_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 3b3c6f1b..1fc301d9 100644
--- a/coord/ops.hpp
+++ b/coord/ops.hpp
@@ -14,16 +14,19 @@
  * Copyright 2012-2017 Danny Robson <danny@nerdcruft.net>
  */
 
-#ifndef CRUFT_UTIL_COORDS_OPS
-#define CRUFT_UTIL_COORDS_OPS
+#ifndef __UTIL_COORDS_OPS
+#define __UTIL_COORDS_OPS
 
-#include "./fwd.hpp"
+#include "fwd.hpp"
+#include "traits.hpp"
+
+// we specifically rely on vector<bool> to compute a few logical operations
+#include "../vector.hpp"
 
 #include "../debug.hpp"
 #include "../maths.hpp"
-#include "../types/bits.hpp"
-
 #include "../preprocessor.hpp"
+#include "../types/bits.hpp"
 
 #include <algorithm>
 #include <cmath>
@@ -32,84 +35,46 @@
 #include <functional>
 
 namespace util {
-    ///////////////////////////////////////////////////////////////////////
-    // operation traits
-    namespace coord {
-        template <
-            template <std::size_t,typename> class A,
-            template <std::size_t,typename> class B
-        >
-        struct result { };
-
-        //-------------------------------------------------------------------------
-        template <> struct result<colour,colour> { template <std::size_t S, typename T> using type = colour<S,T>; };
-        template <> struct result<extent,extent> { template <std::size_t S, typename T> using type = extent<S,T>; };
-        template <> struct result<extent,vector> { template <std::size_t S, typename T> using type = extent<S,T>; };
-        template <> struct result<point,extent>  { template <std::size_t S, typename T> using type = point <S,T>; };
-        template <> struct result<point,vector>  { template <std::size_t S, typename T> using type = point <S,T>; };
-        template <> struct result<vector,point>  { template <std::size_t S, typename T> using type = point <S,T>; };
-        template <> struct result<vector,vector> { template <std::size_t S, typename T> using type = vector<S,T>; };
-
-        template <
-            template <std::size_t,typename> class A,
-            template <std::size_t,typename> class B
-        >
-        using result_t = typename result<A,B>::type;
-
-
-        //---------------------------------------------------------------------
-        template <template <std::size_t,typename> class K>
-        struct has_norm : public std::false_type { };
-
-        template <> struct has_norm<vector>     : public std::true_type { };
-
-        template <template <std::size_t,typename> class K>
-        constexpr auto has_norm_v = has_norm<K>::value;
-
-
-        //---------------------------------------------------------------------
-        template <template <std::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 <std::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 <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<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;
-    }
+    // a templated functor that exposes arithmetic and assignment maths
+    // functions for vector-vector or vector-scalar operations.
+    //
+    // 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 {};
 
 
     //-------------------------------------------------------------------------
-    template <typename T>
-    constexpr
-    std::enable_if_t<std::is_arithmetic<T>::value, std::size_t>
-    arity (void)
-    {
-        return 1;
-    }
+    // 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
+            ,
+            void
+        >
+    > {
+        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;
+        }
+    };
 
 
     ///////////////////////////////////////////////////////////////////////////
@@ -139,7 +104,6 @@ namespace util {
 
     MAKE_COORD(extent)
     MAKE_COORD(point)
-    MAKE_COORD(colour)
     MAKE_COORD(vector)
 
 #undef MAKE_COORD
@@ -149,7 +113,7 @@ namespace util {
         typename ...Args
     >
     constexpr auto
-        make_coord (Args &&...args)
+    make_coord (Args &&...args)
     {
         using T = std::common_type_t<Args...>;
         return K<sizeof...(Args),T> { std::forward<Args> (args)... };
@@ -157,176 +121,293 @@ namespace util {
 
 
     ///////////////////////////////////////////////////////////////////////////
-    // vector operators
-#define ELEMENT_OP(OP)                                  \
-    template <                                          \
-        std::size_t S,                                  \
-        typename T,                                     \
-        typename U,                                     \
-        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                                        \
-        >                                               \
-    >                                                   \
-    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 (std::size_t i = 0; i < S; ++i)             \
-            out[i] = a[i] OP b[i];                      \
-        return out;                                     \
-    }                                                   \
-                                                        \
-    template <                                          \
-        std::size_t S,                                  \
-        typename T,                                     \
-        typename U,                                     \
-        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>> &&                       \
-            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 (std::size_t i = 0; i < S; ++i)             \
-            a[i] PASTE(OP,=) b[i];                      \
-        return a;                                       \
-    }
+    template <typename ValueA, typename ValueB, typename=void>
+    struct arithmetic {};
 
-    ELEMENT_OP(+)
-    ELEMENT_OP(-)
-    ELEMENT_OP(*)
-    ELEMENT_OP(/)
-    ELEMENT_OP(%)
-#undef ELEMENT_OP
 
-    ///////////////////////////////////////////////////////////////////////////
-    // scalar operators
-#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<                    \
-            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 (std::size_t i = 0; i < S; ++i)             \
-            out[i] = u OP k[i];                         \
-        return out;                                     \
-    }                                                   \
-                                                        \
-    template <                                          \
-        std::size_t S,                                  \
-        typename T,                                     \
-        typename U,                                     \
-        template <std::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 (std::size_t i = 0; i < S; ++i)             \
-            out[i] = k[i] OP u;                         \
-        return out;                                     \
-    }
+    template <typename CoordA, typename CoordB>
+    struct arithmetic<
+        CoordA,
+        CoordB,
+        std::enable_if_t<
+            is_coord_v<CoordA> &&
+            is_coord_v<CoordB> &&
+            arity_v<CoordA> == arity_v<CoordB> &&
+            has_result_v<CoordA,CoordB>
+            ,
+            void
+        >
+    > {
+        template <typename OperationT>
+        static constexpr auto
+        eval (OperationT &&op, const CoordA &a, const CoordB &b)
+        {
+            using common_t = std::common_type_t<
+                typename CoordA::value_type,
+                typename CoordB::value_type
+            >;
 
-    SCALAR_OP(+)
-    SCALAR_OP(-)
-    SCALAR_OP(*)
-    SCALAR_OP(/)
-    SCALAR_OP(%)
+            revalue_t<result_t<CoordA,CoordB>,common_t> out {};
+            for (size_t i = 0; i < CoordA::elements; ++i)
+                out[i] = op (a[i], b[i]);
+            return out;
+        }
+    };
+
+
+    template <typename CoordT, typename ScalarT>
+    struct arithmetic<
+        CoordT,
+        ScalarT,
+        std::enable_if_t<
+            is_coord_v<CoordT> && std::is_arithmetic_v<ScalarT> && has_scalar_op_v<CoordT>,
+            void
+        >
+    > {
+        template <typename OperationT>
+        static constexpr auto
+        eval (OperationT &&op, const CoordT &coord, const ScalarT &scalar)
+        {
+            using common_t = std::common_type_t<typename CoordT::value_type, ScalarT>;
+            revalue_t<CoordT,common_t> out {};
+            for (size_t i = 0; i < CoordT::elements; ++i)
+                out[i] = op (coord[i], scalar);
+            return out;
+        }
+    };
+
+
+    template <typename ScalarT, typename CoordT>
+    struct arithmetic<
+        ScalarT,
+        CoordT,
+        std::enable_if_t<
+            is_coord_v<CoordT> && std::is_arithmetic_v<ScalarT> && has_scalar_op_v<CoordT>,
+            void
+        >
+    > {
+        template <typename OperationT>
+        static constexpr auto
+        eval (OperationT &&op, const ScalarT &scalar, const CoordT &coord)
+        {
+            using common_t = std::common_type_t<typename CoordT::value_type, ScalarT>;
+            revalue_t<CoordT,common_t> out {};
+            for (size_t i = 0; i < CoordT::elements; ++i)
+                out[i] = op (scalar, coord[i]);
+            return out;
+        }
+    };
 
-#undef SCALAR_OP
 
 
     //-------------------------------------------------------------------------
-    // scalar assignment operators.
-    //
-    // 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 <                                              \
-        std::size_t S,                                      \
-        typename T,                                         \
-        typename U,                                         \
-        template <std::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 (std::size_t i = 0; i < S; ++i)                 \
-            k[i] OP u;                                      \
-                                                            \
-        return k;                                           \
+    // vector-scalar operations
+    template <
+        typename CoordT,
+        typename ScalarT
+    >
+    struct ops<
+        CoordT,
+        ScalarT,
+        std::enable_if_t<
+            is_coord_v<CoordT> &&
+            !is_coord_v<ScalarT> &&
+            has_scalar_op_v<CoordT>
+        >
+    > {
+        // we allow scalar types which can be naturally promoted to the vector's
+        // value_type
+        template <
+            typename OpT,
+            typename = std::enable_if_t<
+                std::is_same_v<
+                    typename CoordT::value_type,
+                    std::common_type_t<
+                        typename CoordT::value_type,
+                        ScalarT
+                    >
+                >,
+                void
+            >
+        >
+        static constexpr CoordT&
+        assignment (OpT &&op, CoordT &c, const ScalarT s)
+        {
+            for (size_t i = 0; i < CoordT::elements; ++i)
+                c[i] = op (c[i], s);
+            return c;
+        }
+    };
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    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 arithmetic<std::decay_t<A>, std::decay_t<B>>::template eval (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 arithmetic<std::decay_t<A>, std::decay_t<B>>::template eval (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 arithmetic<
+            std::decay_t<A>,
+            std::decay_t<B>
+        >::template eval (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 arithmetic<std::decay_t<A>, std::decay_t<B>>::template eval (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::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 assignment (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 assignment (std::divides{}, a, b);
+    }
 
 
     ///////////////////////////////////////////////////////////////////////////
     // unary operators
-
-#define UNARY_OP(OP)                                \
-    template <                                      \
-        std::size_t S,                              \
-        typename T,                                 \
-        template <std::size_t,typename> class K,    \
-        typename = std::enable_if_t<                \
-            is_coord_v<K<S,T>>, void                \
-        >                                           \
-    >                                               \
-    constexpr                                       \
-    auto                                            \
-    operator OP (K<S,T> k)                          \
-    {                                               \
-        K<S,decltype(OP std::declval<T> ())> out{}; \
-                                                    \
-        for (std::size_t i = 0; i < S; ++i)         \
-            out[i] = OP k[i];                       \
-                                                    \
-        return out;                                 \
+#define UNARY_OP(OP)                                    \
+    template <                                          \
+        typename K,                                     \
+        typename = std::enable_if_t<                    \
+            is_coord_v<K>, void                         \
+        >                                               \
+    >                                                   \
+    constexpr                                           \
+    auto                                                \
+    operator OP (K k)                                   \
+    {                                                   \
+        using value_type = decltype(                    \
+            OP std::declval<typename K::value_type> ()  \
+        );                                              \
+                                                        \
+        revalue_t<K,value_type> out {};                 \
+                                                        \
+        for (std::size_t i = 0; i < K::elements; ++i)   \
+            out[i] = OP k[i];                           \
+                                                        \
+        return out;                                     \
     }
 
     UNARY_OP(!)
@@ -336,7 +417,9 @@ namespace util {
 
 #undef UNARY_OP
 
+
     ///////////////////////////////////////////////////////////////////////////
+    // logic operators
     namespace detail {
         template <
             typename RetT,
@@ -382,20 +465,17 @@ namespace util {
     // logic operators
     namespace detail {
         template <
-            std::size_t S,
-            typename T,
-            template <std::size_t,typename> class K,
+            typename K,
             typename FuncT,
             typename = std::enable_if_t<
-                is_coord_v<K<S,T>>,
-                void
+                is_coord_v<K>, void
             >,
             std::size_t ...Indices
         >
         constexpr auto
-        compare (FuncT &&func, std::index_sequence<Indices...>, const K<S,T> a, const K<S,T> b)
+        compare (FuncT &&func, std::index_sequence<Indices...>, const K a, const K b)
         {
-            return vector<S,bool> {
+            return vector<K::elements,bool> {
                 std::invoke (func, a[Indices], b[Indices])...
             };
         }
@@ -404,18 +484,15 @@ namespace util {
 
     //-------------------------------------------------------------------------
     template <
-        std::size_t S,
-        typename T,
-        template <std::size_t,typename> class K,
+        typename K,
         typename FuncT,
         typename = std::enable_if_t<
-            is_coord_v<K<S,T>>,
-            void
+            is_coord_v<K>, void
         >,
-        typename Indices = std::make_index_sequence<S>
+        typename Indices = std::make_index_sequence<K::elements>
     >
     constexpr auto
-    compare (const K<S,T> a, const K<S,T> b, FuncT &&func)
+    compare (const K a, const K b, FuncT &&func)
     {
         return detail::compare (std::forward<FuncT> (func), Indices{}, a, b);
     }
@@ -423,70 +500,61 @@ namespace util {
 
     //-------------------------------------------------------------------------
     template <
-        std::size_t S,
-        typename T,
-        template <std::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 auto
-    compare (const K<S,T> a, const K<S,T> b)
+    compare (const K a, const K b)
     {
-        return compare (a, b, std::equal_to<T> {});
+        return compare (a, b, std::equal_to<typename K::value_type> {});
     }
 
 
     /// elementwise equality operator
     template <
-        std::size_t S,
-        typename T,
-        template <std::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 bool
-    operator== (const K<S,T> a, const K<S,T> b)
+    operator== (const K a, const K b)
     {
-        return all (compare (a, b, std::equal_to<T> {}));
+        return all (compare (a, b, std::equal_to<typename K::value_type> {}));
     }
 
     ///------------------------------------------------------------------------
     /// elementwise inquality operator
     template <
-        std::size_t S,
-        typename T,
-        template <std::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 bool
-    operator!= (const K<S,T> a, const K<S,T> b)
+    operator!= (const K a, const K b)
     {
-        return any (compare (a, b, std::not_equal_to<T> {}));
+        return any (compare (a, b, std::not_equal_to<typename K::value_type> {}));
     }
 
 
     //-------------------------------------------------------------------------
     template <
-        std::size_t S,
-        typename T,
-        template <std::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
     bool
-    almost_zero (const K<S,T> &k)
+    almost_zero (const K &k)
     {
         return std::all_of (
             std::cbegin (k),
             std::cend (k),
-            [] (T t) { return almost_equal (t); }
+            [] (auto t) { return almost_zero (t); }
         );
     }
 
@@ -504,7 +572,10 @@ namespace util {
     vector<S,std::common_type_t<T,U>>
     operator- (point<S,T> a, point<S,U> b)
     {
-        return a.template as<vector> () - b.template as<vector> ();
+        vector<S,std::common_type_t<T,U>> out {};
+        for (std::size_t i = 0; i < S; ++i)
+            out[i] = a[i] - b[i];
+        return out;
     }
 
 
@@ -542,68 +613,75 @@ namespace util {
     }
 
 
-    //-------------------------------------------------------------------------
     template <
         std::size_t S,
         typename T,
-        template <std::size_t,typename> class A,
-        template <std::size_t,typename> class B,
+        typename K,
         typename = std::enable_if_t<
-            is_coord_v<A<S,T>> && is_coord_v<B<S,T>>, void
+            is_coord_v<K> && std::is_same_v<typename K::value_type, T> && K::elements == S,
+            void
         >
     >
     constexpr
     T
-    dot (A<S,T> a, B<S,T> b)
+    dot (const T (&a)[S], K k)
     {
-        return dot<S,T> (a.data, b.data);
+        return dot (a, k.data);
     }
 
 
     //-------------------------------------------------------------------------
     template <
-        std::size_t S,
-        typename T,
-        template <std::size_t,typename> class K,
+        typename A,
+        typename B,
         typename = std::enable_if_t<
-            is_coord_v<K<S,T>>, void
+            is_coord_v<A> && is_coord_v<B>, void
         >
     >
-    constexpr
-    T
-    dot (K<S,T> a, const T (&b)[S])
+    constexpr auto
+    dot (A a, B b)
     {
-        return dot<S,T> (a.data, b);
+        return dot (a.data, b.data);
     }
 
 
     //-------------------------------------------------------------------------
     template <
-        std::size_t S,
+        typename K,
         typename T,
-        template <std::size_t,typename> class K,
         typename = std::enable_if_t<
-            is_coord_v<K<S,T>>, void
+            is_coord_v<K> && std::is_same_v<T,typename K::value_type>, void
         >
     >
-    constexpr
-    T
-    dot (const T (&a)[S], K<S,T> b)
+    constexpr auto
+    dot (K a, const T (&b)[K::elements])
     {
-        return dot<S,T> (a, b.data);
+        return dot (a.data, b);
+    }
+
+
+    //-------------------------------------------------------------------------
+    template <
+        typename K,
+        typename = std::enable_if_t<
+            is_coord_v<K>, void
+        >
+    >
+    constexpr auto
+    dot (const typename K::value_type (&a)[K::elements], K b)
+    {
+        return dot (a, b.data);
     }
 
 
     ///////////////////////////////////////////////////////////////////////////
     template <
-        std::size_t S,
-        typename T,
-        template <std::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);
     }
@@ -611,17 +689,15 @@ namespace util {
 
     //-------------------------------------------------------------------------
     template <
-        std::size_t S,
-        typename T,
-        template <std::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));
     }
@@ -629,55 +705,47 @@ namespace util {
 
     //-------------------------------------------------------------------------
     template <
-        std::size_t S,
-        typename T,
-        template <std::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 <
-        std::size_t S,
-        typename T,
-        template <std::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 <
-        std::size_t S,
-        typename T,
-        template <std::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);
@@ -686,16 +754,14 @@ namespace util {
 
     ///////////////////////////////////////////////////////////////////////////
     template <
-        std::size_t S,
-        typename T,
-        template <std::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);
@@ -705,16 +771,13 @@ namespace util {
     ///////////////////////////////////////////////////////////////////////////
     // root of sum of squares
     template <
-        std::size_t S,
-        typename T,
-        template <std::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
-    T
-    hypot (K<S,T> k)
+    constexpr typename K::value_type
+    hypot (K k)
     {
         return std::sqrt (sum (k * k));
     }
@@ -722,16 +785,14 @@ namespace util {
 
     ///////////////////////////////////////////////////////////////////////////
     template <
-        std::size_t S,
+        typename K,
         typename T,
-        template <std::size_t,typename> class K,
         typename = std::enable_if_t<
-            is_coord_v<K<S,T>>, void
+            is_coord_v<K> && std::is_same_v<T, typename K::value_type>, void
         >
     >
-    constexpr
-    K<S,T>
-    mod (K<S,T> k, T t)
+    constexpr auto
+    mod (K k, T t)
     {
         std::transform (
             std::cbegin (k),
@@ -739,20 +800,18 @@ namespace util {
             std::begin  (k),
             [t] (auto v) { return mod (v, t);
         });
+
         return k;
     }
 
     ///////////////////////////////////////////////////////////////////////////
     // trigonometric functions
     template <
-        std::size_t S,
-        typename T,
-        template <std::size_t,typename> class K,
-        typename = std::enable_if_t<is_coord_v<K<S,T>>,void>
+        typename K,
+        typename = std::enable_if_t<is_coord_v<K>,void>
     >
-    constexpr
-    K<S,T>
-    sin (K<S,T> k)
+    constexpr auto
+    sin (K k)
     {
         std::transform (
             std::cbegin (k),
@@ -767,14 +826,11 @@ namespace util {
 
     //-------------------------------------------------------------------------
     template <
-        std::size_t S,
-        typename T,
-        template <std::size_t,typename> class K,
-        typename = std::enable_if_t<is_coord_v<K<S,T>>,void>
+        typename K,
+        typename = std::enable_if_t<is_coord_v<K>,void>
     >
-    constexpr
-    K<S,T>
-    cos (K<S,T> k)
+    constexpr auto
+    cos (K k)
     {
         std::transform (
             std::cbegin (k),
@@ -792,22 +848,25 @@ namespace util {
 
     /// return a coord type containing the max element at each offset
     template <
-        std::size_t S,
-        typename T,
-        template <std::size_t,typename> class K,
+        typename K,
         typename = std::enable_if_t<
-            is_coord_v<K<S,T>>, void
+            is_coord_v<K>, void
         >,
         typename ...Args
     >
-    constexpr
-    K<S,T>
-    min (K<S,T> a, K<S,T> b, Args &&...args)
+    constexpr auto
+    min (K a, K b, Args &&...args)
     {
-        static_assert ((... && std::is_same<K<S,T>, std::decay_t<Args>>::value));
+        // the varargs must be the same types as the first two arguments
+        static_assert ((
+            ... && std::is_same_v<
+                K,
+                std::decay_t<Args>
+            >
+        ));
 
-        K<S,T> out {};
-        for (std::size_t i = 0; i < S; ++i)
+        K out {};
+        for (std::size_t i = 0; i < K::elements; ++i)
             out[i] = min (a[i], b[i], args[i]...);
         return out;
     }
@@ -816,22 +875,24 @@ namespace util {
     ///------------------------------------------------------------------------
     // /return a coord type containing the max element at each offset
     template <
-        std::size_t S,
-        typename T,
-        template <std::size_t,typename> class K,
+        typename K,
         typename = std::enable_if_t<
-            is_coord_v<K<S,T>>, void
+            is_coord_v<K>, void
         >,
         typename ...Args
     >
-    constexpr
-    K<S,T>
-    max (K<S,T> a, K<S,T> b, Args &&...args)
+    constexpr auto
+    max (K a, K b, Args &&...args)
     {
-        static_assert ((... && std::is_same<K<S,T>, std::decay_t<Args>>::value));
+        static_assert ((
+            ... && std::is_same_v<
+                K,
+                std::decay_t<Args>
+            >
+        ));
 
-        K<S,T> out {};
-        for (std::size_t i = 0; i < S; ++i)
+        K out {};
+        for (std::size_t i = 0; i < K::elements; ++i)
             out[i] = max (a[i], b[i], args[i]...);
         return out;
     }
@@ -845,16 +906,13 @@ namespace util {
     /// and hi because the min and max calls are ill definied for varying
     /// types (not because varying types would not be useful).
     template <
-        std::size_t S,
-        typename T,
-        template<std::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>
-    limit (K<S,T> k, K<S,T> lo, K<S,T> hi)
+    constexpr auto
+    limit (K k, K lo, K hi)
     {
         assert (all (lo <= hi));
         return max (min (k, hi), lo);
@@ -863,82 +921,68 @@ namespace util {
 
     //-------------------------------------------------------------------------
     template <
-        std::size_t S,
-        typename T,
-        template <std::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>
-    limit (K<S,T> k, T lo, K<S,T> hi)
+    constexpr auto
+    limit (K k, typename K::value_type lo, K hi)
     {
-        return limit (k, K<S,T> {lo}, hi);
+        return limit (k, K {lo}, hi);
     }
 
 
     //-------------------------------------------------------------------------
     template <
-        std::size_t S,
-        typename T,
-        template <std::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>
-    limit (K<S,T> k, K<S,T> lo, T hi)
+    constexpr auto
+    limit (K k, K lo, typename K::value_type hi)
     {
-        return limit (k, lo, K<S,T> {hi});
+        return limit (k, lo, K {hi});
     }
 
 
     //-------------------------------------------------------------------------
     template <
-        std::size_t S,
-        typename T,
-        template <std::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>
-    limit (K<S,T> k, T lo, T hi)
+    constexpr auto
+    limit (K k, typename K::value_type lo, typename K::value_type hi)
     {
-        return limit (k, K<S,T> {lo}, K<S,T> {hi});
+        return limit (k, K {lo}, K {hi});
     }
 
 
     ///------------------------------------------------------------------------
     template <
-        std::size_t S,
-        typename T,
-        template<std::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
-    T
-    min (const K<S,T> k)
+    constexpr auto
+    min (const K &k)
     {
         return *std::min_element (std::cbegin (k), std::cend (k));
     }
 
 
     template <
-        std::size_t S,
-        typename T,
-        template<std::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
-    T
-    max (const K<S,T> k)
+    constexpr auto
+    max (const K &k)
     {
         return *std::max_element (std::cbegin (k), std::cend (k));
     }
@@ -946,16 +990,13 @@ namespace util {
 
     ///////////////////////////////////////////////////////////////////////////
     template <
-        std::size_t S,
-        typename T,
-        template <std::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
-    T
-    sum (const K<S,T> k)
+    constexpr auto
+    sum (const K &k)
     {
         // DO NOT USE util::sum(begin, end) from maths.hpp
         //
@@ -967,30 +1008,33 @@ namespace util {
         // So, if the user wants kahan summation they can request it
         // explicitly.
 
-        return std::accumulate (std::cbegin (k), std::cend (k), T{0});
+        return std::accumulate (std::cbegin (k), std::cend (k), typename K::value_type{0});
     }
 
 
     ///////////////////////////////////////////////////////////////////////////
-#define VECTOR_OP(OP)                                       \
-    template <                                              \
-        std::size_t S,                                      \
-        typename T,                                         \
-        typename U,                                         \
-        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  \
-        >                                                   \
-    >                                                       \
-    constexpr                                               \
-    vector<S,bool>                                          \
-    operator OP (const A<S,T> a, const B<S,U> b)            \
-    {                                                       \
-        vector<S,bool> out {};                              \
-        for (std::size_t i = 0; i < S; ++i)                 \
-            out[i] = a[i] OP b[i];                          \
-        return out;                                         \
+#define VECTOR_OP(OP)                                   \
+    template <                                          \
+        typename A,                                     \
+        typename B,                                     \
+        typename = std::enable_if_t<                    \
+            is_coord_v<A> &&                            \
+            is_coord_v<B> &&                            \
+            A::elements == B::elements &&               \
+            std::is_same_v<                             \
+                typename A::value_type,                 \
+                typename B::value_type                  \
+            >,                                          \
+            void                                        \
+        >                                               \
+    >                                                   \
+    constexpr auto                                      \
+    operator OP (const A a, const B b)                  \
+    {                                                   \
+        vector<A::elements,bool> out {};                \
+        for (std::size_t i = 0; i < A::elements; ++i)   \
+            out[i] = a[i] OP b[i];                      \
+        return out;                                     \
     }
 
     VECTOR_OP(<)
@@ -1003,43 +1047,41 @@ namespace util {
 #undef VECTOR_OP
 
 
-#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;                                 \
-    }                                               \
-                                                    \
-    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 U u, const K<S,T> k)         \
-    {                                               \
-        vector<S,bool> out {};                      \
-        for (std::size_t i = 0; i < S; ++i)         \
-            out[i] = u OP k[i];                     \
-        return out;                                 \
+#define SCALAR_OP(OP)                                   \
+    template <                                          \
+        typename K,                                     \
+        typename U,                                     \
+        typename = std::enable_if_t<                    \
+            is_coord_v<K> &&                            \
+            std::is_arithmetic_v<U>,                    \
+            void                                        \
+        >                                               \
+    >                                                   \
+    constexpr auto                                      \
+    operator OP (const K &k, const U u)                 \
+    {                                                   \
+        vector<K::elements,bool> out {};                \
+        for (std::size_t i = 0; i < K::elements; ++i)   \
+            out[i] = k[i] OP u;                         \
+        return out;                                     \
+    }                                                   \
+                                                        \
+    template <                                          \
+        typename K,                                     \
+        typename U,                                     \
+        typename = std::enable_if_t<                    \
+            is_coord_v<K> &&                            \
+            std::is_arithmetic_v<U>,                    \
+            void                                        \
+        >                                               \
+    >                                                   \
+    constexpr auto                                      \
+    operator OP (const U u, const K &k)                 \
+    {                                                   \
+        vector<K::elements,bool> out {};                \
+        for (std::size_t i = 0; i < K::elements; ++i)   \
+            out[i] = u OP k[i];                         \
+        return out;                                     \
     }
 
     SCALAR_OP(<)
@@ -1146,20 +1188,16 @@ namespace util {
     ///
     /// corresponds to the function `select' from OpenCL.
     template <
-        std::size_t S,
-        typename T,
-        template <std::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>
-    select (vector<S,bool> s, K<S,T> a, K<S,T> b)
+    constexpr auto
+    select (vector<K::elements,bool> s, K a, K b)
     {
-        K<S,T> k {};
-        for (std::size_t i = 0; i < S; ++i)
+        K k {};
+        for (std::size_t i = 0; i < K::elements; ++i)
             k[i] = s[i] ? a[i] : b[i];
         return k;
     }
@@ -1167,20 +1205,18 @@ namespace util {
 
     ///////////////////////////////////////////////////////////////////////////
     template <
-        std::size_t S,
-        typename T,
-        template<std::size_t,typename> class K,
+        typename K,
         typename = std::enable_if_t<
-            is_coord_v<K<S,T>> && std::is_floating_point<T>::value, void
+            is_coord_v<K> && std::is_floating_point<typename K::value_type>::value, void
         >
     >
-    constexpr
-    K<S,T>
-    floor (const K<S,T> k)
+    constexpr auto
+    floor (const K &k)
     {
-        T (*floor_func)(T) = std::floor;
+        using value_type = typename K::value_type;
+        value_type (*floor_func)(value_type) = std::floor;
 
-        K<S,T> out {};
+        K out {};
         std::transform (std::cbegin (k),
                         std::cend   (k),
                         std::begin  (out),
@@ -1196,22 +1232,19 @@ namespace util {
     /// num must be between 0 and S. when 0 it is equivalent to an ordinary
     /// fill, when S it is equivalent to a noop.
     template<
-        std::size_t S,
-        typename T,
-        template <std::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>
-    rshift (const K<S,T> k, const int num, const K<S,T> fill)
+    constexpr auto
+    rshift (const K k, const int num, const K fill)
     {
-        CHECK_LIMIT (num, 0, int (S));
+        CHECK_LIMIT (num, 0, int (K::elements));
 
-        K<S,T> res {};
+        K res {};
 
-        std::copy_n (std::cbegin (k), S - num, std::begin (res) + num);
+        std::copy_n (std::cbegin (k), K::elements - num, std::begin (res) + num);
         std::copy_n (std::cbegin (fill), num, std::begin (res));
 
         return res;
@@ -1220,18 +1253,15 @@ namespace util {
 
     //-------------------------------------------------------------------------
     template<
-        std::size_t S,
-        typename T,
-        template <std::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>
-    rshift (const K<S,T> k, const int num, T fill)
+    constexpr auto
+    rshift (const K k, const int num, typename K::value_type fill)
     {
-        return rshift (k, num, K<S,T> {fill});
+        return rshift (k, num, K {fill});
     }
 
 
@@ -1245,20 +1275,15 @@ namespace util {
     /// \tparam K coordinate data type to operate on
     template <
         std::size_t I,
-        std::size_t S,
-        typename T,
-        template<
-        std::size_t,
-        typename
-    > class K
+        typename K,
+        std::enable_if_t<
+            is_coord_v<K> && I < K::elements, void
+        >
     >
-    const std::enable_if_t<
-        is_coord_v<K<S,T>>,
-        T
-    >&
-    get (const K<S,T> &k)
+    const auto&
+    get (const K &k)
     {
-        static_assert (I < S);
+        static_assert (I < K::elements);
         return k[I];
     };
 
@@ -1273,20 +1298,15 @@ namespace util {
     /// \tparam K coordinate data type to operate on
     template <
         std::size_t I,
-        std::size_t S,
-        typename T,
-        template<
-            std::size_t,
-            typename
-        > class K
+        typename K,
+        typename = std::enable_if_t<
+            is_coord_v<K> && I < K::elements, void
+        >
     >
-    std::enable_if_t<
-        is_coord_v<K<S,T>>,
-        T
-    >&
-    get (K<S,T> &k)
+    auto &
+    get (K &k)
     {
-        static_assert (I < S);
+        static_assert (I < K::elements);
         return k[I];
     };
 }
@@ -1306,14 +1326,11 @@ namespace std {
     template <
         std::size_t S,
         typename T,
-        template<
-            std::size_t,
-            typename
-        > class K
+        template <std::size_t,typename> typename K
     >
     class tuple_size<K<S,T>> : public std::enable_if_t<
         ::util::is_coord_v<K<S,T>>,
-        std::integral_constant<decltype(S), S>
+        std::integral_constant<std::size_t, S>
     > { };
 
 
@@ -1329,17 +1346,12 @@ namespace std {
         std::size_t I,
         std::size_t S,
         typename T,
-        template<
-            std::size_t,
-            typename
-        > class K
+        template <std::size_t,typename> typename K
     >
-    class tuple_element<
-        I, K<S,T>
-    > : public enable_if<
+    class tuple_element<I,K<S,T>> : public std::enable_if<
         ::util::is_coord_v<K<S,T>>,
         T
-    > { };
+    > {};
 }
 
 
@@ -1352,20 +1364,15 @@ namespace std {
     template <
         std::size_t S,
         typename T,
-        template <
-            std::size_t,typename
-        > class K
+        template <std::size_t,typename> typename K
     >
-    struct hash<
-        K<S,T>
-    > : public ::std::enable_if<
+    struct hash<K<S,T>> : enable_if<
         ::util::is_coord_v<K<S,T>>
     > {
-        std::size_t
-        operator() (K<S,T> k) const {
-            std::size_t v = 0xdeadbeef;
+        uint32_t operator() (K<S,T> k) const {
+            uint32_t v = 0xdeadbeef;
 
-            for (auto t: k)
+            for (T t: k)
                 v = ::util::hash::mix (t, v);
 
             return v;
diff --git a/coord/store.hpp b/coord/store.hpp
index 658f3ec5..f877d1fa 100644
--- a/coord/store.hpp
+++ b/coord/store.hpp
@@ -17,11 +17,12 @@
 #ifndef CRUFT_UTIL_COORD_STORE_HPP
 #define CRUFT_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,112 @@ 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 <
-        std::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__)]; \
+        };                                      \
+    };                                          \
 }
 
+
+#define DEFINE_STORE(KLASS,...)                 \
+template <typename T>                           \
+struct util::coord::store<                      \
+    VA_ARGS_COUNT(__VA_ARGS__),                 \
+    T,                                          \
+    ::util::KLASS<                              \
+        VA_ARGS_COUNT(__VA_ARGS__),             \
+        T                                       \
+    >                                           \
+> {                                             \
+    union {                                     \
+        T data[VA_ARGS_COUNT(__VA_ARGS__)];     \
+        struct { T __VA_ARGS__; };              \
+    };                                          \
+};
+
+DEFINE_STORE(extent,w)
+DEFINE_STORE(extent,w,h)
+DEFINE_STORE(extent,w,h,d)
+
+DEFINE_STORE(point, x)
+DEFINE_STORE(point, x, y)
+DEFINE_STORE(point, x, y, z)
+DEFINE_STORE(point, x, y, z, w)
+
+DEFINE_STORE(vector, x)
+DEFINE_STORE(vector, x, y)
+DEFINE_STORE(vector, x, y, z)
+DEFINE_STORE(vector, x, y, z, w)
+
+#undef DEFINE_STORE
+
+#if 0
+template <typename T>
+struct util::coord::store<1,T,::util::extent<1,T>> {
+    union { T data[1]; struct { T w; }; };
+};
+
+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
 #endif
diff --git a/coord/traits.hpp b/coord/traits.hpp
new file mode 100644
index 00000000..6f332f07
--- /dev/null
+++ b/coord/traits.hpp
@@ -0,0 +1,225 @@
+/*
+ * 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 { };
+
+    //-------------------------------------------------------------------------
+    #define RESULT_T(ArgA,ArgB,ResultT) \
+    template <          \
+        std::size_t S,  \
+    typename ValueA,\
+    typename ValueB\
+    > struct result<\
+        ArgA<S,ValueA>,\
+        ArgB<S,ValueB>\
+    >  {\
+    using type = ResultT<S,std::common_type_t<ValueA,ValueB>>; \
+};
+
+#if 0
+    template <
+        std::size_t S,
+        typename ValueA,
+        typename ValueB
+    > struct result<
+        srgba<S,ValueA>,
+        srgba<S,ValueB>
+    >  {
+        using type = srgba<S,std::common_type_t<ValueA,ValueB>>;
+    };
+
+
+    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>; };
+#endif
+
+    RESULT_T(extent,extent,extent)
+    RESULT_T(extent,vector,extent)
+    RESULT_T(point,extent,point)
+    RESULT_T(point,vector,point)
+    RESULT_T(srgba,vector,srgba)
+    RESULT_T(srgba,srgba,srgba)
+    RESULT_T(vector,point,point)
+    RESULT_T(vector,srgba,srgba)
+    RESULT_T(vector,vector,vector)
+
+
+    template <
+        typename A, typename B
+    >
+    using result_t = typename result<A,B>::type;
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename A, typename B, typename = std::void_t<>>
+    struct has_result : public std::false_type {};
+
+
+    template <typename CoordA, typename CoordB>
+    struct has_result<
+        CoordA,
+        CoordB,
+        std::void_t<
+            result_t<CoordA,CoordB>
+        >
+    > : public std::true_type {};
+
+
+    template <typename A, typename B>
+    constexpr auto has_result_v = has_result<A,B>::value;
+
+
+    //---------------------------------------------------------------------
+    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/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 868c061f..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,14 +514,16 @@ 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 becbc0b2..6e29671d 100644
--- a/debug.ipp
+++ b/debug.ipp
@@ -34,7 +34,7 @@ namespace util::debug::detail {
     template <typename ...Args, size_t N>
     void panic [[noreturn]] (const char (&fmt)[N], const Args& ...args)
     {
-        std::cerr << format::printf (fmt, args...) << ::debug::backtrace () << std::endl;
+        std::cerr << ::util::format::printf (fmt, args...) << ::debug::backtrace () << std::endl;
         breakpoint ();
         abort ();
     }
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..5e97fd0e 100644
--- a/debug_win32.cpp
+++ b/debug_win32.cpp
@@ -14,11 +14,12 @@
  * 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 "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/time.ipp b/encode/base.cpp
similarity index 65%
rename from time.ipp
rename to encode/base.cpp
index a1c1604b..abbc2e79 100644
--- a/time.ipp
+++ b/encode/base.cpp
@@ -11,18 +11,8 @@
  * 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 __UTIL_TIME_IPP
-#define __UTIL_TIME_IPP
+#include "base.hpp"
 
-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
diff --git a/encode/base.hpp b/encode/base.hpp
new file mode 100644
index 00000000..d4aad0f9
--- /dev/null
+++ b/encode/base.hpp
@@ -0,0 +1,251 @@
+/*
+ * 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>[static_cast<unsigned>(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>[static_cast<unsigned> (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/except.cpp b/except.cpp
deleted file mode 100644
index d902c840..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 a7f02317..78e5ff86 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 "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 ca0f832e..b28abae1 100644
--- a/exe_win32.cpp
+++ b/exe_win32.cpp
@@ -14,9 +14,10 @@
  * Copyright 2010-2016 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./exe.hpp"
+#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/extent.cpp b/extent.cpp
index 3c1bc38e..e635ec6e 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>
@@ -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 5c456803..c23bac95 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;
@@ -41,7 +43,6 @@ namespace util {
         constexpr
         U aspect (void) const;
 
-
         /// tests whether a point would lie within:
         ///     region { origin, *this }, inclusive of borders.
         ///
@@ -62,24 +63,27 @@ namespace util {
             return all (p >= T{0} && p < *this);
         }
 
-
-        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/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.hpp b/format.hpp
index bd47b24d..8d259f1e 100644
--- a/format.hpp
+++ b/format.hpp
@@ -17,7 +17,6 @@
 #ifndef CRUFT_UTIL_FORMAT_HPP
 #define CRUFT_UTIL_FORMAT_HPP
 
-#include "maths.hpp"
 #include "view.hpp"
 
 #include <algorithm>
@@ -413,7 +412,7 @@ namespace util::format {
         static std::ostream&
         write (std::ostream &os, specifier s, const std::nullptr_t &val)
         {
-            if (s.type != type_t::POINTER)
+            if (s.type != type_t::POINTER || s.type == type_t::USER)
                 throw std::runtime_error ("expected pointer specifier");
             return value<const void*>::write (os, s, val);
         }
@@ -424,8 +423,9 @@ namespace util::format {
     struct value<const char[N]> {
         static std::ostream&
         write (std::ostream &os, specifier spec, const char (&val)[N]) {
-            if (spec.type == type_t::STRING)
+            if (spec.type == type_t::STRING || spec.type == type_t::USER)
                 return value<util::view<const char*>>::write (os, spec, util::view<const char*> (val));
+            throw std::runtime_error ("invalid data type");
         }
     };
 
@@ -445,7 +445,7 @@ namespace util::format {
         write (std::ostream &os, specifier spec, char *val) {
             if (!val)
                 return os << "(nil)";
-            if (spec.type == type_t::STRING)
+            if (spec.type == type_t::STRING || spec.type == type_t::USER)
                 return value<util::view<const char*>>::write (os, spec, util::view<const char*> { val, val + strlen (val) });
             if (spec.type == type_t::POINTER)
                 return value<const void*>::write (os, spec, val);
@@ -460,7 +460,7 @@ namespace util::format {
         write (std::ostream &os, specifier spec, const char *val) {
             if (!val)
                 return os << "(nil)";
-            if (spec.type == type_t::STRING)
+            if (spec.type == type_t::STRING || spec.type == type_t::USER)
                 return value<util::view<const char*>>::write (os, spec, util::view<const char*> { val, val + strlen (val) });
             if (spec.type == type_t::POINTER)
                 return value<const void*>::write (os, spec, val);
diff --git a/geom/aabb.cpp b/geom/aabb.cpp
index 8a826025..16d53848 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"
 
@@ -61,52 +61,6 @@ aabb<S,T>::closest (const point<S,T> q) const
 }
 
 
-///////////////////////////////////////////////////////////////////////////////
-template <size_t S, typename T>
-aabb<S,T>
-aabb<S,T>::expand (const vector<S,T> mag) const noexcept
-{
-    CHECK (all (mag >= T{0}));
-
-    return { p0 - mag, p1 + mag };
-}
-
-
-//-----------------------------------------------------------------------------
-template <size_t S, typename T>
-aabb<S,T>
-aabb<S,T>::expand (const T mag) const noexcept
-{
-    CHECK_GE (mag, T{0});
-
-    return { p0 - mag, p1 + mag };
-}
-
-
-//-----------------------------------------------------------------------------
-template <size_t S, typename T>
-aabb<S,T>
-aabb<S,T>::contract (const util::vector<S,T> mag) const noexcept
-{
-    CHECK (all (mag >= T{0}));
-    CHECK (all (2 * mag <= p1 - p0));
-
-    return { p0 + mag, p1 - mag };
-}
-
-
-//-----------------------------------------------------------------------------
-template <size_t S, typename T>
-aabb<S,T>
-aabb<S,T>::contract (const T mag) const noexcept
-{
-    CHECK_GE (mag, T{0});
-    CHECK (all (2 * mag <=  p1 - p0));
-
-    return { p0 + mag, p1 - mag };
-}
-
-
 //-----------------------------------------------------------------------------
 template <size_t S, typename T>
 void
diff --git a/geom/aabb.hpp b/geom/aabb.hpp
index de82c9a2..6becc1ae 100644
--- a/geom/aabb.hpp
+++ b/geom/aabb.hpp
@@ -44,19 +44,13 @@ namespace util::geom {
 
         point<S,T> closest (point<S,T>) const;
 
-        aabb<S,T> expand (util::vector<S,T>) const noexcept;
-        aabb<S,T> expand (T) const noexcept;
-
-        aabb<S,T> contract (util::vector<S,T>) const noexcept;
-        aabb<S,T> contract (T) const noexcept;
-
         void cover (point<S,T>);
 
         aabb<S,T> operator+ (vector<S,T>) const;
         aabb<S,T> operator- (vector<S,T>) const;
 
-        point<S,T> p0;
-        point<S,T> p1;
+        ::util::point<S,T> p0;
+        ::util::point<S,T> p1;
     };
 
 
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 66af161c..159f8c5e 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/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/geom/ray.cpp b/geom/ray.cpp
index 84802215..45bbd508 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/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/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 a5096107..979dc2fa 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"
 
 #include <cstring>
 
diff --git a/introspection.hpp b/introspection.hpp
index 9b3808cf..f4897786 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.cpp b/io.cpp
index e90059ce..a6abb4a1 100644
--- a/io.cpp
+++ b/io.cpp
@@ -17,9 +17,9 @@
 #include "io.hpp"
 
 #include "debug.hpp"
-#include "except.hpp"
 #include "cast.hpp"
 #include "format.hpp"
+#include "posix/except.hpp"
 
 #include <cstdio>
 #include <fcntl.h>
@@ -45,12 +45,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);
@@ -60,9 +57,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);
 
@@ -90,13 +88,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;
 
@@ -145,9 +140,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);
@@ -199,7 +192,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 ();
 }
 
 
@@ -207,7 +200,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.hpp b/io.hpp
index f3bbe42b..4ed8a543 100644
--- a/io.hpp
+++ b/io.hpp
@@ -43,16 +43,48 @@ namespace util {
     std::vector<T> slurp (FILE *);
 
 
-    //-------------------------------------------------------------------------
+    ///////////////////////////////////////////////////////////////////////////
     void write (const posix::fd&, const void *restrict data, size_t bytes);
 
-    template <typename T>
-    void write (const posix::fd&, const T &data);
-
-    template <typename T>
-    void write (const posix::fd&, const T *restrict first, const T *restrict last);
 
     //-------------------------------------------------------------------------
+    inline void
+    write (const posix::fd &dst, util::view<const uint8_t*> data)
+    {
+        write (dst, std::data (data), std::size (data));
+    }
+
+
+    //-------------------------------------------------------------------------
+    template <typename T>
+    void write (const posix::fd &_fd, const T &data)
+    {
+        return write (_fd, make_view (data));
+    }
+
+
+    ///------------------------------------------------------------------------
+    /// 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>
+    util::view<IteratorA,IteratorB>
+    write (DstT &dst, const util::view<IteratorA, IteratorB> src)
+    {
+        auto remain = src;
+        while (!remain.empty ())
+            remain = src - dst.write (remain);
+        return src;
+    }
+
+
+    ///////////////////////////////////////////////////////////////////////////
     class indenter : public std::streambuf {
     protected:
         std::streambuf* m_dest;
@@ -120,11 +152,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.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
diff --git a/io_posix.cpp b/io_posix.cpp
index c4d8683a..e865c8af 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 "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_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..c83de38e 100644
--- a/io_win32.cpp
+++ b/io_win32.cpp
@@ -14,10 +14,11 @@
  * 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 "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/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/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
diff --git a/json/schema.cpp b/json/schema.cpp
index d135ebb6..ef477346 100644
--- a/json/schema.cpp
+++ b/json/schema.cpp
@@ -14,10 +14,10 @@
  * Copyright 2015-2017 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./schema.hpp"
+#include "schema.hpp"
 
-#include "./tree.hpp"
-#include "./except.hpp"
+#include "tree.hpp"
+#include "except.hpp"
 
 #include "../debug.hpp"
 #include "../io.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 b626520f..58c3d9c9 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/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/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 6ec300e7..a66336a9 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>
@@ -81,8 +81,8 @@ namespace util {
     template <typename A, typename B>
     inline
     typename std::enable_if_t<
-        std::is_integral<A>::value &&
-        std::is_integral<B>::value &&
+        std::is_integral_v<A> &&
+        std::is_integral_v<B> &&
         std::is_signed<A>::value == std::is_signed<B>::value,
         bool
     >
@@ -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;
@@ -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);
     }
 
 
@@ -242,8 +250,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;
+    }
 
 
     //-------------------------------------------------------------------------
@@ -326,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 :
@@ -341,6 +374,7 @@ namespace util {
                (v >=        100) ?  3 :
                (v >=         10) ?  2 :
                                     1;
+        */
     }
 
 
@@ -587,7 +621,16 @@ namespace util {
 
     ///////////////////////////////////////////////////////////////////////////
     /// Variadic minimum
-    template <typename T>
+
+    // disable the single parameter version for non-arithmetic types so that
+    // min for coord types is unambiguous. allow pointers too because it
+    // doesn't add ambiguity and it simplifies some memory juggling.
+    template <
+        typename T,
+        typename = std::enable_if_t<
+            std::is_arithmetic_v<T> || std::is_pointer_v<T>, void
+        >
+    >
     constexpr T
     min  (const T a)
         { return a; }
@@ -609,9 +652,9 @@ namespace util {
     //-------------------------------------------------------------------------
     /// Variadic maximum
     template <typename T>
-    constexpr T
+    constexpr std::enable_if_t<std::is_arithmetic_v<T> || std::is_pointer_v<T>, T>
     max  (const T a)
-        { return a; }
+    { return a; }
 
 
     //-------------------------------------------------------------------------
diff --git a/matrix.cpp b/matrix.cpp
index 3915c06c..f25fb070 100644
--- a/matrix.cpp
+++ b/matrix.cpp
@@ -27,7 +27,8 @@ using util::matrix;
 
 
 ///////////////////////////////////////////////////////////////////////////////
-//template <size_t S, typename T>
+//-----------------------------------------------------------------------------
+//template <std::size_t S, typename T>
 //matrix<S,T>&
 //matrix<S,T>::invert_affine (void)
 //{
@@ -76,7 +77,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::matrix<Rows,Cols,T>::determinant (void) const
 {
@@ -85,7 +86,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
 {
@@ -94,14 +95,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;
@@ -114,42 +115,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;
 
@@ -158,11 +131,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);
 
@@ -174,29 +147,31 @@ 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);
+    return ortho (left, right, bottom, top, T{-1}, T{1});
 }
 
+template util::matrix4f util::ortho2D (float, float, float, float);
+
 
 //-----------------------------------------------------------------------------
-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);
@@ -216,6 +191,8 @@ matrix<Rows,Cols,T>::perspective (T fov, T aspect, range<T> Z)
     } };
 }
 
+template util::matrix4f util::perspective<float> (float, float, range<float>);
+
 
 //-----------------------------------------------------------------------------
 // Emulates gluLookAt
@@ -225,11 +202,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));
 
@@ -244,23 +221,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 },
@@ -271,18 +241,24 @@ 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 util::matrix4f util::scale(float);
+
+
 //-----------------------------------------------------------------------------
-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 },
@@ -292,11 +268,13 @@ matrix<Rows,Cols,T>::scale (util::vector<3,T> v)
     } };
 }
 
+template util::matrix4f util::scale(util::vector3f);
+
 
 //-----------------------------------------------------------------------------
-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));
 
@@ -329,6 +307,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>;
@@ -345,7 +324,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)
 {
@@ -372,24 +351,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 <size_t Rows, 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) {
-        os << "{ ";
-        std::copy_n (m[i], Cols, 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 c3cc4f77..48a7d8f5 100644
--- a/matrix.hpp
+++ b/matrix.hpp
@@ -19,87 +19,109 @@
 
 #include "point.hpp"
 #include "range.hpp"
+#include "vector.hpp"
+#include "iterator.hpp"
 
-#include <ostream>
 #include <cstdlib>
+#include <ostream>
 
 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];
+        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
+        {
+            for (std::size_t r = 0; r < Rows; ++r)
+                for (std::size_t c = 0; c < Cols; ++c)
+                    values[r][c] = _data[r][c];
+        }
+
 
         ///////////////////////////////////////////////////////////////////////
         // index operators return a pointer into the data array so that
         // multidimensional array syntax can be used transparently on this
         // type.
-        constexpr T*
-        operator[] (size_t idx) noexcept
+        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 row_t*
+        data (void)& noexcept
         {
-            return this->values[idx];
+            return &values[0];
         }
 
         //---------------------------------------------------------------------
-        constexpr const T*
-        operator[] (size_t idx) const noexcept
+        constexpr const row_t*
+        data (void) const& noexcept
         {
-            return this->values[idx];
-        }
-
-        //---------------------------------------------------------------------
-        constexpr T*
-        data (void) noexcept
-        {
-            return begin ();
-        }
-
-        //---------------------------------------------------------------------
-        constexpr const T*
-        data (void) const noexcept
-        {
-            return begin ();
-        }
-
-        //---------------------------------------------------------------------
-        constexpr const T*
-        begin (void) const noexcept
-        {
-            return &(*this)[0][0];
-        }
-
-        //---------------------------------------------------------------------
-        constexpr const T*
-        end (void) const noexcept
-        {
-            return &(*this)[Rows][0];
-        }
-
-        //---------------------------------------------------------------------
-        constexpr T*
-        begin (void) noexcept
-        {
-            return &(*this)[0][0];
-        }
-
-        //---------------------------------------------------------------------
-        constexpr T*
-        end (void) noexcept
-        {
-            return &(*this)[Rows][0];
+            return &values[0];
         }
 
         //---------------------------------------------------------------------
         constexpr auto
-        cbegin (void) const noexcept
+        begin (void) const& noexcept
+        {
+            return data ();
+        }
+
+        //---------------------------------------------------------------------
+        constexpr auto
+        begin (void)& noexcept
+        {
+            return data ();
+        }
+
+        //---------------------------------------------------------------------
+        constexpr row_t*
+        end (void)& noexcept
+        {
+            return &values[Rows];
+        }
+
+        //---------------------------------------------------------------------
+        constexpr const row_t*
+        end (void) const& noexcept
+        {
+            return &values[Rows];
+        }
+
+        //---------------------------------------------------------------------
+        constexpr auto
+        cbegin (void) const& noexcept
         {
             return begin ();
         }
 
         //---------------------------------------------------------------------
         constexpr auto
-        cend (void) const noexcept
+        cend (void) const& noexcept
         {
             return end ();
         }
@@ -118,109 +140,166 @@ namespace util {
         }
 
 
-        ///////////////////////////////////////////////////////////////////////
-        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 r = 0; r < Rows; ++r)
+                out[r] = dot (rhs, values[r]);
+
+            return out;
+        }
 
         bool is_affine (void) const;
 
         template <typename U>
         matrix<Rows,Cols,U>
-        cast (void) const
+        cast (void) const noexcept
         {
-            util::matrix<Rows,Cols,T> out;
+            matrix out;
             std::copy (cbegin (), cend (), std::begin (out));
             return out;
         }
 
-        // 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 ();
+        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), row_t{0});
+            return ret;
+        }
+
+
+    private:
+        row_t values[Rows];
     };
 
 
+    // 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 (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, 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>&);
+    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 <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>&);
+    operator!= (const matrix<Rows,Cols,T> &a, const matrix<Rows,Cols,T> &b)
+    {
+        return !(a == b);
+    }
 
 
     ///////////////////////////////////////////////////////////////////////////
     // 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> &a, const matrix<R2,C2,T> &b) noexcept
+    operator* (const matrix<R1,RC,T>&a, const matrix<RC,C2,T>&b)
     {
-        static_assert (R2 == C1);
-
-        matrix<R1,C2,T> res {0};
+        matrix<R1,C2,T> res {};
 
         // TODO: iterating over r,c rather than c,r will cause an ICE with
         // clang#xxxx: 'X86 DAG->DAG Instruction Selection'.
@@ -228,11 +307,11 @@ namespace util {
         // this is likely related to gold and LTO support. for the time being
         // we switch the orders because it appears to confuse the optimiser
         // sufficiently. :(
-        for (size_t c = 0; c < C2; ++c) {
-            for (size_t r = 0; r < R1; ++r) {
-                T accum{0};
+        for (std::size_t c = 0; c < C2; ++c) {
+            for (std::size_t r = 0; r < R1; ++r) {
+                T accum {0};
 
-                for (size_t i = 0; i < R2; ++i)
+                for (std::size_t i = 0; i < RC; ++i)
                     accum += a[r][i] * b[i][c];
 
                 res[r][c] = accum;
@@ -245,8 +324,8 @@ namespace util {
 
     //-------------------------------------------------------------------------
     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
@@ -256,36 +335,128 @@ 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>&);
+    abs (const matrix<Rows,Cols,T> &src)
+    {
+        matrix<Rows,Cols,T> dst;
+        for (size_t r = 0; r < Rows; ++r)
+            dst[r] = abs (src[r]);
+        return dst;
+    }
 
-    template <size_t Rows, size_t Cols, typename T>
-    constexpr
-    T
-    sum (const matrix<Rows,Cols,T>&);
+
+    template <std::size_t Rows, std::size_t Cols, typename T>
+    constexpr T
+    sum (const matrix<Rows,Cols,T> &src)
+    {
+        util::vector<Rows,T> accum {};
+        for (size_t r = 0; r < Rows; ++r)
+            accum[r] = sum (src[r]);
+        return sum (accum);
+    }
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    #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
 
 
     ///////////////////////////////////////////////////////////////////////////
     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;
@@ -298,10 +469,18 @@ namespace util {
 
 
     ///////////////////////////////////////////////////////////////////////////
-    template <size_t Rows, size_t Cols, typename T>
-    std::ostream& operator<< (std::ostream&, const matrix<Rows,Cols,T>&);
-}
-
-#include "matrix.ipp"
+    template <std::size_t Rows, std::size_t Cols, typename 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
diff --git a/matrix.ipp b/matrix.ipp
deleted file mode 100644
index e934426e..00000000
--- a/matrix.ipp
+++ /dev/null
@@ -1,165 +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
-
-#define __UTIL_MATRIX_IPP
-
-
-///////////////////////////////////////////////////////////////////////////////
-#define MATRIX_ELEMENT_OP(OP)                                       \
-template <size_t Rows, 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 (size_t i = 0; i < a.rows; ++i)                             \
-        for (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 <size_t Rows, 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 <size_t Rows, 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 <size_t Rows, 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 <size_t Rows, size_t Cols, typename T>
-constexpr
-util::matrix<Rows,Cols,T>
-util::matrix<Rows,Cols,T>::zeroes (void)
-{
-    return {0};
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-template <size_t Rows, 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 (size_t i = 0; i < Rows; ++i)
-        m[i][i] = 1;
-    return m;
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-template <size_t Rows, 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 <size_t Rows, 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 <size_t Rows, 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 <size_t Rows, 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/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 64b0b678..123bb16b 100644
--- a/matrix3.cpp
+++ b/matrix3.cpp
@@ -14,13 +14,13 @@
  * Copyright 2015 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./matrix.hpp"
+#include "matrix.hpp"
 
 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/memory/buffer/circular.cpp b/memory/buffer/circular.cpp
index c58aabe7..3642f619 100644
--- a/memory/buffer/circular.cpp
+++ b/memory/buffer/circular.cpp
@@ -14,14 +14,14 @@
  * Copyright 2015 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./circular.hpp"
+#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>
@@ -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 ());
@@ -84,14 +85,16 @@ 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));
+    m_begin = reinterpret_cast<ValueT*> (
+        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); });
@@ -101,11 +104,11 @@ 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)
-        errno_error::throw_code ();
+        posix::error::throw_code ();
 
     // all went well, disarm the failsafe
     unmapper.clear ();
@@ -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,61 @@ 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 <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 387cb9c2..f37785ab 100644
--- a/memory/buffer/circular.hpp
+++ b/memory/buffer/circular.hpp
@@ -17,15 +17,20 @@
 #ifndef __UTIL_MEMORY_BUFFER_CIRCULAR_HPP
 #define __UTIL_MEMORY_BUFFER_CIRCULAR_HPP
 
+#include "../../view.hpp"
+
 #include <cstddef>
 
 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 +40,26 @@ 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;
 
+        /// 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:
-        char *m_begin, *m_end;
+        value_type *m_begin, *m_end;
 
     };
 }
diff --git a/memory/buffer/paged.cpp b/memory/buffer/paged.cpp
index 8fb363f9..28bc141f 100644
--- a/memory/buffer/paged.cpp
+++ b/memory/buffer/paged.cpp
@@ -14,13 +14,13 @@
  * Copyright 2015 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./paged.hpp"
+#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/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..dcd365af 100644
--- a/memory/system.cpp
+++ b/memory/system.cpp
@@ -14,10 +14,10 @@
  * Copyright 2015 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./system.hpp"
+#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/parse.cpp b/parse.cpp
index fcd2036d..77f08daf 100644
--- a/parse.cpp
+++ b/parse.cpp
@@ -14,7 +14,9 @@
  * Copyright 2017 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./parse.hpp"
+#include "parse.hpp"
+
+#include "cast.hpp"
 
 #include <cstdlib>
 #include <stdexcept>
@@ -69,9 +71,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)); \
 }
 
 
@@ -84,3 +86,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);
+}
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));
     }
 }
 
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/point.hpp b/point.hpp
index 31c65c90..c29b9876 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/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..36f37570 100644
--- a/posix/dir.cpp
+++ b/posix/dir.cpp
@@ -14,9 +14,9 @@
  * Copyright 2015 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./dir.hpp"
+#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.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/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/except.cpp b/posix/except.cpp
new file mode 100644
index 00000000..ef416417
--- /dev/null
+++ b/posix/except.cpp
@@ -0,0 +1,137 @@
+/*
+ * 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);
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+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
new file mode 100644
index 00000000..44380baf
--- /dev/null
+++ b/posix/except.hpp
@@ -0,0 +1,68 @@
+/*
+ * 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;
+    };
+
+
+    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
diff --git a/posix/fd.cpp b/posix/fd.cpp
index 8d16dbc4..e2e79d03 100644
--- a/posix/fd.cpp
+++ b/posix/fd.cpp
@@ -14,9 +14,9 @@
  * Copyright 2016 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./fd.hpp"
+#include "fd.hpp"
 
-#include "../except.hpp"
+#include "except.hpp"
 
 #include <sys/stat.h>
 #include <fcntl.h>
@@ -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)
-        errno_error::throw_code ();
-}
+    m_fd (error::try_value (::open (path.c_str (), flags, mode)))
+{ ; }
 
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -48,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)
@@ -66,11 +82,9 @@ fd::dup (void) const
 fd
 fd::dup (int _fd)
 {
-    auto res = ::dup (_fd);
-    if (res < 0)
-        errno_error::throw_code ();
-
-    return fd (res);
+    return fd {
+        error::try_value (::dup (_fd))
+    };
 }
 
 
@@ -79,9 +93,7 @@ fd::~fd ()
 {
     if (m_fd < 0)
         return;
-
-    if (close (m_fd))
-        errno_error::throw_code ();
+    close ();
 }
 
 
@@ -90,30 +102,68 @@ struct ::stat
 fd::stat (void) const
 {
     struct stat buf;
-    if (fstat (m_fd, &buf))
-        errno_error::throw_code ();
+    error::try_value (fstat (m_fd, &buf));
     return buf;
 }
 
 
+///////////////////////////////////////////////////////////////////////////////
+void
+fd::close (void)
+{
+    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 (void *buffer, size_t count)
 {
-    auto res = ::read (m_fd, buffer, count);
-    if (res == -1)
-        errno_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)
-        errno_error::throw_code ();
-    return res;
+    return error::try_value (
+        ::write (m_fd, buffer, count)
+    );
 }
 
 
@@ -121,10 +171,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)
-        errno_error::throw_code ();
-    return res;
+    return error::try_value (
+        ::lseek (m_fd, offset, whence)
+    );
 }
 
 
diff --git a/posix/fd.hpp b/posix/fd.hpp
index 05e00cf2..c5ca7228 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>
 
@@ -32,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
@@ -51,15 +55,51 @@ 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 (void *buf, size_t count);
         [[gnu::warn_unused_result]] ssize_t write (const void *buf, size_t count);
 
+
+        //---------------------------------------------------------------------
+        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; }
 
     private:
         int m_fd;
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/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/posix/socket.cpp b/posix/socket.cpp
new file mode 100644
index 00000000..c659e82c
--- /dev/null
+++ b/posix/socket.cpp
@@ -0,0 +1,148 @@
+/*
+ * 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);
+    };
+
+    // TODO: use a wrapper that supports the increment operator
+    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)
+{
+    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)
+        };
+        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 _fd):
+    fd (_fd)
+{ ; }
+
+
+//-----------------------------------------------------------------------------
+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 ()
+{ ; }
+
+
+//-----------------------------------------------------------------------------
+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)
+{
+    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;
+    }
+
+    throw std::runtime_error ("unable to reconnect");
+}
diff --git a/posix/socket.hpp b/posix/socket.hpp
new file mode 100644
index 00000000..289d112e
--- /dev/null
+++ b/posix/socket.hpp
@@ -0,0 +1,67 @@
+/*
+ * 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:
+         explicit socket (int _fd);
+
+         socket (int domain, int type);
+         socket (int domain, int type, int protocol);
+
+         socket (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_value (
+                setsockopt (
+                    native (),
+                    _level,
+                    _name,
+                    &_value, sizeof (_value)
+                )
+            );
+         }
+     };
+};
+
+#endif
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..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>
@@ -126,6 +134,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/random.hpp b/random.hpp
index 235a592d..144efaa1 100644
--- a/random.hpp
+++ b/random.hpp
@@ -17,6 +17,7 @@
 #ifndef CRUFT_UTIL_RANDOM_HPP
 #define CRUFT_UTIL_RANDOM_HPP
 
+#include <algorithm>
 #include <random>
 #include <limits>
 
@@ -74,6 +75,6 @@ namespace util::random {
         std::uniform_int_distribution<size_t> dist (0, N - 1);
         return t[dist (generator ())];
     }
-}
+};
 
 #endif
diff --git a/region.cpp b/region.cpp
index 65f62462..0c96454e 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>
 
@@ -221,7 +221,7 @@ util::region<S,T>
 util::region<S,T>::inset (vector<S,T> mag) const
 {
     // ensure we have enough space to trim off our total extent
-    CHECK (all (e >= 2 * mag));
+    CHECK (all (e >= T{2} * mag));
 
     return {
         p +        mag,
diff --git a/rfc3986.rl b/rfc3986.rl
new file mode 100644
index 00000000..b8da3e5b
--- /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
+    );
+}%%
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 55ce664d..753d10db 100644
--- a/string.cpp
+++ b/string.cpp
@@ -14,7 +14,7 @@
  * Copyright 2011-2017 Danny Robson <danny@nerdcruft.net>
  */
 
-#include "./string.hpp"
+#include "string.hpp"
 
 #include "./debug.hpp"
 
diff --git a/string.hpp b/string.hpp
index 9fb0bef4..5fc4cb6c 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/affine.cpp b/test/affine.cpp
index e27f542d..b68e2ef4 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,25 +81,27 @@ 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 ();
 
         auto diff = util::sum (abs (m - q));
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/coord.cpp b/test/coord.cpp
index a11aede1..5aaeb2fb 100644
--- a/test/coord.cpp
+++ b/test/coord.cpp
@@ -7,6 +7,8 @@
 int
 main (void)
 {
+    static_assert (util::has_result_v<util::point3f, util::vector3f>);
+
     static_assert (sizeof (util::point1u) == 1 * sizeof (util::point1u::value_type), "point1u is not packed");
     static_assert (sizeof (util::point2u) == 2 * sizeof (util::point2u::value_type), "point2u is not packed");
     static_assert (sizeof (util::point3u) == 3 * sizeof (util::point3u::value_type), "point3u is not packed");
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
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/aabb.cpp b/test/geom/aabb.cpp
index 1925e822..177d0553 100644
--- a/test/geom/aabb.cpp
+++ b/test/geom/aabb.cpp
@@ -11,20 +11,5 @@ int
 main (int, char**)
 {
     util::TAP::logger tap;
-
-    {
-        const aabb2f val { { 1, 2 }, { 8, 5 } };
-        const aabb2f res { { 3, 3 }, { 6, 4 } };
-
-        tap.expect_eq (val.contract ({2.f, 1.f}), res, "aabb::contract");
-    }
-
-    {
-        const aabb2f val { { 2,  1 }, { 3, 6 } };
-        const aabb2f res { { 1, -1 }, { 4, 8 } };
-
-        tap.expect_eq (val.expand ({1.f, 2.f}), res, "aabb::expand");
-    }
-
     return tap.status ();
 }
diff --git a/test/geom/ray.cpp b/test/geom/ray.cpp
index 7d5a3dc1..6e11e32a 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 bc308415..bb9c430b 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/maths.cpp b/test/maths.cpp
index 08dbc4a7..c2502d8e 100644
--- a/test/maths.cpp
+++ b/test/maths.cpp
@@ -160,6 +160,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 ();
diff --git a/test/matrix.cpp b/test/matrix.cpp
index 0e077098..dc962a71 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 },
@@ -105,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");
     }
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/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/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/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 {
diff --git a/test/stream.cpp b/test/stream.cpp
index b4164875..ec4c2e61 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"
 
 #include <sstream>
 
diff --git a/test/string.cpp b/test/string.cpp
index b3e20cd5..cce00832 100644
--- a/test/string.cpp
+++ b/test/string.cpp
@@ -9,8 +9,11 @@ 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;
 
     // expected test data must be a std::string so we can check embedded
     // nulls (which are ambiguous when using a cstr).
@@ -18,7 +21,7 @@ main (int, char**)
         const std::string value;
         const char *message;
     } TESTS[] = {
-        { "\0",             "null" },
+        { "\0"s,            "null" },
         { "a",              "single letter" },
         { "123",            "three digits" },
         { "",               "empty string" },
@@ -27,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/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/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/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/test/uri.cpp b/test/uri.cpp
index 0f6e2367..474b489a 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_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[] = {
@@ -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/test/view.cpp b/test/view.cpp
index 72f9bf85..28b07b26 100644
--- a/test/view.cpp
+++ b/test/view.cpp
@@ -1,18 +1,52 @@
 #include "tap.hpp"
 #include "view.hpp"
-    
+
+#include <algorithm>
+
+
+///////////////////////////////////////////////////////////////////////////////
 int
 main (int, char**)
 {
     util::TAP::logger tap;
 
+    tap.expect_eq (
+        std::size (util::make_view ("foo")), 3,
+        "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";
 
-    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/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..24ffed5a 100644
--- a/time.hpp
+++ b/time.hpp
@@ -17,22 +17,32 @@
 #ifndef __UTIL_TIME_HPP
 #define __UTIL_TIME_HPP
 
+#include "stats.hpp"
+
 #include <chrono>
 #include <cstdint>
 #include <string>
 
-#include "./stats.hpp"
 
 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 ();
@@ -45,7 +55,8 @@ namespace util {
             } time;
     };
 
-    // ------------------------------------------------------------------------
+
+    ///////////////////////////////////////////////////////////////////////////
     class period_query {
         public:
             explicit period_query (float seconds);
@@ -59,7 +70,8 @@ namespace util {
             } m_time;
     };
 
-    // ------------------------------------------------------------------------
+
+    ///////////////////////////////////////////////////////////////////////////
     class rate_limiter {
         public:
             explicit rate_limiter (unsigned rate);
@@ -71,7 +83,8 @@ namespace util {
             unsigned m_target;
     };
 
-    // ------------------------------------------------------------------------
+
+    ///////////////////////////////////////////////////////////////////////////
     class polled_duration {
         public:
             polled_duration (std::string name, uint64_t interval);
@@ -89,6 +102,4 @@ namespace util {
     };
 }
 
-#include "./time.ipp"
-
-#endif // __UTIL_TIME_HPP
+#endif
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..2be47ac8
--- /dev/null
+++ b/time/parse8601.cpp.rl
@@ -0,0 +1,181 @@
+/*
+ * 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-2018 Danny Robson <danny@nerdcruft.net>
+ */
+
+#include "time/parse.hpp"
+
+#include "debug.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);
+}
+
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/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
diff --git a/uri.cpp.rl b/uri.cpp.rl
index a5f02f23..8ea4c7ff 100644
--- a/uri.cpp.rl
+++ b/uri.cpp.rl
@@ -20,133 +20,55 @@
 #include "uri.hpp"
 
 #include "debug.hpp"
+#include "iterator.hpp"
 
 #include <algorithm>
 #include <iostream>
 
+using util::uri;
 
+
+///////////////////////////////////////////////////////////////////////////////
 %%{
-    machine uri;
+    machine impl;
 
     action trace { if (0) std::cerr << *p; }
     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
-    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*;
-    host = ip_literal | ipv4address | reg_name;
-    userinfo = (unreserved | pct_encoded | sub_delim | ':')*;
-    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
-        | path_absolute  >path_begin %path_end
-        | path_rootless  >path_begin %path_end
-        | path_empty     >path_begin %path_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 >uri_begin %uri_end
     %success
     $!failure
     $trace;
@@ -164,18 +86,34 @@ 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 };
 
 
 //-----------------------------------------------------------------------------
 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 ();
@@ -194,15 +132,6 @@ util::uri::uri (std::string &&_value):
 }
 
 
-//-----------------------------------------------------------------------------
-util::view<const char*>
-util::uri::get (util::uri::component c)
-{
-    CHECK_NEQ (c, NUM_COMPONENTS);
-    return m_views[c];
-}
-
-
 //-----------------------------------------------------------------------------
 static uint8_t
 hex_to_uint (char c)
@@ -264,16 +193,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 ();
diff --git a/uri.hpp b/uri.hpp
index 92f4749a..0480281d 100644
--- a/uri.hpp
+++ b/uri.hpp
@@ -11,45 +11,95 @@
  * 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 "debug.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 &&);
+        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; };
 
+
+        // 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 c) const&
+        {
+            CHECK_LIMIT (c, 0, NUM_COMPONENTS);
+            return m_views[c];
+        }
+
+        util::view<const char*> all (void) const& { return util::make_view (m_value); }
+
+        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; }
 
         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;
     };
 
diff --git a/vector.hpp b/vector.hpp
index 5179e728..f273e1e7 100644
--- a/vector.hpp
+++ b/vector.hpp
@@ -29,9 +29,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;
@@ -92,6 +92,7 @@ namespace util {
     const json::tree::node&
     operator>> (const json::tree::node&, vector<S,T>&);
 
+    template <typename T> using vector1 = vector<1,T>;
     template <typename T> using vector2 = vector<2,T>;
     template <typename T> using vector3 = vector<3,T>;
     template <typename T> using vector4 = vector<4,T>;
@@ -109,6 +110,7 @@ namespace util {
     using vector3i = vector3<int>;
     using vector4i = vector4<int>;
 
+    using vector1f = vector1<float>;
     using vector2f = vector2<float>;
     using vector3f = vector3<float>;
     using vector4f = vector4<float>;
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 2c07bc74..32d84bed 100644
--- a/view.cpp
+++ b/view.cpp
@@ -11,63 +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>
-
-
-///////////////////////////////////////////////////////////////////////////////
-#define EQUALITY(A,B)                   \
-bool                                    \
-util::equal (A a, B b)                  \
-{                                       \
-    return a.size () == a.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)                                                          \
-    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
-}
-
+#include "view.hpp"
diff --git a/view.hpp b/view.hpp
index 6d69552d..85ad988b 100644
--- a/view.hpp
+++ b/view.hpp
@@ -18,80 +18,176 @@
 #ifndef CRUFT_UTIL_VIEW_HPP
 #define CRUFT_UTIL_VIEW_HPP
 
-#include "./types/traits.hpp"
+#include "types/traits.hpp"
+#include "maths.hpp"
 
-#include <cassert>
 #include <cstdlib>
 #include <ostream>
 #include <string>
 #include <cstring>
 #include <stdexcept>
+#include <iterator>
 
 namespace util {
-    template <typename IteratorT>
+    template <typename BeginT, typename EndT = BeginT>
     struct view {
     public:
         //---------------------------------------------------------------------
         using value_type = typename std::iterator_traits<
-            remove_restrict_t<IteratorT>
+            remove_restrict_t<BeginT>
         >::value_type;
 
 
         //---------------------------------------------------------------------
         constexpr
-        view (const IteratorT &first, const IteratorT &last) noexcept:
+        view (const BeginT &first, const EndT &last) noexcept:
             m_begin (first),
             m_end   (last)
         { ; }
 
 
         //---------------------------------------------------------------------
-        constexpr view (const view &rhs) noexcept = default;
-        view& operator= (const view &rhs) noexcept = default;
+        // 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
+        ):
+            view (_begin, _begin + _size)
+        { ; }
+
+
+        //---------------------------------------------------------------------
+        // 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*>
+            >
+        >
+        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.
+        template <std::size_t N>
+        view (const char (&value)[N]):
+            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)}
+        { ; }
+
+
+        //---------------------------------------------------------------------
+        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}
+        { ; }
 
 
         //---------------------------------------------------------------------
         // 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 (IteratorT{}, IteratorT{})
+            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 CharT, typename Traits, typename Allocator>
+        view (std::basic_string<CharT,Traits,Allocator> &val):
+            view (std::data (val), std::data (val) + std::size (val))
+        { ; }
+
+
+        //---------------------------------------------------------------------
+        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))
+        { ; }
+
+
+        //---------------------------------------------------------------------
+        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))
+        { ; }
+
+
+        //---------------------------------------------------------------------
+        view&
+        operator= (const view &rhs) noexcept
         {
-            std::swap (m_begin, rhs.m_begin);
-            std::swap (m_end,   rhs.m_end);
+            m_begin = rhs.m_begin;
+            m_end   = rhs.m_end;
+            return *this;
         }
 
-        template <std::size_t N>
-        constexpr view (const char (&str)[N]):
-            m_begin (std::begin (str)),
-            m_end   (std::begin (str) + N - 1)
-        { ; }
-
-
-        explicit constexpr view (std::nullptr_t):
-            m_begin (nullptr),
-            m_end   (nullptr)
-        { ; }
-
-
-        //---------------------------------------------------------------------
-        template <typename ContainerT>
-        constexpr explicit
-        view (ContainerT &klass):
-            m_begin (std::begin (klass)),
-            m_end   (std::end   (klass))
-        { ; }
-
-
-        //---------------------------------------------------------------------
-        template <typename ContainerT>
-        constexpr explicit
-        view (const ContainerT &klass):
-            m_begin (std::begin (klass)),
-            m_end   (std::end   (klass))
-        { ; }
-
 
         //---------------------------------------------------------------------
         view&
@@ -100,29 +196,30 @@ namespace util {
             m_begin = rhs.m_begin;
             m_end = rhs.m_end;
 
-            rhs.m_begin = IteratorT{};
-            rhs.m_end = IteratorT{};
+            rhs.m_begin = BeginT{};
+            rhs.m_end = EndT{};
 
             return *this;
         };
 
 
         ///////////////////////////////////////////////////////////////////////
-        constexpr IteratorT begin (void) noexcept { return m_begin; }
-        constexpr IteratorT end   (void) noexcept { return m_end;   }
+        constexpr BeginT begin (void) noexcept { return m_begin; }
+        constexpr EndT 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 BeginT begin (void) const noexcept { return cbegin (); }
+        constexpr const EndT 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 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
@@ -138,7 +235,7 @@ namespace util {
         }
 
         //---------------------------------------------------------------------
-        constexpr auto
+        [[gnu::warn_unused_result]] constexpr auto
         redim (int count) const
         {
             assert (count > 0);
@@ -147,8 +244,39 @@ namespace util {
             return view { m_begin, m_begin + count };
         };
 
+
+        //---------------------------------------------------------------------
+        util::view<BeginT,EndT>
+        operator- (util::view<BeginT,BeginT> prefix) const
+        {
+            assert (prefix.begin () == begin ());
+            return { prefix.end (), end () };
+        }
+
+
         ///////////////////////////////////////////////////////////////////////
-        constexpr value_type&
+        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
+        {
+            return {
+                reinterpret_cast<ValueT*> (m_begin),
+                reinterpret_cast<ValueT*> (m_end)
+            };
+        }
+
+
+
+        ///////////////////////////////////////////////////////////////////////
+        constexpr auto&
         operator[] (size_t idx)& noexcept
         {
             auto it = begin ();
@@ -157,7 +285,7 @@ namespace util {
         }
 
         //---------------------------------------------------------------------
-        constexpr const value_type&
+        constexpr auto&
         operator[] (size_t idx) const& noexcept
         {
             auto it = begin ();
@@ -167,11 +295,48 @@ namespace util {
 
     private:
         ///////////////////////////////////////////////////////////////////////
-        IteratorT m_begin;
-        IteratorT m_end;
+        BeginT m_begin;
+        EndT m_end;
     };
 
 
+    //-------------------------------------------------------------------------
+    template <typename ValueT, std::size_t N>
+    view (const ValueT(&)[N]) -> view<const ValueT*,const ValueT*>;
+
+
+    //-------------------------------------------------------------------------
+    view (const char*) -> view<const char*>;
+
+    view (char*) -> view<char*>;
+
+
+    //-------------------------------------------------------------------------
+    template <
+        typename IteratorT,
+        typename SizeT,
+        typename = std::enable_if_t<
+            std::is_integral_v<SizeT>,void
+        >
+    >
+    view (IteratorT, SizeT) -> view<IteratorT,IteratorT>;
+
+
+    template <typename CharT, typename Traits, typename Allocator>
+    view (std::basic_string<CharT,Traits,Allocator> &) -> view<typename Allocator::pointer>;
+
+
+    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>;
+
+
     ///////////////////////////////////////////////////////////////////////////
     template <typename ValueT, size_t N>
     auto
@@ -211,16 +376,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 IteratorT>
+    template <typename BeginT, typename EndT>
     auto
-    make_view (IteratorT first, IteratorT last)
+    make_view (BeginT first, EndT last)
     {
-        return view<IteratorT> {first, last};
+        return view<BeginT, EndT> {first, last};
     }
 
     //-------------------------------------------------------------------------
@@ -238,6 +404,7 @@ namespace util {
         return { str, str + strlen (str) };
     }
 
+
     //-------------------------------------------------------------------------
     inline
     view<char*> make_view (char *str)
@@ -283,42 +450,93 @@ namespace util {
 
 
     ///////////////////////////////////////////////////////////////////////////
-    template <typename IteratorT>
+    template <typename BeginT, typename EndT>
     constexpr bool
-    operator== (const view<IteratorT> &a, const view<IteratorT> &b)
+    operator== (const view<BeginT> &a, const view<EndT> &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)
+    operator== (const view<IteratorT> &a, const ValueT &b)
+    {
+        return a == make_view (b);
+    }
+
+
+    //-------------------------------------------------------------------------
+    // 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 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);
     }
 
 
     //-------------------------------------------------------------------------
-    // 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, typename ValueT>
+    constexpr bool
+    operator!= (const ValueT &a, const util::view<IteratorT> &b)
+    {
+        return !(a == b);
+    }
 
 
     ///////////////////////////////////////////////////////////////////////////
-    template <typename IteratorT>
+    template <typename BeginT, typename EndT>
     std::ostream&
-    operator<< (std::ostream&, view<IteratorT>);
+    operator<< (std::ostream &os, view<BeginT, EndT> 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.
+    ///
+    /// 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 || (res == 0 && la < lb);
+    }
+
+
 }
 
+
 #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
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"
 
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);