From 320fe6c3780aabf40d1f3c6ebf736a3a51287c6d Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Mon, 3 Jul 2017 17:05:01 +1000
Subject: [PATCH 001/149] job/queue: add trivial job queuing system

---
 CMakeLists.txt     |   3 +
 job/queue.cpp      |  84 +++++++++++++++++++++++++
 job/queue.hpp      | 153 +++++++++++++++++++++++++++++++++++++++++++++
 test/job/queue.cpp |  34 ++++++++++
 4 files changed, 274 insertions(+)
 create mode 100644 job/queue.cpp
 create mode 100644 job/queue.hpp
 create mode 100644 test/job/queue.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index dae941d7..f143c93a 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -306,6 +306,8 @@ list (
     io.hpp
     io.ipp
     iterator.hpp
+    job/queue.cpp
+    job/queue.hpp
     json/fwd.hpp
     json/except.cpp
     json/except.hpp
@@ -481,6 +483,7 @@ if (TESTS)
         hton
         introspection
         iterator
+        job/queue
         json_types
         maths
         matrix
diff --git a/job/queue.cpp b/job/queue.cpp
new file mode 100644
index 00000000..97b0eee0
--- /dev/null
+++ b/job/queue.cpp
@@ -0,0 +1,84 @@
+/*
+ * 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 "./queue.hpp"
+
+#include <iostream>
+
+using util::job::queue;
+
+
+///////////////////////////////////////////////////////////////////////////////
+queue::queue ():
+    queue (std::thread::hardware_concurrency () ?: 1)
+{ ; }
+
+
+//-----------------------------------------------------------------------------
+queue::queue (unsigned thread_count):
+    m_loop ([] (store &s) {
+        args obj;
+
+        while (true) {
+            // acquire the work lock and see if we need to quit, continue,
+            // or sleep
+            std::unique_lock<std::mutex> lk (s.mutex);
+            if (s.pending.empty ()) {
+                s.cv.wait (lk, [&] () {
+                    return s.stopping.load () || !s.pending.empty ();
+                });
+            }
+
+            if (s.stopping.load ())
+                break;
+
+            // extract the arguments and forward them to the functor
+            obj = std::move (s.pending.front ());
+            s.pending.pop_front ();
+            lk.unlock ();
+            s.cv.notify_one ();
+
+            obj.function (obj);
+        }
+    }),
+    m_threads (thread_count)
+{
+    for (auto &t: m_threads)
+        t = std::thread (m_loop, std::ref (m_store));
+}
+
+
+//-----------------------------------------------------------------------------
+queue::~queue ()
+{
+    // tell everyone we want to quit
+    {
+        std::lock_guard<std::mutex> lk {m_store.mutex};
+        m_store.stopping.store (true);
+    }
+    m_store.cv.notify_all ();
+
+    // wait for everyone to tidy up. perhaps we'd like to use a timeout, but
+    // if things deadlock then it's the users fault currently.
+    std::for_each (
+        std::begin (m_threads),
+        std::end (m_threads),
+        [] (auto &t)
+    {
+        t.join ();
+    });
+}
+
diff --git a/job/queue.hpp b/job/queue.hpp
new file mode 100644
index 00000000..ad0432e4
--- /dev/null
+++ b/job/queue.hpp
@@ -0,0 +1,153 @@
+/*
+ * 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_JOB_QUEUE_HPP
+#define CRUFT_UTIL_JOB_QUEUE_HPP
+
+#include <array>
+#include <deque>
+#include <thread>
+#include <vector>
+#include <new>
+#include <cstddef>
+#include <functional>
+#include <atomic>
+#include <mutex>
+#include <condition_variable>
+
+namespace util::job {
+    class queue {
+    public:
+        queue ();
+        queue (unsigned thread_count);
+        ~queue ();
+
+        using cookie = int;
+
+        template <class Function, typename ...Args>
+        cookie
+        submit (cookie &parent, Function&&, Args&&...);
+
+        /// record a functor and a set of parameters to execute at some point
+        /// in the future by an arbitrary available thread.
+        template <class Function, typename ...Args>
+        cookie
+        submit (Function &&func, Args &&...params)
+        {
+            {
+                std::unique_lock<std::mutex> lk (m_store.mutex);
+                m_store.pending.emplace_back (
+                    std::forward<Function> (func),
+                    std::forward<Args> (params)...
+                );
+            }
+
+            m_store.cv.notify_one ();
+
+            // TODO: return a useful identifier to allow waiting
+            return 0;
+        }
+
+        void wait (cookie);
+
+        // HACK: this doesn't actually implement a proper barrier and may not
+        // even guarantee that all jobs are flushed. it's provided to make
+        // some amount of testing slightly more convenient by draining most
+        // of the queue on demand.
+        void
+        flush (void)
+        {
+            // setup a cv and completion flag. this is a poor man's barrier.
+            std::mutex m;
+            std::unique_lock<std::mutex> lk (m);
+            std::condition_variable cv;
+            std::atomic<bool> done = false;
+
+            // submit a job to the back of the queue that sets the done flag
+            // and wakes us back up again.
+            submit ([&] (void) {
+                {
+                    std::lock_guard<std::mutex> _{m};
+                    done.store (true);
+                }
+
+                cv.notify_one ();
+            });
+
+            // wait until the flag is set then exit.
+            do {
+                cv.wait (lk, [&] () { return done.load (); });
+            } while (!done.load ());
+        }
+
+    private:
+        /// stores a functor and associated arguments in a fixed size buffer
+        /// for later execution.
+        ///
+        /// for ease of implementation the arguments are currently restricted
+        /// as follows:
+        ///   * trivial types (memcpy'able)
+        ///   * a fixed total maximum size of around one cache line
+        /// these limitations will be eliminated at some point in the future
+        ///
+        /// the user supplied functor is wrapped with our own that unpacks and
+        /// forwards the arguments from the data buffer. this function must
+        /// be passed a copy of the current arg object as the only argument.
+        struct args {
+            args () = default;
+
+            template <class Function, typename ...Args>
+            args (Function &&func, Args&&...params)
+            {
+                using tuple_t = std::tuple<Args...>;
+                static_assert ((std::is_trivial_v<decltype(params)> && ...));
+                static_assert (sizeof (tuple_t) <= sizeof data);
+
+                union {
+                    decltype(data) *byte_ptr;
+                    tuple_t        *args_ptr;
+                };
+                 byte_ptr = &data;
+                *args_ptr = std::make_tuple (std::forward (params)...);
+
+                function = [func] (args &base) {
+                    std::apply (func, *reinterpret_cast<tuple_t*> (&base.data));
+                };
+            };
+
+            // GCC: switch to hardware_destructive_interference_size when it
+            // becomes available in libstdc++. Until then we use a sensible
+            // guess.
+            std::array<char,64> data;
+
+            std::function<void(args&)> function;
+        };
+
+        struct store {
+            std::atomic<bool> stopping = false;
+            std::deque<args> pending;
+
+            std::condition_variable cv;
+            std::mutex mutex;
+        };
+
+        store m_store;
+        std::function<void(store&)> m_loop;
+        std::vector<std::thread> m_threads;
+    };
+}
+
+#endif
diff --git a/test/job/queue.cpp b/test/job/queue.cpp
new file mode 100644
index 00000000..c17b5372
--- /dev/null
+++ b/test/job/queue.cpp
@@ -0,0 +1,34 @@
+#include "job/queue.hpp"
+#include "tap.hpp"
+
+#include <unistd.h>
+
+int
+main (void)
+{
+    util::TAP::logger tap;
+
+    // dispatch `INNER' simple jobs `OUTTER' times that simply increment an
+    // atomic variable and quit. this tests that all threads are created,
+    // executed, and finished. it's not definitive, but executing this many
+    // items this many times seems reasonably reliable in exposing deadlocks.
+    bool success = true;
+    constexpr int OUTTER = 16;
+    constexpr int INNER  = 1024;
+
+    for (auto i = 0; i < OUTTER && success; ++i) {
+        std::atomic<int> count = 0;
+
+        {
+            util::job::queue q {};
+            for (int j = 0; j < INNER; ++j)
+                q.submit ([&count] () noexcept { ++count; });
+            q.flush ();
+        }
+
+        success = count == INNER && success;
+    }
+
+    tap.expect (success, "trivial increment jobs");
+    return tap.status ();
+}
\ No newline at end of file

From 21f462d4a0a8623c0465908791c1106869ab8da3 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 4 Jul 2017 14:18:45 +1000
Subject: [PATCH 002/149] job/queue: don't use references for parameters

references aren't trivial types. we should support them soon, but this
gets us up and running faster.
---
 job/queue.hpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/job/queue.hpp b/job/queue.hpp
index ad0432e4..ceac6986 100644
--- a/job/queue.hpp
+++ b/job/queue.hpp
@@ -93,6 +93,7 @@ namespace util::job {
             } while (!done.load ());
         }
 
+
     private:
         /// stores a functor and associated arguments in a fixed size buffer
         /// for later execution.
@@ -112,8 +113,8 @@ namespace util::job {
             template <class Function, typename ...Args>
             args (Function &&func, Args&&...params)
             {
-                using tuple_t = std::tuple<Args...>;
-                static_assert ((std::is_trivial_v<decltype(params)> && ...));
+                using tuple_t = std::tuple<std::decay_t<Args>...>;
+                static_assert ((std::is_trivial_v<std::decay_t<decltype(params)>> && ...));
                 static_assert (sizeof (tuple_t) <= sizeof data);
 
                 union {
@@ -121,7 +122,7 @@ namespace util::job {
                     tuple_t        *args_ptr;
                 };
                  byte_ptr = &data;
-                *args_ptr = std::make_tuple (std::forward (params)...);
+                *args_ptr = std::make_tuple (params...);
 
                 function = [func] (args &base) {
                     std::apply (func, *reinterpret_cast<tuple_t*> (&base.data));

From 564d6ab7532aea4c526e7e9a5fe0022760e32204 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 4 Jul 2017 14:20:51 +1000
Subject: [PATCH 003/149] cmake: bump for threading support

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

diff --git a/cmake b/cmake
index 06bb32ff..a1d3200f 160000
--- a/cmake
+++ b/cmake
@@ -1 +1 @@
-Subproject commit 06bb32ff00fc4b6d8581a2e91a17ddab5a1407d4
+Subproject commit a1d3200fde0923ace464ce711fc52d5b183e9e2d

From 825102a328b95cbc6c66b5afabfc69504722bc6b Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 4 Jul 2017 16:18:57 +1000
Subject: [PATCH 004/149] extent: add convenience make_range iterator creator

---
 extent.hpp | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/extent.hpp b/extent.hpp
index eeb804a6..be1c1113 100644
--- a/extent.hpp
+++ b/extent.hpp
@@ -73,7 +73,7 @@ namespace util {
             extent<S,T> m_target;
         };
 
-        extent_range (extent<S,T> target);
+        explicit extent_range (extent<S,T> target);
 
         iterator begin (void) const;
         iterator end   (void) const;
@@ -82,6 +82,13 @@ namespace util {
         extent<S,T> m_target;
     };
 
+    template <size_t S, typename T>
+    extent_range<S,T>
+    make_range (extent<S,T> e)
+    {
+        return extent_range<S,T> {e};
+    }
+
     // convenience typedefs
     template <typename T> using extent2 = extent<2,T>;
     template <typename T> using extent3 = extent<3,T>;

From af3dcbb41868d6381f63a5ca26596570b649c2b4 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 11 Jul 2017 11:06:59 +1000
Subject: [PATCH 005/149] tuple: make nullary 'ignore' inline

works around multiple symbol definition errors at link time.
---
 tuple.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tuple.hpp b/tuple.hpp
index b347e23b..0f05bca3 100644
--- a/tuple.hpp
+++ b/tuple.hpp
@@ -174,7 +174,7 @@ namespace util::tuple {
     /// it is guaranteed that this function will never be defined out in
     /// debug/release/whatever builds. so it is safe to use to guarantee
     /// parameter evaluation.
-    void
+    inline void
     ignore (void)
     { ; }
 

From b9ca3f6969543a380705e9c4e9b7f6ad7adcf5b9 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 11 Jul 2017 11:07:48 +1000
Subject: [PATCH 006/149] tuple: add `index' type query for tuple types

util::tuple::index finds the first occurence of a type in a tuple and
gives the index of this type.
---
 tuple.hpp | 26 +++++++++++++++++++++++++-
 1 file changed, 25 insertions(+), 1 deletion(-)

diff --git a/tuple.hpp b/tuple.hpp
index 0f05bca3..cd6260b4 100644
--- a/tuple.hpp
+++ b/tuple.hpp
@@ -185,7 +185,31 @@ namespace util::tuple {
     {
         ignore (std::forward<Args> (args)...);
     };
-}
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    /// query the index of the first occurrence of type `T' in the tuple type
+    /// `TupleT'.
+    ///
+    /// if the query type does not occur in the tuple type a compiler error
+    /// should be generated.
+    template <class T, class TupleT>
+    struct index;
+
+
+    //-------------------------------------------------------------------------
+    template <class T, class ...Types>
+    struct index<T, std::tuple<T, Types...>> {
+        static constexpr std::size_t value = 0;
+    };
+
+
+    //-------------------------------------------------------------------------
+    template <class T, class U, class ...Types>
+    struct index<T,std::tuple<U, Types...>> {
+        static constexpr std::size_t value = 1 + index<T, std::tuple<Types...>>::value;
+    };
+};
 
 
 #endif

From 3460d5edbe293664bfad2dd8ec977ea5a1effe41 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 11 Jul 2017 16:49:49 +1000
Subject: [PATCH 007/149] crypto/salsa: add initial skeleton for salsa20

---
 CMakeLists.txt        |   3 +
 crypto/salsa.cpp      |  24 +++++
 crypto/salsa.hpp      |  86 ++++++++++++++++
 test/crypto/salsa.cpp | 229 ++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 342 insertions(+)
 create mode 100644 crypto/salsa.cpp
 create mode 100644 crypto/salsa.hpp
 create mode 100644 test/crypto/salsa.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index f143c93a..4bad0e2d 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -199,6 +199,8 @@ list (
     crypto/arc4.hpp
     crypto/ice.cpp
     crypto/ice.hpp
+    crypto/salsa.cpp
+    crypto/salsa.hpp
     crypto/tea.cpp
     crypto/tea.hpp
     crypto/xtea.cpp
@@ -456,6 +458,7 @@ if (TESTS)
         coord
         crypto/arc4
         crypto/ice
+        crypto/salsa
         crypto/tea
         crypto/xtea
         crypto/xxtea
diff --git a/crypto/salsa.cpp b/crypto/salsa.cpp
new file mode 100644
index 00000000..2cf5590b
--- /dev/null
+++ b/crypto/salsa.cpp
@@ -0,0 +1,24 @@
+#include "./salsa.hpp"
+
+
+///////////////////////////////////////////////////////////////////////////////
+std::array<uint8_t,64>
+util::crypto::salsa20 (const std::array<uint8_t,64> bytes) noexcept
+{
+    auto x = *reinterpret_cast<const std::array<uint32_t,16>*> (&bytes);
+    auto y = x;
+
+    for (auto &t: x)
+        t = util::ltoh (t);
+
+    for (int i = 0; i < 10; ++i)
+        x = salsa::doubleround (x);
+
+    for (size_t i = 0; i < std::size (y); ++i)
+        x[i] += y[i];
+
+    for (auto &t: x)
+        t = util::htol (t);
+
+    return *reinterpret_cast<std::array<uint8_t,64>*> (&x);
+}
diff --git a/crypto/salsa.hpp b/crypto/salsa.hpp
new file mode 100644
index 00000000..c8d81c64
--- /dev/null
+++ b/crypto/salsa.hpp
@@ -0,0 +1,86 @@
+#include <cstdint>
+#include <array>
+
+#include "../bitwise.hpp"
+#include "../endian.hpp"
+
+namespace util::crypto::salsa {
+
+    ///////////////////////////////////////////////////////////////////////////
+    constexpr
+    uint32_t
+    R (uint32_t a, uint32_t b, uint32_t c, uint32_t k)
+    {
+        return b ^ util::rotatel (a + c, k);
+    }
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    constexpr
+    std::array<uint32_t,4>
+    quarter (std::array<uint32_t,4> y) noexcept
+    {
+        std::array<uint32_t,4> z {};
+
+        z[1] = R (y[0], y[1], y[3],  7);
+        z[2] = R (z[1], y[2], y[0],  9);
+        z[3] = R (z[2], y[3], z[1], 13);
+        z[0] = R (z[3], y[0], z[2], 18);
+
+        return z;
+    }
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    constexpr
+    std::array<uint32_t,16>
+    row (const std::array<uint32_t,16> y) noexcept
+    {
+        const auto [z00, z01, z02, z03] = quarter ({y[ 0], y[ 1], y[ 2], y[ 3]});
+        const auto [z05, z06, z07, z04] = quarter ({y[ 5], y[ 6], y[ 7], y[ 4]});
+        const auto [z10, z11, z08, z09] = quarter ({y[10], y[11], y[ 8], y[ 9]});
+        const auto [z15, z12, z13, z14] = quarter ({y[15], y[12], y[13], y[14]});
+
+        return {
+            z00, z01, z02, z03,
+            z04, z05, z06, z07,
+            z08, z09, z10, z11,
+            z12, z13, z14, z15
+        };
+    }
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    constexpr
+    std::array<uint32_t,16>
+    col (const std::array<uint32_t,16> x) noexcept
+    {
+        const auto [y00, y04, y08, y12] = quarter ({x[ 0], x[ 4], x[ 8], x[12]});
+        const auto [y05, y09, y13, y01] = quarter ({x[ 5], x[ 9], x[13], x[ 1]});
+        const auto [y10, y14, y02, y06] = quarter ({x[10], x[14], x[ 2], x[ 6]});
+        const auto [y15, y03, y07, y11] = quarter ({x[15], x[ 3], x[ 7], x[11]});
+
+        return {
+            y00, y01, y02, y03,
+            y04, y05, y06, y07,
+            y08, y09, y10, y11,
+            y12, y13, y14, y15,
+        };
+    }
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    constexpr
+    std::array<uint32_t,16>
+    doubleround (const std::array<uint32_t,16> x) noexcept
+    {
+        return row (col (x));
+    }
+}
+
+
+namespace util::crypto {
+    ///////////////////////////////////////////////////////////////////////////
+    std::array<uint8_t,64>
+    salsa20 (const std::array<uint8_t,64>) noexcept;
+}
diff --git a/test/crypto/salsa.cpp b/test/crypto/salsa.cpp
new file mode 100644
index 00000000..e3478be9
--- /dev/null
+++ b/test/crypto/salsa.cpp
@@ -0,0 +1,229 @@
+#include "crypto/salsa.hpp"
+
+#include "tap.hpp"
+
+
+///////////////////////////////////////////////////////////////////////////////
+void
+test_quarter (util::TAP::logger &tap)
+{
+    static const struct {
+        std::array<uint32_t, 4> a, b;
+    } TESTS[] = {
+        { { 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
+          { 0x00000000, 0x00000000, 0x00000000, 0x00000000 } },
+        { { 0x00000001, 0x00000000, 0x00000000, 0x00000000 },
+          { 0x08008145, 0x00000080, 0x00010200, 0x20500000 } },
+        { { 0x00000000, 0x00000001, 0x00000000, 0x00000000 },
+          { 0x88000100, 0x00000001, 0x00000200, 0x00402000 } },
+        { { 0x00000000, 0x00000000, 0x00000001, 0x00000000 },
+          { 0x80040000, 0x00000000, 0x00000001, 0x00002000 } },
+        { { 0x00000000, 0x00000000, 0x00000000, 0x00000001 },
+          { 0x00048044, 0x00000080, 0x00010000, 0x20100001 } },
+        { { 0xe7e8c006, 0xc4f9417d, 0x6479b4b2, 0x68c67137 },
+          { 0xe876d72b, 0x9361dfd5, 0xf1460244, 0x948541a3 } },
+        { { 0xd3917c5b, 0x55f1c407, 0x52a58a7a, 0x8f887a3b },
+          { 0x3e2f308c, 0xd90a8f36, 0x6ab2a923, 0x2883524c } },
+    };
+
+    for (size_t i = 0; i < std::size (TESTS); ++i)
+        tap.expect_eq (util::crypto::salsa::quarter (TESTS[i].a), TESTS[i].b, "quarter %zu", i);
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+void
+test_row (util::TAP::logger &tap)
+{
+    static const struct {
+        std::array<uint32_t, 16> a, b;
+    } TESTS[] = {
+        { { 0x00000001, 0x00000000, 0x00000000, 0x00000000,
+            0x00000001, 0x00000000, 0x00000000, 0x00000000,
+            0x00000001, 0x00000000, 0x00000000, 0x00000000,
+            0x00000001, 0x00000000, 0x00000000, 0x00000000, },
+          { 0x08008145, 0x00000080, 0x00010200, 0x20500000,
+            0x20100001, 0x00048044, 0x00000080, 0x00010000,
+            0x00000001, 0x00002000, 0x80040000, 0x00000000,
+            0x00000001, 0x00000200, 0x00402000, 0x88000100, }
+        },
+        { { 0x08521bd6, 0x1fe88837, 0xbb2aa576, 0x3aa26365,
+            0xc54c6a5b, 0x2fc74c2f, 0x6dd39cc3, 0xda0a64f6,
+            0x90a2f23d, 0x067f95a6, 0x06b35f61, 0x41e4732e,
+            0xe859c100, 0xea4d84b7, 0x0f619bff, 0xbc6e965a, },
+          { 0xa890d39d, 0x65d71596, 0xe9487daa, 0xc8ca6a86,
+            0x949d2192, 0x764b7754, 0xe408d9b9, 0x7a41b4d1,
+            0x3402e183, 0x3c3af432, 0x50669f96, 0xd89ef0a8,
+            0x0040ede5, 0xb545fbce, 0xd257ed4f, 0x1818882d, },
+        }
+    };
+
+    for (size_t i = 0; i < std::size (TESTS); ++i)
+        tap.expect_eq (util::crypto::salsa::row (TESTS[i].a), TESTS[i].b, "row %zu", i);
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+void
+test_col (util::TAP::logger &tap)
+{
+    static const struct {
+        std::array<uint32_t,16> a, b;
+    } TESTS[] = {
+        { { 0x00000001, 0x00000000, 0x00000000, 0x00000000,
+            0x00000001, 0x00000000, 0x00000000, 0x00000000,
+            0x00000001, 0x00000000, 0x00000000, 0x00000000,
+            0x00000001, 0x00000000, 0x00000000, 0x00000000, },
+          { 0x10090288, 0x00000000, 0x00000000, 0x00000000,
+            0x00000101, 0x00000000, 0x00000000, 0x00000000,
+            0x00020401, 0x00000000, 0x00000000, 0x00000000,
+            0x40a04001, 0x00000000, 0x00000000, 0x00000000, } },
+        { { 0x08521bd6, 0x1fe88837, 0xbb2aa576, 0x3aa26365,
+            0xc54c6a5b, 0x2fc74c2f, 0x6dd39cc3, 0xda0a64f6,
+            0x90a2f23d, 0x067f95a6, 0x06b35f61, 0x41e4732e,
+            0xe859c100, 0xea4d84b7, 0x0f619bff, 0xbc6e965a, },
+          { 0x8c9d190a, 0xce8e4c90, 0x1ef8e9d3, 0x1326a71a,
+            0x90a20123, 0xead3c4f3, 0x63a091a0, 0xf0708d69,
+            0x789b010c, 0xd195a681, 0xeb7d5504, 0xa774135c,
+            0x481c2027, 0x53a8e4b5, 0x4c1f89c5, 0x3f78c9c8, } },
+    };
+
+    for (size_t i = 0; i < std::size (TESTS); ++i)
+        tap.expect_eq (util::crypto::salsa::col (TESTS[i].a), TESTS[i].b, "col %zu", i);
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+void
+test_doubleround (util::TAP::logger &tap)
+{
+    static const struct {
+        std::array<uint32_t,16> a, b;
+    } TESTS[] = {
+        { { 0x00000001, 0x00000000, 0x00000000, 0x00000000,
+            0x00000000, 0x00000000, 0x00000000, 0x00000000,
+            0x00000000, 0x00000000, 0x00000000, 0x00000000,
+            0x00000000, 0x00000000, 0x00000000, 0x00000000, },
+          { 0x8186a22d, 0x0040a284, 0x82479210, 0x06929051,
+            0x08000090, 0x02402200, 0x00004000, 0x00800000,
+            0x00010200, 0x20400000, 0x08008104, 0x00000000,
+            0x20500000, 0xa0000040, 0x0008180a, 0x612a8020, } },
+        { { 0xde501066, 0x6f9eb8f7, 0xe4fbbd9b, 0x454e3f57,
+            0xb75540d3, 0x43e93a4c, 0x3a6f2aa0, 0x726d6b36,
+            0x9243f484, 0x9145d1e8, 0x4fa9d247, 0xdc8dee11,
+            0x054bf545, 0x254dd653, 0xd9421b6d, 0x67b276c1, },
+          { 0xccaaf672, 0x23d960f7, 0x9153e63a, 0xcd9a60d0,
+            0x50440492, 0xf07cad19, 0xae344aa0, 0xdf4cfdfc,
+            0xca531c29, 0x8e7943db, 0xac1680cd, 0xd503ca00,
+            0xa74b2ad6, 0xbc331c5c, 0x1dda24c7, 0xee928277, } }
+    };
+
+    for (size_t i = 0; i < std::size (TESTS); ++i)
+        tap.expect_eq (util::crypto::salsa::doubleround (TESTS[i].a), TESTS[i].b, "doubleround %zu", i);
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+void
+test_salsa20 (util::TAP::logger &tap)
+{
+    static const struct {
+        std::array<uint8_t,64> a, b;
+    } TESTS[] = {
+        { { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+          { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } },
+
+        { { 0xd3, 0x9f, 0x0d, 0x73, 0x4c, 0x37, 0x52, 0xb7,
+            0x03, 0x75, 0xde, 0x25, 0xbf, 0xbb, 0xea, 0x88,
+            0x31, 0xed, 0xb3, 0x30, 0x01, 0x6a, 0xb2, 0xdb,
+            0xaf, 0xc7, 0xa6, 0x30, 0x56, 0x10, 0xb3, 0xcf,
+            0x1f, 0xf0, 0x20, 0x3f, 0x0f, 0x53, 0x5d, 0xa1,
+            0x74, 0x93, 0x30, 0x71, 0xee, 0x37, 0xcc, 0x24,
+            0x4f, 0xc9, 0xeb, 0x4f, 0x03, 0x51, 0x9c, 0x2f,
+            0xcb, 0x1a, 0xf4, 0xf3, 0x58, 0x76, 0x68, 0x36 },
+          { 0x6d, 0x2a, 0xb2, 0xa8, 0x9c, 0xf0, 0xf8, 0xee,
+            0xa8, 0xc4, 0xbe, 0xcb, 0x1a, 0x6e, 0xaa, 0x9a,
+            0x1d, 0x1d, 0x96, 0x1a, 0x96, 0x1e, 0xeb, 0xf9,
+            0xbe, 0xa3, 0xfb, 0x30, 0x45, 0x90, 0x33, 0x39,
+            0x76, 0x28, 0x98, 0x9d, 0xb4, 0x39, 0x1b, 0x5e,
+            0x6b, 0x2a, 0xec, 0x23, 0x1b, 0x6f, 0x72, 0x72,
+            0xdb, 0xec, 0xe8, 0x87, 0x6f, 0x9b, 0x6e, 0x12,
+            0x18, 0xe8, 0x5f, 0x9e, 0xb3, 0x13, 0x30, 0xca } },
+
+        { { 0x58, 0x76, 0x68, 0x36, 0x4f, 0xc9, 0xeb, 0x4f,
+            0x03, 0x51, 0x9c, 0x2f, 0xcb, 0x1a, 0xf4, 0xf3,
+            0xbf, 0xbb, 0xea, 0x88, 0xd3, 0x9f, 0x0d, 0x73,
+            0x4c, 0x37, 0x52, 0xb7, 0x03, 0x75, 0xde, 0x25,
+            0x56, 0x10, 0xb3, 0xcf, 0x31, 0xed, 0xb3, 0x30,
+            0x01, 0x6a, 0xb2, 0xdb, 0xaf, 0xc7, 0xa6, 0x30,
+            0xee, 0x37, 0xcc, 0x24, 0x1f, 0xf0, 0x20, 0x3f,
+            0x0f, 0x53, 0x5d, 0xa1, 0x74, 0x93, 0x30, 0x71 },
+          { 0xb3, 0x13, 0x30, 0xca, 0xdb, 0xec, 0xe8, 0x87,
+            0x6f, 0x9b, 0x6e, 0x12, 0x18, 0xe8, 0x5f, 0x9e,
+            0x1a, 0x6e, 0xaa, 0x9a, 0x6d, 0x2a, 0xb2, 0xa8,
+            0x9c, 0xf0, 0xf8, 0xee, 0xa8, 0xc4, 0xbe, 0xcb,
+            0x45, 0x90, 0x33, 0x39, 0x1d, 0x1d, 0x96, 0x1a,
+            0x96, 0x1e, 0xeb, 0xf9, 0xbe, 0xa3, 0xfb, 0x30,
+            0x1b, 0x6f, 0x72, 0x72, 0x76, 0x28, 0x98, 0x9d,
+            0xb4, 0x39, 0x1b, 0x5e, 0x6b, 0x2a, 0xec, 0x23 } }
+    };
+
+    for (size_t i = 0; i < std::size (TESTS); ++i)
+        tap.expect_eq (util::crypto::salsa20 (TESTS[i].a), TESTS[i].b, "salsa20 %zu", i);
+
+    struct {
+        std::array<uint8_t,64> a, b;
+    } million = {
+        { 0x06, 0x7c, 0x53, 0x92, 0x26, 0xbf, 0x09, 0x32,
+          0x04, 0xa1, 0x2f, 0xde, 0x7a, 0xb6, 0xdf, 0xb9,
+          0x4b, 0x1b, 0x00, 0xd8, 0x10, 0x7a, 0x07, 0x59,
+          0xa2, 0x68, 0x65, 0x93, 0xd5, 0x15, 0x36, 0x5f,
+          0xe1, 0xfd, 0x8b, 0xb0, 0x69, 0x84, 0x17, 0x74,
+          0x4c, 0x29, 0xb0, 0xcf, 0xdd, 0x22, 0x9d, 0x6c,
+          0x5e, 0x5e, 0x63, 0x34, 0x5a, 0x75, 0x5b, 0xdc,
+          0x92, 0xbe, 0xef, 0x8f, 0xc4, 0xb0, 0x82, 0xba },
+        { 0x08, 0x12, 0x26, 0xc7, 0x77, 0x4c, 0xd7, 0x43,
+          0xad, 0x7f, 0x90, 0xa2, 0x67, 0xd4, 0xb0, 0xd9,
+          0xc0, 0x13, 0xe9, 0x21, 0x9f, 0xc5, 0x9a, 0xa0,
+          0x80, 0xf3, 0xdb, 0x41, 0xab, 0x88, 0x87, 0xe1,
+          0x7b, 0x0b, 0x44, 0x56, 0xed, 0x52, 0x14, 0x9b,
+          0x85, 0xbd, 0x09, 0x53, 0xa7, 0x74, 0xc2, 0x4e,
+          0x7a, 0x7f, 0xc3, 0xb9, 0xb9, 0xcc, 0xbc, 0x5a,
+          0xf5, 0x09, 0xb7, 0xf8, 0xe2, 0x55, 0xf5, 0x68 }
+    };
+
+    for (int i = 0; i < 1'000'000; ++i)
+        million.a = util::crypto::salsa20 (million.a);
+
+    tap.expect_eq (million.a, million.b, "salsa20 million");
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+int
+main (void)
+{
+    util::TAP::logger tap;
+
+    test_quarter (tap);
+    test_row (tap);
+    test_col (tap);
+    test_doubleround (tap);
+    test_salsa20 (tap);
+
+    return 0;
+}

From a27869d1c81f256136c58441134f36395e2d399d Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Wed, 19 Jul 2017 17:19:20 +1000
Subject: [PATCH 008/149] region: commenting and style for test cases

---
 test/region.cpp | 53 +++++++++++++++++++++++++++++++++----------------
 1 file changed, 36 insertions(+), 17 deletions(-)

diff --git a/test/region.cpp b/test/region.cpp
index 9f4a26d0..eb24e262 100644
--- a/test/region.cpp
+++ b/test/region.cpp
@@ -10,35 +10,54 @@ main (int, char **)
 {
     util::TAP::logger tap;
 
+    // check that two overlapping regions successfully test for intersection
     {
-        util::point2d  ap { 32.7, -6.09703 };
-        util::extent2d ae { 0.8, 2. };
+        const util::point2d  ap { 32.7, -6.09703 };
+        const util::extent2d ae { 0.8, 2. };
+        const util::region2d a (ap, ae);
 
-        util::point2d bp {33.5, -4.5};
-        util::extent2d be { 0.5, 0.5 };
-
-        util::region2d a (ap, ae);
-        util::region2d b (bp, be);
+        const util::point2d  bp {33.5, -4.5};
+        const util::extent2d be { 0.5, 0.5 };
+        const util::region2d b (bp, be);
 
         tap.expect (!a.intersects (b), "simple 2d intersection");
     }
 
-    tap.expect (util::region2d::max ().intersects (util::region2d::unit ()), "maximal region2d intersection");
-    tap.expect (util::region2f::max ().intersects (util::region2f::unit ()), "maximal region2f intersection");
+    // check various floating point maximums successfully test for
+    // intersection. the concern is that infinities are incorrectly handled
+    // in some comparisons.
+    tap.expect (
+        util::region2d::max ().intersects (
+            util::region2d::unit ()
+        ),
+        "maximal region2d intersection"
+    );
 
+    tap.expect (
+        util::region2f::max ().intersects (
+            util::region2f::unit ()
+        ),
+        "maximal region2f intersection"
+    );
+
+    // ensure unit regions are... unit sized...
     tap.expect_eq (util::region2d::unit ().area (), 1.0,  "unit region2d area");
     tap.expect_eq (util::region2f::unit ().area (), 1.0f, "unit region2f area");
 
-    util::point2u  p0 { 0 };
-    util::extent2u e0 { 2 };
+    // test boundary cases of includes and contains
+    {
+        const util::point2u  p0 { 0 };
+        const util::extent2u e0 { 2 };
+        const util::region2u r  {p0, e0};
 
-    tap.expect (util::region2u (p0, e0).includes (util::point2u {1, 1}), "unsigned region centre inclusion");
-    tap.expect (util::region2u (p0, e0).includes (util::point2u {0, 0}), "unsigned region base inclusion");
-    tap.expect (util::region2u (p0, e0).includes (util::point2u {2, 2}), "unsigned region corner inclusion");
+        tap.expect (r.includes (util::point2u {1, 1}), "unsigned region centre inclusion");
+        tap.expect (r.includes (util::point2u {0, 0}), "unsigned region base inclusion");
+        tap.expect (r.includes (util::point2u {2, 2}), "unsigned region corner inclusion");
 
-    tap.expect ( util::region2u (p0, e0).contains (util::point2u {1, 1}), "unsigned region center contains");
-    tap.expect (!util::region2u (p0, e0).contains (util::point2u {0, 0}), "unsigned region base contains");
-    tap.expect (!util::region2u (p0, e0).contains (util::point2u {2, 2}), "unsigned region corner contains");
+        tap.expect ( r.contains (util::point2u {1, 1}), "unsigned region center contains");
+        tap.expect (!r.contains (util::point2u {0, 0}), "unsigned region base contains");
+        tap.expect (!r.contains (util::point2u {2, 2}), "unsigned region corner contains");
+    }
 
     //CHECK (region<2,intmax_t> (0, 0, 10, 10).includes (point2d (0.4, 0.01)));
     //CHECK (region<2,intmax_t> (0, 0, 10, 10).contains (point2d (0.4, 0.01)));

From db5795c25a01ef9f903b223127eb50ca0aa5b41a Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Wed, 19 Jul 2017 17:19:37 +1000
Subject: [PATCH 009/149] region: remove array constructor

the meaning of the array values weren't particularly clear. are they
point-point, point-extent, something else? also the implementation was
horribly incorrect for whatever it claimed to be doing. so we remove the
function entirely to avoid the aforementioned ambiguity.
---
 region.cpp | 9 ---------
 region.hpp | 1 -
 2 files changed, 10 deletions(-)

diff --git a/region.cpp b/region.cpp
index df6b3a5b..3c6c9e6f 100644
--- a/region.cpp
+++ b/region.cpp
@@ -54,15 +54,6 @@ util::region<S,T>::region (point_t _a,
 }
 
 
-//-----------------------------------------------------------------------------
-template <size_t S, typename T>
-util::region<S,T>::region (std::array<T,S*2> args)
-{
-    std::copy (&args[0], &args[S],   p.data);
-    std::copy (&args[S], &args[S*2], e.data);
-}
-
-
 //-----------------------------------------------------------------------------
 template <size_t S, typename T>
 T
diff --git a/region.hpp b/region.hpp
index b707a2bd..46c6580d 100644
--- a/region.hpp
+++ b/region.hpp
@@ -48,7 +48,6 @@ namespace util {
         explicit region (extent_t);
         region (point_t, extent_t);
         region (point_t, point_t);
-        explicit region (std::array<T,S*2>);
 
         //---------------------------------------------------------------------
         template <typename U>

From fcc78eb103365b68dfdef1fec792ba3e06c41f5a Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Wed, 19 Jul 2017 17:20:51 +1000
Subject: [PATCH 010/149] io_posix: style

improve the code style for 80 column limitations
---
 io_posix.cpp | 4 +++-
 io_posix.hpp | 7 +++++--
 2 files changed, 8 insertions(+), 3 deletions(-)

diff --git a/io_posix.cpp b/io_posix.cpp
index f4b612d0..c4d8683a 100644
--- a/io_posix.cpp
+++ b/io_posix.cpp
@@ -27,7 +27,9 @@ using util::detail::posix::mapped_file;
 
 
 //////////////////////////////////////////////////////////////////////////////
-mapped_file::mapped_file (const std::experimental::filesystem::path &path, int fflags, int mflags):
+mapped_file::mapped_file (const std::experimental::filesystem::path &path,
+                          int fflags,
+                          int mflags):
     mapped_file (util::posix::fd (path, fflags), mflags)
 { ; }
 
diff --git a/io_posix.hpp b/io_posix.hpp
index 0eae93eb..338f6b25 100644
--- a/io_posix.hpp
+++ b/io_posix.hpp
@@ -31,8 +31,11 @@ namespace util {
     namespace detail::posix {
         class mapped_file {
         public:
-            mapped_file (const std::experimental::filesystem::path&, int fflags = O_RDONLY | O_BINARY, int mflags = PROT_READ);
-            mapped_file (const util::posix::fd&,  int mflags = PROT_READ);
+            mapped_file (const std::experimental::filesystem::path&,
+                         int fflags = O_RDONLY | O_BINARY,
+                         int mflags = PROT_READ);
+            mapped_file (const util::posix::fd&,
+                         int mflags = PROT_READ);
 
             mapped_file (const mapped_file&) = delete;
             mapped_file& operator= (const mapped_file&) = delete;

From b18feb8bc46e1c7a67a4bbee7104963997027180 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 25 Jul 2017 17:08:52 +1000
Subject: [PATCH 011/149] maths: use bit patterns for tests float values

this makes some of the tests more robust in the face of (potentially
stanard breaking) optimisations.
---
 test/maths.cpp | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/test/maths.cpp b/test/maths.cpp
index d7572f5d..be27388a 100644
--- a/test/maths.cpp
+++ b/test/maths.cpp
@@ -161,13 +161,17 @@ main (void)
 
     tap.expect_eq (util::pow2 (4u), 16u, "pow2");
 
-    static const double POS_ZERO =  1.0 / numeric_limits<double>::infinity ();
-    static const double NEG_ZERO = -1.0 / numeric_limits<double>::infinity ();
+    static const float POS_ZERO =  1.f / numeric_limits<float>::infinity ();
+
+    union {
+        uint32_t neg_zero_bits = 0x80000000;
+        float NEG_ZERO;
+    };
 
     tap.expect_eq (util::sign (-1), -1, "sign(-1)");
     tap.expect_eq (util::sign ( 1),  1, "sign( 1)");
-    tap.expect_eq (util::sign (POS_ZERO),  1., "sign (POS_ZERO)");
-    tap.expect_eq (util::sign (NEG_ZERO), -1., "sign (NEG_ZERO)");
+    tap.expect_eq (util::sign (POS_ZERO),  1.f, "sign (POS_ZERO)");
+    tap.expect_eq (util::sign (NEG_ZERO), -1.f, "sign (NEG_ZERO)");
     tap.expect_eq (util::sign ( numeric_limits<double>::infinity ()),  1., "sign +inf");
     tap.expect_eq (util::sign (-numeric_limits<double>::infinity ()), -1., "sign -inf");
 

From d29276a427ab6323bb1f9e5994b32e4ec2f25785 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 25 Jul 2017 17:10:16 +1000
Subject: [PATCH 012/149] region: add "has" point query

---
 region.cpp      | 9 +++++++++
 region.hpp      | 1 +
 test/region.cpp | 4 ++++
 3 files changed, 14 insertions(+)

diff --git a/region.cpp b/region.cpp
index 3c6c9e6f..1919db23 100644
--- a/region.cpp
+++ b/region.cpp
@@ -180,6 +180,15 @@ util::region<S,T>::contains (point_t q) const
 }
 
 
+//-----------------------------------------------------------------------------
+template <size_t S, typename T>
+bool
+util::region<S,T>::has (const point_t q) const noexcept
+{
+    return all (q >= p) && all (q < p + e);
+}
+
+
 //-----------------------------------------------------------------------------
 // FIXME: This will fail with an actual infinite range (NaNs will be generated
 // in the conditionals).
diff --git a/region.hpp b/region.hpp
index 46c6580d..906a0db5 100644
--- a/region.hpp
+++ b/region.hpp
@@ -74,6 +74,7 @@ namespace util {
         bool includes (point_t) const; // inclusive of borders
         bool contains (point_t) const; // exclusive of borders
         bool intersects (region<S,T>) const;  // exclusive of borders
+        bool has (point_t) const noexcept; // inclusive of top and left borders
 
         // Move a point to be within the region bounds
         void constrain (point_t&) const;
diff --git a/test/region.cpp b/test/region.cpp
index eb24e262..3c54a408 100644
--- a/test/region.cpp
+++ b/test/region.cpp
@@ -57,6 +57,10 @@ main (int, char **)
         tap.expect ( r.contains (util::point2u {1, 1}), "unsigned region center contains");
         tap.expect (!r.contains (util::point2u {0, 0}), "unsigned region base contains");
         tap.expect (!r.contains (util::point2u {2, 2}), "unsigned region corner contains");
+
+        tap.expect ( r.has (util::point2u {1, 1}), "unsigned region centre has");
+        tap.expect ( r.has (util::point2u {1, 1}), "unsigned region base has");
+        tap.expect (!r.has (util::point2u {2, 2}), "unsigned region corner has");
     }
 
     //CHECK (region<2,intmax_t> (0, 0, 10, 10).includes (point2d (0.4, 0.01)));

From f39f7d73623fdc7dcf4ebf414cf5bf23e6151eac Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Wed, 26 Jul 2017 15:25:29 +1000
Subject: [PATCH 013/149] parse: add throwing native type parsers

---
 CMakeLists.txt |  3 ++
 parse.cpp      | 86 ++++++++++++++++++++++++++++++++++++++++++++++++++
 parse.hpp      | 53 +++++++++++++++++++++++++++++++
 test/parse.cpp | 18 +++++++++++
 4 files changed, 160 insertions(+)
 create mode 100644 parse.cpp
 create mode 100644 parse.hpp
 create mode 100644 test/parse.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 4bad0e2d..1e565610 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -334,6 +334,8 @@ list (
     memory/deleter.cpp
     memory/deleter.hpp
     nocopy.hpp
+    parse.cpp
+    parse.hpp
     pascal.cpp
     pascal.hpp
     platform.hpp
@@ -491,6 +493,7 @@ if (TESTS)
         maths
         matrix
         memory/deleter
+        parse
         point
         polynomial
         pool
diff --git a/parse.cpp b/parse.cpp
new file mode 100644
index 00000000..fcd2036d
--- /dev/null
+++ b/parse.cpp
@@ -0,0 +1,86 @@
+/*
+ * 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 "./parse.hpp"
+
+#include <cstdlib>
+#include <stdexcept>
+
+using util::parse;
+
+///////////////////////////////////////////////////////////////////////////////
+template <typename T> struct c_traits;
+template <> struct c_traits<long> { static constexpr auto func = strtol; };
+template <> struct c_traits<long long> { static constexpr auto func = strtoll; };
+template <> struct c_traits<unsigned long> { static constexpr auto func = strtoul; };
+template <> struct c_traits<unsigned long long> { static constexpr auto func = strtoull; };
+
+template <> struct c_traits<float> { static constexpr auto func = strtof; };
+template <> struct c_traits<double> { static constexpr auto func = strtod; };
+template <> struct c_traits<long double> { static constexpr auto func = strtold; };
+
+
+//-----------------------------------------------------------------------------
+template <typename T>
+T
+c_iparse (const char *first, const char *last)
+{
+    auto tail = const_cast<char *> (last);
+    auto val = c_traits<T>::func (first, &tail, 0);
+
+    if (tail != last)
+        throw std::invalid_argument ("unable to parse");
+
+    return val;
+}
+
+
+//-----------------------------------------------------------------------------
+template <typename T>
+T
+c_fparse (const char *first, const char *last)
+{
+    auto tail = const_cast<char *> (last);
+    auto val = c_traits<T>::func (first, &tail);
+
+    if (tail != last)
+        throw std::invalid_argument ("unable to parse");
+
+    return val;
+}
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////
+#define C_PARSE(T, KLASS) \
+template <> \
+T \
+util::parse<T> (const char *first, const char *last) \
+{ \
+    return c_ ## KLASS ## parse<T> (first, last); \
+}
+
+
+//-----------------------------------------------------------------------------
+C_PARSE(long, i)
+C_PARSE(long long, i)
+C_PARSE(unsigned long, i)
+C_PARSE(unsigned long long, i)
+
+C_PARSE(float, f)
+C_PARSE(double, f)
+C_PARSE(long double, f)
diff --git a/parse.hpp b/parse.hpp
new file mode 100644
index 00000000..b03b5ee1
--- /dev/null
+++ b/parse.hpp
@@ -0,0 +1,53 @@
+/*
+ * 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_PARSE_HPP
+#define CRUFT_UTIL_PARSE_HPP
+
+#include <cstring>
+#include <string>
+#include <iterator>
+
+
+namespace util {
+    ///////////////////////////////////////////////////////////////////////////
+    /// extracts an instance of a native type T from the string [first, last).
+    ///
+    /// throws std::invalid_argument when the type cannot be parsed.
+    template <typename T>
+    T
+    parse (const char *first, const char *last);
+
+
+    //-------------------------------------------------------------------------
+    template <typename T>
+    T
+    parse (const char *str)
+    {
+        return parse<T> (str, str + strlen (str));
+    }
+
+
+    //-------------------------------------------------------------------------
+    template <typename T>
+    T
+    parse (const std::string &str)
+    {
+        return parse<T> (std::cbegin (str), std::cend (str));
+    }
+}
+
+#endif
diff --git a/test/parse.cpp b/test/parse.cpp
new file mode 100644
index 00000000..733e40af
--- /dev/null
+++ b/test/parse.cpp
@@ -0,0 +1,18 @@
+#include "parse.hpp"
+#include "tap.hpp"
+
+
+///////////////////////////////////////////////////////////////////////////////
+int
+main (void)
+{
+    util::TAP::logger tap;
+
+    tap.expect_eq (util::parse<long> ("1"), 1L, "parsing long '1'");
+    tap.expect_throw<std::invalid_argument> ([] () { util::parse<long> ("a"); }, "parsing long 'a'");
+
+    tap.expect_eq (util::parse<float> ("1"), 1.f, "parsing float '1'");
+    tap.expect_throw<std::invalid_argument> ([] () { util::parse<float> ("a"); }, "parsing float 'a'");
+
+    return tap.status ();
+}
\ No newline at end of file

From bdd2e060447bd0e4dba8e5079432d3b334fb1c90 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Fri, 28 Jul 2017 14:14:08 +1000
Subject: [PATCH 014/149] extent: add make_extent call

we use this until template constructor guides are available in our
supported compilers
---
 extent.hpp | 34 +++++++++++++++++++++++++++++++++-
 1 file changed, 33 insertions(+), 1 deletion(-)

diff --git a/extent.hpp b/extent.hpp
index be1c1113..e972742a 100644
--- a/extent.hpp
+++ b/extent.hpp
@@ -82,6 +82,32 @@ namespace util {
         extent<S,T> m_target;
     };
 
+
+    /// create an extent from supplied arguments, optionally specifying the
+    /// underlying type.
+    ///
+    /// much like experimental::make_array we use a void type to signal we
+    /// need to deduce the underlying type.
+    template <
+        typename _T = void,
+        typename ...Args
+    >
+    auto
+    make_extent (Args &&...args)
+    {
+        using T = std::conditional_t<
+            std::is_void_v<_T>,
+            std::common_type_t<Args...>,
+            _T
+        >;
+
+        return extent<sizeof...(Args),T> {
+            std::forward<Args> (args)...
+        };
+    }
+
+
+    ///////////////////////////////////////////////////////////////////////////
     template <size_t S, typename T>
     extent_range<S,T>
     make_range (extent<S,T> e)
@@ -89,6 +115,8 @@ namespace util {
         return extent_range<S,T> {e};
     }
 
+
+    ///////////////////////////////////////////////////////////////////////////
     // convenience typedefs
     template <typename T> using extent2 = extent<2,T>;
     template <typename T> using extent3 = extent<3,T>;
@@ -98,20 +126,24 @@ namespace util {
     template <size_t S> using extentf = extent<S,float>;
     template <size_t S> using extentd = extent<S,double>;
 
+
     typedef extent2<int> extent2i;
     typedef extent2<unsigned> extent2u;
     typedef extent2<float> extent2f;
     typedef extent2<double> extent2d;
 
+
     typedef extent3<unsigned> extent3u;
     typedef extent3<float> extent3f;
 
+
+    //-------------------------------------------------------------------------
     template <typename T> using extent_range2 = extent_range<2,T>;
     template <typename T> using extent_range3 = extent_range<3,T>;
 
+
     using extent_range2u = extent_range2<typename extent2u::value_type>;
     using extent_range2i = extent_range2<typename extent2i::value_type>;
-
     using extent_range3u = extent_range2<typename extent3u::value_type>;
 }
 

From 1f337ef964dd8f9480f557f4b69e45fe2888cf54 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Fri, 28 Jul 2017 14:22:21 +1000
Subject: [PATCH 015/149] point: add min/max convenience methods

these create the smallest/largest expressible coordinates
---
 point.hpp | 21 ++++++++++++++++++++-
 1 file changed, 20 insertions(+), 1 deletion(-)

diff --git a/point.hpp b/point.hpp
index 3bc78d59..31c65c90 100644
--- a/point.hpp
+++ b/point.hpp
@@ -37,8 +37,27 @@ namespace util {
 
         template <size_t D> point<D,T> homog (void) const;
 
-        static constexpr point<S,T> origin (void);
+        ///////////////////////////////////////////////////////////////////////
+        static constexpr
+        auto min (void)
+        {
+            return point { std::numeric_limits<T>::lowest () };
+        }
 
+        //-------------------------------------------------------------------
+        static constexpr
+        auto max (void)
+        {
+            return point { std::numeric_limits<T>::max () };
+        }
+
+
+        //-------------------------------------------------------------------
+        static constexpr
+        point<S,T> origin (void);
+
+
+        ///////////////////////////////////////////////////////////////////////
         void sanity (void) const;
     };
 

From 1248f15e4ff1be78562945654dcf03b040e950d8 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Fri, 28 Jul 2017 14:23:20 +1000
Subject: [PATCH 016/149] region: relax assertion to allow zero width/height

some degenerate cases create regions of zero area, but non-zero
dimensions. eg, vertical linear bezier curves.
---
 region.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/region.cpp b/region.cpp
index 1919db23..2a7cafe0 100644
--- a/region.cpp
+++ b/region.cpp
@@ -50,6 +50,11 @@ util::region<S,T>::region (point_t _a,
                            point_t _b):
     region (_a, extent_t { _b - _a })
 {
+    // This check must allow for zero area (but non-zero dimension) regions.
+    // Some code paths need to support this degenerate case. It's ugly but
+    // simplifies generalisation. eg, vertical linear bezier curves.
+    CHECK (all (_a <= _b));
+
     debug::sanity (*this);
 }
 

From e5090ff91617eb9f8d7bec8d0058edbda88d56d1 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Fri, 28 Jul 2017 14:26:49 +1000
Subject: [PATCH 017/149] view: add 'data' accessor call

added for completeness sake. users can now call
std::begin/std::end/std::data
---
 view.hpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/view.hpp b/view.hpp
index 4072e598..00fa5b83 100644
--- a/view.hpp
+++ b/view.hpp
@@ -45,6 +45,9 @@ namespace util {
         constexpr const T& cbegin (void) const noexcept;
         constexpr const T& cend   (void) const noexcept;
 
+        auto data (void)       { return begin (); }
+        auto data (void) const { return begin (); }
+
         constexpr T find (const value_type&) const noexcept;
 
         constexpr bool empty (void) const noexcept;

From 2fad1715cf07fcbe5b2c25a20d7d87f9207f2cdc Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Fri, 28 Jul 2017 16:08:59 +1000
Subject: [PATCH 018/149] coord: define make_klass for all coordinate types

---
 coord/ops.hpp | 32 ++++++++++++++++++++++++++++++++
 extent.hpp    | 24 ------------------------
 2 files changed, 32 insertions(+), 24 deletions(-)

diff --git a/coord/ops.hpp b/coord/ops.hpp
index 52cab527..fb2163b2 100644
--- a/coord/ops.hpp
+++ b/coord/ops.hpp
@@ -931,6 +931,38 @@ namespace util {
         static_assert (I < S);
         return k[I];
     };
+
+
+    /// create a coord from supplied arguments, optionally specifying the
+    /// underlying type.
+    ///
+    /// much like experimental::make_array we use a void type to signal we
+    /// need to deduce the underlying type.
+#define MAKE_COORD(KLASS)                   \
+    template <                              \
+        typename _T = void,                 \
+        typename ...Args                    \
+    >                                       \
+    auto                                    \
+    make_##KLASS (Args &&...args)           \
+    {                                       \
+        using T = std::conditional_t<       \
+            std::is_void_v<_T>,             \
+            std::common_type_t<Args...>,    \
+            _T                              \
+        >;                                  \
+                                            \
+        return KLASS<sizeof...(Args),T> {   \
+            std::forward<Args> (args)...    \
+        };                                  \
+    }
+
+    MAKE_COORD(extent)
+    MAKE_COORD(point)
+    MAKE_COORD(colour)
+    MAKE_COORD(vector)
+
+#undef MAKE_COORD
 }
 
 
diff --git a/extent.hpp b/extent.hpp
index e972742a..cde8c587 100644
--- a/extent.hpp
+++ b/extent.hpp
@@ -83,30 +83,6 @@ namespace util {
     };
 
 
-    /// create an extent from supplied arguments, optionally specifying the
-    /// underlying type.
-    ///
-    /// much like experimental::make_array we use a void type to signal we
-    /// need to deduce the underlying type.
-    template <
-        typename _T = void,
-        typename ...Args
-    >
-    auto
-    make_extent (Args &&...args)
-    {
-        using T = std::conditional_t<
-            std::is_void_v<_T>,
-            std::common_type_t<Args...>,
-            _T
-        >;
-
-        return extent<sizeof...(Args),T> {
-            std::forward<Args> (args)...
-        };
-    }
-
-
     ///////////////////////////////////////////////////////////////////////////
     template <size_t S, typename T>
     extent_range<S,T>

From 0016c83dab9b17ccb7cf5ca134672be398cc4700 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Mon, 31 Jul 2017 15:41:33 +1000
Subject: [PATCH 019/149] coord: add the select function

---
 coord/ops.hpp  | 24 ++++++++++++++++++++++++
 test/coord.cpp | 11 +++++++++++
 2 files changed, 35 insertions(+)

diff --git a/coord/ops.hpp b/coord/ops.hpp
index fb2163b2..925e8853 100644
--- a/coord/ops.hpp
+++ b/coord/ops.hpp
@@ -854,6 +854,30 @@ namespace util {
     }
 
 
+    ///------------------------------------------------------------------------
+    /// returns an instance of K elementwise using a when s is true, and b
+    /// otherwise. ie, k[i] = s[i] ? a[i] : b[i];
+    ///
+    /// corresponds to the function `select' from OpenCL.
+    template <
+        size_t S,
+        typename T,
+        template <size_t,typename> class K,
+        typename = std::enable_if_t<
+            is_coord_v<K<S,T>>,
+            void
+        >
+    >
+    constexpr
+    K<S,T>
+    select (vector<S,bool> s, K<S,T> a, K<S,T> b)
+    {
+        K<S,T> k {};
+        for (size_t i = 0; i < S; ++i)
+            k[i] = s[i] ? a[i] : b[i];
+        return k;
+    }
+
     ///////////////////////////////////////////////////////////////////////////
     template <
         size_t S,
diff --git a/test/coord.cpp b/test/coord.cpp
index dfdfdb12..c25585ea 100644
--- a/test/coord.cpp
+++ b/test/coord.cpp
@@ -53,5 +53,16 @@ main (void)
         );
     }
 
+    {
+        const util::point3f a { -1, 2, 0 };
+        const util::point3f b {  1, 0, 2 };
+
+        const util::point3f lo { -1, 0, 0 };
+        const util::point3f hi {  1, 2, 2 };
+
+        tap.expect_eq (select (a < b, a, b), lo, "select with points and min");
+        tap.expect_eq (select (a > b, a, b), hi, "select with points and max");
+    };
+
     return tap.status ();
 }

From 01f6e5a1e8a1777bb3ef9c47e549e612f8d55fce Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Mon, 31 Jul 2017 15:42:05 +1000
Subject: [PATCH 020/149] region: add make_union function

---
 region.hpp      | 13 +++++++++++++
 test/region.cpp | 22 ++++++++++++++++++++++
 2 files changed, 35 insertions(+)

diff --git a/region.hpp b/region.hpp
index 906a0db5..684e1297 100644
--- a/region.hpp
+++ b/region.hpp
@@ -111,6 +111,19 @@ namespace util {
         void sanity (void) const;
     };
 
+
+    ///////////////////////////////////////////////////////////////////////////
+    /// constructs the minimal region that encompasses a region and a point.
+    template <typename T, size_t S>
+    region<S,T>
+    make_union (region<S,T> r, point<S,T> p)
+    {
+        const auto p0 = select (r.p < p,       r.p,       p);
+        const auto p1 = select (r.away () > p, r.away (), p);
+        return { p0, p1 };
+    }
+
+
     template <typename T> using region2 = region<2,T>;
     template <typename T> using region3 = region<3,T>;
 
diff --git a/test/region.cpp b/test/region.cpp
index 3c54a408..f15bc2eb 100644
--- a/test/region.cpp
+++ b/test/region.cpp
@@ -63,6 +63,28 @@ main (int, char **)
         tap.expect (!r.has (util::point2u {2, 2}), "unsigned region corner has");
     }
 
+    // ensure make_union behaves as expected
+    {
+        const util::point2f  p { -1 };
+        const util::extent2f e {  2 };
+        const util::region2f r { p, e };
+
+        tap.expect_eq (util::make_union (r, util::point2f { 0, 0 }), r, "identity union");
+        tap.expect_eq (
+            util::make_union (r, util::point2f { 2, 3 }),
+            util::region2f { p, util::extent2f { 3, 4 } },
+            "positive expanding union"
+        );
+        tap.expect_eq (
+            util::make_union (r, util::point2f { -3, -2 }),
+            util::region2f {
+                util::point2f { -3, -2 },
+                util::extent2f { 4, 3 }
+            },
+            "negative expanding union"
+        );
+    };
+
     //CHECK (region<2,intmax_t> (0, 0, 10, 10).includes (point2d (0.4, 0.01)));
     //CHECK (region<2,intmax_t> (0, 0, 10, 10).contains (point2d (0.4, 0.01)));
 

From 6c77393a2c49f98dfa42f0fa9c64ab31a87f9dd3 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Mon, 31 Jul 2017 16:16:54 +1000
Subject: [PATCH 021/149] coord: make min and max variadic

---
 coord/ops.hpp | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

diff --git a/coord/ops.hpp b/coord/ops.hpp
index 925e8853..fe275f51 100644
--- a/coord/ops.hpp
+++ b/coord/ops.hpp
@@ -663,15 +663,18 @@ namespace util {
         template <size_t,typename> class K,
         typename = std::enable_if_t<
             is_coord_v<K<S,T>>, void
-        >
+        >,
+        typename ...Args
     >
     constexpr
     K<S,T>
-    min (K<S,T> a, K<S,T> b)
+    min (K<S,T> a, K<S,T> b, Args &&...args)
     {
+        static_assert ((... && std::is_same<K<S,T>, std::decay_t<Args>>::value));
+
         K<S,T> out {};
         for (size_t i = 0; i < S; ++i)
-            out[i] = min (a[i], b[i]);
+            out[i] = min (a[i], b[i], args[i]...);
         return out;
     }
 
@@ -684,15 +687,18 @@ namespace util {
         template <size_t,typename> class K,
         typename = std::enable_if_t<
             is_coord_v<K<S,T>>, void
-        >
+        >,
+        typename ...Args
     >
     constexpr
     K<S,T>
-    max (K<S,T> a, K<S,T> b)
+    max (K<S,T> a, K<S,T> b, Args &&...args)
     {
+        static_assert ((... && std::is_same<K<S,T>, std::decay_t<Args>>::value));
+
         K<S,T> out {};
         for (size_t i = 0; i < S; ++i)
-            out[i] = max (a[i], b[i]);
+            out[i] = max (a[i], b[i], args[i]...);
         return out;
     }
 

From 523c7c7e388ac71c62ce28f41e663f83857e1e54 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 1 Aug 2017 13:31:47 +1000
Subject: [PATCH 022/149] iterator: add the OutputIterator "discard_iterator"

---
 iterator.hpp | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)

diff --git a/iterator.hpp b/iterator.hpp
index c5bbde62..892ef45c 100644
--- a/iterator.hpp
+++ b/iterator.hpp
@@ -279,6 +279,22 @@ namespace util {
             data...
         );
     }
-}
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    /// an output iterator that always discards any parameters on assignment.
+    ///
+    /// sometimes useful to pass to algorithms that generate useful results as
+    /// a return value, while not caring about the implicit OutputIterator
+    /// results.
+    struct discard_iterator : public std::iterator<std::output_iterator_tag, discard_iterator> {
+        template <typename T>
+        void operator= (const T&) { ; }
+
+        discard_iterator& operator++ (   ) { return *this; }
+        discard_iterator  operator++ (int) { return *this; }
+        discard_iterator& operator*  (   ) { return *this; }
+    };
+};
 
 #endif

From eabf93bc2af6535d860f8ddeb93bc94fad3fc150 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 1 Aug 2017 14:16:55 +1000
Subject: [PATCH 023/149] view: remove ipp file in preference of inline code

---
 CMakeLists.txt   |   1 -
 json/flat.cpp.rl |   3 +-
 json/schema.cpp  |   3 +-
 string.cpp       |   4 +-
 view.cpp         |   1 +
 view.hpp         | 130 +++++++++++++++++++-----
 view.ipp         | 256 -----------------------------------------------
 7 files changed, 113 insertions(+), 285 deletions(-)
 delete mode 100644 view.ipp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 1e565610..fbee8d3b 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -417,7 +417,6 @@ list (
     version.cpp
     version.hpp
     view.cpp
-    view.ipp
     view.hpp
 )
 
diff --git a/json/flat.cpp.rl b/json/flat.cpp.rl
index bf577c3d..0ca04ba3 100644
--- a/json/flat.cpp.rl
+++ b/json/flat.cpp.rl
@@ -14,11 +14,12 @@
  * You should have received a copy of the GNU General Public License
  * along with libgim.  If not, see <http://www.gnu.org/licenses/>.
  *
- * Copyright 2010-2015 Danny Robson <danny@nerdcruft.net>
+ * Copyright 2010-2017 Danny Robson <danny@nerdcruft.net>
  */
 
 #include "json/flat.hpp"
 
+#include "debug.hpp"
 #include "json/except.hpp"
 #include "preprocessor.hpp"
 
diff --git a/json/schema.cpp b/json/schema.cpp
index 172c1de6..d135ebb6 100644
--- a/json/schema.cpp
+++ b/json/schema.cpp
@@ -11,7 +11,7 @@
  * 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>
  */
 
 #include "./schema.hpp"
@@ -19,6 +19,7 @@
 #include "./tree.hpp"
 #include "./except.hpp"
 
+#include "../debug.hpp"
 #include "../io.hpp"
 #include "../maths.hpp"
 
diff --git a/string.cpp b/string.cpp
index 34423493..55ce664d 100644
--- a/string.cpp
+++ b/string.cpp
@@ -11,11 +11,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
- * Copyright 2011-2016 Danny Robson <danny@nerdcruft.net>
+ * Copyright 2011-2017 Danny Robson <danny@nerdcruft.net>
  */
 
 #include "./string.hpp"
 
+#include "./debug.hpp"
+
 #include <cstring>
 #include <codecvt>
 #include <locale>
diff --git a/view.cpp b/view.cpp
index 40d011dd..11d60ed0 100644
--- a/view.cpp
+++ b/view.cpp
@@ -16,6 +16,7 @@
 
 #include "./view.hpp"
 
+#include <algorithm>
 #include <iterator>
 
 
diff --git a/view.hpp b/view.hpp
index 00fa5b83..3b893c1e 100644
--- a/view.hpp
+++ b/view.hpp
@@ -23,6 +23,7 @@
 #include <cstdlib>
 #include <ostream>
 #include <string>
+#include <cstring>
 
 namespace util {
     template <typename T>
@@ -31,32 +32,80 @@ namespace util {
         using value_type = typename std::iterator_traits<remove_restrict_t<T>>::value_type;
 
         constexpr
-        view (T first, T last) noexcept;
+        view (T first, T last) noexcept:
+            m_begin (first),
+            m_end   (last)
+        { ; }
 
-        template <typename K> constexpr explicit view (      K &klass);
-        template <typename K> constexpr explicit view (const K &klass);
+        template <typename K>
+        constexpr explicit
+        view (K &klass):
+            m_begin (std::begin (klass)),
+            m_end   (std::end   (klass))
+        { ; }
 
-        constexpr T& begin (void) noexcept;
-        constexpr T& end   (void) noexcept;
+        template <typename K>
+        constexpr explicit
+        view (const K &klass):
+            m_begin (std::begin (klass)),
+            m_end   (std::end   (klass))
+        { ; }
 
-        constexpr const T& begin (void) const noexcept;
-        constexpr const T& end   (void) const noexcept;
+        constexpr T& begin (void) noexcept { return m_begin; }
+        constexpr T& end   (void) noexcept { return m_end;   }
 
-        constexpr const T& cbegin (void) const noexcept;
-        constexpr const T& cend   (void) const noexcept;
+        constexpr const T& begin (void) const noexcept { return cbegin (); }
+        constexpr const T& end   (void) const noexcept { return cend   (); }
+
+        constexpr const T& cbegin (void) const noexcept { return m_begin; }
+        constexpr const T& cend   (void) const noexcept { return m_end;   }
 
         auto data (void)       { return begin (); }
         auto data (void) const { return begin (); }
 
-        constexpr T find (const value_type&) const noexcept;
+        constexpr T
+        find (const value_type &v) const noexcept
+        {
+            for (T i = cbegin (); i != cend (); ++i)
+                if (*i == v)
+                    return i;
+            return cend ();
+        }
 
-        constexpr bool empty (void) const noexcept;
-        constexpr size_t size (void) const noexcept;
+        constexpr bool
+        empty (void) const noexcept
+        {
+            return m_begin == m_end;
+        }
 
-        constexpr value_type& operator[] (size_t) noexcept;
-        constexpr const value_type& operator[] (size_t) const noexcept;
+        constexpr auto
+        size (void) const noexcept
+        {
+            return std::distance (m_begin, m_end);
+        }
 
-        bool operator== (view) const noexcept;
+        constexpr value_type&
+        operator[] (size_t idx) noexcept
+        {
+            auto it = begin ();
+            std::advance (it, idx);
+            return *it;
+        }
+
+        constexpr const value_type&
+        operator[] (size_t idx) const noexcept
+        {
+            auto it = begin ();
+            std::advance (it, idx);
+            return *it;
+        }
+
+        bool
+        operator== (const view &rhs) const noexcept
+        {
+            return rhs.m_begin == m_begin &&
+                   rhs.m_end   == m_end;
+        }
 
     private:
         T m_begin;
@@ -65,15 +114,24 @@ namespace util {
 
     template <typename T, size_t N>
     auto
-    make_view (const T (&)[N]);
+    make_view (const T (&arr)[N])
+    {
+        return util::view<const T*> (arr + 0, arr + N);
+    }
 
     template <typename T>
     auto
-    make_view (T&);
+    make_view (T &t)
+    {
+        return util::view<decltype(std::begin (t))> { std::begin (t), std::end (t) };
+    }
 
     template <typename T>
     auto
-    make_view (const T&);
+    make_view (const T &t)
+    {
+        return util::view<decltype(std::cbegin (t))> { std::cbegin (t), std::cend (t) };
+    }
 
     template <typename T>
     auto
@@ -81,7 +139,10 @@ namespace util {
 
     template <typename T>
     auto
-    make_cview (const T&);
+    make_cview (const T &t)
+    {
+        return util::view<decltype(std::cbegin (t))> { std::cbegin (t), std::cend (t) };
+    }
 
     template <typename T>
     auto
@@ -98,16 +159,37 @@ namespace util {
     }
 
     // string conversions
-    view<const char*> make_view (const char *str);
-    view<char*> make_view (char *str);
+    inline
+    view<const char*> make_view (const char *str)
+    {
+        return { str, str + strlen (str) };
+    }
+
+    inline
+    view<char*> make_view (char *str)
+    {
+        return { str, str + strlen (str) };
+    }
 
     template <typename CharT, typename TraitsT, typename AllocT>
     view<const CharT*>
-    make_view (const std::basic_string<CharT,TraitsT,AllocT>&);
+    make_view (const std::basic_string<CharT,TraitsT,AllocT> &str)
+    {
+        return {
+            std::data (str),
+            std::data (str) + std::size (str)
+        };
+    }
 
     template <typename CharT, typename TraitsT, typename AllocT>
     view<CharT*>
-    make_view (std::basic_string<CharT,TraitsT,AllocT>&);
+    make_view (std::basic_string<CharT,TraitsT,AllocT> &str)
+    {
+        return {
+            std::data (str),
+            std::data (str) + std::size (str)
+        };
+    }
 
     template <typename CharT, typename TraitsT, typename AllocT>
     view<const CharT*>
@@ -136,6 +218,4 @@ namespace util {
     operator<< (std::ostream&, view<T>);
 }
 
-#include "./view.ipp"
-
 #endif
diff --git a/view.ipp b/view.ipp
deleted file mode 100644
index dc42b71b..00000000
--- a/view.ipp
+++ /dev/null
@@ -1,256 +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>
- */
-
-
-#ifdef __UTIL_VIEW_IPP
-#error
-#endif
-#define __UTIL_VIEW_IPP
-
-
-#include "./debug.hpp"
-#include "./iterator.hpp"
-
-
-///////////////////////////////////////////////////////////////////////////////
-template <typename T>
-constexpr
-util::view<T>::view (T _begin, T _end) noexcept:
-    m_begin (_begin),
-    m_end   (_end)
-{ ; }
-
-
-//-----------------------------------------------------------------------------
-template <typename T>
-template <typename K>
-constexpr
-util::view<T>::view (K &data):
-    m_begin (std::begin (data)),
-    m_end   (std::end   (data))
-{ ; }
-
-
-//-----------------------------------------------------------------------------
-template <typename T>
-template <typename K>
-constexpr
-util::view<T>::view (const K &data):
-    m_begin (std::begin (data)),
-    m_end   (std::end (data))
-{ ; }
-
-
-///////////////////////////////////////////////////////////////////////////////
-template <typename T>
-constexpr T&
-util::view<T>::begin (void) noexcept
-{
-    return m_begin;
-}
-
-
-//-----------------------------------------------------------------------------
-template <typename T>
-constexpr T&
-util::view<T>::end (void) noexcept
-{
-    return m_end;
-}
-
-
-//-----------------------------------------------------------------------------
-template <typename T>
-constexpr const T&
-util::view<T>::begin (void) const noexcept
-{
-    return cbegin ();
-}
-
-
-//-----------------------------------------------------------------------------
-template <typename T>
-constexpr const T&
-util::view<T>::end (void) const noexcept
-{
-    return cend ();
-}
-
-
-//-----------------------------------------------------------------------------
-template <typename T>
-constexpr const T&
-util::view<T>::cbegin (void) const noexcept
-{
-    return m_begin;
-}
-
-
-//-----------------------------------------------------------------------------
-template <typename T>
-constexpr const T&
-util::view<T>::cend (void) const noexcept
-{
-    return m_end;   
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-template <typename T>
-constexpr T
-util::view<T>::find (const value_type &v) const noexcept
-{
-   for (T i = cbegin (); i != cend (); ++i)
-       if (*i == v)
-           return i;
-   return cend ();
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-template <typename T>
-constexpr
-bool
-util::view<T>::empty (void) const noexcept
-{
-    return m_begin == m_end;
-}
-
-
-//-----------------------------------------------------------------------------
-template <typename T>
-constexpr
-size_t
-util::view<T>::size (void) const noexcept
-{
-    return m_end - m_begin;
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-template <typename T>
-constexpr
-const typename util::view<T>::value_type&
-util::view<T>::operator[] (size_t idx) const noexcept
-{
-    return m_begin[idx];
-}
-
-
-//-----------------------------------------------------------------------------
-template <typename T>
-constexpr
-typename util::view<T>::value_type&
-util::view<T>::operator[] (size_t idx) noexcept
-{
-    return m_begin[idx];
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-template <typename T>
-bool
-util::view<T>::operator== (const view<T> rhs) const noexcept
-{
-    return rhs.m_begin == m_begin &&
-           rhs.m_end   == m_end;
-}
-
-
-//-----------------------------------------------------------------------------
-template <typename T>
-bool
-util::operator!= (const view<T> a, const view<T> b)
-{
-    return !(a == b);
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-template <typename T, size_t N>
-auto
-util::make_view (const T (&arr)[N])
-{
-    return util::view<const T*> (arr + 0, arr + N);
-}
-
-
-//-----------------------------------------------------------------------------
-template <typename T>
-auto
-util::make_view (T &t)
-{
-    return util::view<decltype(std::begin (t))> { std::begin (t), std::end (t) };
-}
-
-
-//-----------------------------------------------------------------------------
-template <typename T>
-auto
-util::make_view (const T &t)
-{
-    return util::view<decltype(std::cbegin (t))> { std::cbegin (t), std::cend (t) };
-}
-
-
-//-----------------------------------------------------------------------------
-template <typename T>
-auto
-util::make_cview (const T &t)
-{
-    return util::view<decltype(std::cbegin (t))> { std::cbegin (t), std::cend (t) };
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-inline
-util::view<const char*>
-util::make_view (const char *str)
-{
-    return { str, str + strlen (str) };
-}
-
-//-----------------------------------------------------------------------------
-inline
-util::view<char*>
-util::make_view (char *str)
-{
-    return { str, str + strlen (str) };
-}
-
-
-//-----------------------------------------------------------------------------
-template <typename CharT, typename TraitsT, typename AllocT>
-util::view<const CharT*>
-util::make_view (const std::basic_string<CharT,TraitsT,AllocT> &str)
-{
-    return {
-        std::data (str),
-        std::data (str) + std::size (str)
-    };
-}
-
-
-//-----------------------------------------------------------------------------
-template <typename CharT, typename TraitsT, typename AllocT>
-util::view<CharT*>
-util::make_view (std::basic_string<CharT,TraitsT,AllocT> &str)
-{
-    return {
-        std::data (str),
-        std::data (str) + std::size (str)
-    };
-}

From 5634e59dc5d122215aad7aa22aa6042258411a10 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 1 Aug 2017 14:47:44 +1000
Subject: [PATCH 024/149] view: don't return references to iterators

we emulate string_view behaviour. modifying our iterators behind our
backs isn't a great way to ensure invariants are kept.
---
 view.hpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/view.hpp b/view.hpp
index 3b893c1e..718a758f 100644
--- a/view.hpp
+++ b/view.hpp
@@ -51,14 +51,14 @@ namespace util {
             m_end   (std::end   (klass))
         { ; }
 
-        constexpr T& begin (void) noexcept { return m_begin; }
-        constexpr T& end   (void) noexcept { return m_end;   }
+        constexpr T begin (void) noexcept { return m_begin; }
+        constexpr T end   (void) noexcept { return m_end;   }
 
-        constexpr const T& begin (void) const noexcept { return cbegin (); }
-        constexpr const T& end   (void) const noexcept { return cend   (); }
+        constexpr const T begin (void) const noexcept { return cbegin (); }
+        constexpr const T end   (void) const noexcept { return cend   (); }
 
-        constexpr const T& cbegin (void) const noexcept { return m_begin; }
-        constexpr const T& cend   (void) const noexcept { return m_end;   }
+        constexpr const T cbegin (void) const noexcept { return m_begin; }
+        constexpr const T cend   (void) const noexcept { return m_end;   }
 
         auto data (void)       { return begin (); }
         auto data (void) const { return begin (); }

From 2b3ef6dbc613a654a5439c5426664fd216edd5b8 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Wed, 2 Aug 2017 16:17:24 +1000
Subject: [PATCH 025/149] debug: correct CHECK_NEZ error message

---
 debug.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/debug.hpp b/debug.hpp
index e111ce48..9e400b2d 100644
--- a/debug.hpp
+++ b/debug.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 __DEBUG_HPP
@@ -222,7 +222,7 @@
     DEBUG_ONLY (                                            \
         const auto &__a = (A);                              \
         if (::util::exactly_zero (__a))                     \
-            _CHECK_PANIC ("expected zero\n"                 \
+            _CHECK_PANIC ("expected non-zero\n"             \
                           "__a: %s is %!",                  \
                           #A, __a);                         \
     );                                                      \

From 96d621a4610469ebc769b5bed8e8ef55f50a5388 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 8 Aug 2017 13:54:45 +1000
Subject: [PATCH 026/149] signal: don't forward arguments we may reuse

---
 signal.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/signal.hpp b/signal.hpp
index 17e7dfde..93da480e 100644
--- a/signal.hpp
+++ b/signal.hpp
@@ -32,7 +32,7 @@ namespace util {
             R operator() (T first, T last, Args&&... args)
             {
                 while (first != last)
-                    if (!(*first++)(std::forward<Args> (args)...))
+                    if (!(*first++)(args...))
                         return false;
 
                 return true;
@@ -47,7 +47,7 @@ namespace util {
             R operator() (T first, T last, Args&&... args)
             {
                 while (first != last)
-                    if ((*first++)(std::forward<Args> (args)...))
+                    if ((*first++)(args...))
                         return true;
 
                 return false;
@@ -62,7 +62,7 @@ namespace util {
             R operator() (T first, T last, Args&&... args)
             {
                 while (first != last) {
-                    (*first++)(std::forward<Args> (args)...);
+                    (*first++)(args...);
                 }
             }
         };

From 6ecab5b6d07929972e816b933c9acc4f6d8ee6aa Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 8 Aug 2017 13:55:06 +1000
Subject: [PATCH 027/149] signal: warn if discarding auto-disconnect cookies

---
 signal.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/signal.hpp b/signal.hpp
index 93da480e..88d1dd5d 100644
--- a/signal.hpp
+++ b/signal.hpp
@@ -81,8 +81,8 @@ namespace util {
             ~signal ();
 
             /// Add a callback to list.
-            cookie connect (callback&&);
-            cookie connect (const callback&);
+            cookie connect [[gnu::warn_unused_result]] (callback&&);
+            cookie connect [[gnu::warn_unused_result]] (const callback&);
 
             void disconnect (cookie&);
 

From ff5e6945e30cc36b67f2403bca0c70a57e8437a8 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 8 Aug 2017 13:55:20 +1000
Subject: [PATCH 028/149] signal: remove unused code

---
 signal.ipp | 18 +++++-------------
 1 file changed, 5 insertions(+), 13 deletions(-)

diff --git a/signal.ipp b/signal.ipp
index 56f4e5e5..73cdef12 100644
--- a/signal.ipp
+++ b/signal.ipp
@@ -165,20 +165,12 @@ namespace util {
         if (m_children.empty ())
             return R();
 
-        //auto i = m_children.cbegin ();
-        //bool looping;
-
         C<F> combiner;
-        return combiner (m_children.begin (), m_children.end (), std::forward<Args> (tail)...);
-
-        //do {
-        //    // Increment before we execute so that the caller is able to
-        //    // deregister themselves during execution.
-        //    auto current = i++;
-        //    looping = m_children.cend () != i;
-
-        //    (*current)(std::forward<Args> (tail)...);
-        //} while (looping);
+        return combiner (
+            m_children.begin (),
+            m_children.end (),
+            std::forward<Args> (tail)...
+        );
     }
 
 

From fc41f0991d475d1c5d2a154f6f76b396c507fde6 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Wed, 9 Aug 2017 17:17:55 +1000
Subject: [PATCH 029/149] region: add overload of inset for vectors

---
 region.cpp | 19 ++++++++++++++-----
 region.hpp |  3 ++-
 2 files changed, 16 insertions(+), 6 deletions(-)

diff --git a/region.cpp b/region.cpp
index 2a7cafe0..13986dcd 100644
--- a/region.cpp
+++ b/region.cpp
@@ -262,14 +262,23 @@ util::region<S,T>::resize (extent<S,T> _e)
 //-----------------------------------------------------------------------------
 template <size_t S, typename T>
 util::region<S,T>
-util::region<S,T>::inset (T mag)
+util::region<S,T>::inset (T mag) const
 {
-    // ensure we have enough space to inset
-    CHECK (min (e) >= 2 * mag);
+    return inset (util::vector<S,T> {mag});
+}
+
+
+//-----------------------------------------------------------------------------
+template <size_t S, typename T>
+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));
 
     return {
-        p + mag,
-        e - static_cast<T> (2 * mag)
+        p +        mag,
+        e - T{2} * mag
     };
 }
 
diff --git a/region.hpp b/region.hpp
index 684e1297..d5048f60 100644
--- a/region.hpp
+++ b/region.hpp
@@ -87,7 +87,8 @@ namespace util {
         region& resize (extent<S,T>);
 
         // Compute a region `mag` units into the region
-        region inset (T mag);
+        region inset (T mag) const;
+        region inset (vector<S,T> mag) const;
 
         region expanded (T mag) const;
         region expanded (vector<S,T>) const;

From b6edf25cd8401265a7ac77aa09de2095454d3d09 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Wed, 9 Aug 2017 17:27:28 +1000
Subject: [PATCH 030/149] region: remove the resize method

we're moving away from mutating operators so this is somewhat
out-of-place. it's not a huge functional change though as there are
enough locations where the internal representation of point/extent are
assumed that we just do it through the members.
---
 region.cpp | 9 ---------
 region.hpp | 2 --
 2 files changed, 11 deletions(-)

diff --git a/region.cpp b/region.cpp
index 13986dcd..9138dbe0 100644
--- a/region.cpp
+++ b/region.cpp
@@ -250,15 +250,6 @@ util::region<S,T>::intersection (region<S,T> rhs) const
 }
 
 
-//-----------------------------------------------------------------------------
-template <size_t S, typename T>
-util::region<S,T>&
-util::region<S,T>::resize (extent<S,T> _e)
-{
-    e = _e;
-    return *this;
-}
-
 //-----------------------------------------------------------------------------
 template <size_t S, typename T>
 util::region<S,T>
diff --git a/region.hpp b/region.hpp
index d5048f60..81ef39cc 100644
--- a/region.hpp
+++ b/region.hpp
@@ -84,8 +84,6 @@ namespace util {
         region intersection (region<S,T>) const;
 
         //---------------------------------------------------------------------
-        region& resize (extent<S,T>);
-
         // Compute a region `mag` units into the region
         region inset (T mag) const;
         region inset (vector<S,T> mag) const;

From 72f631ab4be17128fa94e40d61a3141ea916a7ae Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Wed, 9 Aug 2017 17:28:53 +1000
Subject: [PATCH 031/149] region: remove `expanded' function

we're trying to move away from mutating operators.

also, we do the bad thing of just renaming the non-mutating operator
given it appears no one is using the mutating operator in our code bases
anyway...
---
 region.cpp | 27 +++------------------------
 region.hpp |  7 ++-----
 2 files changed, 5 insertions(+), 29 deletions(-)

diff --git a/region.cpp b/region.cpp
index 9138dbe0..a39d49d9 100644
--- a/region.cpp
+++ b/region.cpp
@@ -274,31 +274,10 @@ util::region<S,T>::inset (vector<S,T> mag) const
 }
 
 
-//-----------------------------------------------------------------------------
-template <size_t S, typename T>
-util::region<S,T>&
-util::region<S,T>::expand (vector<S,T> v)
-{
-    p -= v;
-    e += v * T{2};
-
-    return *this;
-}
-
-
-//-----------------------------------------------------------------------------
-template <size_t S, typename T>
-util::region<S,T>&
-util::region<S,T>::expand (T mag)
-{
-    return expand (vector<S,T> {mag});
-}
-
-
 //-----------------------------------------------------------------------------
 template <size_t S, typename T>
 util::region<S,T>
-util::region<S,T>::expanded (vector<S,T> v) const
+util::region<S,T>::expand (vector<S,T> v) const
 {
     return {
         p - v,
@@ -310,9 +289,9 @@ util::region<S,T>::expanded (vector<S,T> v) const
 //-----------------------------------------------------------------------------
 template <size_t S, typename T>
 util::region<S,T>
-util::region<S,T>::expanded (T mag) const
+util::region<S,T>::expand (T mag) const
 {
-    return expanded (vector<S,T> {mag});
+    return expand (vector<S,T> {mag});
 }
 
 
diff --git a/region.hpp b/region.hpp
index 81ef39cc..379eefcc 100644
--- a/region.hpp
+++ b/region.hpp
@@ -88,11 +88,8 @@ namespace util {
         region inset (T mag) const;
         region inset (vector<S,T> mag) const;
 
-        region expanded (T mag) const;
-        region expanded (vector<S,T>) const;
-
-        region& expand (T mag);
-        region& expand (vector<S,T>);
+        region expand (T mag) const;
+        region expand (vector<S,T>) const;
 
         // arithmetic operators
         region operator+ (vector<S,T>) const;

From f36a14973a259c9dd4e3a7f748b2779f2412a577 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Fri, 11 Aug 2017 14:39:46 +1000
Subject: [PATCH 032/149] region: add `encloses' test for subregions

---
 region.cpp | 9 +++++++++
 region.hpp | 3 +++
 2 files changed, 12 insertions(+)

diff --git a/region.cpp b/region.cpp
index a39d49d9..164ddf14 100644
--- a/region.cpp
+++ b/region.cpp
@@ -252,6 +252,15 @@ util::region<S,T>::intersection (region<S,T> rhs) const
 
 //-----------------------------------------------------------------------------
 template <size_t S, typename T>
+bool
+util::region<S,T>::encloses (const region<S,T> r) const noexcept
+{
+    return all (p <= r.p) && all (p + e >= r.p + r.e);
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+template <size_t S, typename T>
 util::region<S,T>
 util::region<S,T>::inset (T mag) const
 {
diff --git a/region.hpp b/region.hpp
index 379eefcc..e052bc4b 100644
--- a/region.hpp
+++ b/region.hpp
@@ -83,6 +83,9 @@ namespace util {
         // Compute binary region combinations
         region intersection (region<S,T>) const;
 
+        // Test if a region lies completely within our space
+        bool encloses (region<S,T>) const noexcept;
+
         //---------------------------------------------------------------------
         // Compute a region `mag` units into the region
         region inset (T mag) const;

From 31d2e6bfd8313505b26d1168942ee91d956381cb Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Fri, 11 Aug 2017 15:15:44 +1000
Subject: [PATCH 033/149] region: remove duplicate point/region coverage tests

---
 region.cpp      | 52 +++++++++++++------------------------------------
 region.hpp      | 20 +++++++++----------
 test/region.cpp | 21 ++++++++------------
 3 files changed, 31 insertions(+), 62 deletions(-)

diff --git a/region.cpp b/region.cpp
index 164ddf14..b71f3b59 100644
--- a/region.cpp
+++ b/region.cpp
@@ -11,7 +11,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
- * Copyright 2010-2016 Danny Robson <danny@nerdcruft.net>
+ * Copyright 2010-2017 Danny Robson <danny@nerdcruft.net>
  */
 
 
@@ -23,6 +23,8 @@
 
 #include <array>
 
+using util::region;
+
 
 //-----------------------------------------------------------------------------
 template <size_t S, typename T>
@@ -159,41 +161,6 @@ util::region<S,T>::closest (point_t q) const
 }
 
 
-//-----------------------------------------------------------------------------
-template <size_t S, typename T>
-bool
-util::region<S,T>::includes (point_t q) const
-{
-    for (size_t i = 0; i < S; ++i)
-        if (q[i] < p[i] || q[i] > p[i] + e[i])
-            return false;
-
-    return true;
-}
-
-
-//-----------------------------------------------------------------------------
-template <size_t S, typename T>
-bool
-util::region<S,T>::contains (point_t q) const
-{
-    for (size_t i = 0; i < S; ++i)
-        if (q[i] <= p[i] || q[i] >= p[i] + e[i])
-            return false;
-
-    return true;
-}
-
-
-//-----------------------------------------------------------------------------
-template <size_t S, typename T>
-bool
-util::region<S,T>::has (const point_t q) const noexcept
-{
-    return all (q >= p) && all (q < p + e);
-}
-
-
 //-----------------------------------------------------------------------------
 // FIXME: This will fail with an actual infinite range (NaNs will be generated
 // in the conditionals).
@@ -202,7 +169,7 @@ bool
 util::region<S,T>::intersects (region<S,T> rhs) const
 {
     for (size_t i = 0; i < S; ++i)
-        if (p[i]     >= rhs.p[i] + rhs.e[i] ||
+        if (    p[i] >= rhs.p[i] + rhs.e[i] ||
             rhs.p[i] >=     p[i] +     e[i])
         { return false; }
 
@@ -253,12 +220,21 @@ util::region<S,T>::intersection (region<S,T> rhs) const
 //-----------------------------------------------------------------------------
 template <size_t S, typename T>
 bool
-util::region<S,T>::encloses (const region<S,T> r) const noexcept
+util::region<S,T>::covers (region<S, T> r) const noexcept
 {
     return all (p <= r.p) && all (p + e >= r.p + r.e);
 }
 
 
+//-----------------------------------------------------------------------------
+template <size_t S, typename T>
+bool
+region<S,T>::covers (const point<S,T> q) const noexcept
+{
+    return all (p <= q) && all (p + e >= q);
+}
+
+
 ///////////////////////////////////////////////////////////////////////////////
 template <size_t S, typename T>
 util::region<S,T>
diff --git a/region.hpp b/region.hpp
index e052bc4b..7ab9a848 100644
--- a/region.hpp
+++ b/region.hpp
@@ -70,21 +70,19 @@ namespace util {
         point_t closest (point_t) const;
 
         //---------------------------------------------------------------------
-        // Point and region relation queries
-        bool includes (point_t) const; // inclusive of borders
-        bool contains (point_t) const; // exclusive of borders
-        bool intersects (region<S,T>) const;  // exclusive of borders
-        bool has (point_t) const noexcept; // inclusive of top and left borders
-
-        // Move a point to be within the region bounds
-        void constrain (point_t&) const;
-        point_t constrained (point_t) const;
-
+        // exclusive of borders
+        bool intersects (region<S,T>) const;
         // Compute binary region combinations
         region intersection (region<S,T>) const;
 
         // Test if a region lies completely within our space
-        bool encloses (region<S,T>) const noexcept;
+        bool covers (region<S,T>) const noexcept;
+        // Test if a point lies within out space. Inclusive of borders
+        bool covers (point<S,T>) const noexcept;
+
+        // Move a point to be within the region bounds
+        void constrain (point_t&) const;
+        point_t constrained (point_t) const;
 
         //---------------------------------------------------------------------
         // Compute a region `mag` units into the region
diff --git a/test/region.cpp b/test/region.cpp
index f15bc2eb..ca7ff390 100644
--- a/test/region.cpp
+++ b/test/region.cpp
@@ -46,21 +46,16 @@ main (int, char **)
 
     // test boundary cases of includes and contains
     {
-        const util::point2u  p0 { 0 };
-        const util::extent2u e0 { 2 };
-        const util::region2u r  {p0, e0};
+        const util::point2f  p0 { 0 };
+        const util::extent2f e0 { 2 };
+        const util::region2f r  {p0, e0};
 
-        tap.expect (r.includes (util::point2u {1, 1}), "unsigned region centre inclusion");
-        tap.expect (r.includes (util::point2u {0, 0}), "unsigned region base inclusion");
-        tap.expect (r.includes (util::point2u {2, 2}), "unsigned region corner inclusion");
+        tap.expect (!r.covers (util::point2f {-1, 1}), "region/point covers, invalid x");
+        tap.expect (!r.covers (util::point2f { 1, 3}), "region/point covers, invalid y ");
 
-        tap.expect ( r.contains (util::point2u {1, 1}), "unsigned region center contains");
-        tap.expect (!r.contains (util::point2u {0, 0}), "unsigned region base contains");
-        tap.expect (!r.contains (util::point2u {2, 2}), "unsigned region corner contains");
-
-        tap.expect ( r.has (util::point2u {1, 1}), "unsigned region centre has");
-        tap.expect ( r.has (util::point2u {1, 1}), "unsigned region base has");
-        tap.expect (!r.has (util::point2u {2, 2}), "unsigned region corner has");
+        tap.expect (r.covers (util::point2f {1, 1}), "region/point covers, centre");
+        tap.expect (r.covers (util::point2f {0, 0}), "region/point covers, base");
+        tap.expect (r.covers (util::point2f {2, 2}), "region/point covers, corner");
     }
 
     // ensure make_union behaves as expected

From 9abfef2769aee11f528518ac12dbdd4b5ef1348f Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Fri, 11 Aug 2017 15:19:14 +1000
Subject: [PATCH 034/149] region: remove mutating point constrain function

---
 region.cpp | 13 ++-----------
 region.hpp |  3 +--
 2 files changed, 3 insertions(+), 13 deletions(-)

diff --git a/region.cpp b/region.cpp
index b71f3b59..9cbb4dff 100644
--- a/region.cpp
+++ b/region.cpp
@@ -179,20 +179,11 @@ util::region<S,T>::intersects (region<S,T> rhs) const
 
 //-----------------------------------------------------------------------------
 template <size_t S, typename T>
-void
-util::region<S,T>::constrain (point_t &q) const
+typename region<S,T>::point_t
+region<S,T>::constrain (point_t q) const noexcept
 {
     for (size_t i = 0; i < S; ++i)
         q[i] = limit (q[i], p[i], p[i] + e[i]);
-}
-
-
-//-----------------------------------------------------------------------------
-template <size_t S, typename T>
-typename util::region<S,T>::point_t
-util::region<S,T>::constrained (point_t q) const
-{
-    constrain (q);
     return q;
 }
 
diff --git a/region.hpp b/region.hpp
index 7ab9a848..db88f01d 100644
--- a/region.hpp
+++ b/region.hpp
@@ -81,8 +81,7 @@ namespace util {
         bool covers (point<S,T>) const noexcept;
 
         // Move a point to be within the region bounds
-        void constrain (point_t&) const;
-        point_t constrained (point_t) const;
+        point_t constrain (point_t) const noexcept;
 
         //---------------------------------------------------------------------
         // Compute a region `mag` units into the region

From ec0cb7d2c1660f33c149f3a118c5e8a067b70a3c Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Fri, 11 Aug 2017 15:20:48 +1000
Subject: [PATCH 035/149] region: remove scale operation

it's not immediately apparent how scale operates on both of point and
extent components. rather than complicate matters we remove them in
preference of letting the user construct it directly.
---
 region.cpp | 11 -----------
 region.hpp |  2 --
 2 files changed, 13 deletions(-)

diff --git a/region.cpp b/region.cpp
index 9cbb4dff..b25079d5 100644
--- a/region.cpp
+++ b/region.cpp
@@ -98,17 +98,6 @@ util::region<S,T>::magnitude (extent_t _e)
 }
 
 
-//-----------------------------------------------------------------------------
-template <size_t S, typename T>
-void
-util::region<S,T>::scale (T factor)
-{
-    auto o = (e * factor - e) / T(2);
-    p -= o;
-    e *= factor;
-}
-
-
 //-----------------------------------------------------------------------------
 template <size_t S, typename T>
 bool
diff --git a/region.hpp b/region.hpp
index db88f01d..f38bf813 100644
--- a/region.hpp
+++ b/region.hpp
@@ -59,8 +59,6 @@ namespace util {
         extent_t magnitude (void) const;
         extent_t magnitude (extent_t);
 
-        void scale (T factor);
-
         bool empty (void) const;
 
         //---------------------------------------------------------------------

From 959bc85987cd63d166ef5edb4643713c408f3fee Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 15 Aug 2017 16:44:54 +1000
Subject: [PATCH 036/149] range: add signed integer instantiations

---
 range.cpp | 18 ++++++++++--------
 1 file changed, 10 insertions(+), 8 deletions(-)

diff --git a/range.cpp b/range.cpp
index d376b3bb..1246ac54 100644
--- a/range.cpp
+++ b/range.cpp
@@ -204,14 +204,16 @@ namespace util {
 
 
 //-----------------------------------------------------------------------------
-namespace util {
-    template struct range<double>;
-    template struct range<float>;
-    template struct range<uint8_t>;
-    template struct range<uint16_t>;
-    template struct range<uint32_t>;
-    template struct range<uint64_t>;
-}
+template struct util::range<double>;
+template struct util::range<float>;
+template struct util::range<int8_t>;
+template struct util::range<int16_t>;
+template struct util::range<int32_t>;
+template struct util::range<int64_t>;
+template struct util::range<uint8_t>;
+template struct util::range<uint16_t>;
+template struct util::range<uint32_t>;
+template struct util::range<uint64_t>;
 
 
 //-----------------------------------------------------------------------------

From 651324d6f941964bb1326cfe5b2bc9db37a721e0 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Wed, 16 Aug 2017 17:25:29 +1000
Subject: [PATCH 037/149] tuple: clarify warn_unused_arg usage for ignore(...)

---
 tuple.hpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tuple.hpp b/tuple.hpp
index cd6260b4..ad15b6c2 100644
--- a/tuple.hpp
+++ b/tuple.hpp
@@ -169,7 +169,8 @@ namespace util::tuple {
     /// do nothing with a set of parameters.
     ///
     /// useful for temporarily silencing unused argument warnings in parameter
-    /// packs.
+    /// packs, or for avoiding assignment of [[gnu::warn_unused_result]] to a
+    /// temporary value we'd just cast to void anyway (GCC#66425).
     ///
     /// it is guaranteed that this function will never be defined out in
     /// debug/release/whatever builds. so it is safe to use to guarantee

From d6b77f879f404c5db6ff5b8b43d024e0af8e11c2 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Wed, 16 Aug 2017 17:25:56 +1000
Subject: [PATCH 038/149] region: add convenience zero() constructor

---
 region.hpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/region.hpp b/region.hpp
index f38bf813..92f527af 100644
--- a/region.hpp
+++ b/region.hpp
@@ -102,6 +102,9 @@ namespace util {
         static constexpr region<S,T> max  (void);
         static constexpr region<S,T> unit (void);
 
+        static constexpr region<S,T> zero (void)
+        { return { point_t {0}, extent_t {0} }; }
+
         void sanity (void) const;
     };
 

From c49738e7a398ecb2364fe8af846c50d9a06999d5 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Wed, 16 Aug 2017 17:26:16 +1000
Subject: [PATCH 039/149] coord/ops: add elementwise limit operation

---
 coord/ops.hpp | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/coord/ops.hpp b/coord/ops.hpp
index fe275f51..ba70e257 100644
--- a/coord/ops.hpp
+++ b/coord/ops.hpp
@@ -703,6 +703,25 @@ namespace util {
     }
 
 
+    //-------------------------------------------------------------------------
+
+    template <
+        size_t S,
+        typename T,
+        template<size_t,typename> class K,
+        typename = std::enable_if_t<
+            is_coord_v<K<S,T>>, void
+        >
+    >
+    constexpr
+    K<S,T>
+    limit (K<S,T> k, K<S,T> lo, K<S,T> hi)
+    {
+        assert (all (lo <= hi));
+        return max (min (k, hi), lo);
+    }
+
+
     ///------------------------------------------------------------------------
     template <
         size_t S,

From 46d28ba7be9be2e018ca83f6fcd8133ed8090c7f Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Fri, 18 Aug 2017 11:15:00 +1000
Subject: [PATCH 040/149] debug: add variable escape and memory clobber
 functions

---
 debug.hpp | 66 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 66 insertions(+)

diff --git a/debug.hpp b/debug.hpp
index 9e400b2d..a5e58220 100644
--- a/debug.hpp
+++ b/debug.hpp
@@ -221,6 +221,7 @@
 #define CHECK_NEZ(A) do {                                   \
     DEBUG_ONLY (                                            \
         const auto &__a = (A);                              \
+                                                            \
         if (::util::exactly_zero (__a))                     \
             _CHECK_PANIC ("expected non-zero\n"             \
                           "__a: %s is %!",                  \
@@ -234,6 +235,7 @@
     DEBUG_ONLY (                                                    \
         const auto &__check_mod_v = (V);                            \
         const auto &__check_mod_m = (M);                            \
+                                                                    \
         if (!::util::exactly_zero (__check_mod_v % __check_mod_m))  \
             _CHECK_PANIC ("expected zero modulus\n"                 \
                           "__v: %s is %!\n"                         \
@@ -296,6 +298,70 @@
 } while (0)
 
 
+///////////////////////////////////////////////////////////////////////////////
+/// make the compiler think a particular variable may now be aliased somewhere.
+///
+/// useful for preventing optimisations eliding a variable.
+///
+/// stolen from Chandler Carruth's 2015 talk: "Tuning C++".
+namespace util::debug {
+    template <class T>
+    inline T*
+    escape (T *t)
+    {
+        asm volatile ("": : "g"(t): "memory");
+        return t;
+    }
+
+
+    template <class T>
+    inline const T*
+    escape (const T *t)
+    {
+        asm volatile ("": : "g"(t): "memory");
+        return t;
+    }
+
+
+    template <class T>
+    inline const T&
+    escape (const T &t)
+    {
+        return *escape (&t);
+    }
+
+
+    template <class T>
+    inline T&
+    escape (T &t)
+    {
+        return *escape (&t);
+    }
+
+
+    template <typename T, typename ...Args>
+    inline void
+    escape (T t, Args ...args)
+    {
+        escape (t);
+        escape (args...);
+    }
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+/// force the compiler to conceptually dirty the global memory space.
+///
+/// stolen from Chandler Carruth's 2015 talk: "Tuning C++".
+namespace util::debug {
+    inline void
+    clobber (void)
+    {
+        asm volatile ("": : : "memory");
+    }
+}
+
+
 ///////////////////////////////////////////////////////////////////////////////
 constexpr void panic [[noreturn]] (const char*);
 

From dcdfa339d7795a1a8fda4a5294eedbe40f302ff6 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Mon, 21 Aug 2017 16:50:46 +1000
Subject: [PATCH 041/149] adapter: actually perform the reverse in reverse
 adapter

---
 adapter.hpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/adapter.hpp b/adapter.hpp
index a5b87a05..c258a685 100644
--- a/adapter.hpp
+++ b/adapter.hpp
@@ -30,14 +30,14 @@ namespace util::adapter {
                 m_target (_target)
             { ; }
 
-            auto begin (void) { return m_target.begin (); }
-            auto end   (void) { return m_target.end (); }
+            auto begin (void) & { return m_target.rbegin (); }
+            auto end   (void) & { return m_target.rend (); }
 
-            auto begin (void) const { return m_target.begin (); }
-            auto end   (void) const { return m_target.end (); }
+            auto begin (void) const& { return m_target.rbegin (); }
+            auto end   (void) const& { return m_target.rend (); }
 
-            auto cbegin (void) { return m_target.cbegin (); }
-            auto cend   (void) { return m_target.cend (); }
+            auto cbegin (void) const& { return m_target.crbegin (); }
+            auto cend   (void) const& { return m_target.crend (); }
 
         private:
             T &m_target;

From 439809ca655509bda22bd601069e78fbf84461eb Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Mon, 21 Aug 2017 16:51:03 +1000
Subject: [PATCH 042/149] adapter: add make_reverse for reverse adapter

---
 adapter.hpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/adapter.hpp b/adapter.hpp
index c258a685..c7d1ec7c 100644
--- a/adapter.hpp
+++ b/adapter.hpp
@@ -44,6 +44,14 @@ namespace util::adapter {
         };
 
 
+        template <typename Container>
+        auto
+        make_reverse (Container &c)
+        {
+            return reverse<Container> { c };
+        };
+
+
         // adapt a container's range methods to return indices rather than iterators
         template <typename T>
         struct indices {

From a016e98b12254392263b27821c1ece6b1acf6fc6 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Mon, 21 Aug 2017 18:48:52 +1000
Subject: [PATCH 043/149] region: add make_range for regions

introduces an object that provides iterators suitable for row-major
scanning of points covering a region object. mostly a wrapper for the
equivalent extent_range.
---
 region.hpp      | 97 +++++++++++++++++++++++++++++++++++++++++++++----
 test/region.cpp | 24 ++++++++++++
 2 files changed, 114 insertions(+), 7 deletions(-)

diff --git a/region.hpp b/region.hpp
index 92f527af..a22ffd3c 100644
--- a/region.hpp
+++ b/region.hpp
@@ -11,17 +11,17 @@
  * 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_REGION_HPP
-#define __UTIL_REGION_HPP
+#ifndef CRUFT_UTIL_REGION_HPP
+#define CRUFT_UTIL_REGION_HPP
 
-#include "extent.hpp"
-#include "point.hpp"
-#include "vector.hpp"
-#include "types/traits.hpp"
+#include "./extent.hpp"
+#include "./point.hpp"
+#include "./vector.hpp"
+#include "./types/traits.hpp"
 
 #include <ostream>
 
@@ -121,6 +121,89 @@ namespace util {
     }
 
 
+    ///////////////////////////////////////////////////////////////////////////
+    /// construct a point iterator across a given region, generating each
+    /// valid point in row-major sequence.
+    ///
+    /// this is only defined for integral types as it's not clear how to
+    /// handle floats; it's _super_ unlikely anyone actually wants to visit
+    /// every single floating point value for a region (and if so they can
+    /// damn well code that monstrosity themselves).
+    template <
+        typename T,
+        std::size_t S,
+        typename = std::enable_if_t<
+            std::is_integral_v<T>, void
+        >
+    >
+    auto
+    make_range (region<S,T> r)
+    {
+        using region_t = region<S,T>;
+        using point_t = typename region_t::point_t;
+        using vector_t = util::vector<S,T>;
+
+        // this range object is mostly a wrapper around the existing
+        // extent_range object with a constant offset. it's not going to be as
+        // performant, but when we discover this is an issue we can do write a
+        // better version of this object & iterator.
+        class region_range {
+        public:
+            class iterator : public std::iterator<std::forward_iterator_tag, point_t, size_t> {
+            public:
+                iterator (typename extent_range<S,T>::iterator _inner, vector_t _offset):
+                    m_inner (_inner),
+                    m_offset (_offset)
+                { ; }
+
+
+                point_t operator* (void) const { return *m_inner + m_offset; }
+
+                iterator&
+                operator++ (void)
+                {
+                    ++m_inner;
+                    return *this;
+                }
+
+
+                bool operator== (const iterator &rhs) const
+                {
+                    assert (m_offset == rhs.m_offset);
+                    return m_inner == rhs.m_inner;
+                }
+
+
+                bool operator!= (const iterator &rhs) const
+                { return !(*this == rhs); }
+
+
+            private:
+                typename extent_range<S,T>::iterator m_inner;
+                vector_t m_offset;
+            };
+
+            region_range (region_t _r):
+                m_range { _r.e + T{1} },
+                m_offset { _r.p.template as<util::vector> () }
+            { ; }
+
+            iterator begin (void) const { return { m_range.begin (), m_offset }; }
+            iterator end   (void) const { return { m_range.end   (), m_offset }; }
+
+            iterator cbegin (void) const { return begin (); }
+            iterator cend   (void) const { return end   (); }
+
+        private:
+            const extent_range<S,T> m_range;
+            const vector_t m_offset;
+        };
+
+
+        return region_range { r };
+    };
+
+
     template <typename T> using region2 = region<2,T>;
     template <typename T> using region3 = region<3,T>;
 
diff --git a/test/region.cpp b/test/region.cpp
index ca7ff390..4d41729f 100644
--- a/test/region.cpp
+++ b/test/region.cpp
@@ -3,6 +3,7 @@
 #include "point.hpp"
 #include "tap.hpp"
 
+#include <vector>
 
 //-----------------------------------------------------------------------------
 int
@@ -80,6 +81,29 @@ main (int, char **)
         );
     };
 
+    // ensure make_region covers the expected values
+    {
+        const util::region2i REGION {
+            util::point2i { -1, 1 },
+            util::point2i {  1, 3 }
+        };
+
+        const util::point2i EXPECTED[] = {
+            { -1,  1 }, {  0,  1 }, {  1,  1 },
+            { -1,  2 }, {  0,  2 }, {  1,  2 },
+            { -1,  3 }, {  0,  3 }, {  1,  3 },
+        };
+
+        std::vector<util::point2i> values;
+        auto sequence = util::make_range (REGION);
+        std::copy (std::cbegin (sequence), std::cend (sequence), std::back_inserter (values));
+
+        bool success = values.size () == std::size (EXPECTED)
+                       && std::equal (std::cbegin (values),   std::cend (values),
+                                      std::cbegin (EXPECTED), std::cend (EXPECTED));
+        tap.expect (success, "make_range(region2i)");
+    };
+
     //CHECK (region<2,intmax_t> (0, 0, 10, 10).includes (point2d (0.4, 0.01)));
     //CHECK (region<2,intmax_t> (0, 0, 10, 10).contains (point2d (0.4, 0.01)));
 

From 10f777c380a0009331c7d823c47b141c07ddb13c Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 22 Aug 2017 15:05:58 +1000
Subject: [PATCH 044/149] matrix: remove mutating operations

---
 matrix.cpp | 9 ---------
 matrix.hpp | 2 --
 2 files changed, 11 deletions(-)

diff --git a/matrix.cpp b/matrix.cpp
index dea7a429..3915c06c 100644
--- a/matrix.cpp
+++ b/matrix.cpp
@@ -27,15 +27,6 @@ using util::matrix;
 
 
 ///////////////////////////////////////////////////////////////////////////////
-template <size_t Rows, size_t Cols, typename T>
-matrix<Rows,Cols,T>&
-matrix<Rows,Cols,T>::invert (void)
-{
-    return *this = inverse ();
-}
-
-
-//-----------------------------------------------------------------------------
 //template <size_t S, typename T>
 //matrix<S,T>&
 //matrix<S,T>::invert_affine (void)
diff --git a/matrix.hpp b/matrix.hpp
index e66cf5a7..3443f754 100644
--- a/matrix.hpp
+++ b/matrix.hpp
@@ -50,9 +50,7 @@ namespace util {
         T determinant (void) const;
 
         matrix  inverse (void) const;
-        matrix& invert  (void);
         matrix  inverse_affine (void) const;
-        matrix& invert_affine  (void);
 
         vector<Rows,T> operator* (const vector<Rows,T>&) const;
         point<Rows,T>  operator* (const point<Rows,T> &) const;

From 8b089d412c3b1a68a8182aed913199a2216b9b19 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 22 Aug 2017 15:06:16 +1000
Subject: [PATCH 045/149] matrix: add fallback implementation for
 inverse_affine

---
 matrix.hpp | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/matrix.hpp b/matrix.hpp
index 3443f754..417ecb59 100644
--- a/matrix.hpp
+++ b/matrix.hpp
@@ -49,8 +49,14 @@ namespace util {
 
         T determinant (void) const;
 
-        matrix  inverse (void) const;
-        matrix  inverse_affine (void) const;
+        matrix inverse (void) const;
+
+        matrix
+        inverse_affine (void) const
+        {
+            // TODO: ensure we have specialisations for typical dimensions
+            return inverse ();
+        }
 
         vector<Rows,T> operator* (const vector<Rows,T>&) const;
         point<Rows,T>  operator* (const point<Rows,T> &) const;

From 2576061b262c4b609cad22caac5bc340300db9a2 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 22 Aug 2017 15:46:49 +1000
Subject: [PATCH 046/149] ray: extract make member function as free function

for consistency with other make_foo functions. to be replaced with
deduction guides in the future.
---
 geom/ray.cpp      | 24 ------------------------
 geom/ray.hpp      | 28 +++++++++++++++++++++++-----
 test/geom/ray.cpp | 18 +++++++++---------
 3 files changed, 32 insertions(+), 38 deletions(-)

diff --git a/geom/ray.cpp b/geom/ray.cpp
index 41fa0d76..3650ad3f 100644
--- a/geom/ray.cpp
+++ b/geom/ray.cpp
@@ -24,30 +24,6 @@
 using util::geom::ray;
 
 
-///////////////////////////////////////////////////////////////////////////////
-template <size_t S, typename T>
-ray<S,T>::ray (util::point<S,T> _origin,
-               util::vector<S,T> _direction):
-    origin (_origin),
-    direction (_direction)
-{
-    CHECK (is_normalised (direction));
-}
-
-
-//-----------------------------------------------------------------------------
-template <size_t S, typename T>
-ray<S,T>
-ray<S,T>::make (util::point<S,T> origin,
-                util::point<S,T> target)
-{
-    return {
-        origin,
-        normalised (target - origin)
-    };
-}
-
-
 ///////////////////////////////////////////////////////////////////////////////
 /// returns the distance along the ray in a ray-plane intersection
 ///
diff --git a/geom/ray.hpp b/geom/ray.hpp
index 2f63abed..b3381281 100644
--- a/geom/ray.hpp
+++ b/geom/ray.hpp
@@ -28,13 +28,17 @@
 namespace util::geom {
     template <size_t S, typename T>
     struct ray {
-        ray (point<S,T> origin,
-             vector<S,T> direction);
+        constexpr ray (point<S,T> _origin, vector<S,T> _direction) noexcept:
+            origin (_origin),
+            direction (_direction)
+        { ; }
 
-        static
-        ray<S,T> make (point<S,T> origin,
-                       point<S,T> target);
+        constexpr ray (point<S,T> _origin, point <S,T> _distant) noexcept:
+            ray (_origin, _origin.to (_distant ))
+        { ; }
 
+
+        //---------------------------------------------------------------------
         // intersection tests
         T intersect (plane<S,T>) const;
         T intersect (AABB<S,T>) const;
@@ -50,6 +54,20 @@ namespace util::geom {
         vector<S,T> direction;
     };
 
+    template <std::size_t S, typename T>
+    constexpr auto
+    make_ray (point<S,T> p, vector<S,T> d) noexcept
+    {
+        return ray<S,T> { p, d };
+    }
+
+    template <std::size_t S, typename T>
+    constexpr auto
+    make_ray (point<S,T> p, point<S,T> q)
+    {
+        return ray<S,T> { p, q };
+    };
+
     typedef ray<2,float> ray2f;
     typedef ray<3,float> ray3f;
 }
diff --git a/test/geom/ray.cpp b/test/geom/ray.cpp
index 45d989e4..2cef97e1 100644
--- a/test/geom/ray.cpp
+++ b/test/geom/ray.cpp
@@ -12,8 +12,8 @@ void
 test_intersect_plane (util::TAP::logger &tap)
 {
     // trivial case: origin ray facing z, plane at unit z facing -z.
-    const util::geom::ray3f  l ({0,0,0}, {0,0, 1});
-    const util::geom::plane3f p ({0,0,1}, {0,0,-1});
+    const util::geom::ray3f l (util::point3f {0,0,0}, util::vector3f {0,0, 1});
+    const util::geom::plane3f p (util::point3f {0,0,1}, util::vector3f {0,0,-1});
 
     tap.expect_eq (l.intersect (p), 1.f, "ray-plane intersect");
 }
@@ -32,15 +32,15 @@ test_intersect_aabb (util::TAP::logger &tap)
     };
 
     const ray2f forward {
-        { 0.5f, -0.5f },
-        { 0.f,   1.f }
+        util::point2f { 0.5f, -0.5f },
+        util::vector2f { 0.f,   1.f }
     };
 
     tap.expect_eq (forward.intersect (box), 0.5f, "ray-aabb intersect");
 
     const ray2f behind {
-        { 0.5f, 2.f },
-        { 0.f, 1.f }
+        util::point2f { 0.5f, 2.f },
+        util::vector2f { 0.f, 1.f }
     };
 
     tap.expect_nan (behind.intersect (box), "ray-aabb intersect behind");
@@ -55,13 +55,13 @@ test_intersect_sphere (util::TAP::logger &tap)
 
     const sphere3f s = {{0.f, 0.f, 0.f}, 1.f};
 
-    const ray3f r0 {{0.f, 2.f, 0.f}, {0.f, -1.f, 0.f}};
+    const ray3f r0 {util::point3f {0.f, 2.f, 0.f}, util::vector3f {0.f, -1.f, 0.f}};
     tap.expect_eq (r0.intersect (s), 1.f, "ray-sphere simple");
 
-    const ray3f r1 {{0.f, 1.f, 0.f}, {0.f, 1.f, 0.f}};
+    const ray3f r1 {util::point3f {0.f, 1.f, 0.f}, util::vector3f {0.f, 1.f, 0.f}};
     tap.expect_eq (r1.intersect (s), 0.f, "ray-sphere adjacent");
 
-    const ray3f r2 {{0.f, 2.f, 0.f}, {0.f, 1.f, 0.f}};
+    const ray3f r2 {util::point3f {0.f, 2.f, 0.f}, util::vector3f {0.f, 1.f, 0.f}};
     tap.expect_nan (r2.intersect (s), "ray-sphere no-intersect");
 }
 

From 1d988608c183b95814547077f37823d827d17fd1 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 22 Aug 2017 17:23:36 +1000
Subject: [PATCH 047/149] geom/ray: add an (explicitly) default constructor

---
 geom/ray.hpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/geom/ray.hpp b/geom/ray.hpp
index b3381281..12f8aa13 100644
--- a/geom/ray.hpp
+++ b/geom/ray.hpp
@@ -28,6 +28,8 @@
 namespace util::geom {
     template <size_t S, typename T>
     struct ray {
+        constexpr ray () = default;
+
         constexpr ray (point<S,T> _origin, vector<S,T> _direction) noexcept:
             origin (_origin),
             direction (_direction)

From d8e4354f228661ec4dbc3f46627553c6f941309f Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Thu, 24 Aug 2017 12:26:36 +1000
Subject: [PATCH 048/149] maths: only enable util::limit for scalar types

this reduces conflicts with the coord limit operation.
---
 maths.hpp | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/maths.hpp b/maths.hpp
index 9e8e9f35..475666ea 100644
--- a/maths.hpp
+++ b/maths.hpp
@@ -628,7 +628,10 @@ namespace util {
     // min/max clamping
     template <typename T, typename U, typename V>
     constexpr
-    T
+    std::enable_if_t<
+        std::is_scalar_v<T> && std::is_scalar_v<U> && std::is_scalar_v<V>,
+        std::common_type_t<T,U,V>
+    >
     limit (const T val, const U lo, const V hi)
     {
         assert (lo <= hi);

From e134d911e6f8b2bd521dd5ba66a9de6e0deec08f Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Thu, 24 Aug 2017 12:27:18 +1000
Subject: [PATCH 049/149] geom/ray: reinsert is_normalised check for direction
 param

---
 geom/ray.hpp | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/geom/ray.hpp b/geom/ray.hpp
index 12f8aa13..5b2d13f6 100644
--- a/geom/ray.hpp
+++ b/geom/ray.hpp
@@ -33,11 +33,15 @@ namespace util::geom {
         constexpr ray (point<S,T> _origin, vector<S,T> _direction) noexcept:
             origin (_origin),
             direction (_direction)
-        { ; }
+        {
+            CHECK (is_normalised (direction));
+        }
 
         constexpr ray (point<S,T> _origin, point <S,T> _distant) noexcept:
             ray (_origin, _origin.to (_distant ))
-        { ; }
+        {
+            CHECK (is_normalised (direction));
+        }
 
 
         //---------------------------------------------------------------------

From ac19e165ba3d2cb94a8c839e7a35ec9b4c9b48c4 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Thu, 24 Aug 2017 12:49:59 +1000
Subject: [PATCH 050/149] coord/ops: add comment for util::limit

---
 coord/ops.hpp | 57 ++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 56 insertions(+), 1 deletion(-)

diff --git a/coord/ops.hpp b/coord/ops.hpp
index ba70e257..c02a8700 100644
--- a/coord/ops.hpp
+++ b/coord/ops.hpp
@@ -704,7 +704,12 @@ namespace util {
 
 
     //-------------------------------------------------------------------------
-
+    /// returns a coordinate type where each element has been clamped to the
+    /// range [lo,hi].
+    ///
+    /// we specifically do not allow different coordinate types for val, lo,
+    /// and hi because the min and max calls are ill definied for varying
+    /// types (not because varying types would not be useful).
     template <
         size_t S,
         typename T,
@@ -722,6 +727,56 @@ namespace util {
     }
 
 
+    //-------------------------------------------------------------------------
+    template <
+        size_t S,
+        typename T,
+        template <size_t,typename> class K,
+        typename = std::enable_if_t<
+            is_coord_v<K<S,T>>, void
+        >
+    >
+    constexpr
+    K<S,T>
+    limit (K<S,T> k, T lo, K<S,T> hi)
+    {
+        return limit (k, K<S,T> {lo}, hi);
+    }
+
+
+    //-------------------------------------------------------------------------
+    template <
+        size_t S,
+        typename T,
+        template <size_t,typename> class K,
+        typename = std::enable_if_t<
+            is_coord_v<K<S,T>>, void
+        >
+    >
+    constexpr
+    K<S,T>
+    limit (K<S,T> k, K<S,T> lo, T hi)
+    {
+        return limit (k, lo, K<S,T> {hi});
+    }
+
+
+    //-------------------------------------------------------------------------
+    template <
+        size_t S,
+        typename T,
+        template <size_t,typename> class K,
+        typename = std::enable_if_t<
+            is_coord_v<K<S,T>>, void
+        >
+    >
+    constexpr K<S,T>
+    limit (K<S,T> k, T lo, T hi)
+    {
+        return limit (k, K<S,T> {lo}, K<S,T> {hi});
+    }
+
+
     ///------------------------------------------------------------------------
     template <
         size_t S,

From 14718594c9e609783be864a8e604adb5986d1ff5 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Thu, 24 Aug 2017 12:50:17 +1000
Subject: [PATCH 051/149] coord: add tests for vec/num/num overload of
 util::limit

---
 test/coord.cpp | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/test/coord.cpp b/test/coord.cpp
index c25585ea..c2b9f183 100644
--- a/test/coord.cpp
+++ b/test/coord.cpp
@@ -42,6 +42,7 @@ main (void)
         tap.expect (x == p.x && y == p.y, "structured bindings extract correct data");
     }
 
+    // ensure the distance function behaves correctly with non-normal numbers.
     {
         util::point3f a { 103, 0, 14 };
         util::point3f b { 104, INFINITY, 15 };
@@ -53,6 +54,7 @@ main (void)
         );
     }
 
+    // ensure the util::select function behaves as expected
     {
         const util::point3f a { -1, 2, 0 };
         const util::point3f b {  1, 0, 2 };
@@ -64,5 +66,18 @@ main (void)
         tap.expect_eq (select (a > b, a, b), hi, "select with points and max");
     };
 
+    // ensure that util::limit resolves to the coord overload. the exact
+    // values are less useful than exercising the compiler/linker.
+    {
+        const util::vector3f val {  0, -1,  2 };
+        const util::vector3f lo  { -1,  1, -2 };
+        const util::vector3f hi  {  1,  2,  0 };
+
+        tap.expect_eq (limit (val,  lo,  hi), util::vector3f { 0, 1, 0 }, "limit with vec/vec/vec");
+        tap.expect_eq (limit (val, 0.f,  hi), util::vector3f { 0, 0, 0 }, "limit with vec/num/vec");
+        tap.expect_eq (limit (val,  lo, 2.f), util::vector3f { 0, 1, 2 }, "limit with vec/vec/num");
+        tap.expect_eq (limit (val, 0.f, 2.f), util::vector3f { 0, 0, 2 }, "limit with vec/num/num");
+    }
+
     return tap.status ();
 }

From 84963aacf80c27a606bf4cbcf503c2af1d3348c5 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Thu, 24 Aug 2017 14:32:58 +1000
Subject: [PATCH 052/149] coord/ops: make 'all' and 'any' constexpr

---
 coord/ops.hpp  | 70 +++++++++++++++++++++++++++++++++++++++++++-------
 test/coord.cpp | 12 +++++++++
 2 files changed, 73 insertions(+), 9 deletions(-)

diff --git a/coord/ops.hpp b/coord/ops.hpp
index c02a8700..2e488311 100644
--- a/coord/ops.hpp
+++ b/coord/ops.hpp
@@ -899,38 +899,90 @@ namespace util {
 #undef SCALAR_OP
 
 
-    //-------------------------------------------------------------------------
+    ///////////////////////////////////////////////////////////////////////////
+    namespace detail {
+        template <
+            std::size_t S,
+            template <std::size_t,typename> class K,
+            std::size_t ...I,
+            typename = std::enable_if_t<
+                is_coord_v<K<S,bool>>,
+                void
+            >
+        >
+        constexpr bool
+        any (const K<S,bool> k, std::index_sequence<I...>)
+        {
+            return (k[I] || ...);
+        }
+    };
+
+
+    ///---------------------------------------------------------------------------
+    /// returns true if any element is true.
+    ///
+    /// this function must be suitable for use in static_assert, so it must remain
+    /// constexpr.
+    ///
+    /// we would ideally use std::any_of, but it is not constexpr.
+    /// we would ideally use range-for, but cbegin is not constexpr.
+    /// so... moar templates.
     template <
         size_t S,
         template <size_t,typename> class K,
         typename = std::enable_if_t<
             is_coord_v<K<S,bool>>, void
-        >
+        >,
+        typename Indices = std::make_index_sequence<S>
     >
     constexpr
     bool
     any (const K<S,bool> k)
     {
-        return std::any_of (std::cbegin (k),
-                            std::cend   (k),
-                            identity<bool>);
+        return detail::any (k, Indices{});
+    }
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    namespace detail {
+        template <
+            std::size_t S,
+            template <size_t,typename> class K,
+            std::size_t ...I,
+            typename = std::enable_if_t<
+                is_coord_v<K<S,bool>>,
+                void
+            >
+        >
+        constexpr bool
+        all (const K<S,bool> k, std::index_sequence<I...>)
+        {
+            return (k[I] && ...);
+        }
     }
 
     //-------------------------------------------------------------------------
+    /// returns true if all elements are true.
+    ///
+    /// this function must be suitable for use in static_assert, so it must be
+    /// constexpr.
+    ///
+    /// we would ideally use std::all_of, but it is not constexpr.
+    /// we would ideally use range-for, but cbegin is not constexpr.
+    /// so... moar templates.
     template <
         size_t S,
         template <size_t,typename> class K,
         typename = std::enable_if_t<
             is_coord_v<K<S,bool>>, void
-        >
+        >,
+        typename Indices = std::make_index_sequence<S>
     >
     constexpr
     bool
     all (const K<S,bool> k)
     {
-        return std::all_of (std::cbegin (k),
-                            std::cend   (k),
-                            identity<bool>);
+        return detail::all (k, Indices {});
     }
 
 
diff --git a/test/coord.cpp b/test/coord.cpp
index c2b9f183..593cc0ec 100644
--- a/test/coord.cpp
+++ b/test/coord.cpp
@@ -54,6 +54,18 @@ main (void)
         );
     }
 
+    // test expected outputs for various logical operations
+    {
+        constexpr util::point3i a {  0, -1,  2 };
+        constexpr util::point3i b {  0,  1, -2 };
+        constexpr util::point3i c { -9, -9, -9 };
+
+        tap.expect (!all (a <= b), "all, expected failure");
+        tap.expect ( all (a <= a), "all, expected success");
+        tap.expect (!any (a <= c), "any, expected failure");
+        tap.expect ( any (a <= b), "any, expected success");
+    };
+
     // ensure the util::select function behaves as expected
     {
         const util::point3f a { -1, 2, 0 };

From 0b52ef47be0d30e415605c2fe48ff7491eb6a978 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Thu, 24 Aug 2017 14:33:20 +1000
Subject: [PATCH 053/149] coord/ops: make make_foo functions constexpr

---
 coord/ops.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/coord/ops.hpp b/coord/ops.hpp
index 2e488311..d8b47903 100644
--- a/coord/ops.hpp
+++ b/coord/ops.hpp
@@ -1099,7 +1099,7 @@ namespace util {
         typename _T = void,                 \
         typename ...Args                    \
     >                                       \
-    auto                                    \
+    constexpr auto                          \
     make_##KLASS (Args &&...args)           \
     {                                       \
         using T = std::conditional_t<       \

From a14847bb59d57bbe347f8d16ee8363233818fd92 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Thu, 24 Aug 2017 14:33:41 +1000
Subject: [PATCH 054/149] vector: add and correct 4-dimension types

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

diff --git a/vector.hpp b/vector.hpp
index bfeb6398..f274a650 100644
--- a/vector.hpp
+++ b/vector.hpp
@@ -61,7 +61,6 @@ namespace util {
     const json::tree::node&
     operator>> (const json::tree::node&, vector<S,T>&);
 
-    // convenience typedefs
     template <typename T> using vector2 = vector<2,T>;
     template <typename T> using vector3 = vector<3,T>;
     template <typename T> using vector4 = vector<4,T>;
@@ -72,9 +71,11 @@ namespace util {
 
     typedef vector2<unsigned> vector2u;
     typedef vector3<unsigned> vector3u;
+    typedef vector4<unsigned> vector4u;
 
     typedef vector2<int> vector2i;
     typedef vector3<int> vector3i;
+    typedef vector4<int> vector4i;
 
     typedef vector2<float> vector2f;
     typedef vector3<float> vector3f;
@@ -82,7 +83,7 @@ namespace util {
 
     typedef vector2<double> vector2d;
     typedef vector3<double> vector3d;
-    typedef vector3<double> vector4d;
+    typedef vector4<double> vector4d;
 }
 
 #include "vector.ipp"

From 1d4992e3e4c5ec379e795fbfa76c431ad36dc488 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Thu, 24 Aug 2017 14:34:22 +1000
Subject: [PATCH 055/149] coord/base: add comments for constructors

---
 coord/base.hpp | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/coord/base.hpp b/coord/base.hpp
index bc3c0d65..0b519ee7 100644
--- a/coord/base.hpp
+++ b/coord/base.hpp
@@ -40,13 +40,22 @@ namespace util::coord {
         static constexpr size_t dimension = S;
         static constexpr size_t elements = S;
 
+        /// returns the number of elements we contain
         static constexpr size_t size (void) { return S; }
 
-        // constructors
+        // inherit the fancy elementwise constructors from `init'.
         using init<S,T,tags...>::init;
+
+        /// constructs, but does not initialise, the data.
+        ///
+        /// used to avoid unnecessary initialisation in many situations where
+        /// we have arrays of these types that are about to be overwritten. it
+        /// is a very important performance optimisation.
         base () = default;
 
-        constexpr explicit base (T val)
+        /// constructs an instance where all elements are initialised to `val'.
+        constexpr explicit
+        base (T val)
         { std::fill (begin (), end (), val); }
 
         constexpr base (const base<S,T,KLASS,tags...> &rhs) = default;

From ad345f19d5226763e524e9af36e7f362e465e72e Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Thu, 24 Aug 2017 14:34:46 +1000
Subject: [PATCH 056/149] coord/base: add restrictions to redim with/out params

redim to lower dimensionality should not allow a parameter, and redim to
higher dimensions should require a fill parameter.
---
 coord/base.hpp | 60 +++++++++++++++++++++++++++++---------------------
 1 file changed, 35 insertions(+), 25 deletions(-)

diff --git a/coord/base.hpp b/coord/base.hpp
index 0b519ee7..8a6dbc03 100644
--- a/coord/base.hpp
+++ b/coord/base.hpp
@@ -18,6 +18,8 @@
 #define __UTIL_COORD_BASE_HPP
 
 #include "init.hpp"
+
+#include "./ops.hpp"
 #include "../maths.hpp"
 
 #include <algorithm>
@@ -103,51 +105,59 @@ namespace util::coord {
         }
 
         ///////////////////////////////////////////////////////////////////////
-        // redimension
-        template <size_t D>
-        KLASS<D,T>
+        /// returns an instance with the same data, but truncated to `D'
+        /// elements
+        ///
+        /// explicitly does not allow a fill parameter given it can't be used
+        /// when reducing dimensions.
+        template <std::size_t D>
+        std::enable_if_t<
+            D <= S, KLASS<D,T>
+        >
         redim (void) const
         {
             KLASS<D,T> out;
-            std::copy_n (std::cbegin (this->data),
-                         min (S, D),
-                         std::begin  (out.data));
+            std::copy_n (cbegin (), D, std::begin  (out.data));
             return out;
         }
 
 
         //---------------------------------------------------------------------
-        template<size_t D>
-        KLASS<D,T>
+        /// returns an instance with the same data, but more elements, where
+        /// the new elements are initialised with values with the same index
+        /// in the coordinate `fill'.
+        ///
+        /// explicitly requires a fill parameter so that we avoid undefined
+        /// values.
+        template <std::size_t D>
+        std::enable_if_t<
+            (D > S), KLASS<D,T>
+        >
         redim (const KLASS<D,T> fill) const
         {
             KLASS<D,T> out;
 
-            static constexpr auto L1 = min (S, D);
-            static constexpr auto L2 = D - L1;
-
-            std::copy_n (std::cbegin (this->data),
-                         L1,
-                         std::begin (out.data));
-
-            std::copy_n (fill.data + L1,
-                         L2,
-                         out.data + L1);
+            auto next = std::copy (cbegin (), cend (), std::begin (out));
+            std::copy (std::cbegin (fill) + S, std::cend (fill), next);
             return out;
         }
 
         //---------------------------------------------------------------------
-        template <size_t D>
-        KLASS<D,T>
+        /// returns an instance with the same data, but more elements, where
+        /// all the new elemenst are initialised with the scalar `fill'.
+        ///
+        /// explicitly requires a fill parameter so that we avoid undefined
+        /// values.
+        template <std::size_t D>
+        std::enable_if_t<
+            (D > S), KLASS<D,T>
+        >
         redim (T fill) const
         {
             KLASS<D,T> out;
 
-            auto cursor = std::copy_n (std::cbegin (this->data),
-                                       min (S, D),
-                                       std::begin (out.data));
-            std::fill (cursor, std::end (out.data), fill);
-
+            auto next = std::copy (cbegin (), cend (), std::begin (out));
+            std::fill (next, std::end (out), fill);
             return out;
         }
     };

From efb719b8224254f7432679d3b74fae2c1286acc1 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Thu, 24 Aug 2017 14:39:06 +1000
Subject: [PATCH 057/149] coord/base: add indices method

---
 coord/base.hpp | 15 +++++++++++++++
 test/coord.cpp |  8 ++++++++
 2 files changed, 23 insertions(+)

diff --git a/coord/base.hpp b/coord/base.hpp
index 8a6dbc03..8a32ade2 100644
--- a/coord/base.hpp
+++ b/coord/base.hpp
@@ -160,6 +160,21 @@ namespace util::coord {
             std::fill (next, std::end (out), fill);
             return out;
         }
+
+
+        ///////////////////////////////////////////////////////////////////////
+        /// returns an instance with elements specified by the Indices
+        /// parameter. eg, point2f p{}.indices<0,2> would return {p.x, p.z}.
+        ///
+        /// 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>
+        indices (void) const
+        {
+            static_assert (all (make_vector ((Indices < S)...)));
+            return KLASS<sizeof...(Indices),T> { this->data[Indices]... };
+        }
     };
 }
 
diff --git a/test/coord.cpp b/test/coord.cpp
index 593cc0ec..8de918aa 100644
--- a/test/coord.cpp
+++ b/test/coord.cpp
@@ -91,5 +91,13 @@ main (void)
         tap.expect_eq (limit (val, 0.f, 2.f), util::vector3f { 0, 0, 2 }, "limit with vec/num/num");
     }
 
+    // ensure that klass::indices appears to link correctly
+    {
+        const util::vector3i seq { 0, 1, 2 };
+        const util::vector4i res { 2, 0, 0, 1 };
+
+        tap.expect_eq (seq.indices<2,0,0,1> (), res, "coord::indices expansion");
+    };
+
     return tap.status ();
 }

From 6e32ad84a7ce7ada36f8f72a02060daf17817ab3 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Thu, 24 Aug 2017 15:54:51 +1000
Subject: [PATCH 058/149] coord: use consistent naming for point coverage tests

use inclusive for tests that include all borders, and exclusive for
tests that do not accept the bottom right borders.
---
 extent.hpp      | 25 ++++++++++++++++++++++---
 extent.ipp      | 15 +--------------
 region.cpp      |  9 ---------
 region.hpp      | 19 +++++++++++++++++--
 test/region.cpp | 10 +++++-----
 5 files changed, 45 insertions(+), 33 deletions(-)

diff --git a/extent.hpp b/extent.hpp
index cde8c587..5c456803 100644
--- a/extent.hpp
+++ b/extent.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_EXTENT_HPP
@@ -41,8 +41,27 @@ namespace util {
         constexpr
         U aspect (void) const;
 
-        template <typename U>
-        bool includes (util::point<S,U>) const;
+
+        /// tests whether a point would lie within:
+        ///     region { origin, *this }, inclusive of borders.
+        ///
+        /// included for parity with util::region.
+        constexpr bool
+        inclusive (util::point<S,T> p) const
+        {
+            return all (p >= T{0} && p <= *this);
+        }
+
+
+        /// tests whether a point would like within:
+        ///     region { origin, *this }, exclusive of the bottom-right border
+        /// included for parity with util::region
+        constexpr bool
+        exclusive (point<S,T> p) const
+        {
+            return all (p >= T{0} && p < *this);
+        }
+
 
         extent expanded (vector<S,T>) const;
         extent expanded (T) const;
diff --git a/extent.ipp b/extent.ipp
index 2f732d56..8c725523 100644
--- a/extent.ipp
+++ b/extent.ipp
@@ -11,7 +11,7 @@
  * 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>
  */
 
 
@@ -66,19 +66,6 @@ util::extent<S,T>::aspect (void) const
 }
 
 
-///////////////////////////////////////////////////////////////////////////////
-template <size_t S, typename T>
-template <typename U>
-bool
-util::extent<S,T>::includes (point<S,U> p) const
-{
-    for (size_t i = 0; i < S; ++i)
-        if (p[i] < 0 || static_cast<T> (p[i]) >= this->data[i])
-            return false;
-    return true;
-}
-
-
 ///////////////////////////////////////////////////////////////////////////////
 template <size_t S, typename T>
 constexpr
diff --git a/region.cpp b/region.cpp
index b25079d5..65f62462 100644
--- a/region.cpp
+++ b/region.cpp
@@ -206,15 +206,6 @@ util::region<S,T>::covers (region<S, T> r) const noexcept
 }
 
 
-//-----------------------------------------------------------------------------
-template <size_t S, typename T>
-bool
-region<S,T>::covers (const point<S,T> q) const noexcept
-{
-    return all (p <= q) && all (p + e >= q);
-}
-
-
 ///////////////////////////////////////////////////////////////////////////////
 template <size_t S, typename T>
 util::region<S,T>
diff --git a/region.hpp b/region.hpp
index a22ffd3c..7299b726 100644
--- a/region.hpp
+++ b/region.hpp
@@ -70,13 +70,28 @@ namespace util {
         //---------------------------------------------------------------------
         // exclusive of borders
         bool intersects (region<S,T>) const;
+
         // Compute binary region combinations
         region intersection (region<S,T>) const;
 
         // Test if a region lies completely within our space
         bool covers (region<S,T>) const noexcept;
-        // Test if a point lies within out space. Inclusive of borders
-        bool covers (point<S,T>) const noexcept;
+
+        /// Test if a point lies within our space. Inclusive of borders
+        constexpr
+        bool
+        inclusive (point<S,T> q) const noexcept
+        {
+            return all (p <= q && p + e >= q);
+        }
+
+        /// test if a point lies within our space, exclusive of the
+        /// bottom-right border
+        constexpr bool
+        exclusive (point<S,T> q) const noexcept
+        {
+            return all (p <= q && p + e > q);
+        }
 
         // Move a point to be within the region bounds
         point_t constrain (point_t) const noexcept;
diff --git a/test/region.cpp b/test/region.cpp
index 4d41729f..dceb0ceb 100644
--- a/test/region.cpp
+++ b/test/region.cpp
@@ -51,12 +51,12 @@ main (int, char **)
         const util::extent2f e0 { 2 };
         const util::region2f r  {p0, e0};
 
-        tap.expect (!r.covers (util::point2f {-1, 1}), "region/point covers, invalid x");
-        tap.expect (!r.covers (util::point2f { 1, 3}), "region/point covers, invalid y ");
+        tap.expect (!r.inclusive (util::point2f {-1, 1}), "region/point inclusive, invalid x");
+        tap.expect (!r.inclusive (util::point2f { 1, 3}), "region/point inclusive, invalid y ");
 
-        tap.expect (r.covers (util::point2f {1, 1}), "region/point covers, centre");
-        tap.expect (r.covers (util::point2f {0, 0}), "region/point covers, base");
-        tap.expect (r.covers (util::point2f {2, 2}), "region/point covers, corner");
+        tap.expect (r.inclusive (util::point2f {1, 1}), "region/point inclusive, centre");
+        tap.expect (r.inclusive (util::point2f {0, 0}), "region/point inclusive, base");
+        tap.expect (r.inclusive (util::point2f {2, 2}), "region/point inclusive, corner");
     }
 
     // ensure make_union behaves as expected

From dba4e673ca6b2923893b3880a1e81ea0e6607aa8 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Thu, 24 Aug 2017 16:25:27 +1000
Subject: [PATCH 059/149] coord/ops: add scalar/vector relational operators

---
 coord/ops.hpp | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/coord/ops.hpp b/coord/ops.hpp
index d8b47903..c996b8d4 100644
--- a/coord/ops.hpp
+++ b/coord/ops.hpp
@@ -887,6 +887,25 @@ namespace util {
         for (size_t i = 0; i < S; ++i)      \
             out[i] = k[i] OP u;             \
         return out;                         \
+    }                                       \
+                                            \
+    template <                              \
+        size_t S,                           \
+        typename T,                         \
+        typename U,                         \
+        template <size_t,typename> class K, \
+        typename = std::enable_if_t<        \
+            is_coord_v<K<S,T>>, void        \
+        >                                   \
+    >                                       \
+    constexpr                               \
+    vector<S,bool>                          \
+    operator OP (const U u, const K<S,T> k) \
+    {                                       \
+        vector<S,bool> out {};              \
+        for (size_t i = 0; i < S; ++i)      \
+            out[i] = u OP k[i];             \
+        return out;                         \
     }
 
     SCALAR_OP(<)

From 359702fb8664e71e51395b70b012ff446610be61 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Thu, 24 Aug 2017 16:25:57 +1000
Subject: [PATCH 060/149] geom/aabb: remove mutating operators

---
 geom/aabb.cpp      | 90 +++++++++++++++++-----------------------------
 geom/aabb.hpp      | 12 +++----
 test/geom/aabb.cpp | 33 ++++-------------
 3 files changed, 42 insertions(+), 93 deletions(-)

diff --git a/geom/aabb.cpp b/geom/aabb.cpp
index b2601671..81901265 100644
--- a/geom/aabb.cpp
+++ b/geom/aabb.cpp
@@ -85,91 +85,65 @@ AABB<S,T>::closest (point<S,T> q) const
 
 ///////////////////////////////////////////////////////////////////////////////
 template <size_t S, typename T>
-AABB<S,T>&
-AABB<S,T>::expand (util::vector<S,T> mag)
+AABB<S,T>
+AABB<S,T>::expanded (vector<S,T> mag) const noexcept
 {
-    p0 -= mag / T{2};
-    p1 += mag / T{2};
+    CHECK (all (mag >= T{0}));
+    CHECK (all (mag <  p1 - p0));
 
-    return *this;
-}
-
-
-//-----------------------------------------------------------------------------
-template <size_t S, typename T>
-AABB<S,T>&
-AABB<S,T>::expand (T t)
-{
-    return expand (vector<S,T> {t});
+    return {
+        p0 - mag / T{2},
+        p1 + mag / T{2}
+    };
 }
 
 
 //-----------------------------------------------------------------------------
 template <size_t S, typename T>
 AABB<S,T>
-AABB<S,T>::expanded (vector<S,T> mag)
+AABB<S,T>::expanded (T t) const noexcept
 {
-    auto ret = *this;
-    ret.expand (mag);
-    return ret;
-}
+    CHECK_GE (t, T{0});
+    CHECK (all (t < p1 - p0));
 
-
-//-----------------------------------------------------------------------------
-template <size_t S, typename T>
-AABB<S,T>
-AABB<S,T>::expanded (T t)
-{
-    return expanded (vector<S,T> {t});
+    return {
+        p0 - t / T{2},
+        p1 + t / T{2}
+    };
 }
 
 
 ///////////////////////////////////////////////////////////////////////////////
 template <size_t S, typename T>
-AABB<S,T>&
-AABB<S,T>::contract (util::vector<S,T> mag)
+AABB<S,T>
+AABB<S,T>::contracted (util::vector<S,T> mag) const noexcept
 {
-    // Avoid contracting magnitudes larger than our extent
-    auto diff = p1 - p0;
-    auto delta = min (diff, mag);
+    CHECK (all (mag > T{0}));
+    CHECK (all (mag <= p1 - p0));
 
-    p0 += delta / T{2};
-    p1 -= delta / T{2};
-
-    return *this;
-}
-
-
-//-----------------------------------------------------------------------------
-template <size_t S, typename T>
-AABB<S,T>&
-AABB<S,T>::contract (T mag)
-{
-    return contract (util::vector<S,T> {mag});
+    return {
+        p0 + mag / T{2},
+        p1 - mag / T{2}
+    };
 }
 
 
 //-----------------------------------------------------------------------------
 template <size_t S, typename T>
 AABB<S,T>
-AABB<S,T>::contracted (util::vector<S,T> mag) const
+AABB<S,T>::contracted (T mag) const noexcept
 {
-    AABB<S,T> res = *this;
-    res.contract (mag);
-    return res;
+    CHECK_GE (mag, T{0});
+    CHECK (all (mag <= p1 - p0));
+
+    return {
+        p0 + mag / T{2},
+        p1 - mag / T{2}
+    };
 }
 
 
-//-----------------------------------------------------------------------------
-template <size_t S, typename T>
-AABB<S,T>
-AABB<S,T>::contracted (T mag) const
-{
-    return contracted (vector<S,T> {mag});
-}
-
-
-//-----------------------------------------------------------------------------
+///////////////////////////////////////////////////////////////////////////////
 template <size_t S, typename T>
 void
 AABB<S,T>::cover (point<S,T> p)
diff --git a/geom/aabb.hpp b/geom/aabb.hpp
index 2c169d25..aaafb61a 100644
--- a/geom/aabb.hpp
+++ b/geom/aabb.hpp
@@ -36,15 +36,11 @@ namespace util::geom {
 
         point<S,T> closest (point<S,T>) const;
 
-        AABB<S,T>& expand (util::vector<S,T>);
-        AABB<S,T>& expand (T);
-        AABB<S,T>  expanded (util::vector<S,T>);
-        AABB<S,T>  expanded (T);
+        AABB<S,T>  expanded (util::vector<S,T>) const noexcept;
+        AABB<S,T>  expanded (T) const noexcept;
 
-        AABB<S,T>& contract (util::vector<S,T>);
-        AABB<S,T>& contract (T);
-        AABB<S,T>  contracted (util::vector<S,T>) const;
-        AABB<S,T>  contracted (T) const;
+        AABB<S,T>  contracted (util::vector<S,T>) const noexcept;
+        AABB<S,T>  contracted (T) const noexcept;
 
         void cover (point<S,T>);
 
diff --git a/test/geom/aabb.cpp b/test/geom/aabb.cpp
index cbd5c43b..696254a4 100644
--- a/test/geom/aabb.cpp
+++ b/test/geom/aabb.cpp
@@ -14,39 +14,18 @@ main (int, char**)
 
     {
         // Test contraction
-        AABB2f box {
-            { 2, 2 },
-            { 8, 8 }
-        };
+        const AABB2f val { { 2, 2 }, { 8, 8 } };
+        const AABB2f res { { 3, 3 }, { 7, 7 } };
 
-        box.contract (2.f);
-
-        tap.expect_eq<AABB2f, AABB2f> (box, { { 3, 3 }, { 7, 7 }}, "over contraction");
+        tap.expect_eq (val.contracted (2.f), res, "over contraction");
     }
 
     {
         // Test expansion
-        AABB2f box {
-            { 2, 2 },
-            { 8, 8 }
-        };
+        const AABB2f val { { 2, 2 }, { 8, 8 } };
+        const AABB2f res { { 1, 1 }, { 9, 9 } };
 
-        box.expand (2.f);
-
-        tap.expect_eq<AABB2f, AABB2f> (box, { { 1, 1 }, { 9, 9 }}, "expansion");
-    }
-
-
-    {
-        // Ensure we don't wrap-around on unsigned position types when contracting
-        AABB2f small {
-            { 0, 0 },
-            { 1, 1 }
-        };
-
-        small.contract (10);
-
-        tap.expect_eq<AABB2f, AABB2f> (small, { { 0.5f, 0.5f }, { 0.5f, 0.5f }}, "unsigned over-contract");
+        tap.expect_eq (val.expanded (2.f), res, "expansion");
     }
 
     return tap.status ();

From cd1bb730f29cb287654fe2e2649400ec060f7a94 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Thu, 24 Aug 2017 16:43:54 +1000
Subject: [PATCH 061/149] geom/aabb: rename AABB to aabb

---
 geom/aabb.cpp      | 54 +++++++++++++++++++++++-----------------------
 geom/aabb.hpp      | 32 +++++++++++++--------------
 geom/aabb.ipp      |  4 ++--
 geom/ellipse.cpp   |  8 +++----
 geom/fwd.hpp       |  2 +-
 geom/iostream.hpp  |  2 +-
 geom/ops.hpp       |  2 +-
 geom/ray.cpp       |  2 +-
 geom/ray.hpp       |  2 +-
 test/geom/aabb.cpp | 10 ++++-----
 test/geom/ray.cpp  |  4 ++--
 11 files changed, 61 insertions(+), 61 deletions(-)

diff --git a/geom/aabb.cpp b/geom/aabb.cpp
index 81901265..ad122a4b 100644
--- a/geom/aabb.cpp
+++ b/geom/aabb.cpp
@@ -21,11 +21,11 @@
 #include "../coord/iostream.hpp"
 #include "../debug.hpp"
 
-using util::geom::AABB;
+using util::geom::aabb;
 
 //-----------------------------------------------------------------------------
 template <size_t S, typename T>
-AABB<S,T>::AABB (point<S,T> _p0, point<S,T> _p1):
+aabb<S,T>::aabb (point<S,T> _p0, point<S,T> _p1):
     p0 (_p0),
     p1 (_p1)
 {
@@ -36,7 +36,7 @@ AABB<S,T>::AABB (point<S,T> _p0, point<S,T> _p1):
 //-----------------------------------------------------------------------------
 template <size_t S, typename T>
 T
-AABB<S,T>::diameter (void) const
+aabb<S,T>::diameter (void) const
 {
     return magnitude ().diameter ();
 }
@@ -45,7 +45,7 @@ AABB<S,T>::diameter (void) const
 //-----------------------------------------------------------------------------
 template <size_t S, typename T>
 util::extent<S,T>
-AABB<S,T>::magnitude (void) const
+aabb<S,T>::magnitude (void) const
 {
     extent<S,T> out;
     for (size_t i = 0; i < S; ++i)
@@ -57,7 +57,7 @@ AABB<S,T>::magnitude (void) const
 //-----------------------------------------------------------------------------
 template <size_t S, typename T>
 bool
-AABB<S,T>::overlaps (point<S,T> p) const
+aabb<S,T>::overlaps (point<S,T> p) const
 {
     for (size_t i = 0; i < S; ++i)
         if (p0[i] > p[i] || p1[i] < p[i])
@@ -70,7 +70,7 @@ AABB<S,T>::overlaps (point<S,T> p) const
 //-----------------------------------------------------------------------------
 template <size_t S, typename T>
 util::point<S,T>
-AABB<S,T>::closest (point<S,T> q) const
+aabb<S,T>::closest (point<S,T> q) const
 {
     point<S,T> res;
 
@@ -85,8 +85,8 @@ AABB<S,T>::closest (point<S,T> q) const
 
 ///////////////////////////////////////////////////////////////////////////////
 template <size_t S, typename T>
-AABB<S,T>
-AABB<S,T>::expanded (vector<S,T> mag) const noexcept
+aabb<S,T>
+aabb<S,T>::expanded (vector<S,T> mag) const noexcept
 {
     CHECK (all (mag >= T{0}));
     CHECK (all (mag <  p1 - p0));
@@ -100,8 +100,8 @@ AABB<S,T>::expanded (vector<S,T> mag) const noexcept
 
 //-----------------------------------------------------------------------------
 template <size_t S, typename T>
-AABB<S,T>
-AABB<S,T>::expanded (T t) const noexcept
+aabb<S,T>
+aabb<S,T>::expanded (T t) const noexcept
 {
     CHECK_GE (t, T{0});
     CHECK (all (t < p1 - p0));
@@ -115,8 +115,8 @@ AABB<S,T>::expanded (T t) const noexcept
 
 ///////////////////////////////////////////////////////////////////////////////
 template <size_t S, typename T>
-AABB<S,T>
-AABB<S,T>::contracted (util::vector<S,T> mag) const noexcept
+aabb<S,T>
+aabb<S,T>::contracted (util::vector<S,T> mag) const noexcept
 {
     CHECK (all (mag > T{0}));
     CHECK (all (mag <= p1 - p0));
@@ -130,8 +130,8 @@ AABB<S,T>::contracted (util::vector<S,T> mag) const noexcept
 
 //-----------------------------------------------------------------------------
 template <size_t S, typename T>
-AABB<S,T>
-AABB<S,T>::contracted (T mag) const noexcept
+aabb<S,T>
+aabb<S,T>::contracted (T mag) const noexcept
 {
     CHECK_GE (mag, T{0});
     CHECK (all (mag <= p1 - p0));
@@ -146,7 +146,7 @@ AABB<S,T>::contracted (T mag) const noexcept
 ///////////////////////////////////////////////////////////////////////////////
 template <size_t S, typename T>
 void
-AABB<S,T>::cover (point<S,T> p)
+aabb<S,T>::cover (point<S,T> p)
 {
     p0 = min (p, p0);
     p1 = max (p, p1);
@@ -155,8 +155,8 @@ AABB<S,T>::cover (point<S,T> p)
 
 ///////////////////////////////////////////////////////////////////////////////
 template <size_t S, typename T>
-AABB<S,T>
-AABB<S,T>::operator+ (vector<S,T> v) const
+aabb<S,T>
+aabb<S,T>::operator+ (vector<S,T> v) const
 {
     return { p0 + v, p1 + v };
 }
@@ -164,8 +164,8 @@ AABB<S,T>::operator+ (vector<S,T> v) const
 
 //-----------------------------------------------------------------------------
 template <size_t S, typename T>
-AABB<S,T>
-AABB<S,T>::operator- (vector<S,T> v) const
+aabb<S,T>
+aabb<S,T>::operator- (vector<S,T> v) const
 {
     return { p0 - v, p1 - v };
 }
@@ -174,7 +174,7 @@ AABB<S,T>::operator- (vector<S,T> v) const
 ///////////////////////////////////////////////////////////////////////////////
 template <size_t S, typename T>
 bool
-AABB<S,T>::operator== (const AABB<S,T> rhs) const
+aabb<S,T>::operator== (const aabb<S,T> rhs) const
 {
     return rhs.p0 == p0 && rhs.p1 == p1;
 }
@@ -184,8 +184,8 @@ AABB<S,T>::operator== (const AABB<S,T> rhs) const
 //-----------------------------------------------------------------------------
 namespace util::debug {
     template <size_t S, typename T>
-    struct validator<AABB<S,T>> {
-        static bool is_valid (const AABB<S,T> &b)
+    struct validator<aabb<S,T>> {
+        static bool is_valid (const aabb<S,T> &b)
         {
             for (size_t i = 0; i < S; ++i)
                 if (b.p1[i] < b.p0[i])
@@ -200,18 +200,18 @@ namespace util::debug {
 //-----------------------------------------------------------------------------
 template <size_t S, typename T>
 std::ostream&
-util::geom::operator<< (std::ostream &os, util::geom::AABB<S,T> b)
+util::geom::operator<< (std::ostream &os, util::geom::aabb<S,T> b)
 {
-    os << "AABB(" << b.p0 << ", " << b.p1 << ")";
+    os << "aabb(" << b.p0 << ", " << b.p1 << ")";
     return os;
 }
 
 
 //-----------------------------------------------------------------------------
 #define INSTANTIATE_S_T(S,T)                             \
-namespace util::geom { template struct AABB<S,T>; }      \
-template bool util::debug::is_valid (const AABB<S,T>&);  \
-template std::ostream& util::geom::operator<< (std::ostream&, AABB<S,T>);
+namespace util::geom { template struct aabb<S,T>; }      \
+template bool util::debug::is_valid (const aabb<S,T>&);  \
+template std::ostream& util::geom::operator<< (std::ostream&, aabb<S,T>);
 
 #define INSTANTIATE(T)  \
 INSTANTIATE_S_T(2,T)    \
diff --git a/geom/aabb.hpp b/geom/aabb.hpp
index aaafb61a..62793d7d 100644
--- a/geom/aabb.hpp
+++ b/geom/aabb.hpp
@@ -25,9 +25,9 @@
 
 namespace util::geom {
     template <size_t S, typename T>
-    struct AABB {
-        AABB () = default;
-        AABB (point<S,T>, point<S,T>);
+    struct aabb {
+        aabb () = default;
+        aabb (point<S,T>, point<S,T>);
 
         T diameter (void) const;
         extent<S,T> magnitude (void) const;
@@ -36,30 +36,30 @@ namespace util::geom {
 
         point<S,T> closest (point<S,T>) const;
 
-        AABB<S,T>  expanded (util::vector<S,T>) const noexcept;
-        AABB<S,T>  expanded (T) const noexcept;
+        aabb<S,T>  expanded (util::vector<S,T>) const noexcept;
+        aabb<S,T>  expanded (T) const noexcept;
 
-        AABB<S,T>  contracted (util::vector<S,T>) const noexcept;
-        AABB<S,T>  contracted (T) const noexcept;
+        aabb<S,T>  contracted (util::vector<S,T>) const noexcept;
+        aabb<S,T>  contracted (T) const noexcept;
 
         void cover (point<S,T>);
 
-        AABB<S,T> operator+ (vector<S,T>) const;
-        AABB<S,T> operator- (vector<S,T>) const;
+        aabb<S,T> operator+ (vector<S,T>) const;
+        aabb<S,T> operator- (vector<S,T>) const;
 
-        bool operator== (AABB) const;
+        bool operator== (aabb) const;
 
         point<S,T> p0;
         point<S,T> p1;
     };
 
-    typedef AABB<2,float> AABB2f;
-    typedef AABB<2,unsigned> AABB2u;
-    typedef AABB<2,int> AABB2i;
+    typedef aabb<2,float> aabb2f;
+    typedef aabb<2,unsigned> aabb2u;
+    typedef aabb<2,int> aabb2i;
 
-    typedef AABB<3,float> AABB3f;
-    typedef AABB<3,unsigned> AABB3u;
-    typedef AABB<3,int> AABB3i;
+    typedef aabb<3,float> aabb3f;
+    typedef aabb<3,unsigned> aabb3u;
+    typedef aabb<3,int> aabb3i;
 }
 
 #include "aabb.ipp"
diff --git a/geom/aabb.ipp b/geom/aabb.ipp
index 78017b34..6e13332e 100644
--- a/geom/aabb.ipp
+++ b/geom/aabb.ipp
@@ -28,9 +28,9 @@
 ///////////////////////////////////////////////////////////////////////////////
 namespace util::geom {
     template <size_t S, typename T, typename G>
-    struct sampler<S,T,AABB,G> {
+    struct sampler<S,T,aabb,G> {
         static point<S,T>
-        fn (AABB<S,T> b, G &g)
+        fn (aabb<S,T> b, G &g)
         {
             std::uniform_real_distribution<T> d;
 
diff --git a/geom/ellipse.cpp b/geom/ellipse.cpp
index 5d59698b..e0516b19 100644
--- a/geom/ellipse.cpp
+++ b/geom/ellipse.cpp
@@ -47,7 +47,7 @@ template bool util::geom::intersects (ellipse<3,float>, util::point<3,float>);
 
 ///////////////////////////////////////////////////////////////////////////////
 template <size_t S, typename T>
-static util::geom::AABB<S,T>
+static util::geom::aabb<S,T>
 bounds (ellipse<S,T> e)
 {
     return {
@@ -59,7 +59,7 @@ bounds (ellipse<S,T> e)
 
 //-----------------------------------------------------------------------------
 template <size_t S, typename T, template <size_t,typename> class K>
-util::geom::AABB<S,T>
+util::geom::aabb<S,T>
 util::geom::bounds (K<S,T> k)
 {
     return ::bounds (k);
@@ -67,5 +67,5 @@ util::geom::bounds (K<S,T> k)
 
 
 //-----------------------------------------------------------------------------
-template util::geom::AABB<2,float> util::geom::bounds (ellipse<2,float>);
-template util::geom::AABB<3,float> util::geom::bounds (ellipse<3,float>);
+template util::geom::aabb<2,float> util::geom::bounds (ellipse<2,float>);
+template util::geom::aabb<3,float> util::geom::bounds (ellipse<3,float>);
diff --git a/geom/fwd.hpp b/geom/fwd.hpp
index 78772ffb..611a89a9 100644
--- a/geom/fwd.hpp
+++ b/geom/fwd.hpp
@@ -22,7 +22,7 @@
 namespace util::geom {
     template <size_t S, typename T> struct ray;
     template <size_t S, typename T> struct plane;
-    template <size_t S, typename T> struct AABB;
+    template <size_t S, typename T> struct aabb;
     template <size_t S, typename T> struct sphere;
     template <size_t S, typename T> struct ellipse;
     template <size_t S, typename T> struct rect;
diff --git a/geom/iostream.hpp b/geom/iostream.hpp
index 507aecab..66af161c 100644
--- a/geom/iostream.hpp
+++ b/geom/iostream.hpp
@@ -26,7 +26,7 @@
 namespace util::geom {
     template <size_t S, typename T>
     std::ostream&
-    operator<< (std::ostream&, AABB<S,T>);
+    operator<< (std::ostream&, aabb<S,T>);
 
     template <size_t S, typename T>
     std::ostream&
diff --git a/geom/ops.hpp b/geom/ops.hpp
index 504d584d..e0f5f979 100644
--- a/geom/ops.hpp
+++ b/geom/ops.hpp
@@ -55,7 +55,7 @@ namespace util::geom {
         typename T,
         template <size_t,typename> class K
     >
-    AABB<S,T>
+    aabb<S,T>
     bounds (K<S,T>);
 
     template <
diff --git a/geom/ray.cpp b/geom/ray.cpp
index 3650ad3f..84802215 100644
--- a/geom/ray.cpp
+++ b/geom/ray.cpp
@@ -44,7 +44,7 @@ ray<S,T>::intersect (plane<S,T> q) const
 /// returns NaN if behind
 template <size_t S, typename T>
 T
-ray<S,T>::intersect (AABB<S,T> r) const
+ray<S,T>::intersect (aabb<S,T> r) const
 {
     auto t1 = (r.p0 - origin) / direction;
     auto t2 = (r.p1 - origin) / direction;
diff --git a/geom/ray.hpp b/geom/ray.hpp
index 5b2d13f6..3f506e86 100644
--- a/geom/ray.hpp
+++ b/geom/ray.hpp
@@ -47,7 +47,7 @@ namespace util::geom {
         //---------------------------------------------------------------------
         // intersection tests
         T intersect (plane<S,T>) const;
-        T intersect (AABB<S,T>) const;
+        T intersect (aabb<S,T>) const;
         T intersect (sphere<S,T>) const;
 
         // queries
diff --git a/test/geom/aabb.cpp b/test/geom/aabb.cpp
index 696254a4..8e1cf651 100644
--- a/test/geom/aabb.cpp
+++ b/test/geom/aabb.cpp
@@ -4,7 +4,7 @@
 
 #include <tuple>
 
-using util::geom::AABB2f;
+using util::geom::aabb2f;
 
 
 int
@@ -14,16 +14,16 @@ main (int, char**)
 
     {
         // Test contraction
-        const AABB2f val { { 2, 2 }, { 8, 8 } };
-        const AABB2f res { { 3, 3 }, { 7, 7 } };
+        const aabb2f val { { 2, 2 }, { 8, 8 } };
+        const aabb2f res { { 3, 3 }, { 7, 7 } };
 
         tap.expect_eq (val.contracted (2.f), res, "over contraction");
     }
 
     {
         // Test expansion
-        const AABB2f val { { 2, 2 }, { 8, 8 } };
-        const AABB2f res { { 1, 1 }, { 9, 9 } };
+        const aabb2f val { { 2, 2 }, { 8, 8 } };
+        const aabb2f res { { 1, 1 }, { 9, 9 } };
 
         tap.expect_eq (val.expanded (2.f), res, "expansion");
     }
diff --git a/test/geom/ray.cpp b/test/geom/ray.cpp
index 2cef97e1..7d5a3dc1 100644
--- a/test/geom/ray.cpp
+++ b/test/geom/ray.cpp
@@ -23,10 +23,10 @@ test_intersect_plane (util::TAP::logger &tap)
 void
 test_intersect_aabb (util::TAP::logger &tap)
 {
-    using util::geom::AABB2f;
+    using util::geom::aabb2f;
 
     // trivial case: unit aabb at origin, ray from (0.5,-0.5) upwards
-    const AABB2f box {
+    const aabb2f box {
         { 0.f, 0.f },
         { 1.f, 1.f }
     };

From f77cdabaee0ba43400bc4e60e26019fb2779e533 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Thu, 24 Aug 2017 16:47:02 +1000
Subject: [PATCH 062/149] geom/aabb: dont use mutating function naming
 convention

---
 geom/aabb.cpp      | 8 ++++----
 geom/aabb.hpp      | 8 ++++----
 test/geom/aabb.cpp | 4 ++--
 3 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/geom/aabb.cpp b/geom/aabb.cpp
index ad122a4b..50aa3d21 100644
--- a/geom/aabb.cpp
+++ b/geom/aabb.cpp
@@ -86,7 +86,7 @@ aabb<S,T>::closest (point<S,T> q) const
 ///////////////////////////////////////////////////////////////////////////////
 template <size_t S, typename T>
 aabb<S,T>
-aabb<S,T>::expanded (vector<S,T> mag) const noexcept
+aabb<S,T>::expand (vector<S,T> mag) const noexcept
 {
     CHECK (all (mag >= T{0}));
     CHECK (all (mag <  p1 - p0));
@@ -101,7 +101,7 @@ aabb<S,T>::expanded (vector<S,T> mag) const noexcept
 //-----------------------------------------------------------------------------
 template <size_t S, typename T>
 aabb<S,T>
-aabb<S,T>::expanded (T t) const noexcept
+aabb<S,T>::expand (T t) const noexcept
 {
     CHECK_GE (t, T{0});
     CHECK (all (t < p1 - p0));
@@ -116,7 +116,7 @@ aabb<S,T>::expanded (T t) const noexcept
 ///////////////////////////////////////////////////////////////////////////////
 template <size_t S, typename T>
 aabb<S,T>
-aabb<S,T>::contracted (util::vector<S,T> mag) const noexcept
+aabb<S,T>::contract (util::vector<S,T> mag) const noexcept
 {
     CHECK (all (mag > T{0}));
     CHECK (all (mag <= p1 - p0));
@@ -131,7 +131,7 @@ aabb<S,T>::contracted (util::vector<S,T> mag) const noexcept
 //-----------------------------------------------------------------------------
 template <size_t S, typename T>
 aabb<S,T>
-aabb<S,T>::contracted (T mag) const noexcept
+aabb<S,T>::contract (T mag) const noexcept
 {
     CHECK_GE (mag, T{0});
     CHECK (all (mag <= p1 - p0));
diff --git a/geom/aabb.hpp b/geom/aabb.hpp
index 62793d7d..6f11b6aa 100644
--- a/geom/aabb.hpp
+++ b/geom/aabb.hpp
@@ -36,11 +36,11 @@ namespace util::geom {
 
         point<S,T> closest (point<S,T>) const;
 
-        aabb<S,T>  expanded (util::vector<S,T>) const noexcept;
-        aabb<S,T>  expanded (T) const noexcept;
+        aabb<S,T> expand (util::vector<S,T>) const noexcept;
+        aabb<S,T> expand (T) const noexcept;
 
-        aabb<S,T>  contracted (util::vector<S,T>) const noexcept;
-        aabb<S,T>  contracted (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>);
 
diff --git a/test/geom/aabb.cpp b/test/geom/aabb.cpp
index 8e1cf651..f9346f44 100644
--- a/test/geom/aabb.cpp
+++ b/test/geom/aabb.cpp
@@ -17,7 +17,7 @@ main (int, char**)
         const aabb2f val { { 2, 2 }, { 8, 8 } };
         const aabb2f res { { 3, 3 }, { 7, 7 } };
 
-        tap.expect_eq (val.contracted (2.f), res, "over contraction");
+        tap.expect_eq (val.contract (2.f), res, "over contraction");
     }
 
     {
@@ -25,7 +25,7 @@ main (int, char**)
         const aabb2f val { { 2, 2 }, { 8, 8 } };
         const aabb2f res { { 1, 1 }, { 9, 9 } };
 
-        tap.expect_eq (val.expanded (2.f), res, "expansion");
+        tap.expect_eq (val.expand (2.f), res, "expansion");
     }
 
     return tap.status ();

From 1cea1600d3cfc0f7a67a1ce19753baa1ea4fcaba Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Thu, 24 Aug 2017 16:54:48 +1000
Subject: [PATCH 063/149] geom/aabb: change contract/expand semantics to mirror
 region

---
 geom/aabb.cpp      | 32 +++++++++-----------------------
 test/geom/aabb.cpp |  4 ++--
 2 files changed, 11 insertions(+), 25 deletions(-)

diff --git a/geom/aabb.cpp b/geom/aabb.cpp
index 50aa3d21..c491885e 100644
--- a/geom/aabb.cpp
+++ b/geom/aabb.cpp
@@ -89,27 +89,19 @@ aabb<S,T>
 aabb<S,T>::expand (vector<S,T> mag) const noexcept
 {
     CHECK (all (mag >= T{0}));
-    CHECK (all (mag <  p1 - p0));
 
-    return {
-        p0 - mag / T{2},
-        p1 + mag / T{2}
-    };
+    return { p0 - mag, p1 + mag };
 }
 
 
 //-----------------------------------------------------------------------------
 template <size_t S, typename T>
 aabb<S,T>
-aabb<S,T>::expand (T t) const noexcept
+aabb<S,T>::expand (T mag) const noexcept
 {
-    CHECK_GE (t, T{0});
-    CHECK (all (t < p1 - p0));
+    CHECK_GE (mag, T{0});
 
-    return {
-        p0 - t / T{2},
-        p1 + t / T{2}
-    };
+    return { p0 - mag, p1 + mag };
 }
 
 
@@ -118,13 +110,10 @@ template <size_t S, typename T>
 aabb<S,T>
 aabb<S,T>::contract (util::vector<S,T> mag) const noexcept
 {
-    CHECK (all (mag > T{0}));
-    CHECK (all (mag <= p1 - p0));
+    CHECK (all (mag >= T{0}));
+    CHECK (all (2 * mag <= p1 - p0));
 
-    return {
-        p0 + mag / T{2},
-        p1 - mag / T{2}
-    };
+    return { p0 + mag, p1 - mag };
 }
 
 
@@ -134,12 +123,9 @@ aabb<S,T>
 aabb<S,T>::contract (T mag) const noexcept
 {
     CHECK_GE (mag, T{0});
-    CHECK (all (mag <= p1 - p0));
+    CHECK (all (2 * mag <=  p1 - p0));
 
-    return {
-        p0 + mag / T{2},
-        p1 - mag / T{2}
-    };
+    return { p0 + mag, p1 - mag };
 }
 
 
diff --git a/test/geom/aabb.cpp b/test/geom/aabb.cpp
index f9346f44..35583bd4 100644
--- a/test/geom/aabb.cpp
+++ b/test/geom/aabb.cpp
@@ -17,7 +17,7 @@ main (int, char**)
         const aabb2f val { { 2, 2 }, { 8, 8 } };
         const aabb2f res { { 3, 3 }, { 7, 7 } };
 
-        tap.expect_eq (val.contract (2.f), res, "over contraction");
+        tap.expect_eq (val.contract (1.f), res, "over contraction");
     }
 
     {
@@ -25,7 +25,7 @@ main (int, char**)
         const aabb2f val { { 2, 2 }, { 8, 8 } };
         const aabb2f res { { 1, 1 }, { 9, 9 } };
 
-        tap.expect_eq (val.expand (2.f), res, "expansion");
+        tap.expect_eq (val.expand (1.f), res, "expansion");
     }
 
     return tap.status ();

From 56444b4a50ab925b15ed2246c17c0fb45797a1e6 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Thu, 24 Aug 2017 17:02:18 +1000
Subject: [PATCH 064/149] geom/aabb: add (minimally) more thorough test data

---
 test/geom/aabb.cpp | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/test/geom/aabb.cpp b/test/geom/aabb.cpp
index 35583bd4..1925e822 100644
--- a/test/geom/aabb.cpp
+++ b/test/geom/aabb.cpp
@@ -13,19 +13,17 @@ main (int, char**)
     util::TAP::logger tap;
 
     {
-        // Test contraction
-        const aabb2f val { { 2, 2 }, { 8, 8 } };
-        const aabb2f res { { 3, 3 }, { 7, 7 } };
+        const aabb2f val { { 1, 2 }, { 8, 5 } };
+        const aabb2f res { { 3, 3 }, { 6, 4 } };
 
-        tap.expect_eq (val.contract (1.f), res, "over contraction");
+        tap.expect_eq (val.contract ({2.f, 1.f}), res, "aabb::contract");
     }
 
     {
-        // Test expansion
-        const aabb2f val { { 2, 2 }, { 8, 8 } };
-        const aabb2f res { { 1, 1 }, { 9, 9 } };
+        const aabb2f val { { 2,  1 }, { 3, 6 } };
+        const aabb2f res { { 1, -1 }, { 4, 8 } };
 
-        tap.expect_eq (val.expand (1.f), res, "expansion");
+        tap.expect_eq (val.expand ({1.f, 2.f}), res, "aabb::expand");
     }
 
     return tap.status ();

From 94e02fced4adf4426d4413d9a07bac125aea32c5 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Thu, 24 Aug 2017 17:08:37 +1000
Subject: [PATCH 065/149] geom/aabb: make the equality operator a free function

---
 geom/aabb.cpp | 13 ++-----------
 geom/aabb.hpp | 20 +++++++++++++++-----
 2 files changed, 17 insertions(+), 16 deletions(-)

diff --git a/geom/aabb.cpp b/geom/aabb.cpp
index c491885e..029ea30e 100644
--- a/geom/aabb.cpp
+++ b/geom/aabb.cpp
@@ -11,7 +11,7 @@
  * 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>
  */
 
 
@@ -23,6 +23,7 @@
 
 using util::geom::aabb;
 
+
 //-----------------------------------------------------------------------------
 template <size_t S, typename T>
 aabb<S,T>::aabb (point<S,T> _p0, point<S,T> _p1):
@@ -158,16 +159,6 @@ aabb<S,T>::operator- (vector<S,T> v) const
 
 
 ///////////////////////////////////////////////////////////////////////////////
-template <size_t S, typename T>
-bool
-aabb<S,T>::operator== (const aabb<S,T> rhs) const
-{
-    return rhs.p0 == p0 && rhs.p1 == p1;
-}
-
-
-
-//-----------------------------------------------------------------------------
 namespace util::debug {
     template <size_t S, typename T>
     struct validator<aabb<S,T>> {
diff --git a/geom/aabb.hpp b/geom/aabb.hpp
index 6f11b6aa..ab943799 100644
--- a/geom/aabb.hpp
+++ b/geom/aabb.hpp
@@ -11,12 +11,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
- * Copyright 2015-2016 Danny Robson <danny@nerdcruft.net>
+ * Copyright 2015-2017 Danny Robson <danny@nerdcruft.net>
  */
 
 
-#ifndef __UTIL_GEOM_AABB_HPP
-#define __UTIL_GEOM_AABB_HPP
+#ifndef CRUFT_UTIL_GEOM_AABB_HPP
+#define CRUFT_UTIL_GEOM_AABB_HPP
 
 #include "../point.hpp"
 #include "../extent.hpp"
@@ -24,6 +24,7 @@
 #include <cstdint>
 
 namespace util::geom {
+    ///////////////////////////////////////////////////////////////////////////
     template <size_t S, typename T>
     struct aabb {
         aabb () = default;
@@ -47,12 +48,21 @@ namespace util::geom {
         aabb<S,T> operator+ (vector<S,T>) const;
         aabb<S,T> operator- (vector<S,T>) const;
 
-        bool operator== (aabb) const;
-
         point<S,T> p0;
         point<S,T> p1;
     };
 
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <std::size_t S, typename T>
+    constexpr bool
+    operator== (const aabb<S,T> &a, const aabb<S,T> &b) noexcept
+    {
+        return a.p0 == b.p0 && a.p1 == b.p1;
+    }
+
+
+    ///////////////////////////////////////////////////////////////////////////
     typedef aabb<2,float> aabb2f;
     typedef aabb<2,unsigned> aabb2u;
     typedef aabb<2,int> aabb2i;

From 9fe89984765c9ca31818f38f8e78d9f8fe803f91 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Thu, 24 Aug 2017 17:11:48 +1000
Subject: [PATCH 066/149] geom/aabb: rename overlaps as inclusive for
 consistency

---
 geom/aabb.cpp | 2 +-
 geom/aabb.hpp | 3 ++-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/geom/aabb.cpp b/geom/aabb.cpp
index 029ea30e..4b1acb05 100644
--- a/geom/aabb.cpp
+++ b/geom/aabb.cpp
@@ -58,7 +58,7 @@ aabb<S,T>::magnitude (void) const
 //-----------------------------------------------------------------------------
 template <size_t S, typename T>
 bool
-aabb<S,T>::overlaps (point<S,T> p) const
+aabb<S,T>::inclusive (point<S,T> p) const
 {
     for (size_t i = 0; i < S; ++i)
         if (p0[i] > p[i] || p1[i] < p[i])
diff --git a/geom/aabb.hpp b/geom/aabb.hpp
index ab943799..461ac8fb 100644
--- a/geom/aabb.hpp
+++ b/geom/aabb.hpp
@@ -33,7 +33,8 @@ namespace util::geom {
         T diameter (void) const;
         extent<S,T> magnitude (void) const;
 
-        bool overlaps (point<S,T>) const;
+        /// tests whether a point lies within the region, inclusive of borders
+        bool inclusive (point<S,T>) const;
 
         point<S,T> closest (point<S,T>) const;
 

From d47f52b63f0391eac2acfcd5cd8541c3cc81cf4c Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Thu, 24 Aug 2017 17:12:17 +1000
Subject: [PATCH 067/149] geom/aabb: use vector operations for inclusive test

---
 geom/aabb.cpp | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/geom/aabb.cpp b/geom/aabb.cpp
index 4b1acb05..dd44c6e8 100644
--- a/geom/aabb.cpp
+++ b/geom/aabb.cpp
@@ -60,11 +60,7 @@ template <size_t S, typename T>
 bool
 aabb<S,T>::inclusive (point<S,T> p) const
 {
-    for (size_t i = 0; i < S; ++i)
-        if (p0[i] > p[i] || p1[i] < p[i])
-            return false;
-
-    return true;
+    return all (p0 <= p && p1 >= p);
 }
 
 

From e82d770d2b3146ac7006defeb767a8918f64dee2 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Thu, 24 Aug 2017 17:21:23 +1000
Subject: [PATCH 068/149] geom/aabb: move inclusive point query into header

---
 geom/aabb.cpp | 14 +-------------
 geom/aabb.hpp |  6 ++++--
 2 files changed, 5 insertions(+), 15 deletions(-)

diff --git a/geom/aabb.cpp b/geom/aabb.cpp
index dd44c6e8..03d1608a 100644
--- a/geom/aabb.cpp
+++ b/geom/aabb.cpp
@@ -48,19 +48,7 @@ template <size_t S, typename T>
 util::extent<S,T>
 aabb<S,T>::magnitude (void) const
 {
-    extent<S,T> out;
-    for (size_t i = 0; i < S; ++i)
-        out[i] = p1[i] - p0[i];
-    return out;
-}
-
-
-//-----------------------------------------------------------------------------
-template <size_t S, typename T>
-bool
-aabb<S,T>::inclusive (point<S,T> p) const
-{
-    return all (p0 <= p && p1 >= p);
+    return (p1 - p0).template as<util::extent> ();
 }
 
 
diff --git a/geom/aabb.hpp b/geom/aabb.hpp
index 461ac8fb..31ca00ce 100644
--- a/geom/aabb.hpp
+++ b/geom/aabb.hpp
@@ -30,11 +30,13 @@ namespace util::geom {
         aabb () = default;
         aabb (point<S,T>, point<S,T>);
 
-        T diameter (void) const;
         extent<S,T> magnitude (void) const;
+        T diameter (void) const;
 
         /// tests whether a point lies within the region, inclusive of borders
-        bool inclusive (point<S,T>) const;
+        constexpr bool
+        inclusive (point<S,T> p) const noexcept
+        { return all (p0 <= p && p1 >= p); }
 
         point<S,T> closest (point<S,T>) const;
 

From f53b547a40ae196c6663c0d1ec12d803e0934311 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Thu, 24 Aug 2017 17:27:31 +1000
Subject: [PATCH 069/149] geom/aabb: prefer to use vector operations over loops

---
 geom/aabb.cpp | 15 ++-------------
 1 file changed, 2 insertions(+), 13 deletions(-)

diff --git a/geom/aabb.cpp b/geom/aabb.cpp
index 03d1608a..a5258ba7 100644
--- a/geom/aabb.cpp
+++ b/geom/aabb.cpp
@@ -57,14 +57,7 @@ template <size_t S, typename T>
 util::point<S,T>
 aabb<S,T>::closest (point<S,T> q) const
 {
-    point<S,T> res;
-
-    for (size_t i = 0; i < S; ++i)
-        res[i] = q[i] < p0[i] ? p0[i] :
-                 q[i] > p1[i] ? p1[i] :
-                 q[i];
-
-    return res;
+    return limit (q, p0, p1);
 }
 
 
@@ -148,11 +141,7 @@ namespace util::debug {
     struct validator<aabb<S,T>> {
         static bool is_valid (const aabb<S,T> &b)
         {
-            for (size_t i = 0; i < S; ++i)
-                if (b.p1[i] < b.p0[i])
-                    return false;
-
-            return true;
+            return all (b.p0 <= b.p1);
         }
     };
 }

From 1277975708128a073f966242e90f72962b55ec9c Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Thu, 24 Aug 2017 17:27:46 +1000
Subject: [PATCH 070/149] geom/aabb: add brief class description

---
 geom/aabb.hpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/geom/aabb.hpp b/geom/aabb.hpp
index 31ca00ce..a471136c 100644
--- a/geom/aabb.hpp
+++ b/geom/aabb.hpp
@@ -25,6 +25,10 @@
 
 namespace util::geom {
     ///////////////////////////////////////////////////////////////////////////
+    /// represents an axis-aligned bounding-box through two opposing corners.
+    ///
+    /// p0 must be less-than-or-equal to p1. equality is allowed so that we
+    /// can represent zero sized bounding-boxes.
     template <size_t S, typename T>
     struct aabb {
         aabb () = default;

From 8b2c1d3fd29b4238b38fe34aa97b6dda08d43524 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Thu, 24 Aug 2017 17:52:06 +1000
Subject: [PATCH 071/149] coord/init: make 1-dimension constructor explicit

---
 coord/init.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/coord/init.hpp b/coord/init.hpp
index 5423e75b..cef7dd30 100644
--- a/coord/init.hpp
+++ b/coord/init.hpp
@@ -31,7 +31,7 @@ namespace util::coord {
     {
         using store<1,T,tags...>::store;
         constexpr init () = default;
-        constexpr init (T v0):
+        constexpr explicit init (T v0):
             store<1,T,tags...> ({v0})
         { ; }
     };

From e573c0bcc6b906c9398cf880741c9b9cb39b6348 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Thu, 24 Aug 2017 17:52:46 +1000
Subject: [PATCH 072/149] geom/aabb: style and headers

---
 geom/aabb.cpp | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/geom/aabb.cpp b/geom/aabb.cpp
index a5258ba7..74b75a1f 100644
--- a/geom/aabb.cpp
+++ b/geom/aabb.cpp
@@ -24,9 +24,9 @@
 using util::geom::aabb;
 
 
-//-----------------------------------------------------------------------------
+///////////////////////////////////////////////////////////////////////////////
 template <size_t S, typename T>
-aabb<S,T>::aabb (point<S,T> _p0, point<S,T> _p1):
+aabb<S,T>::aabb (const point<S,T> _p0, const point<S,T> _p1):
     p0 (_p0),
     p1 (_p1)
 {
@@ -34,7 +34,7 @@ aabb<S,T>::aabb (point<S,T> _p0, point<S,T> _p1):
 }
 
 
-//-----------------------------------------------------------------------------
+///////////////////////////////////////////////////////////////////////////////
 template <size_t S, typename T>
 T
 aabb<S,T>::diameter (void) const
@@ -55,7 +55,7 @@ aabb<S,T>::magnitude (void) const
 //-----------------------------------------------------------------------------
 template <size_t S, typename T>
 util::point<S,T>
-aabb<S,T>::closest (point<S,T> q) const
+aabb<S,T>::closest (const point<S,T> q) const
 {
     return limit (q, p0, p1);
 }
@@ -64,7 +64,7 @@ aabb<S,T>::closest (point<S,T> q) const
 ///////////////////////////////////////////////////////////////////////////////
 template <size_t S, typename T>
 aabb<S,T>
-aabb<S,T>::expand (vector<S,T> mag) const noexcept
+aabb<S,T>::expand (const vector<S,T> mag) const noexcept
 {
     CHECK (all (mag >= T{0}));
 
@@ -75,7 +75,7 @@ aabb<S,T>::expand (vector<S,T> mag) const noexcept
 //-----------------------------------------------------------------------------
 template <size_t S, typename T>
 aabb<S,T>
-aabb<S,T>::expand (T mag) const noexcept
+aabb<S,T>::expand (const T mag) const noexcept
 {
     CHECK_GE (mag, T{0});
 
@@ -83,10 +83,10 @@ aabb<S,T>::expand (T mag) const noexcept
 }
 
 
-///////////////////////////////////////////////////////////////////////////////
+//-----------------------------------------------------------------------------
 template <size_t S, typename T>
 aabb<S,T>
-aabb<S,T>::contract (util::vector<S,T> mag) const noexcept
+aabb<S,T>::contract (const util::vector<S,T> mag) const noexcept
 {
     CHECK (all (mag >= T{0}));
     CHECK (all (2 * mag <= p1 - p0));
@@ -98,7 +98,7 @@ aabb<S,T>::contract (util::vector<S,T> mag) const noexcept
 //-----------------------------------------------------------------------------
 template <size_t S, typename T>
 aabb<S,T>
-aabb<S,T>::contract (T mag) const noexcept
+aabb<S,T>::contract (const T mag) const noexcept
 {
     CHECK_GE (mag, T{0});
     CHECK (all (2 * mag <=  p1 - p0));
@@ -107,10 +107,10 @@ aabb<S,T>::contract (T mag) const noexcept
 }
 
 
-///////////////////////////////////////////////////////////////////////////////
+//-----------------------------------------------------------------------------
 template <size_t S, typename T>
 void
-aabb<S,T>::cover (point<S,T> p)
+aabb<S,T>::cover (const point<S,T> p)
 {
     p0 = min (p, p0);
     p1 = max (p, p1);
@@ -120,7 +120,7 @@ aabb<S,T>::cover (point<S,T> p)
 ///////////////////////////////////////////////////////////////////////////////
 template <size_t S, typename T>
 aabb<S,T>
-aabb<S,T>::operator+ (vector<S,T> v) const
+aabb<S,T>::operator+ (const vector<S,T> v) const
 {
     return { p0 + v, p1 + v };
 }
@@ -129,7 +129,7 @@ aabb<S,T>::operator+ (vector<S,T> v) const
 //-----------------------------------------------------------------------------
 template <size_t S, typename T>
 aabb<S,T>
-aabb<S,T>::operator- (vector<S,T> v) const
+aabb<S,T>::operator- (const vector<S,T> v) const
 {
     return { p0 - v, p1 - v };
 }

From 07d74187c597ca71a73a966eb87d9f05442e35bd Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Thu, 24 Aug 2017 17:52:59 +1000
Subject: [PATCH 073/149] geom/aabb: don't write the class name with ostream
 operators

---
 geom/aabb.cpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/geom/aabb.cpp b/geom/aabb.cpp
index 74b75a1f..8a826025 100644
--- a/geom/aabb.cpp
+++ b/geom/aabb.cpp
@@ -152,8 +152,7 @@ template <size_t S, typename T>
 std::ostream&
 util::geom::operator<< (std::ostream &os, util::geom::aabb<S,T> b)
 {
-    os << "aabb(" << b.p0 << ", " << b.p1 << ")";
-    return os;
+    return os << "[ " << b.p0 << ", " << b.p1 << " ]";
 }
 
 

From 8f6af0f837d98e4758f73c91640ee64b7f8ddfd5 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Thu, 24 Aug 2017 17:53:27 +1000
Subject: [PATCH 074/149] job/queue: make single argument constructor explicit

---
 job/queue.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/job/queue.hpp b/job/queue.hpp
index ceac6986..ddc3194e 100644
--- a/job/queue.hpp
+++ b/job/queue.hpp
@@ -32,7 +32,7 @@ namespace util::job {
     class queue {
     public:
         queue ();
-        queue (unsigned thread_count);
+        explicit queue (unsigned thread_count);
         ~queue ();
 
         using cookie = int;

From e9ef2ae316e1b41eb98a1110463d2d09e8870cdd Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Thu, 24 Aug 2017 17:53:46 +1000
Subject: [PATCH 075/149] sarray: add assignment operator for completeness in
 test

---
 test/sarray.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/test/sarray.cpp b/test/sarray.cpp
index e44d5c28..70370de8 100644
--- a/test/sarray.cpp
+++ b/test/sarray.cpp
@@ -19,6 +19,12 @@ struct counter {
         counter (rhs.var)
     { ; }
 
+    counter& operator= (const counter &rhs)
+    {
+        var = rhs.var;
+        return *this;
+    }
+
     ~counter ()
     { --var; }
 

From 3c9dcba2fb54e29509fe5e2f40f083f020e78dac Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Fri, 25 Aug 2017 13:03:21 +1000
Subject: [PATCH 076/149] coord/ops: add rshift coord operation

shifts each element to the right `num' places and fills the left space
with a constant or elements from another vector.
---
 coord/ops.hpp  | 47 +++++++++++++++++++++++++++++++++++++++++++++++
 test/coord.cpp | 12 ++++++++++++
 2 files changed, 59 insertions(+)

diff --git a/coord/ops.hpp b/coord/ops.hpp
index c996b8d4..70dadb81 100644
--- a/coord/ops.hpp
+++ b/coord/ops.hpp
@@ -1052,6 +1052,53 @@ namespace util {
         return out;
     }
 
+
+    ///////////////////////////////////////////////////////////////////////////
+    /// shifts all elements `num' indices to the right, setting the left-most
+    /// `num' indices to the value `fill'.
+    ///
+    /// 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 <size_t,typename> class K,
+        typename = std::enable_if_t<
+            is_coord_v<K<S,T>>, void
+        >
+    >
+    constexpr
+    K<S,T>
+    rshift (const K<S,T> k, const int num, const K<S,T> fill)
+    {
+        CHECK_LIMIT (num, 0, int (S));
+
+        K<S,T> res {};
+
+        std::copy_n (std::cbegin (k), S - num, std::begin (res) + num);
+        std::copy_n (std::cbegin (fill), num, std::begin (res));
+
+        return res;
+    }
+
+
+    //-------------------------------------------------------------------------
+    template<
+        std::size_t S,
+        typename T,
+        template <size_t,typename> class K,
+        typename = std::enable_if_t<
+            is_coord_v<K<S,T>>, void
+        >
+    >
+    constexpr
+    K<S,T>
+    rshift (const K<S,T> k, const int num, T fill)
+    {
+        return rshift (k, num, K<S,T> {fill});
+    }
+
+
     /// returns the data at a templated index in a coordinate.
     ///
     /// specifically required for structured bindings support.
diff --git a/test/coord.cpp b/test/coord.cpp
index 8de918aa..7f606db9 100644
--- a/test/coord.cpp
+++ b/test/coord.cpp
@@ -99,5 +99,17 @@ main (void)
         tap.expect_eq (seq.indices<2,0,0,1> (), res, "coord::indices expansion");
     };
 
+    // ensure that util::shift operations appear to operate correctly
+    {
+        const util::vector3i seq { 0, 1, 2 };
+        tap.expect_eq (rshift (seq, 1, 0), util::make_vector (0, 0, 1), "rshift, scalar fill");
+
+        tap.expect_eq (
+            rshift (seq, 2, util::make_vector (3, 4, 5 )),
+            util::make_vector (3, 4, 0),
+            "rshift, coord fill"
+        );
+    };
+
     return tap.status ();
 }

From 8f216a0a27982b3fca916761077c191ac83fc152 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Sun, 27 Aug 2017 11:37:18 +1000
Subject: [PATCH 077/149] coord/base: don't use std::fill in constexpr
 constructor

---
 coord/base.hpp | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/coord/base.hpp b/coord/base.hpp
index 8a32ade2..6e38df40 100644
--- a/coord/base.hpp
+++ b/coord/base.hpp
@@ -57,8 +57,11 @@ namespace util::coord {
 
         /// constructs an instance where all elements are initialised to `val'.
         constexpr explicit
-        base (T val)
-        { std::fill (begin (), end (), val); }
+        base (T fill)
+        {
+            for (decltype(S) i = 0; i < S; ++i)
+                this->data[i] = fill;
+        }
 
         constexpr base (const base<S,T,KLASS,tags...> &rhs) = default;
         base& operator= (const base<S,T,KLASS,tags...> &rhs) = default;

From 31652ed3a360243be76ebff3572c4670d1a76fe7 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Sun, 27 Aug 2017 11:37:52 +1000
Subject: [PATCH 078/149] coord/base: add clarifying comment to index assertion

---
 coord/base.hpp | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/coord/base.hpp b/coord/base.hpp
index 6e38df40..22bf4601 100644
--- a/coord/base.hpp
+++ b/coord/base.hpp
@@ -175,7 +175,11 @@ namespace util::coord {
         KLASS<sizeof...(Indices),T>
         indices (void) const
         {
-            static_assert (all (make_vector ((Indices < S)...)));
+            static_assert (
+                all (make_vector ((Indices < S)...)),
+                "indices must fall within the defined range for the type"
+            );
+
             return KLASS<sizeof...(Indices),T> { this->data[Indices]... };
         }
     };

From 677a0aa4a9fba7e55212217375ae990b97578fcb Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Sun, 27 Aug 2017 12:27:26 +1000
Subject: [PATCH 079/149] coord/ops: use vector ops for point difference

---
 coord/ops.hpp | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/coord/ops.hpp b/coord/ops.hpp
index 70dadb81..b86b0fc4 100644
--- a/coord/ops.hpp
+++ b/coord/ops.hpp
@@ -367,10 +367,7 @@ namespace util {
     vector<S,std::common_type_t<T,U>>
     operator- (point<S,T> a, point<S,U> b)
     {
-        vector<S,std::common_type_t<T,U>> out {};
-        for (size_t i = 0; i < S; ++i)
-            out[i] = a[i] - b[i];
-        return out;
+        return a.template as<vector> () - b.template as<vector> ();
     }
 
 

From cde0fe882e9a7cf83a26ec34edf110b0b2218a99 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Sun, 27 Aug 2017 12:28:00 +1000
Subject: [PATCH 080/149] vector: add more convenience typedefs for bools

---
 vector.hpp | 29 +++++++++++++++++------------
 1 file changed, 17 insertions(+), 12 deletions(-)

diff --git a/vector.hpp b/vector.hpp
index f274a650..2d58c1bc 100644
--- a/vector.hpp
+++ b/vector.hpp
@@ -68,22 +68,27 @@ namespace util {
     template <size_t S> using vectoru = vector<S,unsigned>;
     template <size_t S> using vectori = vector<S,int>;
     template <size_t S> using vectorf = vector<S,float>;
+    template <std::size_t S> using vectorb = vector<S,bool>;
 
-    typedef vector2<unsigned> vector2u;
-    typedef vector3<unsigned> vector3u;
-    typedef vector4<unsigned> vector4u;
+    using vector2u = vector2<unsigned>;
+    using vector3u = vector3<unsigned>;
+    using vector4u = vector4<unsigned>;
 
-    typedef vector2<int> vector2i;
-    typedef vector3<int> vector3i;
-    typedef vector4<int> vector4i;
+    using vector2i = vector2<int>;
+    using vector3i = vector3<int>;
+    using vector4i = vector4<int>;
 
-    typedef vector2<float> vector2f;
-    typedef vector3<float> vector3f;
-    typedef vector4<float> vector4f;
+    using vector2f = vector2<float>;
+    using vector3f = vector3<float>;
+    using vector4f = vector4<float>;
 
-    typedef vector2<double> vector2d;
-    typedef vector3<double> vector3d;
-    typedef vector4<double> vector4d;
+    using vector2d = vector2<double>;
+    using vector3d = vector3<double>;
+    using vector4d = vector4<double>;
+
+    using vector2b = vector2<bool>;
+    using vector3b = vector3<bool>;
+    using vector4b = vector4<bool>;
 }
 
 #include "vector.ipp"

From 9aa0ba8f5569a7e028efcc2eb2a4bfbaa3d1ef33 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Sun, 27 Aug 2017 12:28:56 +1000
Subject: [PATCH 081/149] test: use constexpr for test data where possible

---
 test/coord.cpp  | 2 +-
 test/extent.cpp | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/test/coord.cpp b/test/coord.cpp
index 7f606db9..4836918c 100644
--- a/test/coord.cpp
+++ b/test/coord.cpp
@@ -54,7 +54,7 @@ main (void)
         );
     }
 
-    // test expected outputs for various logical operations
+    // test expected outputs for various vector-logical operations
     {
         constexpr util::point3i a {  0, -1,  2 };
         constexpr util::point3i b {  0,  1, -2 };
diff --git a/test/extent.cpp b/test/extent.cpp
index cedd6301..624d897e 100644
--- a/test/extent.cpp
+++ b/test/extent.cpp
@@ -8,13 +8,13 @@ main (void)
     util::TAP::logger tap;
 
     {
-        util::extent2u hi { 8, 4 };
-        util::extent2u lo { 6, 2 };
+        constexpr const util::extent2u hi { 8, 4 };
+        constexpr const util::extent2u lo { 6, 2 };
         tap.expect_eq (lo, hi.contracted (2), "extent scalar contraction by value");
     }
 
     {
-        static const util::point2u EXPECTED[] = {
+        static constexpr util::point2u EXPECTED[] = {
             { 0, 0 }, { 1, 0 }, { 2, 0 },
             { 0, 1 }, { 1, 1 }, { 2, 1 },
             { 0, 2 }, { 1, 2 }, { 2, 2 },

From e7fe5d044abf2851db752770b175ab84317edda2 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Sun, 27 Aug 2017 12:30:09 +1000
Subject: [PATCH 082/149] extent: prefer to use brace initialisation

---
 extent.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/extent.cpp b/extent.cpp
index 03b4becb..3c1bc38e 100644
--- a/extent.cpp
+++ b/extent.cpp
@@ -98,7 +98,7 @@ template <size_t S, typename T>
 typename extent_range<S,T>::iterator
 extent_range<S,T>::begin (void) const
 {
-    return iterator (m_target, util::point<S,T> (0));
+    return { m_target, util::point<S,T> (0) };
 }
 
 
@@ -110,7 +110,7 @@ extent_range<S,T>::end (void) const
     util::point<S,T> cursor (0);
     cursor[S-1] = m_target[S-1];
 
-    return iterator (m_target, cursor);
+    return { m_target, cursor };
 }
 
 

From 3799135236484b767d9bbc05d61280480c4c5f01 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Sun, 27 Aug 2017 12:32:00 +1000
Subject: [PATCH 083/149] coord: add general vector comparison function

---
 coord/base.hpp  |  1 +
 coord/ops.hpp   | 83 ++++++++++++++++++++++++++++++++++++++++---------
 test/coord.cpp  |  7 -----
 test/matrix.cpp |  9 +++++-
 vector.hpp      | 14 ++++++---
 5 files changed, 87 insertions(+), 27 deletions(-)

diff --git a/coord/base.hpp b/coord/base.hpp
index 22bf4601..e63e4a52 100644
--- a/coord/base.hpp
+++ b/coord/base.hpp
@@ -185,5 +185,6 @@ namespace util::coord {
     };
 }
 
+#include "../vector.hpp"
 
 #endif
diff --git a/coord/ops.hpp b/coord/ops.hpp
index b86b0fc4..7ed7183e 100644
--- a/coord/ops.hpp
+++ b/coord/ops.hpp
@@ -11,11 +11,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
- * Copyright 2012-2016 Danny Robson <danny@nerdcruft.net>
+ * Copyright 2012-2017 Danny Robson <danny@nerdcruft.net>
  */
 
-#ifndef __UTIL_COORDS_OPS
-#define __UTIL_COORDS_OPS
+#ifndef CRUFT_UTIL_COORDS_OPS
+#define CRUFT_UTIL_COORDS_OPS
 
 #include "./fwd.hpp"
 
@@ -28,6 +28,7 @@
 #include <cmath>
 #include <cstdlib>
 #include <iterator>
+#include <functional>
 
 namespace util {
     ///////////////////////////////////////////////////////////////////////
@@ -293,6 +294,63 @@ namespace util {
 
     ///////////////////////////////////////////////////////////////////////////
     // logic operators
+    namespace detail {
+        template <
+            std::size_t S,
+            typename T,
+            template <std::size_t,typename> class K,
+            typename FuncT,
+            typename = std::enable_if_t<
+                is_coord_v<K<S,T>>,
+                void
+            >,
+            std::size_t ...Indices
+        >
+        constexpr auto
+        compare (FuncT &&func, std::index_sequence<Indices...>, const K<S,T> a, const K<S,T> b)
+        {
+            return vector<S,bool> {
+                std::invoke (func, a[Indices], b[Indices])...
+            };
+        }
+    }
+
+
+    //-------------------------------------------------------------------------
+    template <
+        std::size_t S,
+        typename T,
+        template <std::size_t,typename> class K,
+        typename FuncT,
+        typename = std::enable_if_t<
+            is_coord_v<K<S,T>>,
+            void
+        >,
+        typename Indices = std::make_index_sequence<S>
+    >
+    constexpr auto
+    compare (const K<S,T> a, const K<S,T> b, FuncT &&func)
+    {
+        return detail::compare (std::forward<FuncT> (func), Indices{}, a, b);
+    }
+
+
+    //-------------------------------------------------------------------------
+    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
+    compare (const K<S,T> a, const K<S,T> b)
+    {
+        return compare (a, b, std::equal_to<T> {});
+    }
+
 
     /// elementwise equality operator
     template <
@@ -303,16 +361,10 @@ namespace util {
             is_coord_v<K<S,T>>, void
         >
     >
-    constexpr
-    bool
+    constexpr bool
     operator== (const K<S,T> a, const K<S,T> b)
     {
-        bool (*predicate)(const T&, const T&) = almost_equal;
-
-        return std::equal (std::cbegin (a),
-                           std::cend   (a),
-                           std::cbegin (b),
-                           predicate);
+        return all (compare (a, b, std::equal_to<T> {}));
     }
 
     ///------------------------------------------------------------------------
@@ -325,11 +377,10 @@ namespace util {
             is_coord_v<K<S,T>>, void
         >
     >
-    constexpr
-    bool
-    operator!= (K<S,T> a, K<S,T> b)
+    constexpr bool
+    operator!= (const K<S,T> a, const K<S,T> b)
     {
-        return !(a == b);
+        return any (compare (a, b, std::not_equal_to<T> {}));
     }
 
 
@@ -909,6 +960,7 @@ namespace util {
     SCALAR_OP(>)
     SCALAR_OP(<=)
     SCALAR_OP(>=)
+    SCALAR_OP(==)
     SCALAR_OP(&&)
     SCALAR_OP(||)
 
@@ -1026,6 +1078,7 @@ namespace util {
         return k;
     }
 
+
     ///////////////////////////////////////////////////////////////////////////
     template <
         size_t S,
diff --git a/test/coord.cpp b/test/coord.cpp
index 4836918c..a11aede1 100644
--- a/test/coord.cpp
+++ b/test/coord.cpp
@@ -23,13 +23,6 @@ main (void)
 
     tap.expect_eq (-p, util::point2i { 1, -2 }, "unary point negation");
     tap.expect_eq ( p, p, "unary point addition");
-    tap.expect (
-        std::is_same<
-            bool,
-            decltype(!p)::value_type
-        >::value,
-        "unary point boolean negation has type bool"
-    );
 
     auto vec = util::vector4f (0.5f);
     tap.expect_eq (vec, util::normalised (vec), "normalisation of normalised vector");
diff --git a/test/matrix.cpp b/test/matrix.cpp
index 844a8ef8..0e077098 100644
--- a/test/matrix.cpp
+++ b/test/matrix.cpp
@@ -203,7 +203,14 @@ main (void)
             euler = mod (euler + 4 * PI2, PI2);
             truth = mod (truth + 4 * PI2, PI2);
 
-            tap.expect_eq (truth, euler, "matrix-to-euler, %s", t.msg);
+            tap.expect (
+                all (compare (
+                    truth, euler,
+                    [] (auto a, auto b) { return util::almost_equal (a, b); }
+                )),
+                "matrix-to-euler, %s",
+                t.msg
+            );
         }
     }
 
diff --git a/vector.hpp b/vector.hpp
index 2d58c1bc..fcf5e9e4 100644
--- a/vector.hpp
+++ b/vector.hpp
@@ -11,15 +11,21 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
- * Copyright 2011-2016 Danny Robson <danny@nerdcruft.net>
+ * Copyright 2011-2017 Danny Robson <danny@nerdcruft.net>
  */
 
-#ifndef __UTIL_VECTOR_HPP
-#define __UTIL_VECTOR_HPP
+#ifndef CRUFT_UTIL_VECTOR_HPP
+#define CRUFT_UTIL_VECTOR_HPP
+
+#include "./coord/fwd.hpp"
+#include "./coord.hpp"
 
-#include "coord.hpp"
 #include "json/fwd.hpp"
 
+#include <cstddef>
+
+
+///////////////////////////////////////////////////////////////////////////////
 namespace util {
     template <size_t S, typename T>
     struct vector : public coord::base<S,T,vector,coord::xyzw,coord::stpq>

From c4e367e648c90a5170a6f306cd4d5522a3330bbe Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Mon, 28 Aug 2017 12:25:23 +1000
Subject: [PATCH 084/149] coord: use std::size_t over size_t

---
 coord/base.hpp     |  22 +--
 coord/fwd.hpp      |  16 ++-
 coord/init.hpp     |   8 +-
 coord/iostream.hpp |  12 +-
 coord/names.hpp    |   4 +-
 coord/ops.hpp      | 324 ++++++++++++++++++++++-----------------------
 coord/store.hpp    |  12 +-
 7 files changed, 200 insertions(+), 198 deletions(-)

diff --git a/coord/base.hpp b/coord/base.hpp
index e63e4a52..2afb74bd 100644
--- a/coord/base.hpp
+++ b/coord/base.hpp
@@ -11,11 +11,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
- * Copyright 2012-2016 Danny Robson <danny@nerdcruft.net>
+ * Copyright 2012-2017 Danny Robson <danny@nerdcruft.net>
  */
 
-#ifndef __UTIL_COORD_BASE_HPP
-#define __UTIL_COORD_BASE_HPP
+#ifndef CRUFT_UTIL_COORD_BASE_HPP
+#define CRUFT_UTIL_COORD_BASE_HPP
 
 #include "init.hpp"
 
@@ -29,9 +29,9 @@
 namespace util::coord {
     /////////////////////////////////////////////////////////////////////////
     template <
-        size_t S,
+        std::size_t S,
         typename T,
-        template <size_t, typename> class KLASS,
+        template <std::size_t, typename> class KLASS,
         typename ...tags
     >
     struct base : public init<S,T,tags...> {
@@ -39,11 +39,11 @@ namespace util::coord {
         static_assert (std::is_arithmetic<T>::value);
 
         using value_type = T;
-        static constexpr size_t dimension = S;
-        static constexpr size_t elements = S;
+        static constexpr std::size_t dimension = S;
+        static constexpr std::size_t elements = S;
 
         /// returns the number of elements we contain
-        static constexpr size_t size (void) { return S; }
+        static constexpr std::size_t size (void) { return S; }
 
         // inherit the fancy elementwise constructors from `init'.
         using init<S,T,tags...>::init;
@@ -67,8 +67,8 @@ namespace util::coord {
         base& operator= (const base<S,T,KLASS,tags...> &rhs) = default;
 
         // element accessors
-        T& operator[] (size_t i) { return this->data[i]; }
-        constexpr const T& operator[] (size_t i) const { return this->data[i]; }
+        T& operator[] (std::size_t i) { return this->data[i]; }
+        constexpr const T& operator[] (std::size_t i) const { return this->data[i]; }
 
         auto cbegin (void) const { return std::cbegin (this->data); }
         auto cend   (void) const { return std::cend   (this->data); }
@@ -87,7 +87,7 @@ namespace util::coord {
 
         ///////////////////////////////////////////////////////////////////////
         // conversions
-        template <template <size_t, typename> class K>
+        template <template <std::size_t, typename> class K>
         K<S,T> as (void) const
         {
             K<S,T> k;
diff --git a/coord/fwd.hpp b/coord/fwd.hpp
index e1c3347e..3aecbc39 100644
--- a/coord/fwd.hpp
+++ b/coord/fwd.hpp
@@ -11,17 +11,19 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
- * Copyright 2016 Danny Robson <danny@nerdcruft.net>
+ * Copyright 2016-2017 Danny Robson <danny@nerdcruft.net>
  */
 
-#ifndef __UTIL_COORD_FWD_HPP
-#define __UTIL_COORD_FWD_HPP
+#ifndef CRUFT_UTIL_COORD_FWD_HPP
+#define CRUFT_UTIL_COORD_FWD_HPP
+
+#include <cstddef>
 
 namespace util {
-    template <size_t,typename> struct colour;
-    template <size_t,typename> struct extent;
-    template <size_t,typename> struct point;
-    template <size_t,typename> struct vector;
+    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;
 }
 
 #endif
diff --git a/coord/init.hpp b/coord/init.hpp
index cef7dd30..68d5555f 100644
--- a/coord/init.hpp
+++ b/coord/init.hpp
@@ -14,15 +14,15 @@
  * Copyright 2015 Danny Robson <danny@nerdcruft.net>
  */
 
-#ifndef __UTIL_COORD_INIT_HPP
-#define __UTIL_COORD_INIT_HPP
+#ifndef CRUFT_UTIL_COORD_INIT_HPP
+#define CRUFT_UTIL_COORD_INIT_HPP
 
 #include "store.hpp"
 
-#include <cstdlib>
+#include <cstddef>
 
 namespace util::coord {
-    template <size_t S, typename T, typename...>
+    template <std::size_t S, typename T, typename...>
     struct init;
 
     //-------------------------------------------------------------------------
diff --git a/coord/iostream.hpp b/coord/iostream.hpp
index c95b0d7f..52709f32 100644
--- a/coord/iostream.hpp
+++ b/coord/iostream.hpp
@@ -11,21 +11,22 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
- * Copyright 2016 Danny Robson <danny@nerdcruft.net>
+ * Copyright 2016-2017 Danny Robson <danny@nerdcruft.net>
  */
 
-#ifndef __UTIL_IOSTREAM
-#define __UTIL_IOSTREAM
+#ifndef CRUFT_UTIL_IOSTREAM
+#define CRUFT_UTIL_IOSTREAM
 
 #include "../iterator.hpp"
 
+#include <cstddef>
 #include <ostream>
 #include <algorithm>
 
 namespace util {
     template <
-        template <size_t,typename> class K,
-        size_t S,
+        template <std::size_t,typename> class K,
+        std::size_t S,
         typename T
     >
     std::ostream&
@@ -40,7 +41,6 @@ namespace util {
 
         return os;
     }
-
 }
 
 #endif
diff --git a/coord/names.hpp b/coord/names.hpp
index d34dec13..d8c9c294 100644
--- a/coord/names.hpp
+++ b/coord/names.hpp
@@ -14,8 +14,8 @@
  * Copyright 2015 Danny Robson <danny@nerdcruft.net>
  */
 
-#ifndef __UTIL_COORD_NAMES_HPP
-#define __UTIL_COORD_NAMES_HPP
+#ifndef CRUFT_UTIL_COORD_NAMES_HPP
+#define CRUFT_UTIL_COORD_NAMES_HPP
 
 namespace util::coord {
     ///////////////////////////////////////////////////////////////////////
diff --git a/coord/ops.hpp b/coord/ops.hpp
index 7ed7183e..7092fd6b 100644
--- a/coord/ops.hpp
+++ b/coord/ops.hpp
@@ -35,39 +35,39 @@ namespace util {
     // operation traits
     namespace coord {
         template <
-            template <size_t,typename> class A,
-            template <size_t,typename> class B
+            template <std::size_t,typename> class A,
+            template <std::size_t,typename> class B
         >
         struct result { };
 
         //-------------------------------------------------------------------------
-        template <> struct result<colour,colour> { template <size_t S, typename T> using type = colour<S,T>; };
-        template <> struct result<extent,extent> { template <size_t S, typename T> using type = extent<S,T>; };
-        template <> struct result<extent,vector> { template <size_t S, typename T> using type = extent<S,T>; };
-        template <> struct result<point,extent>  { template <size_t S, typename T> using type = point <S,T>; };
-        template <> struct result<point,vector>  { template <size_t S, typename T> using type = point <S,T>; };
-        template <> struct result<vector,point>  { template <size_t S, typename T> using type = point <S,T>; };
-        template <> struct result<vector,vector> { template <size_t S, typename T> using type = vector<S,T>; };
+        template <> 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 <size_t,typename> class A,
-            template <size_t,typename> class B
+            template <std::size_t,typename> class A,
+            template <std::size_t,typename> class B
         >
         using result_t = typename result<A,B>::type;
 
 
         //---------------------------------------------------------------------
-        template <template <size_t,typename> class K>
+        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 <size_t,typename> class K>
+        template <template <std::size_t,typename> class K>
         constexpr auto has_norm_v = has_norm<K>::value;
 
 
         //---------------------------------------------------------------------
-        template <template <size_t,typename> class K>
+        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 { };
@@ -75,16 +75,16 @@ namespace util {
         template <> struct has_scalar_op<point>      : public std::true_type { };
         template <> struct has_scalar_op<vector>     : public std::true_type { };
 
-        template <template <size_t,typename> class K>
+        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 <size_t S, typename T> struct is_coord<point<S,T>>      : std::true_type { };
-    template <size_t S, typename T> struct is_coord<extent<S,T>>     : std::true_type { };
-    template <size_t S, typename T> struct is_coord<vector<S,T>>     : std::true_type { };
-    template <size_t S, typename T> struct is_coord<colour<S,T>>     : std::true_type { };
+    template <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
@@ -115,11 +115,11 @@ namespace util {
     // vector operators
 #define ELEMENT_OP(OP)                                  \
     template <                                          \
-        size_t S,                                       \
+        std::size_t S,                                  \
         typename T,                                     \
         typename U,                                     \
-        template <size_t,typename> class A,             \
-        template <size_t,typename> class B,             \
+        template <std::size_t,typename> class A,        \
+        template <std::size_t,typename> class B,        \
         typename = std::enable_if_t<                    \
             is_coord_v<A<S,T>> && is_coord_v<B<S,U>>,   \
             void                                        \
@@ -132,17 +132,17 @@ namespace util {
         typename coord::result<A,B>::template type<     \
             S,std::common_type_t<T,U>                   \
         > out {};                                       \
-        for (size_t i = 0; i < S; ++i)                  \
+        for (std::size_t i = 0; i < S; ++i)             \
             out[i] = a[i] OP b[i];                      \
         return out;                                     \
     }                                                   \
                                                         \
     template <                                          \
-        size_t S,                                       \
+        std::size_t S,                                  \
         typename T,                                     \
         typename U,                                     \
-        template <size_t,typename> class A,             \
-        template <size_t,typename> class B,             \
+        template <std::size_t,typename> class A,        \
+        template <std::size_t,typename> class B,        \
         typename = std::enable_if_t<                    \
             is_coord_v<A<S,T>> &&                       \
             is_coord_v<B<S,U>> &&                       \
@@ -155,7 +155,7 @@ namespace util {
     auto&                                               \
     operator PASTE(OP,=) (A<S,T>& a, B<S,U> b)          \
     {                                                   \
-        for (size_t i = 0; i < S; ++i)                  \
+        for (std::size_t i = 0; i < S; ++i)             \
             a[i] PASTE(OP,=) b[i];                      \
         return a;                                       \
     }
@@ -171,10 +171,10 @@ namespace util {
     // scalar operators
 #define SCALAR_OP(OP)                                   \
     template <                                          \
-        size_t S,                                       \
+        std::size_t S,                                  \
         typename T,                                     \
         typename U,                                     \
-        template <size_t,typename> class K,             \
+        template <std::size_t,typename> class K,        \
         typename = std::enable_if_t<                    \
             coord::has_scalar_op_v<K>, void             \
         >                                               \
@@ -185,16 +185,16 @@ namespace util {
     {                                                   \
         K<S,std::common_type_t<T,U>> out{};             \
                                                         \
-        for (size_t i = 0; i < S; ++i)                  \
+        for (std::size_t i = 0; i < S; ++i)             \
             out[i] = u OP k[i];                         \
         return out;                                     \
     }                                                   \
                                                         \
     template <                                          \
-        size_t S,                                       \
+        std::size_t S,                                  \
         typename T,                                     \
         typename U,                                     \
-        template <size_t,typename> class K,             \
+        template <std::size_t,typename> class K,        \
         typename = std::enable_if_t<                    \
             coord::has_scalar_op_v<K>,void              \
         >                                               \
@@ -205,7 +205,7 @@ namespace util {
     {                                                   \
         K<S,std::common_type_t<T,U>> out {};            \
                                                         \
-        for (size_t i = 0; i < S; ++i)                  \
+        for (std::size_t i = 0; i < S; ++i)             \
             out[i] = k[i] OP u;                         \
         return out;                                     \
     }
@@ -226,10 +226,10 @@ namespace util {
     // destination type to avoid silent errors accumulating.
 #define SCALAR_OP(OP)                                       \
     template <                                              \
-        size_t S,                                           \
+        std::size_t S,                                      \
         typename T,                                         \
         typename U,                                         \
-        template <size_t,typename> class K,                 \
+        template <std::size_t,typename> class K,            \
         typename = std::enable_if_t<                        \
             is_coord<K<S,T>>::value &&                      \
             std::is_arithmetic<T>::value &&                 \
@@ -246,7 +246,7 @@ namespace util {
     >&                                                      \
     operator OP (K<S,T> &k, U u)                            \
     {                                                       \
-        for (size_t i = 0; i < S; ++i)                      \
+        for (std::size_t i = 0; i < S; ++i)                 \
             k[i] OP u;                                      \
                                                             \
         return k;                                           \
@@ -265,9 +265,9 @@ namespace util {
 
 #define UNARY_OP(OP)                                \
     template <                                      \
-        size_t S,                                   \
+        std::size_t S,                              \
         typename T,                                 \
-        template <size_t,typename> class K,         \
+        template <std::size_t,typename> class K,    \
         typename = std::enable_if_t<                \
             is_coord_v<K<S,T>>, void                \
         >                                           \
@@ -278,7 +278,7 @@ namespace util {
     {                                               \
         K<S,decltype(OP std::declval<T> ())> out{}; \
                                                     \
-        for (size_t i = 0; i < S; ++i)              \
+        for (std::size_t i = 0; i < S; ++i)         \
             out[i] = OP k[i];                       \
                                                     \
         return out;                                 \
@@ -354,9 +354,9 @@ namespace util {
 
     /// elementwise equality operator
     template <
-        size_t S,
+        std::size_t S,
         typename T,
-        template <size_t,typename> class K,
+        template <std::size_t,typename> class K,
         typename = std::enable_if_t<
             is_coord_v<K<S,T>>, void
         >
@@ -370,9 +370,9 @@ namespace util {
     ///------------------------------------------------------------------------
     /// elementwise inquality operator
     template <
-        size_t S,
+        std::size_t S,
         typename T,
-        template <size_t,typename> class K,
+        template <std::size_t,typename> class K,
         typename = std::enable_if_t<
             is_coord_v<K<S,T>>, void
         >
@@ -386,9 +386,9 @@ namespace util {
 
     //-------------------------------------------------------------------------
     template <
-        size_t S,
+        std::size_t S,
         typename T,
-        template <size_t,typename> class K,
+        template <std::size_t,typename> class K,
         typename = std::enable_if_t<
             is_coord_v<K<S,T>>, void
         >
@@ -410,7 +410,7 @@ namespace util {
 
     /// point-point subtraction giving a vector difference
     template <
-        size_t S,
+        std::size_t S,
         typename T,
         typename U
     >
@@ -424,7 +424,7 @@ namespace util {
 
     //-------------------------------------------------------------------------
     template <
-        size_t S,
+        std::size_t S,
         typename T,
         typename U,
         typename = std::enable_if_t<
@@ -442,7 +442,7 @@ namespace util {
 
     ///////////////////////////////////////////////////////////////////////////
     template <
-        size_t S,
+        std::size_t S,
         typename T
     >
     constexpr
@@ -450,7 +450,7 @@ namespace util {
     dot (const T (&a)[S], const T (&b)[S])
     {
         T sum = 0;
-        for (size_t i = 0; i < S; ++i)
+        for (std::size_t i = 0; i < S; ++i)
             sum += a[i] * b[i];
         return sum;
     }
@@ -458,10 +458,10 @@ namespace util {
 
     //-------------------------------------------------------------------------
     template <
-        size_t S,
+        std::size_t S,
         typename T,
-        template <size_t,typename> class A,
-        template <size_t,typename> class B,
+        template <std::size_t,typename> class A,
+        template <std::size_t,typename> class B,
         typename = std::enable_if_t<
             is_coord_v<A<S,T>> && is_coord_v<B<S,T>>, void
         >
@@ -476,9 +476,9 @@ namespace util {
 
     //-------------------------------------------------------------------------
     template <
-        size_t S,
+        std::size_t S,
         typename T,
-        template <size_t,typename> class K,
+        template <std::size_t,typename> class K,
         typename = std::enable_if_t<
             is_coord_v<K<S,T>>, void
         >
@@ -493,9 +493,9 @@ namespace util {
 
     //-------------------------------------------------------------------------
     template <
-        size_t S,
+        std::size_t S,
         typename T,
-        template <size_t,typename> class K,
+        template <std::size_t,typename> class K,
         typename = std::enable_if_t<
             is_coord_v<K<S,T>>, void
         >
@@ -510,9 +510,9 @@ namespace util {
 
     ///////////////////////////////////////////////////////////////////////////
     template <
-        size_t S,
+        std::size_t S,
         typename T,
-        template <size_t,typename> class K,
+        template <std::size_t,typename> class K,
         typename = std::enable_if_t<coord::has_norm_v<K>,void>
     >
     constexpr
@@ -525,9 +525,9 @@ namespace util {
 
     //-------------------------------------------------------------------------
     template <
-        size_t S,
+        std::size_t S,
         typename T,
-        template <size_t,typename> class K,
+        template <std::size_t,typename> class K,
         typename = std::enable_if_t<
             coord::has_norm_v<K>,
             void
@@ -543,9 +543,9 @@ namespace util {
 
     //-------------------------------------------------------------------------
     template <
-        size_t S,
+        std::size_t S,
         typename T,
-        template <size_t,typename> class K,
+        template <std::size_t,typename> class K,
         typename = std::enable_if_t<
             coord::has_norm_v<K>,
             void
@@ -564,9 +564,9 @@ namespace util {
 
     //-------------------------------------------------------------------------
     template <
-        size_t S,
+        std::size_t S,
         typename T,
-        template <size_t,typename> class K,
+        template <std::size_t,typename> class K,
         typename = std::enable_if_t<
             coord::has_norm_v<K>,
             void
@@ -582,9 +582,9 @@ namespace util {
 
     ///////////////////////////////////////////////////////////////////////////
     template <
-        size_t S,
+        std::size_t S,
         typename T,
-        template <size_t,typename> class K,
+        template <std::size_t,typename> class K,
         typename = std::enable_if_t<
             is_coord_v<K<S,T>>, void
         >
@@ -600,9 +600,9 @@ namespace util {
 
     ///////////////////////////////////////////////////////////////////////////
     template <
-        size_t S,
+        std::size_t S,
         typename T,
-        template <size_t,typename> class K,
+        template <std::size_t,typename> class K,
         typename = std::enable_if_t<
             is_coord_v<K<S,T>>, void
         >
@@ -619,9 +619,9 @@ namespace util {
     ///////////////////////////////////////////////////////////////////////////
     // root of sum of squares
     template <
-        size_t S,
+        std::size_t S,
         typename T,
-        template <size_t,typename> class K,
+        template <std::size_t,typename> class K,
         typename = std::enable_if_t<
             is_coord_v<K<S,T>>, void
         >
@@ -636,9 +636,9 @@ namespace util {
 
     ///////////////////////////////////////////////////////////////////////////
     template <
-        size_t S,
+        std::size_t S,
         typename T,
-        template <size_t,typename> class K,
+        template <std::size_t,typename> class K,
         typename = std::enable_if_t<
             is_coord_v<K<S,T>>, void
         >
@@ -659,9 +659,9 @@ namespace util {
     ///////////////////////////////////////////////////////////////////////////
     // trigonometric functions
     template <
-        size_t S,
+        std::size_t S,
         typename T,
-        template <size_t,typename> class K,
+        template <std::size_t,typename> class K,
         typename = std::enable_if_t<is_coord_v<K<S,T>>,void>
     >
     constexpr
@@ -681,9 +681,9 @@ namespace util {
 
     //-------------------------------------------------------------------------
     template <
-        size_t S,
+        std::size_t S,
         typename T,
-        template <size_t,typename> class K,
+        template <std::size_t,typename> class K,
         typename = std::enable_if_t<is_coord_v<K<S,T>>,void>
     >
     constexpr
@@ -706,9 +706,9 @@ namespace util {
 
     /// return a coord type containing the max element at each offset
     template <
-        size_t S,
+        std::size_t S,
         typename T,
-        template <size_t,typename> class K,
+        template <std::size_t,typename> class K,
         typename = std::enable_if_t<
             is_coord_v<K<S,T>>, void
         >,
@@ -721,7 +721,7 @@ namespace util {
         static_assert ((... && std::is_same<K<S,T>, std::decay_t<Args>>::value));
 
         K<S,T> out {};
-        for (size_t i = 0; i < S; ++i)
+        for (std::size_t i = 0; i < S; ++i)
             out[i] = min (a[i], b[i], args[i]...);
         return out;
     }
@@ -730,9 +730,9 @@ namespace util {
     ///------------------------------------------------------------------------
     // /return a coord type containing the max element at each offset
     template <
-        size_t S,
+        std::size_t S,
         typename T,
-        template <size_t,typename> class K,
+        template <std::size_t,typename> class K,
         typename = std::enable_if_t<
             is_coord_v<K<S,T>>, void
         >,
@@ -745,7 +745,7 @@ namespace util {
         static_assert ((... && std::is_same<K<S,T>, std::decay_t<Args>>::value));
 
         K<S,T> out {};
-        for (size_t i = 0; i < S; ++i)
+        for (std::size_t i = 0; i < S; ++i)
             out[i] = max (a[i], b[i], args[i]...);
         return out;
     }
@@ -759,9 +759,9 @@ 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 <
-        size_t S,
+        std::size_t S,
         typename T,
-        template<size_t,typename> class K,
+        template<std::size_t,typename> class K,
         typename = std::enable_if_t<
             is_coord_v<K<S,T>>, void
         >
@@ -777,9 +777,9 @@ namespace util {
 
     //-------------------------------------------------------------------------
     template <
-        size_t S,
+        std::size_t S,
         typename T,
-        template <size_t,typename> class K,
+        template <std::size_t,typename> class K,
         typename = std::enable_if_t<
             is_coord_v<K<S,T>>, void
         >
@@ -794,9 +794,9 @@ namespace util {
 
     //-------------------------------------------------------------------------
     template <
-        size_t S,
+        std::size_t S,
         typename T,
-        template <size_t,typename> class K,
+        template <std::size_t,typename> class K,
         typename = std::enable_if_t<
             is_coord_v<K<S,T>>, void
         >
@@ -811,9 +811,9 @@ namespace util {
 
     //-------------------------------------------------------------------------
     template <
-        size_t S,
+        std::size_t S,
         typename T,
-        template <size_t,typename> class K,
+        template <std::size_t,typename> class K,
         typename = std::enable_if_t<
             is_coord_v<K<S,T>>, void
         >
@@ -827,9 +827,9 @@ namespace util {
 
     ///------------------------------------------------------------------------
     template <
-        size_t S,
+        std::size_t S,
         typename T,
-        template<size_t,typename> class K,
+        template<std::size_t,typename> class K,
         typename = std::enable_if_t<
             is_coord_v<K<S,T>>, void
         >
@@ -843,9 +843,9 @@ namespace util {
 
 
     template <
-        size_t S,
+        std::size_t S,
         typename T,
-        template<size_t,typename> class K,
+        template<std::size_t,typename> class K,
         typename = std::enable_if_t<
             is_coord_v<K<S,T>>, void
         >
@@ -860,9 +860,9 @@ namespace util {
 
     ///////////////////////////////////////////////////////////////////////////
     template <
-        size_t S,
+        std::size_t S,
         typename T,
-        template <size_t,typename> class K,
+        template <std::size_t,typename> class K,
         typename = std::enable_if_t<
             is_coord_v<K<S,T>>, void
         >
@@ -888,11 +888,11 @@ namespace util {
     ///////////////////////////////////////////////////////////////////////////
 #define VECTOR_OP(OP)                                       \
     template <                                              \
-        size_t S,                                           \
+        std::size_t S,                                      \
         typename T,                                         \
         typename U,                                         \
-        template <size_t,typename> class A,                 \
-        template <size_t,typename> class B,                 \
+        template <std::size_t,typename> class A,            \
+        template <std::size_t,typename> class B,            \
         typename = std::enable_if_t<                        \
             is_coord_v<A<S,T>> && is_coord_v<B<S,U>>, void  \
         >                                                   \
@@ -902,7 +902,7 @@ namespace util {
     operator OP (const A<S,T> a, const B<S,U> b)            \
     {                                                       \
         vector<S,bool> out {};                              \
-        for (size_t i = 0; i < S; ++i)                      \
+        for (std::size_t i = 0; i < S; ++i)                 \
             out[i] = a[i] OP b[i];                          \
         return out;                                         \
     }
@@ -917,43 +917,43 @@ namespace util {
 #undef VECTOR_OP
 
 
-#define SCALAR_OP(OP)                       \
-    template <                              \
-        size_t S,                           \
-        typename T,                         \
-        typename U,                         \
-        template <size_t,typename> class K, \
-        typename = std::enable_if_t<        \
-            is_coord_v<K<S,T>>, void        \
-        >                                   \
-    >                                       \
-    constexpr                               \
-    vector<S,bool>                          \
-    operator OP (const K<S,T> k, const U u) \
-    {                                       \
-        vector<S,bool> out {};              \
-        for (size_t i = 0; i < S; ++i)      \
-            out[i] = k[i] OP u;             \
-        return out;                         \
-    }                                       \
-                                            \
-    template <                              \
-        size_t S,                           \
-        typename T,                         \
-        typename U,                         \
-        template <size_t,typename> class K, \
-        typename = std::enable_if_t<        \
-            is_coord_v<K<S,T>>, void        \
-        >                                   \
-    >                                       \
-    constexpr                               \
-    vector<S,bool>                          \
-    operator OP (const U u, const K<S,T> k) \
-    {                                       \
-        vector<S,bool> out {};              \
-        for (size_t i = 0; i < S; ++i)      \
-            out[i] = u OP k[i];             \
-        return out;                         \
+#define SCALAR_OP(OP)                               \
+    template <                                      \
+        std::size_t S,                              \
+        typename T,                                 \
+        typename U,                                 \
+        template <std::size_t,typename> class K,    \
+        typename = std::enable_if_t<                \
+            is_coord_v<K<S,T>>, void                \
+        >                                           \
+    >                                               \
+    constexpr                                       \
+    vector<S,bool>                                  \
+    operator OP (const K<S,T> k, const U u)         \
+    {                                               \
+        vector<S,bool> out {};                      \
+        for (std::size_t i = 0; i < S; ++i)         \
+            out[i] = k[i] OP u;                     \
+        return out;                                 \
+    }                                               \
+                                                    \
+    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;                                 \
     }
 
     SCALAR_OP(<)
@@ -996,8 +996,8 @@ namespace util {
     /// we would ideally use range-for, but cbegin is not constexpr.
     /// so... moar templates.
     template <
-        size_t S,
-        template <size_t,typename> class K,
+        std::size_t S,
+        template <std::size_t,typename> class K,
         typename = std::enable_if_t<
             is_coord_v<K<S,bool>>, void
         >,
@@ -1015,7 +1015,7 @@ namespace util {
     namespace detail {
         template <
             std::size_t S,
-            template <size_t,typename> class K,
+            template <std::size_t,typename> class K,
             std::size_t ...I,
             typename = std::enable_if_t<
                 is_coord_v<K<S,bool>>,
@@ -1039,8 +1039,8 @@ namespace util {
     /// we would ideally use range-for, but cbegin is not constexpr.
     /// so... moar templates.
     template <
-        size_t S,
-        template <size_t,typename> class K,
+        std::size_t S,
+        template <std::size_t,typename> class K,
         typename = std::enable_if_t<
             is_coord_v<K<S,bool>>, void
         >,
@@ -1060,9 +1060,9 @@ namespace util {
     ///
     /// corresponds to the function `select' from OpenCL.
     template <
-        size_t S,
+        std::size_t S,
         typename T,
-        template <size_t,typename> class K,
+        template <std::size_t,typename> class K,
         typename = std::enable_if_t<
             is_coord_v<K<S,T>>,
             void
@@ -1073,7 +1073,7 @@ namespace util {
     select (vector<S,bool> s, K<S,T> a, K<S,T> b)
     {
         K<S,T> k {};
-        for (size_t i = 0; i < S; ++i)
+        for (std::size_t i = 0; i < S; ++i)
             k[i] = s[i] ? a[i] : b[i];
         return k;
     }
@@ -1081,9 +1081,9 @@ namespace util {
 
     ///////////////////////////////////////////////////////////////////////////
     template <
-        size_t S,
+        std::size_t S,
         typename T,
-        template<size_t,typename> class K,
+        template<std::size_t,typename> class K,
         typename = std::enable_if_t<
             is_coord_v<K<S,T>> && std::is_floating_point<T>::value, void
         >
@@ -1112,7 +1112,7 @@ namespace util {
     template<
         std::size_t S,
         typename T,
-        template <size_t,typename> class K,
+        template <std::size_t,typename> class K,
         typename = std::enable_if_t<
             is_coord_v<K<S,T>>, void
         >
@@ -1136,7 +1136,7 @@ namespace util {
     template<
         std::size_t S,
         typename T,
-        template <size_t,typename> class K,
+        template <std::size_t,typename> class K,
         typename = std::enable_if_t<
             is_coord_v<K<S,T>>, void
         >
@@ -1158,11 +1158,11 @@ namespace util {
     /// \tparam T underlying data type of the coordinate
     /// \tparam K coordinate data type to operate on
     template <
-        size_t I,
-        size_t S,
+        std::size_t I,
+        std::size_t S,
         typename T,
         template<
-        size_t,
+        std::size_t,
         typename
     > class K
     >
@@ -1186,11 +1186,11 @@ namespace util {
     /// \tparam T underlying data type of the coordinate
     /// \tparam K coordinate data type to operate on
     template <
-        size_t I,
-        size_t S,
+        std::size_t I,
+        std::size_t S,
         typename T,
         template<
-            size_t,
+            std::size_t,
             typename
         > class K
     >
@@ -1250,10 +1250,10 @@ namespace std {
     /// \tparam T data type
     /// \tparam K coordinate class
     template <
-        size_t S,
+        std::size_t S,
         typename T,
         template<
-            size_t,
+            std::size_t,
             typename
         > class K
     >
@@ -1272,11 +1272,11 @@ namespace std {
     /// \tparam T data type for the coordinate
     /// \tparam K the underlying coordinate class
     template <
-        size_t I,
-        size_t S,
+        std::size_t I,
+        std::size_t S,
         typename T,
         template<
-            size_t,
+            std::size_t,
             typename
         > class K
     >
@@ -1296,7 +1296,7 @@ namespace std {
 
 namespace std {
     template <
-        size_t S,
+        std::size_t S,
         typename T,
         template <
             std::size_t,typename
@@ -1309,7 +1309,7 @@ namespace std {
     > {
         std::size_t
         operator() (K<S,T> k) const {
-            size_t v = 0xdeadbeef;
+            std::size_t v = 0xdeadbeef;
 
             for (auto t: k)
                 v = ::util::hash::mix (t, v);
diff --git a/coord/store.hpp b/coord/store.hpp
index a5bc4036..658f3ec5 100644
--- a/coord/store.hpp
+++ b/coord/store.hpp
@@ -11,11 +11,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
- * Copyright 2015 Danny Robson <danny@nerdcruft.net>
+ * Copyright 2015-2017 Danny Robson <danny@nerdcruft.net>
  */
 
-#ifndef __UTIL_COORD_STORE_HPP
-#define __UTIL_COORD_STORE_HPP
+#ifndef CRUFT_UTIL_COORD_STORE_HPP
+#define CRUFT_UTIL_COORD_STORE_HPP
 
 #include "names.hpp"
 
@@ -31,8 +31,8 @@
 namespace util::coord::detail {
     template <typename T>
     constexpr
-    size_t
-    alignment (size_t S)
+    std::size_t
+    alignment (std::size_t S)
     {
         (void)S;
 
@@ -63,7 +63,7 @@ namespace util::coord {
     // advantage of native platform SIMD. eg, 4f types are aligned to 16 bytes
     // on SSE platforms.
     template <
-        size_t S,
+        std::size_t S,
         typename T,
         typename...
     >

From c0df6bf8a24b9f671f2a0819876b37aa9d2e5e35 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Mon, 28 Aug 2017 12:58:18 +1000
Subject: [PATCH 085/149] coord/ops: move make_coord higher for visibility

latter code may require make_coord it should be above most of the
operations.
---
 coord/ops.hpp | 76 +++++++++++++++++++++++++++++----------------------
 1 file changed, 44 insertions(+), 32 deletions(-)

diff --git a/coord/ops.hpp b/coord/ops.hpp
index 7092fd6b..d1c37654 100644
--- a/coord/ops.hpp
+++ b/coord/ops.hpp
@@ -111,6 +111,50 @@ namespace util {
     }
 
 
+    ///////////////////////////////////////////////////////////////////////////
+    /// create a coord from supplied arguments, optionally specifying the
+    /// underlying type.
+    ///
+    /// much like experimental::make_array we use a void type to signal we
+    /// need to deduce the underlying type.
+#define MAKE_COORD(KLASS)                   \
+    template <                              \
+        typename _T = void,                 \
+        typename ...Args                    \
+    >                                       \
+    constexpr auto                          \
+    make_##KLASS (Args &&...args)           \
+    {                                       \
+        using T = std::conditional_t<       \
+            std::is_void_v<_T>,             \
+            std::common_type_t<Args...>,    \
+            _T                              \
+        >;                                  \
+                                            \
+        return KLASS<sizeof...(Args),T> {   \
+            std::forward<Args> (args)...    \
+        };                                  \
+    }
+
+    MAKE_COORD(extent)
+    MAKE_COORD(point)
+    MAKE_COORD(colour)
+    MAKE_COORD(vector)
+
+#undef MAKE_COORD
+
+    template <
+        template <std::size_t,typename> class K,
+        typename ...Args
+    >
+    constexpr auto
+        make_coord (Args &&...args)
+    {
+        using T = std::common_type_t<Args...>;
+        return K<sizeof...(Args),T> { std::forward<Args> (args)... };
+    }
+
+
     ///////////////////////////////////////////////////////////////////////////
     // vector operators
 #define ELEMENT_OP(OP)                                  \
@@ -1203,38 +1247,6 @@ namespace util {
         static_assert (I < S);
         return k[I];
     };
-
-
-    /// create a coord from supplied arguments, optionally specifying the
-    /// underlying type.
-    ///
-    /// much like experimental::make_array we use a void type to signal we
-    /// need to deduce the underlying type.
-#define MAKE_COORD(KLASS)                   \
-    template <                              \
-        typename _T = void,                 \
-        typename ...Args                    \
-    >                                       \
-    constexpr auto                          \
-    make_##KLASS (Args &&...args)           \
-    {                                       \
-        using T = std::conditional_t<       \
-            std::is_void_v<_T>,             \
-            std::common_type_t<Args...>,    \
-            _T                              \
-        >;                                  \
-                                            \
-        return KLASS<sizeof...(Args),T> {   \
-            std::forward<Args> (args)...    \
-        };                                  \
-    }
-
-    MAKE_COORD(extent)
-    MAKE_COORD(point)
-    MAKE_COORD(colour)
-    MAKE_COORD(vector)
-
-#undef MAKE_COORD
 }
 
 

From 31afd9dcfdf6280ef87dfb7920b1846eb810e08d Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Mon, 28 Aug 2017 12:59:06 +1000
Subject: [PATCH 086/149] coord/ops: initial stubs for coord::apply

---
 coord/ops.hpp | 41 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)

diff --git a/coord/ops.hpp b/coord/ops.hpp
index d1c37654..3ee732e4 100644
--- a/coord/ops.hpp
+++ b/coord/ops.hpp
@@ -335,6 +335,47 @@ namespace util {
 
 #undef UNARY_OP
 
+    ///////////////////////////////////////////////////////////////////////////
+    namespace detail {
+        template <
+            typename RetT,
+            typename ArgT,
+            typename FuncT,
+            std::size_t ...Indices,
+            typename = std::enable_if_t<
+                is_coord_v<ArgT> && is_coord_v<RetT>, void
+            >
+        >
+        constexpr auto
+        apply (const std::index_sequence<Indices...>,
+               FuncT &&func,
+               const ArgT &a,
+               const ArgT &b)
+        {
+            return RetT {
+                std::invoke (func, a[Indices], b[Indices])...
+            };
+        }
+    }
+
+
+    template <
+        typename RetT,
+        std::size_t S,
+        typename T,
+        template <std::size_t,typename> class ArgT,
+        typename FuncT,
+        typename = std::enable_if_t<
+            is_coord_v<RetT> && is_coord_v<ArgT>, void
+        >,
+        typename Indices = std::make_index_sequence<S>
+    >
+    constexpr auto
+    apply (FuncT &&func, const ArgT<S,T> &a, const ArgT<S,T> &b)
+    {
+        return detail::apply (Indices{}, std::forward<FuncT> (func), a, b);
+    }
+
 
     ///////////////////////////////////////////////////////////////////////////
     // logic operators

From 107947899c0cddbde49331e9e0732afc5974b996 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Mon, 28 Aug 2017 14:12:36 +1000
Subject: [PATCH 087/149] random: remove generator choice from easy API

it's supposed to be an easy replacement for std::rand, we don't need to
let the user choose their generator.
---
 memory/buffer/circular.cpp |  2 +-
 random.hpp                 | 56 ++++++++++++++++++++++++--------------
 2 files changed, 37 insertions(+), 21 deletions(-)

diff --git a/memory/buffer/circular.cpp b/memory/buffer/circular.cpp
index 457db4fe..c44435d3 100644
--- a/memory/buffer/circular.cpp
+++ b/memory/buffer/circular.cpp
@@ -48,7 +48,7 @@ tmpname (std::string &str, size_t length)
 
     str.resize (length);
     std::generate_n (str.begin (), length, [&] (void) {
-        return util::rand::choose (alphanum);
+        return util::random::choose (alphanum);
     });
 }
 
diff --git a/random.hpp b/random.hpp
index b2bbe4a5..e75a3a97 100644
--- a/random.hpp
+++ b/random.hpp
@@ -14,36 +14,52 @@
  * Copyright 2016 Danny Robson <danny@nerdcruft.net>
  */
 
-#ifndef __UTIL_RANDOM_HPP
-#define __UTIL_RANDOM_HPP
+#ifndef CRUFT_UTIL_RANDOM_HPP
+#define CRUFT_UTIL_RANDOM_HPP
 
 #include <random>
 
 
-///////////////////////////////////////////////////////////////////////////////
-namespace util::rand {
-    //-------------------------------------------------------------------------
-    using default_generator = std::minstd_rand;
-
-
-    //-------------------------------------------------------------------------
-    template <typename Generator = default_generator>
-    Generator&
-    thread_engine (void)
+namespace util::random {
+    ///////////////////////////////////////////////////////////////////////////
+    /// return correctly initialised thread-local generator of an unspecified,
+    /// but not entirely useless, type. ie, not LCG.
+    auto&
+    generator (void)
     {
-        std::random_device rd;
-        thread_local Generator gen (rd ());
+        static thread_local std::mt19937_64 gen { std::random_device {}() };
         return gen;
     }
 
 
-    //-------------------------------------------------------------------------
-    template <typename Generator = default_generator, typename T, size_t N>
-    T&
-    choose (T (&t)[N], Generator gen = thread_engine<Generator> ())
+    ///////////////////////////////////////////////////////////////////////////
+    /// select a value uniformly from the range [lo, hi)
+    template <typename T>
+    std::enable_if_t<std::is_floating_point_v<T>,T>
+    uniform (T lo, T hi)
     {
-        std::uniform_int_distribution<size_t> dist (0, N-1);
-        return t[dist (gen)];
+        return std::uniform_real_distribution { lo, hi } (generator ());
+    }
+
+
+    //-------------------------------------------------------------------------
+    /// select a value uniformly from the range [lo, hi)
+    template <typename T>
+    std::enable_if_t<std::is_integral_v<T>,T>
+    uniform (T lo, T hi)
+    {
+        return std::uniform_int_distribution { lo, hi } (generator ());
+    }
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    /// choose a value at random from an array
+    template <typename T, size_t N>
+    T&
+    choose (T (&t)[N])
+    {
+        std::uniform_int_distribution<size_t> dist (0, N - 1);
+        return t[dist (generator ())];
     }
 }
 

From b2cf1ae188de3f8397f9f6b76fffc09ba7b9d87f Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Mon, 28 Aug 2017 16:02:04 +1000
Subject: [PATCH 088/149] random: add forgotten template param to distributions

---
 random.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/random.hpp b/random.hpp
index e75a3a97..e4b97490 100644
--- a/random.hpp
+++ b/random.hpp
@@ -38,7 +38,7 @@ namespace util::random {
     std::enable_if_t<std::is_floating_point_v<T>,T>
     uniform (T lo, T hi)
     {
-        return std::uniform_real_distribution { lo, hi } (generator ());
+        return std::uniform_real_distribution<T> { lo, hi } (generator ());
     }
 
 
@@ -48,7 +48,7 @@ namespace util::random {
     std::enable_if_t<std::is_integral_v<T>,T>
     uniform (T lo, T hi)
     {
-        return std::uniform_int_distribution { lo, hi } (generator ());
+        return std::uniform_int_distribution<T> { lo, hi } (generator ());
     }
 
 

From a91df8895dbc75955ef48f1ab512cae65b9e2bb2 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 29 Aug 2017 12:19:58 +1000
Subject: [PATCH 089/149] geom: prefer inline implementation over ipp

---
 CMakeLists.txt |  1 -
 geom/aabb.hpp  | 22 +++++++++++++++++++++-
 geom/aabb.ipp  | 43 -------------------------------------------
 3 files changed, 21 insertions(+), 45 deletions(-)
 delete mode 100644 geom/aabb.ipp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index fbee8d3b..0118de99 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -230,7 +230,6 @@ list (
     geom/fwd.hpp
     geom/aabb.cpp
     geom/aabb.hpp
-    geom/aabb.ipp
     geom/cylinder.cpp
     geom/cylinder.hpp
     geom/ellipse.cpp
diff --git a/geom/aabb.hpp b/geom/aabb.hpp
index a471136c..de82c9a2 100644
--- a/geom/aabb.hpp
+++ b/geom/aabb.hpp
@@ -79,6 +79,26 @@ namespace util::geom {
     typedef aabb<3,int> aabb3i;
 }
 
-#include "aabb.ipp"
+
+///////////////////////////////////////////////////////////////////////////////
+#include "./sample.hpp"
+
+#include <random>
+
+namespace util::geom {
+    template <size_t S, typename T, typename G>
+    struct sampler<S,T,aabb,G> {
+        static point<S,T>
+        fn (aabb<S,T> b, G &g)
+        {
+            std::uniform_real_distribution<T> d;
+
+            point<S,T> p;
+            std::generate (p.begin (), p.end (), [&] (void) { return d (g); });
+
+            return p * (b.p1 - b.p0) + b.p0.template as<util::vector> ();
+        }
+    };
+}
 
 #endif
diff --git a/geom/aabb.ipp b/geom/aabb.ipp
deleted file mode 100644
index 6e13332e..00000000
--- a/geom/aabb.ipp
+++ /dev/null
@@ -1,43 +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>
- */
-
-#if defined(__UTIL_GEOM_AABB_IPP)
-#error
-#endif
-
-#define __UTIL_GEOM_AABB_IPP
-
-#include "sample.hpp"
-
-#include <random>
-
-
-///////////////////////////////////////////////////////////////////////////////
-namespace util::geom {
-    template <size_t S, typename T, typename G>
-    struct sampler<S,T,aabb,G> {
-        static point<S,T>
-        fn (aabb<S,T> b, G &g)
-        {
-            std::uniform_real_distribution<T> d;
-
-            point<S,T> p;
-            std::generate (p.begin (), p.end (), [&] (void) { return d (g); });
-
-            return p * (b.p1 - b.p0) + b.p0.template as<util::vector> ();
-        }
-    };
-}

From 2cb5fd7391538de18902b4b78743160acb871cef Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 29 Aug 2017 12:21:03 +1000
Subject: [PATCH 090/149] geom/sample: prefer inline impl over ipp files

---
 CMakeLists.txt   |  1 -
 geom/ellipse.cpp |  7 ++++---
 geom/ops.hpp     |  2 +-
 geom/sample.hpp  | 37 ++++++++++++++++++++++++++++++++-----
 geom/sample.ipp  | 45 ---------------------------------------------
 5 files changed, 37 insertions(+), 55 deletions(-)
 delete mode 100644 geom/sample.ipp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 0118de99..6ebaec42 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -245,7 +245,6 @@ list (
     geom/rect.cpp
     geom/rect.hpp
     geom/sample.hpp
-    geom/sample.ipp
     geom/sphere.cpp
     geom/sphere.hpp
     geom/tri.cpp
diff --git a/geom/ellipse.cpp b/geom/ellipse.cpp
index e0516b19..530339cd 100644
--- a/geom/ellipse.cpp
+++ b/geom/ellipse.cpp
@@ -11,12 +11,13 @@
  * 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>
  */
 
-#include "ellipse.hpp"
+#include "./ellipse.hpp"
 
-#include "ops.hpp"
+#include "./ops.hpp"
+#include "./aabb.hpp"
 
 using util::geom::ellipse;
 
diff --git a/geom/ops.hpp b/geom/ops.hpp
index e0f5f979..304edc20 100644
--- a/geom/ops.hpp
+++ b/geom/ops.hpp
@@ -17,7 +17,7 @@
 #ifndef __UTIL_GEOM_OPS_HPP
 #define __UTIL_GEOM_OPS_HPP
 
-#include "aabb.hpp"
+#include "./fwd.hpp"
 #include "../point.hpp"
 
 
diff --git a/geom/sample.hpp b/geom/sample.hpp
index bf11741f..bf4cc88a 100644
--- a/geom/sample.hpp
+++ b/geom/sample.hpp
@@ -11,17 +11,32 @@
  * 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_GEOM_SAMPLE_HPP
 #define __UTIL_GEOM_SAMPLE_HPP
 
-#include "../point.hpp"
+#include "../coord/fwd.hpp"
+#include "./ops.hpp"
+
+#include <cstddef>
 
 
 ///////////////////////////////////////////////////////////////////////////////
 namespace util::geom {
+    /// a function object that selects a uniformly random point inside a shape
+    /// using a provided random generator. the point will lie within the shape,
+    /// inclusive of boundaries.
+    ///
+    /// may be specialised for arbitrary shapes but uses rejection sampling
+    /// as a safe default. this implies that execution may not take a constant
+    /// time.
+    ///
+    /// \tparam S coordinate type dimension
+    /// \tparam T value type for the shape/coordinate
+    /// \tparam K the shape type to test
+    /// \tparam G a UniformRandomBitGenerator, eg std::min19937
     template <
         size_t S,
         typename T,
@@ -29,9 +44,23 @@ namespace util::geom {
         typename G
     >
     struct sampler {
-        static point<S,T> fn (K<S,T>, G&);
+        static point<S,T>
+        fn (K<S,T> k, G &g)
+        {
+            auto b = bounds (k);
+
+            while (true) {
+                auto p = sample (b, g);
+                if (intersects (k, p))
+                    return p;
+            }
+        }
     };
 
+
+    ///////////////////////////////////////////////////////////////////////////
+    /// a convenience function that calls sample::fn to select a random point
+    /// in a provided shape.
     template <
         size_t S,
         typename T,
@@ -45,6 +74,4 @@ namespace util::geom {
     }
 }
 
-#include "sample.ipp"
-
 #endif
diff --git a/geom/sample.ipp b/geom/sample.ipp
deleted file mode 100644
index d74f53c9..00000000
--- a/geom/sample.ipp
+++ /dev/null
@@ -1,45 +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>
- */
-
-#if defined(__UTIL_GEOM_SAMPLE_IPP)
-#error
-#endif
-
-#define __UTIL_GEOM_SAMPLE_IPP
-
-#include "ops.hpp"
-
-namespace util::geom {
-    // use rejection sampling by default
-    template <
-        size_t S,
-        typename T,
-        template <size_t,typename> class K,
-        typename G
-    >
-    point<S,T>
-    sampler<S,T,K,G>::fn (K<S,T> k, G &g)
-    {
-        auto b = bounds (k);
-
-        while (true) {
-            auto p = sample (b, g);
-            if (intersects (k, p))
-                return p;
-        }
-    }
-}
-

From 417175b2dd027d8e56f77b678e0d26d6aa06cb4e Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 29 Aug 2017 12:28:59 +1000
Subject: [PATCH 091/149] alloc/arena: add descriptive comment for arena

---
 alloc/arena.hpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/alloc/arena.hpp b/alloc/arena.hpp
index a61939bb..16be21dd 100644
--- a/alloc/arena.hpp
+++ b/alloc/arena.hpp
@@ -23,6 +23,8 @@
 #include <utility>
 
 namespace util::alloc {
+    /// wraps a block allocator with an interface suitable for allocating
+    /// individual objects.
     template <class T>
     class arena {
     public:

From 9d5e5992464cfb2bf9ad0fa7f540b0381d58f8fa Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 29 Aug 2017 16:53:11 +1000
Subject: [PATCH 092/149] alloc: seperate out the raw allocators from the
 adapters

---
 CMakeLists.txt               | 28 ++++++++++++++--------------
 alloc/fallback.cpp           |  1 -
 alloc/fwd.hpp                | 21 ++++++++++++---------
 alloc/{ => raw}/affix.cpp    |  3 ++-
 alloc/{ => raw}/affix.hpp    | 15 +++++++++++----
 alloc/{ => raw}/aligned.hpp  |  6 +++---
 alloc/{ => raw}/dynamic.hpp  |  6 +++---
 alloc/raw/fallback.cpp       | 17 +++++++++++++++++
 alloc/{ => raw}/fallback.hpp | 20 ++++++++++++++------
 alloc/{ => raw}/linear.cpp   |  6 +++---
 alloc/{ => raw}/linear.hpp   |  6 +++---
 alloc/{ => raw}/malloc.cpp   |  4 ++--
 alloc/{ => raw}/malloc.hpp   |  8 ++++----
 alloc/{ => raw}/null.cpp     |  4 ++--
 alloc/{ => raw}/null.hpp     |  6 +++---
 alloc/{ => raw}/stack.cpp    |  8 ++++----
 alloc/{ => raw}/stack.hpp    |  6 +++---
 alloc/{ => raw}/stack.ipp    |  4 ++--
 test/alloc/aligned.cpp       |  6 +++---
 test/alloc/arena.cpp         |  9 ++++++---
 test/alloc/dynamic.cpp       |  9 +++++----
 test/alloc/linear.cpp        |  5 +++--
 test/alloc/stack.cpp         |  6 +++---
 23 files changed, 122 insertions(+), 82 deletions(-)
 delete mode 100644 alloc/fallback.cpp
 rename alloc/{ => raw}/affix.cpp (95%)
 rename alloc/{ => raw}/affix.hpp (66%)
 rename alloc/{ => raw}/aligned.hpp (96%)
 rename alloc/{ => raw}/dynamic.hpp (98%)
 create mode 100644 alloc/raw/fallback.cpp
 rename alloc/{ => raw}/fallback.hpp (63%)
 rename alloc/{ => raw}/linear.cpp (97%)
 rename alloc/{ => raw}/linear.hpp (93%)
 rename alloc/{ => raw}/malloc.cpp (96%)
 rename alloc/{ => raw}/malloc.hpp (88%)
 rename alloc/{ => raw}/null.cpp (97%)
 rename alloc/{ => raw}/null.hpp (93%)
 rename alloc/{ => raw}/stack.cpp (97%)
 rename alloc/{ => raw}/stack.hpp (93%)
 rename alloc/{ => raw}/stack.ipp (89%)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 6ebaec42..afae28d3 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -150,26 +150,26 @@ list (
     algo/sort.hpp
     algo/sort.ipp
     alloc/fwd.hpp
-    alloc/affix.cpp
-    alloc/affix.hpp
-    alloc/aligned.hpp
     alloc/allocator.cpp
     alloc/allocator.hpp
     alloc/allocator.ipp
     alloc/arena.cpp
     alloc/arena.hpp
     alloc/arena.ipp
-    alloc/dynamic.hpp
-    alloc/fallback.cpp
-    alloc/fallback.hpp
-    alloc/linear.cpp
-    alloc/linear.hpp
-    alloc/malloc.cpp
-    alloc/malloc.hpp
-    alloc/null.cpp
-    alloc/null.hpp
-    alloc/stack.cpp
-    alloc/stack.hpp
+    alloc/raw/affix.cpp
+    alloc/raw/affix.hpp
+    alloc/raw/aligned.hpp
+    alloc/raw/dynamic.hpp
+    alloc/raw/fallback.cpp
+    alloc/raw/fallback.hpp
+    alloc/raw/linear.cpp
+    alloc/raw/linear.hpp
+    alloc/raw/malloc.cpp
+    alloc/raw/malloc.hpp
+    alloc/raw/null.cpp
+    alloc/raw/null.hpp
+    alloc/raw/stack.cpp
+    alloc/raw/stack.hpp
     annotation.hpp
     ascii.hpp
     backtrace.hpp
diff --git a/alloc/fallback.cpp b/alloc/fallback.cpp
deleted file mode 100644
index 76435d99..00000000
--- a/alloc/fallback.cpp
+++ /dev/null
@@ -1 +0,0 @@
-#include "./fallback.hpp"
diff --git a/alloc/fwd.hpp b/alloc/fwd.hpp
index d9e3ac57..cb3fd8a5 100644
--- a/alloc/fwd.hpp
+++ b/alloc/fwd.hpp
@@ -19,17 +19,20 @@
 
 
 namespace util::alloc {
-    class affix;
-    class fallback;
-    class linear;
-    class malloc;
-    class null;
-    class stack;
+    namespace raw {
+        class affix;
+        class fallback;
+        class linear;
+        class malloc;
+        class null;
+        class stack;
 
-    class dynamic;
+        class dynamic;
+
+        template <typename AllocT>
+        class aligned;
+    }
 
-    template <typename AllocT>
-    class aligned;
 
     template <typename T> class arena;
     template <typename B, typename T> class allocator;
diff --git a/alloc/affix.cpp b/alloc/raw/affix.cpp
similarity index 95%
rename from alloc/affix.cpp
rename to alloc/raw/affix.cpp
index 87f37ba4..7f5f681a 100644
--- a/alloc/affix.cpp
+++ b/alloc/raw/affix.cpp
@@ -16,7 +16,8 @@
 
 #include "./affix.hpp"
 
-using util::alloc::affix;
+using util::alloc::raw::affix;
 
 
 ///////////////////////////////////////////////////////////////////////////////
+
diff --git a/alloc/affix.hpp b/alloc/raw/affix.hpp
similarity index 66%
rename from alloc/affix.hpp
rename to alloc/raw/affix.hpp
index a337280a..1cb0111d 100644
--- a/alloc/affix.hpp
+++ b/alloc/raw/affix.hpp
@@ -14,13 +14,20 @@
  * Copyright 2015 Danny Robson <danny@nerdcruft.net>
  */
 
-#ifndef __UTIL_ALLOC_AFFIX_HPP
-#define __UTIL_ALLOC_AFFIX_HPP
+#ifndef CRUFT_UTIL_ALLOC_RAW_AFFIX_HPP
+#define CRUFT_UTIL_ALLOC_RAW_AFFIX_HPP
 
 #include <cstddef>
 
-namespace util::alloc {
-    template <class parent, class prefix, class suffix>
+namespace util::alloc::raw {
+    /// a raw memory allocator which initialises an instance of PrefixT
+    /// immediately before each allocation and, if specified, an instance
+    /// of SuffixT after the allocation.
+    ///
+    /// uses an instance of ParentT to actually perform the bulk allocations.
+    ///
+    /// useful for sentinels, reference counts, etc.
+    template <class ParentT, class PrefixT, class SuffixT>
     class affix {
         void* allocate   (size_t bytes);
         void* allocate   (size_t bytes, size_t align);
diff --git a/alloc/aligned.hpp b/alloc/raw/aligned.hpp
similarity index 96%
rename from alloc/aligned.hpp
rename to alloc/raw/aligned.hpp
index 2cd034d0..dcd7e881 100644
--- a/alloc/aligned.hpp
+++ b/alloc/raw/aligned.hpp
@@ -14,10 +14,10 @@
  * Copyright 2016 Danny Robson <danny@nerdcruft.net>
  */
 
-#ifndef __CRUFT_UTIL_ALLOC_ALIGNED_HPP
-#define __CRUFT_UTIL_ALLOC_ALIGNED_HPP
+#ifndef CRUFT_UTIL_ALLOC_RAW_ALIGNED_HPP
+#define CRUFT_UTIL_ALLOC_RAW_ALIGNED_HPP
 
-namespace util::alloc {
+namespace util::alloc::raw {
     /// wraps a child allocator and enforces a fixed alignment
     template <typename ChildT>
     class aligned {
diff --git a/alloc/dynamic.hpp b/alloc/raw/dynamic.hpp
similarity index 98%
rename from alloc/dynamic.hpp
rename to alloc/raw/dynamic.hpp
index 62b1ce5f..931faf29 100644
--- a/alloc/dynamic.hpp
+++ b/alloc/raw/dynamic.hpp
@@ -14,13 +14,13 @@
  * Copyright 2016 Danny Robson <danny@nerdcruft.net>
  */
 
-#ifndef __UTIL_ALLOC_DYNAMIC_HPP
-#define __UTIL_ALLOC_DYNAMIC_HPP
+#ifndef CRUFT_UTIL_ALLOC_RAW_DYNAMIC_HPP
+#define CRUFT_UTIL_ALLOC_RAW_DYNAMIC_HPP
 
 #include <cstddef>
 #include <memory>
 
-namespace util::alloc {
+namespace util::alloc::raw {
     // wraps an allocator given at construction time, forwarding all calls to
     // the inner object. used to allow virtual dispatch of the non-virtual
     // allocator interface.
diff --git a/alloc/raw/fallback.cpp b/alloc/raw/fallback.cpp
new file mode 100644
index 00000000..1c1762f0
--- /dev/null
+++ b/alloc/raw/fallback.cpp
@@ -0,0 +1,17 @@
+/*
+ * 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 "./fallback.hpp"
diff --git a/alloc/fallback.hpp b/alloc/raw/fallback.hpp
similarity index 63%
rename from alloc/fallback.hpp
rename to alloc/raw/fallback.hpp
index e4a2e875..22ec0b32 100644
--- a/alloc/fallback.hpp
+++ b/alloc/raw/fallback.hpp
@@ -11,25 +11,33 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
- * Copyright 2015 Danny Robson <danny@nerdcruft.net>
+ * Copyright 2015-2017 Danny Robson <danny@nerdcruft.net>
  */
 
-#ifndef __UTIL_ALLOC_FALLBACK_HPP
-#define __UTIL_ALLOC_FALLBACK_HPP
+#ifndef CRUFT_UTIL_ALLOC_RAW_FALLBACK_HPP
+#define CRUFT_UTIL_ALLOC_RAW_FALLBACK_HPP
 
 #include <cstddef>
+#include <tuple>
 
-namespace util::alloc {
-    template <class A, class B>
+namespace util::alloc::raw {
+    /// A raw memory allocator that allocates memory series of child
+    /// allocators, preferring earlier allocators.
+    template <typename ...ChildT>
     class fallback {
     public:
-        fallback (A&, B&);
+        fallback (ChildT &..._children):
+            m_children (_children...)
+        { ; }
 
         void* allocate (size_t bytes);
         void* allocate (size_t bytes, size_t align);
 
         void deallocate (void *ptr, size_t bytes);
         void deallocate (void *ptr, size_t bytes, size_t align);
+
+    private:
+        std::tuple<ChildT&...> m_children;
     };
 }
 
diff --git a/alloc/linear.cpp b/alloc/raw/linear.cpp
similarity index 97%
rename from alloc/linear.cpp
rename to alloc/raw/linear.cpp
index cd61b5a3..5c1d47e9 100644
--- a/alloc/linear.cpp
+++ b/alloc/raw/linear.cpp
@@ -16,10 +16,10 @@
 
 #include "./linear.hpp"
 
-#include "../pointer.hpp"
-#include "../debug.hpp"
+#include "../../pointer.hpp"
+#include "../../debug.hpp"
 
-using util::alloc::linear;
+using util::alloc::raw::linear;
 
 
 ///////////////////////////////////////////////////////////////////////////////
diff --git a/alloc/linear.hpp b/alloc/raw/linear.hpp
similarity index 93%
rename from alloc/linear.hpp
rename to alloc/raw/linear.hpp
index 07c4d82e..aec0f475 100644
--- a/alloc/linear.hpp
+++ b/alloc/raw/linear.hpp
@@ -14,12 +14,12 @@
  * Copyright 2015 Danny Robson <danny@nerdcruft.net>
  */
 
-#ifndef __UTIL_ALLOC_LINEAR_HPP
-#define __UTIL_ALLOC_LINEAR_HPP
+#ifndef CRUFT_UTIL_ALLOC_RAW_LINEAR_HPP
+#define CRUFT_UTIL_ALLOC_RAW_LINEAR_HPP
 
 #include <cstddef>
 
-namespace util::alloc {
+namespace util::alloc::raw {
     // allocate progressively across a buffer without concern for deallocation.
     // deallocation is a noop; the only way to free allocations is via reset.
     class linear {
diff --git a/alloc/malloc.cpp b/alloc/raw/malloc.cpp
similarity index 96%
rename from alloc/malloc.cpp
rename to alloc/raw/malloc.cpp
index cc5afd1e..4901c92a 100644
--- a/alloc/malloc.cpp
+++ b/alloc/raw/malloc.cpp
@@ -16,11 +16,11 @@
 
 #include "./malloc.hpp"
 
-#include "../debug.hpp"
+#include "../../debug.hpp"
 
 #include <cstdlib>
 
-using util::alloc::malloc;
+using util::alloc::raw::malloc;
 
 
 ///////////////////////////////////////////////////////////////////////////////
diff --git a/alloc/malloc.hpp b/alloc/raw/malloc.hpp
similarity index 88%
rename from alloc/malloc.hpp
rename to alloc/raw/malloc.hpp
index 8137ce80..cdaaf93a 100644
--- a/alloc/malloc.hpp
+++ b/alloc/raw/malloc.hpp
@@ -14,13 +14,13 @@
  * Copyright 2015 Danny Robson <danny@nerdcruft.net>
  */
 
-#ifndef __UTIL_ALLOC_MALLOC_HPP
-#define __UTIL_ALLOC_MALLOC_HPP
+#ifndef CRUFT_UTIL_ALLOC_RAW_MALLOC_HPP
+#define CRUFT_UTIL_ALLOC_RAW_MALLOC_HPP
 
 #include <cstddef>
 
 
-namespace util::alloc {
+namespace util::alloc::raw {
     class malloc {
     public:
         void* allocate (size_t bytes);
@@ -32,4 +32,4 @@ namespace util::alloc {
 }
 
 
-#endif
+#endif
\ No newline at end of file
diff --git a/alloc/null.cpp b/alloc/raw/null.cpp
similarity index 97%
rename from alloc/null.cpp
rename to alloc/raw/null.cpp
index 7e041fa6..11070fb4 100644
--- a/alloc/null.cpp
+++ b/alloc/raw/null.cpp
@@ -17,11 +17,11 @@
 
 #include "./null.hpp"
 
-#include "../debug.hpp"
+#include "../../debug.hpp"
 
 #include <new>
 
-using util::alloc::null;
+using util::alloc::raw::null;
 
 
 ///////////////////////////////////////////////////////////////////////////////
diff --git a/alloc/null.hpp b/alloc/raw/null.hpp
similarity index 93%
rename from alloc/null.hpp
rename to alloc/raw/null.hpp
index 162b7800..971a5f48 100644
--- a/alloc/null.hpp
+++ b/alloc/raw/null.hpp
@@ -14,13 +14,13 @@
  * Copyright 2015 Danny Robson <danny@nerdcruft.net>
  */
 
-#ifndef __UTIL_ALLOC_NULL_HPP
-#define __UTIL_ALLOC_NULL_HPP
+#ifndef CRUFT_UTIL_ALLOC_RAW_NULL_HPP
+#define CRUFT_UTIL_ALLOC_RAW_NULL_HPP
 
 #include <cstddef>
 
 
-namespace util::alloc {
+namespace util::alloc::raw {
     // allocator that always fails, throwing bad_alloc. deallocate will
     // succeed with nullptr as with delete, but is undefined with other values
     // (it is likely to at least assert).
diff --git a/alloc/stack.cpp b/alloc/raw/stack.cpp
similarity index 97%
rename from alloc/stack.cpp
rename to alloc/raw/stack.cpp
index 3956fd65..7d05ea0b 100644
--- a/alloc/stack.cpp
+++ b/alloc/raw/stack.cpp
@@ -16,11 +16,11 @@
 
 #include "./stack.hpp"
 
-#include "../debug.hpp"
-#include "../pointer.hpp"
-#include "../cast.hpp"
+#include "../../debug.hpp"
+#include "../../pointer.hpp"
+#include "../../cast.hpp"
 
-using util::alloc::stack;
+using util::alloc::raw::stack;
 
 
 ///////////////////////////////////////////////////////////////////////////////
diff --git a/alloc/stack.hpp b/alloc/raw/stack.hpp
similarity index 93%
rename from alloc/stack.hpp
rename to alloc/raw/stack.hpp
index 272ba54a..c2aac44c 100644
--- a/alloc/stack.hpp
+++ b/alloc/raw/stack.hpp
@@ -14,13 +14,13 @@
  * Copyright 2015 Danny Robson <danny@nerdcruft.net>
  */
 
-#ifndef __UTIL_ALLOC_STACK_HPP
-#define __UTIL_ALLOC_STACK_HPP
+#ifndef CRUFT_UTIL_ALLOC_RAW_STACK_HPP
+#define CRUFT_UTIL_ALLOC_RAW_STACK_HPP
 
 #include <cstddef>
 
 
-namespace util::alloc {
+namespace util::alloc::raw {
     // allocate memory from a buffer in a stacklike manner. deallocation that
     // is not correctly ordered has undefined (read 'bad') results.
     class stack {
diff --git a/alloc/stack.ipp b/alloc/raw/stack.ipp
similarity index 89%
rename from alloc/stack.ipp
rename to alloc/raw/stack.ipp
index c779ae58..d3248e0f 100644
--- a/alloc/stack.ipp
+++ b/alloc/raw/stack.ipp
@@ -14,10 +14,10 @@
  * Copyright 2015 Danny Robson <danny@nerdcruft.net>
  */
 
-#ifdef __UTIL_ALLOC_STACK_IPP
+#ifdef CRUFT_UTIL_ALLOC_RAW_STACK_IPP
 #error
 #endif
 
-#define __UTIL_ALLOC_STACK_IPP
+#define CRUFT_UTIL_ALLOC_RAW_STACK_IPP
 
 
diff --git a/test/alloc/aligned.cpp b/test/alloc/aligned.cpp
index 71fae127..22faa649 100644
--- a/test/alloc/aligned.cpp
+++ b/test/alloc/aligned.cpp
@@ -1,7 +1,7 @@
 #include "tap.hpp"
 
-#include "alloc/aligned.hpp"
-#include "alloc/linear.hpp"
+#include "alloc/raw/aligned.hpp"
+#include "alloc/raw/linear.hpp"
 
 
 int
@@ -20,7 +20,7 @@ main (int, char**)
     // we're probably operating correctly. 
     static constexpr std::size_t alignment = 3;
 
-    util::alloc::aligned<util::alloc::linear> alloc (
+    util::alloc::raw::aligned<util::alloc::raw::linear> alloc (
         alignment, std::begin (buffer), std::end (buffer)
     );
 
diff --git a/test/alloc/arena.cpp b/test/alloc/arena.cpp
index 4813ad26..6ea41e32 100644
--- a/test/alloc/arena.cpp
+++ b/test/alloc/arena.cpp
@@ -1,11 +1,13 @@
 #include "tap.hpp"
 #include "alloc/arena.hpp"
-#include "alloc/linear.hpp"
+#include "alloc/raw/linear.hpp"
 
 
+///////////////////////////////////////////////////////////////////////////////
 static char g_backing[1024*1024];
 
 
+//-----------------------------------------------------------------------------
 struct setter {
     setter (const setter&) = delete;
 
@@ -20,11 +22,12 @@ struct setter {
 };
 
 
+//-----------------------------------------------------------------------------
 int
 main (void)
 {
-    util::alloc::linear alloc (std::begin (g_backing), std::end (g_backing));
-    util::alloc::arena<util::alloc::linear>  arena (alloc);
+    util::alloc::raw::linear alloc (std::begin (g_backing), std::end (g_backing));
+    util::alloc::arena<util::alloc::raw::linear>  arena (alloc);
 
     util::TAP::logger tap;
 
diff --git a/test/alloc/dynamic.cpp b/test/alloc/dynamic.cpp
index f669a4d9..ca39bd71 100644
--- a/test/alloc/dynamic.cpp
+++ b/test/alloc/dynamic.cpp
@@ -1,14 +1,15 @@
-
 #include "tap.hpp"
-#include "alloc/dynamic.hpp"
-#include "alloc/null.hpp"
+#include "alloc/raw/dynamic.hpp"
+#include "alloc/raw/null.hpp"
 
+
+///////////////////////////////////////////////////////////////////////////////
 int
 main (void)
 {
     util::TAP::logger tap;
 
-    auto obj = util::alloc::dynamic::make<util::alloc::null> ();
+    auto obj = util::alloc::raw::dynamic::make<util::alloc::raw::null> ();
 
     tap.expect_throw<std::bad_alloc> (
         [&] (void) {
diff --git a/test/alloc/linear.cpp b/test/alloc/linear.cpp
index e8800d70..0e94c68b 100644
--- a/test/alloc/linear.cpp
+++ b/test/alloc/linear.cpp
@@ -1,7 +1,8 @@
 #include "tap.hpp"
-#include "alloc/linear.hpp"
+#include "alloc/raw/linear.hpp"
 
 
+///////////////////////////////////////////////////////////////////////////////
 int
 main (void)
 {
@@ -10,7 +11,7 @@ main (void)
     constexpr size_t BUFFER_SIZE = 1024;
 
     alignas (std::max_align_t) char memory[BUFFER_SIZE];
-    util::alloc::linear store (std::begin (memory), std::end (memory));
+    util::alloc::raw::linear store (std::begin (memory), std::end (memory));
 
     tap.expect_eq (store.base (), std::begin (memory), "base pointers match");
     tap.expect_eq (store.offset (std::begin (memory)), 0u, "base offset is 0");
diff --git a/test/alloc/stack.cpp b/test/alloc/stack.cpp
index a52b6b5d..0c383c5c 100644
--- a/test/alloc/stack.cpp
+++ b/test/alloc/stack.cpp
@@ -1,10 +1,10 @@
 #include "tap.hpp"
-#include "alloc/stack.hpp"
+#include "alloc/raw/stack.hpp"
 
 
 ///////////////////////////////////////////////////////////////////////////////
 void
-n_allocations (util::alloc::stack &store,
+n_allocations (util::alloc::raw::stack &store,
                unsigned count,
                size_t bytes,
                size_t alignment = alignof (std::max_align_t))
@@ -32,7 +32,7 @@ main (void)
     alignas (std::max_align_t) char memory[BUFFER_SIZE];
     std::fill (std::begin (memory), std::end (memory), 0);
 
-    util::alloc::stack store (memory, memory + BUFFER_AVAILABLE);
+    util::alloc::raw::stack store (memory, memory + BUFFER_AVAILABLE);
 
     tap.expect_eq (store.base (), std::begin (memory), "base pointers match");
     tap.expect_eq (store.offset (std::begin (memory)), 0u, "base offset is 0");

From cfc8cb56914a3101669d1063b626e6cef918b4ca Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 29 Aug 2017 16:59:54 +1000
Subject: [PATCH 093/149] allow/raw/stack: remove unused ipp file

---
 alloc/raw/stack.ipp | 23 -----------------------
 1 file changed, 23 deletions(-)
 delete mode 100644 alloc/raw/stack.ipp

diff --git a/alloc/raw/stack.ipp b/alloc/raw/stack.ipp
deleted file mode 100644
index d3248e0f..00000000
--- a/alloc/raw/stack.ipp
+++ /dev/null
@@ -1,23 +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>
- */
-
-#ifdef CRUFT_UTIL_ALLOC_RAW_STACK_IPP
-#error
-#endif
-
-#define CRUFT_UTIL_ALLOC_RAW_STACK_IPP
-
-

From 9da28a64c9f75ffbeef84cd30e42b101d5d2fd80 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Wed, 30 Aug 2017 13:42:49 +1000
Subject: [PATCH 094/149] memory/deleter: use more descriptive template param
 names

---
 memory/deleter.hpp | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/memory/deleter.hpp b/memory/deleter.hpp
index 5921afcf..7d6d7c5e 100644
--- a/memory/deleter.hpp
+++ b/memory/deleter.hpp
@@ -42,20 +42,24 @@ namespace util::memory {
     // XXX: Generates a "sorry, unimplemented" under GCC (which is
     // effectively an ICE). Their bug tracker seems to indicate they don't
     // give a fuck, so we can't use this except under clang.
-    template <typename T, typename U, void (U::*F)(T*)>
+    template <
+        typename ValueT,
+        typename OwnerT,
+        void (OwnerT::*Func)(ValueT*)
+    >
     class owner_deleter {
     public:
-        owner_deleter (U &owner):
+        owner_deleter (OwnerT &owner):
             m_owner (owner)
         { ; }
 
-        inline void operator() (T *t)
+        inline void operator() (ValueT *t)
         {
-            (m_owner.*F) (t);
+            (m_owner.*Func) (t);
         }
 
     private:
-        U& m_owner;
+        OwnerT& m_owner;
     };
 }
 

From 4a929813792bd6d72f1c0aa43b6285299a4560fd Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Wed, 30 Aug 2017 15:13:24 +1000
Subject: [PATCH 095/149] view: we really don't need a dedicated find function

---
 view.hpp | 10 +---------
 1 file changed, 1 insertion(+), 9 deletions(-)

diff --git a/view.hpp b/view.hpp
index 718a758f..fd2cb02b 100644
--- a/view.hpp
+++ b/view.hpp
@@ -63,15 +63,6 @@ namespace util {
         auto data (void)       { return begin (); }
         auto data (void) const { return begin (); }
 
-        constexpr T
-        find (const value_type &v) const noexcept
-        {
-            for (T i = cbegin (); i != cend (); ++i)
-                if (*i == v)
-                    return i;
-            return cend ();
-        }
-
         constexpr bool
         empty (void) const noexcept
         {
@@ -112,6 +103,7 @@ namespace util {
         T m_end;
     };
 
+
     template <typename T, size_t N>
     auto
     make_view (const T (&arr)[N])

From 0f4fece00f2a2649f998242ddf3f18e4d03559cf Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Wed, 30 Aug 2017 15:13:43 +1000
Subject: [PATCH 096/149] alloc/raw/linear: add constructor from range types

---
 alloc/raw/linear.cpp | 1 -
 alloc/raw/linear.hpp | 6 ++++++
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/alloc/raw/linear.cpp b/alloc/raw/linear.cpp
index 5c1d47e9..65d7097a 100644
--- a/alloc/raw/linear.cpp
+++ b/alloc/raw/linear.cpp
@@ -30,7 +30,6 @@ linear::linear (void *begin, void *end):
 {
     CHECK_NEZ (begin);
     CHECK_NEZ (end);
-
     CHECK_LE (begin, end);
 }
 
diff --git a/alloc/raw/linear.hpp b/alloc/raw/linear.hpp
index aec0f475..f5df05cb 100644
--- a/alloc/raw/linear.hpp
+++ b/alloc/raw/linear.hpp
@@ -18,6 +18,7 @@
 #define CRUFT_UTIL_ALLOC_RAW_LINEAR_HPP
 
 #include <cstddef>
+#include <iterator>
 
 namespace util::alloc::raw {
     // allocate progressively across a buffer without concern for deallocation.
@@ -31,6 +32,11 @@ namespace util::alloc::raw {
 
         linear (void *begin, void *end);
 
+        template <typename T>
+        linear (T &&view):
+            linear (std::begin (view), std::end (view))
+        { ; }
+
         void* allocate (size_t bytes);
         void* allocate (size_t bytes, size_t alignment);
 

From 4826b4c4661b0c50c23966dc56b442aed0e9e980 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Wed, 30 Aug 2017 15:23:42 +1000
Subject: [PATCH 097/149] maths: add some comments to rounding functions

---
 maths.hpp | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/maths.hpp b/maths.hpp
index 475666ea..d5e146e7 100644
--- a/maths.hpp
+++ b/maths.hpp
@@ -253,7 +253,7 @@ namespace util {
 
 
     ///////////////////////////////////////////////////////////////////////////////
-    // Rounding
+    /// round T up to the nearest multiple of U
     template <typename T, typename U>
     inline
     typename std::common_type<
@@ -262,14 +262,13 @@ namespace util {
     >::type
     round_to (T value, U size)
     {
-        if (value % size == 0)
-            return value;
-
-        return value + (size - value % size);
+        auto remainder = value % size;
+        return value + size - remainder;
     }
 
 
-    //-----------------------------------------------------------------------------
+    ///----------------------------------------------------------------------------
+    /// round T up to the nearest power-of-2
     template <typename T>
     constexpr
     std::enable_if_t<
@@ -290,7 +289,8 @@ namespace util {
     }
 
 
-    //-----------------------------------------------------------------------------
+    ///----------------------------------------------------------------------------
+    /// round T up to the nearest multiple of U and return the quotient.
     template <typename T, typename U>
     constexpr std::enable_if_t<
         std::is_integral<T>::value &&

From 5126bb486c454de847bf21e808bfd89825be12f0 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Wed, 30 Aug 2017 15:37:39 +1000
Subject: [PATCH 098/149] maths: revert invalid 'simplification' of round_to

---
 maths.hpp | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/maths.hpp b/maths.hpp
index d5e146e7..4d420cc6 100644
--- a/maths.hpp
+++ b/maths.hpp
@@ -262,8 +262,11 @@ namespace util {
     >::type
     round_to (T value, U size)
     {
-        auto remainder = value % size;
-        return value + size - remainder;
+        // we perform this as two steps to avoid unnecessarily incrementing when
+        // remainder is zero.
+        if (value % size)
+            value += size - value % size;
+        return value;
     }
 
 

From 885b0b4669a53eecebd01ec31e87a0690f0e9d3b Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Wed, 30 Aug 2017 15:38:13 +1000
Subject: [PATCH 099/149] pointer: add some comments...

---
 pointer.hpp | 44 +++++++++++++++++++++++++++++++++++---------
 1 file changed, 35 insertions(+), 9 deletions(-)

diff --git a/pointer.hpp b/pointer.hpp
index c5ef3b13..bd55ccfc 100644
--- a/pointer.hpp
+++ b/pointer.hpp
@@ -11,11 +11,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
- * Copyright 2011 Danny Robson <danny@nerdcruft.net>
+ * Copyright 2011-2017 Danny Robson <danny@nerdcruft.net>
  */
 
-#ifndef __POINTER_HPP
-#define __POINTER_HPP
+#ifndef CRUFT_UTIL_POINTER_HPP
+#define CRUFT_UTIL_POINTER_HPP
 
 #include <cstddef>
 #include <cstdint>
@@ -23,10 +23,13 @@
 
 namespace util {
     ///////////////////////////////////////////////////////////////////////////
+    /// round the pointer upwards to satisfy the provided alignment
     template <typename T>
-    T*
+    constexpr T*
     align (T *_ptr, size_t alignment)
     {
+        // we perform this as two steps to avoid unnecessarily incrementing when
+        // remainder is zero.
         auto ptr = reinterpret_cast<uintptr_t> (_ptr);
         if (ptr % alignment)
             ptr += alignment - ptr % alignment;
@@ -34,13 +37,36 @@ namespace util {
     }
 
 
-    //-------------------------------------------------------------------------
-    inline uintptr_t
+    ///------------------------------------------------------------------------
+    /// round the pointer upwards to satisfy the provided alignment
+    constexpr inline uintptr_t
     align (uintptr_t ptr, size_t alignment)
     {
-        return reinterpret_cast<uintptr_t> (
-            align (reinterpret_cast<void*> (ptr), alignment)
-        );
+        // we perform this as two steps to avoid unnecessarily incrementing when
+        // remainder is zero.
+        if (ptr % alignment)
+            ptr += alignment - ptr % alignment;
+        return ptr;
+    }
+
+
+    ///------------------------------------------------------------------------
+    /// round the pointer upwards to the nearest valid alignment for T
+    template <typename T>
+    constexpr auto
+    align (T *t)
+    {
+        return align (t, alignof (T));
+    }
+
+
+    ///------------------------------------------------------------------------
+    /// round the pointer upwards to the nearest valid alignment for T
+    template <typename T>
+    constexpr auto
+    align (uintptr_t ptr)
+    {
+        return align (ptr, alignof (T));
     }
 }
 

From a9f8594b264eae4ba75d8f9d44ca7a253a671d0f Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Wed, 30 Aug 2017 15:39:02 +1000
Subject: [PATCH 100/149] maths: rename round_to as round_up

this shows more explicitly the rounding policy we're using
---
 maths.hpp                  | 2 +-
 memory/buffer/circular.cpp | 2 +-
 memory/buffer/paged.cpp    | 6 +++---
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/maths.hpp b/maths.hpp
index 4d420cc6..a921deab 100644
--- a/maths.hpp
+++ b/maths.hpp
@@ -260,7 +260,7 @@ namespace util {
         std::enable_if_t<std::is_integral<T>::value,T>,
         std::enable_if_t<std::is_integral<U>::value,U>
     >::type
-    round_to (T value, U size)
+    round_up (T value, U size)
     {
         // we perform this as two steps to avoid unnecessarily incrementing when
         // remainder is zero.
diff --git a/memory/buffer/circular.cpp b/memory/buffer/circular.cpp
index c44435d3..c58aabe7 100644
--- a/memory/buffer/circular.cpp
+++ b/memory/buffer/circular.cpp
@@ -57,7 +57,7 @@ tmpname (std::string &str, size_t length)
 circular::circular (size_t bytes)
 {
     bytes = max (bytes, sizeof (value_type));
-    bytes = round_to (bytes, pagesize ());
+    bytes = round_up (bytes, pagesize ());
 
     int fd = -1;
 
diff --git a/memory/buffer/paged.cpp b/memory/buffer/paged.cpp
index 5d937e90..8fb363f9 100644
--- a/memory/buffer/paged.cpp
+++ b/memory/buffer/paged.cpp
@@ -29,7 +29,7 @@ using util::memory::buffer::paged;
 
 ///////////////////////////////////////////////////////////////////////////////
 paged::paged (size_t bytes, size_t _window):
-    m_window (round_to (_window, pagesize ()))
+    m_window (round_up (_window, pagesize ()))
 {
     // reserve the address region with no access permissions
     m_begin = reinterpret_cast<char*> (
@@ -40,7 +40,7 @@ paged::paged (size_t bytes, size_t _window):
         errno_error::throw_code ();
 
     // remap the initial window with read/write permissions
-    m_cursor = m_begin + round_to (min (m_window, bytes), pagesize ());
+    m_cursor = m_begin + round_up (min (m_window, bytes), pagesize ());
     if (MAP_FAILED == mmap (m_begin,
                             m_cursor - m_begin,
                             PROT_READ | PROT_WRITE,
@@ -48,7 +48,7 @@ paged::paged (size_t bytes, size_t _window):
         errno_error::throw_code ();
 
     // record the nominal end address
-    m_end = m_begin + round_to (bytes, pagesize ());
+    m_end = m_begin + round_up (bytes, pagesize ());
 }
 
 

From 367fc1dcb12adc7a56ed5eabbedf6bef101ca7bf Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Thu, 31 Aug 2017 13:03:19 +1000
Subject: [PATCH 101/149] view: add redim operation

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

diff --git a/view.hpp b/view.hpp
index fd2cb02b..a7d3f8d5 100644
--- a/view.hpp
+++ b/view.hpp
@@ -24,6 +24,7 @@
 #include <ostream>
 #include <string>
 #include <cstring>
+#include <stdexcept>
 
 namespace util {
     template <typename T>
@@ -75,6 +76,14 @@ namespace util {
             return std::distance (m_begin, m_end);
         }
 
+        constexpr auto
+        redim (int count) const noexcept
+        {
+            if (count > size ())
+                throw std::invalid_argument ("redim to higher size not allowed");
+            return view { m_begin, m_begin + count };
+        };
+
         constexpr value_type&
         operator[] (size_t idx) noexcept
         {

From 0e97044adf8f0c198a3817d4e0f96ff3167e7edf Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Thu, 31 Aug 2017 13:48:33 +1000
Subject: [PATCH 102/149] allow/raw: rename base as begin

---
 alloc/raw/affix.hpp   |  4 ++--
 alloc/raw/aligned.hpp |  4 ++--
 alloc/raw/dynamic.hpp | 16 ++++++++--------
 alloc/raw/linear.cpp  |  4 ++--
 alloc/raw/linear.hpp  | 10 ++++++++--
 alloc/raw/null.cpp    |  4 ++--
 alloc/raw/null.hpp    |  4 ++--
 alloc/raw/stack.cpp   |  4 ++--
 alloc/raw/stack.hpp   |  4 ++--
 test/alloc/linear.cpp |  2 +-
 test/alloc/stack.cpp  |  2 +-
 11 files changed, 32 insertions(+), 26 deletions(-)

diff --git a/alloc/raw/affix.hpp b/alloc/raw/affix.hpp
index 1cb0111d..ef80effc 100644
--- a/alloc/raw/affix.hpp
+++ b/alloc/raw/affix.hpp
@@ -35,8 +35,8 @@ namespace util::alloc::raw {
         void  deallocate (void *ptr, size_t bytes);
         void  deallocate (void *ptr, size_t bytes, size_t align);
 
-        void* base (void);
-        const void* base (void) const;
+        void* begin (void);
+        const void* begin (void) const;
 
         size_t offset (const void*) const;
     };
diff --git a/alloc/raw/aligned.hpp b/alloc/raw/aligned.hpp
index dcd7e881..cd1d8fd0 100644
--- a/alloc/raw/aligned.hpp
+++ b/alloc/raw/aligned.hpp
@@ -66,8 +66,8 @@ namespace util::alloc::raw {
 
 
         ///////////////////////////////////////////////////////////////////////
-        auto base (void)       { return m_successor.base (); }
-        auto base (void) const { return m_successor.base (); }
+        auto begin (void)       { return m_successor.begin (); }
+        auto begin (void) const { return m_successor.begin (); }
 
 
         //---------------------------------------------------------------------
diff --git a/alloc/raw/dynamic.hpp b/alloc/raw/dynamic.hpp
index 931faf29..b7bd5418 100644
--- a/alloc/raw/dynamic.hpp
+++ b/alloc/raw/dynamic.hpp
@@ -57,8 +57,8 @@ namespace util::alloc::raw {
         auto deallocate (void *ptr, size_t bytes, size_t alignment) { return m_child->deallocate (ptr, bytes, alignment); }
 
         //---------------------------------------------------------------------
-        auto base (void)       { return m_child->base (); }
-        auto base (void) const { return m_child->base (); }
+        auto begin (void)       { return m_child->begin (); }
+        auto begin (void) const { return m_child->begin (); }
 
         auto offset (const void *ptr) const
         { return m_child->offset (ptr); }
@@ -93,8 +93,8 @@ namespace util::alloc::raw {
             virtual void deallocate (void *ptr, size_t bytes) = 0;
             virtual void deallocate (void *ptr, size_t bytes, size_t alignment) = 0;
 
-            virtual void*       base (void) = 0;
-            virtual const void* base (void) const = 0;
+            virtual void*       begin (void) = 0;
+            virtual const void* begin (void) const = 0;
             virtual size_t      offset (const void*) const = 0;
 
             virtual void reset (void) = 0;
@@ -133,12 +133,12 @@ namespace util::alloc::raw {
             { m_target.deallocate (ptr, bytes, alignment); }
 
             const void*
-            base (void) const override
-            { return m_target.base (); }
+            begin (void) const override
+            { return m_target.begin (); }
 
             void*
-            base (void) override
-            { return m_target.base (); }
+            begin (void) override
+            { return m_target.begin (); }
 
             size_t
             offset (const void *ptr) const override
diff --git a/alloc/raw/linear.cpp b/alloc/raw/linear.cpp
index 65d7097a..30501b0d 100644
--- a/alloc/raw/linear.cpp
+++ b/alloc/raw/linear.cpp
@@ -77,7 +77,7 @@ linear::deallocate (void *ptr, size_t bytes, size_t alignment)
 
 //-----------------------------------------------------------------------------
 void*
-linear::base (void)
+linear::begin (void)
 {
     return m_begin;
 }
@@ -85,7 +85,7 @@ linear::base (void)
 
 //-----------------------------------------------------------------------------
 const void*
-linear::base (void) const
+linear::begin (void) const
 {
     return m_begin;
 }
diff --git a/alloc/raw/linear.hpp b/alloc/raw/linear.hpp
index f5df05cb..82f496da 100644
--- a/alloc/raw/linear.hpp
+++ b/alloc/raw/linear.hpp
@@ -43,8 +43,14 @@ namespace util::alloc::raw {
         void  deallocate (void *ptr, size_t bytes);
         void  deallocate (void *ptr, size_t bytes, size_t alignment);
 
-        void* base (void);
-        const void* base (void) const;
+        void* begin (void);
+        void* end (void);
+        void* cursor (void);
+
+        const void* begin (void) const;
+        const void* end (void) const;
+        const void* cursor (void) const;
+
         size_t offset (const void*) const;
 
         void reset (void);
diff --git a/alloc/raw/null.cpp b/alloc/raw/null.cpp
index 11070fb4..c885f6e9 100644
--- a/alloc/raw/null.cpp
+++ b/alloc/raw/null.cpp
@@ -68,7 +68,7 @@ null::deallocate (void *ptr, size_t bytes, size_t align)
 
 ///////////////////////////////////////////////////////////////////////////////
 void*
-null::base (void)
+null::begin (void)
 {
     return nullptr;
 }
@@ -76,7 +76,7 @@ null::base (void)
 
 //-----------------------------------------------------------------------------
 const void*
-null::base (void) const
+null::begin (void) const
 {
     return nullptr;
 }
diff --git a/alloc/raw/null.hpp b/alloc/raw/null.hpp
index 971a5f48..9003c424 100644
--- a/alloc/raw/null.hpp
+++ b/alloc/raw/null.hpp
@@ -35,8 +35,8 @@ namespace util::alloc::raw {
         void deallocate (void *ptr, size_t bytes);
         void deallocate (void *ptr, size_t bytes, size_t align);
 
-        void* base (void);
-        const void* base (void) const;
+        void* begin (void);
+        const void* begin (void) const;
         size_t offset (const void*) const;
 
         void reset (void);
diff --git a/alloc/raw/stack.cpp b/alloc/raw/stack.cpp
index 7d05ea0b..1f297e2c 100644
--- a/alloc/raw/stack.cpp
+++ b/alloc/raw/stack.cpp
@@ -113,7 +113,7 @@ stack::deallocate (void *_ptr, size_t bytes, size_t alignment)
 
 //-----------------------------------------------------------------------------
 void*
-stack::base (void)
+stack::begin (void)
 {
     return m_begin;
 }
@@ -121,7 +121,7 @@ stack::base (void)
 
 //-----------------------------------------------------------------------------
 const void*
-stack::base (void) const
+stack::begin (void) const
 {
     return m_begin;
 }
diff --git a/alloc/raw/stack.hpp b/alloc/raw/stack.hpp
index c2aac44c..11288ce9 100644
--- a/alloc/raw/stack.hpp
+++ b/alloc/raw/stack.hpp
@@ -38,8 +38,8 @@ namespace util::alloc::raw {
         void deallocate (void *ptr, size_t bytes);
         void deallocate (void *ptr, size_t bytes, size_t alignment);
 
-        void* base (void);
-        const void* base (void) const;
+        void* begin (void);
+        const void* begin (void) const;
         size_t offset (const void*) const;
 
         void reset (void);
diff --git a/test/alloc/linear.cpp b/test/alloc/linear.cpp
index 0e94c68b..7bc06717 100644
--- a/test/alloc/linear.cpp
+++ b/test/alloc/linear.cpp
@@ -13,7 +13,7 @@ main (void)
     alignas (std::max_align_t) char memory[BUFFER_SIZE];
     util::alloc::raw::linear store (std::begin (memory), std::end (memory));
 
-    tap.expect_eq (store.base (), std::begin (memory), "base pointers match");
+    tap.expect_eq (store.begin (), std::begin (memory), "base pointers match");
     tap.expect_eq (store.offset (std::begin (memory)), 0u, "base offset is 0");
     tap.expect_eq (store.capacity (), BUFFER_SIZE, "bytes capacity matches");
 
diff --git a/test/alloc/stack.cpp b/test/alloc/stack.cpp
index 0c383c5c..a24d750e 100644
--- a/test/alloc/stack.cpp
+++ b/test/alloc/stack.cpp
@@ -34,7 +34,7 @@ main (void)
 
     util::alloc::raw::stack store (memory, memory + BUFFER_AVAILABLE);
 
-    tap.expect_eq (store.base (), std::begin (memory), "base pointers match");
+    tap.expect_eq (store.begin (), std::begin (memory), "base pointers match");
     tap.expect_eq (store.offset (std::begin (memory)), 0u, "base offset is 0");
     tap.expect_eq (store.capacity (), BUFFER_AVAILABLE, "bytes capacity matches");
 

From acfbec871a9d1674e0659c912254db0780a63e09 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Thu, 31 Aug 2017 13:48:44 +1000
Subject: [PATCH 103/149] view: remove noexcept from redim

redim can throw, it shouldn't be noexcept...
---
 view.hpp | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/view.hpp b/view.hpp
index a7d3f8d5..a027ffe0 100644
--- a/view.hpp
+++ b/view.hpp
@@ -11,13 +11,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
- * Copyright 2015-2016 Danny Robson <danny@nerdcruft.net>
+ * Copyright 2015-2017 Danny Robson <danny@nerdcruft.net>
  */
 
 
-#ifndef __UTIL_VIEW_HPP
-#define __UTIL_VIEW_HPP
+#ifndef CRUFT_UTIL_VIEW_HPP
+#define CRUFT_UTIL_VIEW_HPP
 
+#include "./debug.hpp"
 #include "./types/traits.hpp"
 
 #include <cstdlib>
@@ -77,8 +78,9 @@ namespace util {
         }
 
         constexpr auto
-        redim (int count) const noexcept
+        redim (int count) const
         {
+            CHECK_GT (count, 0);
             if (count > size ())
                 throw std::invalid_argument ("redim to higher size not allowed");
             return view { m_begin, m_begin + count };

From 77d5bf0cb736203cd09944f4469e45aad0ebc1b3 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Fri, 1 Sep 2017 13:36:13 +1000
Subject: [PATCH 104/149] iterator: add simple explanation of infix_iterator

---
 iterator.hpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/iterator.hpp b/iterator.hpp
index 892ef45c..0d807c87 100644
--- a/iterator.hpp
+++ b/iterator.hpp
@@ -71,6 +71,16 @@ class referencing_iterator {
 
 namespace util {
     ///////////////////////////////////////////////////////////////////////////
+    /// an output iterator that inserts a delimiter between successive
+    /// assignments
+    ///
+    /// very useful for outputting comma seperated lists to an ostream, eg:
+    ///
+    /// std::copy (
+    ///     std::cbegin (container),
+    ///     std::cend   (container),
+    ///     util::infix_iterator<value_type> (os, ", ")
+    /// );
     template <
         typename T,
         class CharT = char,

From 1567ad790cea146eb70a12bdb2fd45d920720e12 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Fri, 1 Sep 2017 13:36:27 +1000
Subject: [PATCH 105/149] iterator: add the make_infix helper function

---
 iterator.hpp | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/iterator.hpp b/iterator.hpp
index 0d807c87..3c2e2bef 100644
--- a/iterator.hpp
+++ b/iterator.hpp
@@ -120,6 +120,39 @@ namespace util {
     };
 
 
+    namespace detail {
+        template <typename ContainerT, typename CharT>
+        struct infix_t {
+            const ContainerT &_container;
+            const CharT *_delimiter;
+        };
+
+        template <typename ContainerT, typename CharT>
+        std::ostream&
+        operator<< (std::ostream &os, const infix_t<ContainerT,CharT> &val)
+        {
+            std::copy (std::cbegin (val._container),
+                       std::cend (val._container),
+                       infix_iterator<typename ContainerT::value_type> (os, val._delimiter));
+            return os;
+        }
+
+    };
+
+
+    /// a helper function that returns an object that will use a
+    /// util::infix_iterator to output a container's values to an ostream with
+    /// the given delimiter.
+    ///
+    /// reduces boilerplate code required to output lists of things
+    template <typename ContainerT, typename CharT = char>
+    auto
+    make_infix (const ContainerT &_container, const CharT *_delimiter = ", ")
+    {
+        return detail::infix_t<ContainerT,CharT> { _container, _delimiter };
+    };
+
+
     ///////////////////////////////////////////////////////////////////////////
     template <typename ContainerT>
     class indices {

From 40c4fbc5edb33fce86c299fa0a28394ab4a7bc6d Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Fri, 1 Sep 2017 14:17:03 +1000
Subject: [PATCH 106/149] introspection: add forgotten required header

---
 introspection.hpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/introspection.hpp b/introspection.hpp
index 4aeab3f6..c4474fdc 100644
--- a/introspection.hpp
+++ b/introspection.hpp
@@ -23,10 +23,11 @@
 #include <array>
 #include <cstddef>
 #include <cstdint>
+#include <experimental/filesystem>
+#include <ostream>
 #include <string>
 #include <tuple>
 #include <utility>
-#include <experimental/filesystem>
 
 
 namespace util {

From 9cfaade94b220f69b8afda457121cea51487c691 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 5 Sep 2017 14:29:58 +1000
Subject: [PATCH 107/149] preprocessor: add variadic REDUCE for PASTE

---
 preprocessor.hpp | 71 ++++++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 66 insertions(+), 5 deletions(-)

diff --git a/preprocessor.hpp b/preprocessor.hpp
index 67845134..c43e5b52 100644
--- a/preprocessor.hpp
+++ b/preprocessor.hpp
@@ -11,17 +11,32 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
- * Copyright 2012-2016 Danny Robson <danny@nerdcruft.net>
+ * Copyright 2012-2017 Danny Robson <danny@nerdcruft.net>
  */
 
-#ifndef __UTIL_PREPROCESSOR_HPP
-#define __UTIL_PREPROCESSOR_HPP
+#ifndef CRUFT_UTIL_PREPROCESSOR_HPP
+#define CRUFT_UTIL_PREPROCESSOR_HPP
+
+//-----------------------------------------------------------------------------
+//
+// HERE BE DRAGONS.
+//
+// Don't use this code unless you need to do minor token pasting.
+// Don't judge me...
+//
+//-----------------------------------------------------------------------------
 
 
+///////////////////////////////////////////////////////////////////////////////
+// token concatenation operations. you should probably prefer PASTE over
+// PASTE2. PASTE2 is defined purely so that PASTE can make use of this macro
+// (because it clearly can't use itself).
+//
+// do not use PASTE_DETAIL directly.
 #define PASTE_DETAIL(x, y) x##y
-#define PASTE(x, y) PASTE_DETAIL(x, y)
+#define PASTE2(x, y) PASTE_DETAIL(x, y)
 
-#define PASTE_LIST(x,y) PASTE(x,y),
+#define PASTE_LIST(x,y) PASTE2(x,y),
 
 #define NAMESPACE_LIST(x,y) x::y,
 
@@ -37,6 +52,18 @@
 //
 // Based off a technique seen on StackOverflow:
 // http://stackoverflow.com/questions/11761703/overloading-macro-on-number-of-arguments
+
+#define REDUCE_2_01(F,X,  ...) X
+#define REDUCE_2_02(F,X,Y,...) F(X,Y)
+#define REDUCE_2_03(F,X,Y,...) REDUCE_2_02(F,F(X,Y),__VA_ARGS__)
+#define REDUCE_2_04(F,X,Y,...) REDUCE_2_03(F,F(X,Y),__VA_ARGS__)
+#define REDUCE_2_05(F,X,Y,...) REDUCE_2_04(F,F(X,Y),__VA_ARGS__)
+#define REDUCE_2_06(F,X,Y,...) REDUCE_2_05(F,F(X,Y),__VA_ARGS__)
+#define REDUCE_2_07(F,X,Y,...) REDUCE_2_06(F,F(X,Y),__VA_ARGS__)
+#define REDUCE_2_08(F,X,Y,...) REDUCE_2_07(F,F(X,Y),__VA_ARGS__)
+
+
+//-----------------------------------------------------------------------------
 #define MAP_0_01(F, X)      F(X)
 #define MAP_0_02(F, X, ...) F(X)MAP_0_01(F, __VA_ARGS__)
 #define MAP_0_03(F, X, ...) F(X)MAP_0_02(F, __VA_ARGS__)
@@ -146,6 +173,7 @@
 #define MAP_0_96(F, X, ...) F(X)MAP_0_95(F, __VA_ARGS__)
 
 
+//-----------------------------------------------------------------------------
 #define MAP_1_01(F, A, X)      F(A, X)
 #define MAP_1_02(F, A, X, ...) F(A, X)MAP_1_01(F, A, __VA_ARGS__)
 #define MAP_1_03(F, A, X, ...) F(A, X)MAP_1_02(F, A, __VA_ARGS__)
@@ -254,6 +282,8 @@
 #define MAP_1_95(F, A, X, ...) F(A, X)MAP_1_94(F, A, __VA_ARGS__)
 #define MAP_1_96(F, A, X, ...) F(A, X)MAP_1_95(F, A, __VA_ARGS__)
 
+
+//-----------------------------------------------------------------------------
 // Uses the sliding pairs dispatch technique: by passing __VA_ARGS__ as the
 // first set of variables and appending (reverse orderred) names of the
 // corresponding macros, we get the name of the correct arity macro.
@@ -277,6 +307,37 @@
 ) NAME
 
 
+//-----------------------------------------------------------------------------
+// reduces a series of values by repeated application of some macro 'func'.
+//
+// useful for things like variadic 'paste'
+//
+// it's only implemented for up to 8 arguments (because that's all you should
+// need you monster...) but we need to have enough arguments to make
+// ARITY_DISPATCH work so we fill it with nonces.
+#define REDUCE(FUNC,...)                                \
+ARITY_DISPATCH(__VA_ARGS__,                             \
+    _96, _95, _94, _93, _92, _91, _90, _89,             \
+    _88, _87, _86, _85, _84, _83, _82, _81,             \
+    _80, _79, _78, _77, _76, _75, _74, _73,             \
+    _72, _71, _70, _69, _68, _67, _66, _65,             \
+    _64, _63, _62, _61, _60, _59, _58, _57,             \
+    _56, _55, _54, _53, _52, _51, _50, _49,             \
+    _48, _47, _46, _45, _44, _43, _42, _41,             \
+    _40, _39, _38, _37, _36, _35, _34, _33,             \
+    _32, _31, _30, _29, _28, _27, _26, _25,             \
+    _24, _23, _22, _21, _20, _19, _18, _17,             \
+    _16, _15, _14, _13, _12, _11, _10, _09,             \
+    REDUCE_2_08, REDUCE_2_07, REDUCE_2_06, REDUCE_2_05, \
+    REDUCE_2_04, REDUCE_2_03, REDUCE_2_02, REDUCE_2_01, \
+    STATIC_ASSERT("invalid arity for REDUCE")           \
+)(FUNC,__VA_ARGS__)
+
+
+// concatenate a series of tokens
+#define PASTE(...) REDUCE(PASTE2,__VA_ARGS__)
+
+
 // Map a macro across __VA_ARGS__. Can be easily expanded, but has non-obvious
 // failure mode when supported arity is exceeded.
 //

From a1c8c8e2acd5091c4b98a45317aa966ea971b6fa Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Wed, 6 Sep 2017 13:31:02 +1000
Subject: [PATCH 108/149] types/traits add remove_noexcept and func_traits

---
 types/traits.hpp | 90 +++++++++++++++++++++++++++++++++++++-----------
 1 file changed, 69 insertions(+), 21 deletions(-)

diff --git a/types/traits.hpp b/types/traits.hpp
index 0281881a..ebb948c2 100644
--- a/types/traits.hpp
+++ b/types/traits.hpp
@@ -11,7 +11,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
- * Copyright 2012 Danny Robson <danny@nerdcruft.net>
+ * Copyright 2012-2017 Danny Robson <danny@nerdcruft.net>
  */
 
 #ifndef __UTIL_TYPES_TRAITS_HPP
@@ -83,26 +83,6 @@ template <typename T, typename U> struct is_lossless_cast : std::enable_if<
 >::value { };
 
 
-///////////////////////////////////////////////////////////////////////////////
-template <typename T>
-struct func_traits : public func_traits<decltype(&T::operator())>
-{ };
-
-
-//-----------------------------------------------------------------------------
-template <typename C, typename R, typename ...Args>
-struct func_traits<R(C::*)(Args...) const> {
-    typedef R return_type;
-};
-
-
-//-----------------------------------------------------------------------------
-template <typename R, typename ...Args>
-struct func_traits<R(Args...)> {
-    typedef R return_type;
-};
-
-
 ///////////////////////////////////////////////////////////////////////////////
 template <typename T> struct remove_restrict              { using type = T;  };
 template <typename T> struct remove_restrict<T *restrict> { using type = T*; };
@@ -111,4 +91,72 @@ template <typename T>
 using remove_restrict_t = typename remove_restrict<T>::type;
 
 
+///////////////////////////////////////////////////////////////////////////////
+/// removes the noexcept type specifier from invokable types
+template <typename T>
+struct remove_noexcept
+{ using type = T; };
+
+
+//-----------------------------------------------------------------------------
+template <typename ResultT, typename ...Args>
+struct remove_noexcept<ResultT(&)(Args...) noexcept> {
+    using type = ResultT(&)(Args...);
+};
+
+
+//-----------------------------------------------------------------------------
+template <typename ResultT, typename ...Args>
+struct remove_noexcept<ResultT(*)(Args...) noexcept> {
+    using type = ResultT(*)(Args...);
+};
+
+
+//-----------------------------------------------------------------------------
+template <typename ClassT, typename ResultT, typename ...Args>
+struct remove_noexcept<ResultT(ClassT::*)(Args...) noexcept> {
+    using type = ResultT(ClassT::*)(Args...);
+};
+
+
+//-----------------------------------------------------------------------------
+template <typename T>
+using remove_noexcept_t = typename remove_noexcept<T>::type;
+
+
+///////////////////////////////////////////////////////////////////////////////
+/// type traits class for querying invokable type return values and argument
+/// types.
+///
+/// if the type is invokable the alias `return_type' will be defined for the
+/// return type, and the alias tuple `argument_types' will be defined for the
+/// arguments;
+template <typename T>
+struct func_traits : public func_traits<remove_noexcept_t<T>> { };
+
+
+//-----------------------------------------------------------------------------
+template <typename ClassT, typename ResultT, typename ...Args>
+struct func_traits<ResultT(ClassT::*)(Args...) const> {
+    using return_type = ResultT;
+    using argument_types = std::tuple<Args...>;
+};
+
+
+//-----------------------------------------------------------------------------
+template <typename ResultT, typename ...Args>
+struct func_traits<ResultT(*)(Args...)>  {
+    using return_type = ResultT;
+    using argument_types = std::tuple<Args...>;
+};
+
+
+//-----------------------------------------------------------------------------
+template <typename ResultT, typename ...Args>
+struct func_traits<ResultT(&)(Args...)>  {
+    using return_type = ResultT;
+    using argument_types = std::tuple<Args...>;
+};
+
+
 #endif

From c105fb4d0ffed0cc5cfb659d9262b4dbc1476511 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Fri, 8 Sep 2017 14:10:11 +1000
Subject: [PATCH 109/149] debug: fully qualify panic detail functions

silences warnings under clang
---
 debug.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/debug.cpp b/debug.cpp
index 5ff4aeb6..31847bdb 100644
--- a/debug.cpp
+++ b/debug.cpp
@@ -26,7 +26,7 @@ using namespace util::debug;
 
 ////////////////////////////////////////////////////////////////////////////////
 void
-detail::panic (const char *msg)
+util::debug::detail::panic (const char *msg)
 {
     std::cerr << "PANIC: " << msg << "\n" << ::debug::backtrace () << std::endl;
     breakpoint ();
@@ -36,7 +36,7 @@ detail::panic (const char *msg)
 
 ////////////////////////////////////////////////////////////////////////////////
 void
-detail::not_implemented (const char *msg)
+util::debug::detail::not_implemented (const char *msg)
 {
     panic (msg);
 }
@@ -44,7 +44,7 @@ detail::not_implemented (const char *msg)
 
 //-----------------------------------------------------------------------------
 void
-detail::unreachable (const char *msg)
+util::debug::detail::unreachable (const char *msg)
 {
     panic (msg);
 }

From a307b5f7770f6a3f2b3bbfac6ce98da23304a5d7 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Fri, 8 Sep 2017 14:10:57 +1000
Subject: [PATCH 110/149] types/traits: add chaining type modifier

---
 types/traits.hpp | 40 ++++++++++++++++++++++++++++++++++++++--
 1 file changed, 38 insertions(+), 2 deletions(-)

diff --git a/types/traits.hpp b/types/traits.hpp
index ebb948c2..2ef637f3 100644
--- a/types/traits.hpp
+++ b/types/traits.hpp
@@ -14,12 +14,48 @@
  * Copyright 2012-2017 Danny Robson <danny@nerdcruft.net>
  */
 
-#ifndef __UTIL_TYPES_TRAITS_HPP
-#define __UTIL_TYPES_TRAITS_HPP
+#ifndef CRUFT_UTIL_TYPES_TRAITS_HPP
+#define CRUFT_UTIL_TYPES_TRAITS_HPP
 
 #include <memory>
 #include <type_traits>
 
+
+///////////////////////////////////////////////////////////////////////////////
+/// applies a series of type-modifiers to a provided type.
+///
+/// modifiers are applied in the order they are provided.
+///
+/// use without any modifiers results in the identity modifier.
+namespace util {
+    //-------------------------------------------------------------------------
+    template <typename TypeT, template <typename> class ...ModifierT>
+    struct chain;
+
+
+    //-------------------------------------------------------------------------
+    template <typename TypeT>
+    struct chain<TypeT> { using type = TypeT; };
+
+
+    //-------------------------------------------------------------------------
+    template <
+        typename TypeT,
+        template <typename> class HeadT,
+        template <typename> class ...TailT
+    >
+    struct chain<TypeT, HeadT, TailT...> : public chain<
+        typename HeadT<TypeT>::type,
+        TailT...
+    > { };
+
+
+    //-------------------------------------------------------------------------
+    template <typename T, template <typename> class ...Args>
+    using chain_t = typename chain<T, Args...>::type;
+}
+
+
 ///////////////////////////////////////////////////////////////////////////////
 template <typename T> struct is_dereferencable     : std::false_type { };
 template <typename T> struct is_dereferencable<T*> : std::true_type  { };

From bb07f6573c5b43343d11d551e5357a1d91fdf728 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Fri, 8 Sep 2017 14:19:03 +1000
Subject: [PATCH 111/149] type/traits: add remove_noexcept

---
 types/traits.hpp | 60 ++++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 50 insertions(+), 10 deletions(-)

diff --git a/types/traits.hpp b/types/traits.hpp
index 2ef637f3..0ca8b96d 100644
--- a/types/traits.hpp
+++ b/types/traits.hpp
@@ -129,22 +129,62 @@ using remove_restrict_t = typename remove_restrict<T>::type;
 
 ///////////////////////////////////////////////////////////////////////////////
 /// removes the noexcept type specifier from invokable types
-template <typename T>
-struct remove_noexcept
-{ using type = T; };
+namespace detail {
+    template <typename T>
+    struct remove_noexcept
+    { using type = T; };
 
 
-//-----------------------------------------------------------------------------
-template <typename ResultT, typename ...Args>
-struct remove_noexcept<ResultT(&)(Args...) noexcept> {
-    using type = ResultT(&)(Args...);
+    //-------------------------------------------------------------------------
+    template <typename ResultT, typename ...Args>
+    struct remove_noexcept<ResultT(&)(Args...) noexcept> {
+        using type = ResultT(&)(Args...);
+    };
+
+
+    //-------------------------------------------------------------------------
+    template <typename ResultT, typename ...Args>
+    struct remove_noexcept<ResultT(*const)(Args...) noexcept> {
+        using type = ResultT(*const)(Args...);
+    };
+
+
+    //-------------------------------------------------------------------------
+    template <typename ResultT, typename ...Args>
+    struct remove_noexcept<ResultT(*)(Args...) noexcept> {
+        using type = ResultT(*)(Args...);
+    };
+
+
+    //-------------------------------------------------------------------------
+    template <typename ClassT, typename ResultT, typename ...Args>
+    struct remove_noexcept<ResultT(ClassT::*)(Args...) noexcept> {
+        using type = ResultT(ClassT::*)(Args...);
+    };
+
+
+    //-------------------------------------------------------------------------
+    template <typename ClassT, typename ResultT, typename ...Args>
+    struct remove_noexcept<ResultT(ClassT::*)(Args...) const noexcept> {
+        using type = ResultT(ClassT::*)(Args...) const;
+    };
 };
 
 
 //-----------------------------------------------------------------------------
-template <typename ResultT, typename ...Args>
-struct remove_noexcept<ResultT(*)(Args...) noexcept> {
-    using type = ResultT(*)(Args...);
+template <typename T>
+struct remove_noexcept : public detail::remove_noexcept<T> { };
+
+//-----------------------------------------------------------------------------
+template <typename T>
+using remove_noexcept_t = typename remove_noexcept<T>::type;
+
+
+///////////////////////////////////////////////////////////////////////////////
+/// removes any `const' qualifier from the supplied member function
+template <typename FuncT>
+struct remove_member_const {
+    using type = FuncT;
 };
 
 

From fb5614ae2b1c41eaeeffd911bf66dda66659db3c Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Fri, 8 Sep 2017 14:19:28 +1000
Subject: [PATCH 112/149] types/traits: add remove_member_const

---
 types/traits.hpp | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/types/traits.hpp b/types/traits.hpp
index 0ca8b96d..738522a6 100644
--- a/types/traits.hpp
+++ b/types/traits.hpp
@@ -189,15 +189,17 @@ struct remove_member_const {
 
 
 //-----------------------------------------------------------------------------
-template <typename ClassT, typename ResultT, typename ...Args>
-struct remove_noexcept<ResultT(ClassT::*)(Args...) noexcept> {
-    using type = ResultT(ClassT::*)(Args...);
+template <typename ClassT, typename ReturnT, typename ...Args>
+struct remove_member_const<ReturnT(ClassT::*const)(Args...) const> {
+    using type = ReturnT(ClassT::*const)(Args...);
 };
 
 
 //-----------------------------------------------------------------------------
-template <typename T>
-using remove_noexcept_t = typename remove_noexcept<T>::type;
+template <typename ClassT, typename ReturnT, typename ...Args>
+struct remove_member_const<ReturnT(ClassT::*)(Args...) const> {
+    using type = ReturnT(ClassT::*)(Args...);
+};
 
 
 ///////////////////////////////////////////////////////////////////////////////

From d79b7da0679eb8bbd1489ac89de389a069cbb820 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Fri, 8 Sep 2017 14:19:46 +1000
Subject: [PATCH 113/149] types/traits: make func_traits more robust

---
 types/traits.hpp | 68 +++++++++++++++++++++++++++++++-----------------
 1 file changed, 44 insertions(+), 24 deletions(-)

diff --git a/types/traits.hpp b/types/traits.hpp
index 738522a6..b15af3c7 100644
--- a/types/traits.hpp
+++ b/types/traits.hpp
@@ -209,31 +209,51 @@ struct remove_member_const<ReturnT(ClassT::*)(Args...) const> {
 /// if the type is invokable the alias `return_type' will be defined for the
 /// return type, and the alias tuple `argument_types' will be defined for the
 /// arguments;
+namespace detail {
+    template <typename T>
+    struct func_traits { };
+
+
+    //-------------------------------------------------------------------------
+    template <typename ClassT, typename ResultT, typename ...Args>
+    struct func_traits<ResultT(ClassT::*)(Args...)> {
+        using return_type = ResultT;
+        using argument_types = std::tuple<Args...>;
+    };
+
+
+    //-------------------------------------------------------------------------
+    template <typename ResultT, typename ...Args>
+    struct func_traits<ResultT(*)(Args...)>  {
+        using return_type = ResultT;
+        using argument_types = std::tuple<Args...>;
+    };
+
+
+    //-------------------------------------------------------------------------
+    template <typename ResultT, typename ...Args>
+    struct func_traits<ResultT(&)(Args...)>  {
+        using return_type = ResultT;
+        using argument_types = std::tuple<Args...>;
+    };
+};
+
+
+//-----------------------------------------------------------------------------
 template <typename T>
-struct func_traits : public func_traits<remove_noexcept_t<T>> { };
-
-
-//-----------------------------------------------------------------------------
-template <typename ClassT, typename ResultT, typename ...Args>
-struct func_traits<ResultT(ClassT::*)(Args...) const> {
-    using return_type = ResultT;
-    using argument_types = std::tuple<Args...>;
-};
-
-
-//-----------------------------------------------------------------------------
-template <typename ResultT, typename ...Args>
-struct func_traits<ResultT(*)(Args...)>  {
-    using return_type = ResultT;
-    using argument_types = std::tuple<Args...>;
-};
-
-
-//-----------------------------------------------------------------------------
-template <typename ResultT, typename ...Args>
-struct func_traits<ResultT(&)(Args...)>  {
-    using return_type = ResultT;
-    using argument_types = std::tuple<Args...>;
+struct func_traits : public ::detail::func_traits<
+    // we apply as many transforms as possible before palming it off to the
+    // detail class so that we don't have to write as many distinct cases.
+    ::util::chain_t<T,
+        std::remove_cv,
+        std::decay,
+        remove_member_const,
+        remove_noexcept
+    >
+> {
+    // we may as well record the underlying type here. it might prove useful
+    // to someone.
+    using type = T;
 };
 
 

From 8e7f23c4dd45593f8b0ccf426dbd2bf049071f2d Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Fri, 8 Sep 2017 14:20:01 +1000
Subject: [PATCH 114/149] traits: add trivial type_traits tests

---
 CMakeLists.txt  |  1 +
 test/traits.cpp | 58 +++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 59 insertions(+)
 create mode 100644 test/traits.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index afae28d3..9711e82d 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -507,6 +507,7 @@ if (TESTS)
         stringid
         strongdef
         tuple
+        traits
         typeidx
         uri
         vector
diff --git a/test/traits.cpp b/test/traits.cpp
new file mode 100644
index 00000000..674a9f86
--- /dev/null
+++ b/test/traits.cpp
@@ -0,0 +1,58 @@
+#include <cruft/util/tap.hpp>
+#include <cruft/util/types/traits.hpp>
+
+
+///////////////////////////////////////////////////////////////////////////////
+template <typename FuncT>
+constexpr bool
+returns_int (FuncT)
+{
+    return std::is_same_v<
+        int,
+        typename func_traits<FuncT>::return_type
+    >;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+template <typename, class = std::void_t<>>
+struct has_return_type : std::false_type {};
+
+
+//-----------------------------------------------------------------------------
+template <typename T>
+struct has_return_type<
+    T, std::void_t<typename func_traits<T>::return_type>
+> : std::true_type {};
+
+
+///////////////////////////////////////////////////////////////////////////////
+int plain (char, float);
+int with_noexcept (char, float) noexcept;
+struct foo {
+    int bar (double, char) const;
+    int with_noexcept (double, char) noexcept;
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+int
+main (void)
+{
+    util::TAP::logger tap;
+
+    tap.expect (returns_int ( plain), "free-function by-reference");
+    tap.expect (returns_int (&plain), "free-function by-pointer");
+
+    tap.expect (returns_int ( with_noexcept), "free-function with noexcept by-reference");
+    tap.expect (returns_int (&with_noexcept), "free-function with noexcept by-pointer");
+
+    tap.expect (returns_int (&foo::bar), "member-function by reference");
+    tap.expect (returns_int (&foo::with_noexcept), "member-function with noexcept by reference");
+
+    using all_t = void (*const &)(void *, unsigned int, unsigned int, void **) noexcept;
+    tap.expect (std::is_same_v<void, typename func_traits<all_t>::return_type>,
+                "complex function type");
+
+    tap.expect (!has_return_type<int>::value, "integer is not applicable to func_traits");
+}
\ No newline at end of file

From edfe4b73bb005346e492730a9f2acc0c3728b4e4 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Fri, 8 Sep 2017 17:02:33 +1000
Subject: [PATCH 115/149] introspection: identify the bug that CLANG_WORKAROUND
 addresses

---
 introspection.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/introspection.hpp b/introspection.hpp
index c4474fdc..67410f36 100644
--- a/introspection.hpp
+++ b/introspection.hpp
@@ -31,9 +31,9 @@
 
 
 namespace util {
-    // XXX: clang-3.9/clang-4.0 will not instantiate static constexpr member
-    // variables from class specialisations, so we have to use detail classes
-    // to hold the variables and instantiate _those_ members instead.
+    // clang#18781: clang-3.9/clang-4.0 will not instantiate static constexpr
+    // member variables from class specialisations, so we have to use detail
+    // classes to hold the variables and instantiate _those_ members instead.
     template <typename T>
     struct type_name;
 

From ca3851c4de079d2741bb133407cd84339171f8a7 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Fri, 8 Sep 2017 17:03:22 +1000
Subject: [PATCH 116/149] tuple: `ignore' should be noexcept

---
 tuple.hpp | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/tuple.hpp b/tuple.hpp
index ad15b6c2..375250e7 100644
--- a/tuple.hpp
+++ b/tuple.hpp
@@ -176,16 +176,14 @@ namespace util::tuple {
     /// debug/release/whatever builds. so it is safe to use to guarantee
     /// parameter evaluation.
     inline void
-    ignore (void)
+    ignore (void) noexcept
     { ; }
 
     //-------------------------------------------------------------------------
     template <typename T, typename ...Args>
     void
-    ignore (T, Args ...args)
-    {
-        ignore (std::forward<Args> (args)...);
-    };
+    ignore (T, const Args&...) noexcept
+    { ; }
 
 
     ///////////////////////////////////////////////////////////////////////////

From a2995186f63bd698268f3d8914908a42acecc491 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Sun, 10 Sep 2017 12:42:18 +1000
Subject: [PATCH 117/149] traits: add nth_argument trait query

---
 types/traits.hpp | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/types/traits.hpp b/types/traits.hpp
index b15af3c7..fbde1c3d 100644
--- a/types/traits.hpp
+++ b/types/traits.hpp
@@ -257,4 +257,17 @@ struct func_traits : public ::detail::func_traits<
 };
 
 
+
+///////////////////////////////////////////////////////////////////////////////
+template <std::size_t N, typename FuncT>
+struct nth_argument : std::tuple_element<
+    N,
+    typename func_traits<FuncT>::argument_types
+> { };
+
+
+template <std::size_t N, typename FuncT>
+using nth_argument_t = typename nth_argument<N, FuncT>::type;
+
+
 #endif

From 4050754ab43563d672f04371c552f7b060deef7b Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 12 Sep 2017 14:17:30 +1000
Subject: [PATCH 118/149] preprocessor: use a script to create map/reduce

We need over 300 arguments for some projects and I'm not going to code
that shit by hand.
---
 .gitignore            |   1 +
 CMakeLists.txt        |  23 +-
 coord/ops.hpp         |   3 +-
 introspection.hpp     |   2 +-
 io.cpp                |   2 +-
 json/flat.cpp.rl      |   4 +-
 json/tree.cpp         |   7 +-
 log.hpp               |   3 +-
 preprocessor.hpp      | 516 ------------------------------------------
 preprocessor.py       | 202 +++++++++++++++++
 test/preprocessor.cpp |  21 ++
 11 files changed, 256 insertions(+), 528 deletions(-)
 delete mode 100644 preprocessor.hpp
 create mode 100755 preprocessor.py
 create mode 100644 test/preprocessor.cpp

diff --git a/.gitignore b/.gitignore
index 6bb74d77..a5bbabed 100644
--- a/.gitignore
+++ b/.gitignore
@@ -17,6 +17,7 @@
 Makefile
 Makefile.in
 /missing
+/preprocessor.hpp
 /stamp-h1
 /test-driver
 /uri.cpp
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 9711e82d..eb847c7c 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -13,7 +13,8 @@ include (nc)
 
 include (search_libs)
 
-find_package(RAGEL 6.9 REQUIRED)
+find_package (PythonInterp 3 REQUIRED)
+find_package (RAGEL 6.9 REQUIRED)
 
 
 ###############################################################################
@@ -418,6 +419,25 @@ list (
     view.hpp
 )
 
+
+##-----------------------------------------------------------------------------
+## We shouldn't be building into the source directory, but I can't stand trying
+## to coax CMake into behaving here any longer. Feel free to fix it.
+add_custom_command (
+OUTPUT
+    "${CMAKE_CURRENT_SOURCE_DIR}/preprocessor.hpp"
+COMMENT
+    "[preprocessor.py] preprocessor.hpp"
+COMMAND
+    "${PYTHON_EXECUTABLE}"
+    "${CMAKE_CURRENT_SOURCE_DIR}/preprocessor.py"
+    "${CMAKE_CURRENT_SOURCE_DIR}/preprocessor.hpp"
+    320
+DEPENDS
+    "${CMAKE_CURRENT_SOURCE_DIR}/preprocessor.py"
+)
+
+
 ###############################################################################
 add_library(cruft-util ${UTIL_FILES})
 target_link_libraries (cruft-util ${LIBS})
@@ -494,6 +514,7 @@ if (TESTS)
         point
         polynomial
         pool
+        preprocessor
         quaternion
         rand/buckets
         range
diff --git a/coord/ops.hpp b/coord/ops.hpp
index 3ee732e4..3b3c6f1b 100644
--- a/coord/ops.hpp
+++ b/coord/ops.hpp
@@ -21,9 +21,10 @@
 
 #include "../debug.hpp"
 #include "../maths.hpp"
-#include "../preprocessor.hpp"
 #include "../types/bits.hpp"
 
+#include "../preprocessor.hpp"
+
 #include <algorithm>
 #include <cmath>
 #include <cstdlib>
diff --git a/introspection.hpp b/introspection.hpp
index 67410f36..9b3808cf 100644
--- a/introspection.hpp
+++ b/introspection.hpp
@@ -174,7 +174,7 @@ namespace util {
         const char*,                                            \
         util::enum_traits<::NS::E>::value_count                 \
     > PASTE(util::__enum_traits_,E)::names = {                  \
-      MAP(STRINGIZE_LIST, __VA_ARGS__)                          \
+      MAP0(STRINGIZE_LIST, __VA_ARGS__)                         \
     };
 
 
diff --git a/io.cpp b/io.cpp
index 704a437a..f984633b 100644
--- a/io.cpp
+++ b/io.cpp
@@ -11,7 +11,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
- * Copyright 2010-2016 Danny Robson <danny@nerdcruft.net>
+ * Copyright 2010-2017 Danny Robson <danny@nerdcruft.net>
  */
 
 #include "io.hpp"
diff --git a/json/flat.cpp.rl b/json/flat.cpp.rl
index 0ca04ba3..8d03ff30 100644
--- a/json/flat.cpp.rl
+++ b/json/flat.cpp.rl
@@ -172,9 +172,7 @@ template                                \
 std::vector<json::flat::item<KLASS>>    \
 json::flat::parse (util::view<KLASS>);
 
-MAP(
-    INSTANTIATE,
-
+MAP0(INSTANTIATE,
     std::string::iterator,
     std::string::const_iterator,
     const char* restrict,
diff --git a/json/tree.cpp b/json/tree.cpp
index 770511cb..b626520f 100644
--- a/json/tree.cpp
+++ b/json/tree.cpp
@@ -23,9 +23,10 @@
 #include "../debug.hpp"
 #include "../io.hpp"
 #include "../maths.hpp"
-#include "../preprocessor.hpp"
 #include "../stream.hpp"
 
+#include "preprocessor.hpp"
+
 #include <algorithm>
 #include <cstdlib>
 #include <iomanip>
@@ -226,9 +227,7 @@ template                            \
 std::unique_ptr<json::tree::node>   \
 json::tree::parse (util::view<KLASS>);
 
-MAP(
-    INSTANTIATE,
-
+MAP0(INSTANTIATE,
     std::string::iterator,
     std::string::const_iterator,
     const char* restrict,
diff --git a/log.hpp b/log.hpp
index aa30788c..da9da9e1 100644
--- a/log.hpp
+++ b/log.hpp
@@ -18,6 +18,7 @@
 #define __UTIL_LOG_HPP
 
 #include "./nocopy.hpp"
+
 #include "./preprocessor.hpp"
 
 #include <ostream>
@@ -45,7 +46,7 @@ namespace util {
         DEBUG                   /** debug-level messages */
     };
 
-    #define MAP_LEVEL_T(F) MAP(F, EMERGENCY, ALERT, CRITICAL, ERROR, WARN, NOTICE, INFO, DEBUG)
+    #define MAP_LEVEL_T(F) MAP0(F, EMERGENCY, ALERT, CRITICAL, ERROR, WARN, NOTICE, INFO, DEBUG)
 
     constexpr auto DEFAULT_LOG_LEVEL = NOTICE;
 
diff --git a/preprocessor.hpp b/preprocessor.hpp
deleted file mode 100644
index c43e5b52..00000000
--- a/preprocessor.hpp
+++ /dev/null
@@ -1,516 +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 2012-2017 Danny Robson <danny@nerdcruft.net>
- */
-
-#ifndef CRUFT_UTIL_PREPROCESSOR_HPP
-#define CRUFT_UTIL_PREPROCESSOR_HPP
-
-//-----------------------------------------------------------------------------
-//
-// HERE BE DRAGONS.
-//
-// Don't use this code unless you need to do minor token pasting.
-// Don't judge me...
-//
-//-----------------------------------------------------------------------------
-
-
-///////////////////////////////////////////////////////////////////////////////
-// token concatenation operations. you should probably prefer PASTE over
-// PASTE2. PASTE2 is defined purely so that PASTE can make use of this macro
-// (because it clearly can't use itself).
-//
-// do not use PASTE_DETAIL directly.
-#define PASTE_DETAIL(x, y) x##y
-#define PASTE2(x, y) PASTE_DETAIL(x, y)
-
-#define PASTE_LIST(x,y) PASTE2(x,y),
-
-#define NAMESPACE_LIST(x,y) x::y,
-
-#define STRINGIZE_DETAIL(x) #x
-#define STRINGIZE(x) STRINGIZE_DETAIL(x)
-
-#define STRINGIZE_LIST(x) STRINGIZE(x),
-
-#define STATIC_ASSERT(MSG) static_assert(false, MSG);
-
-///////////////////////////////////////////////////////////////////////////////
-// Varags functional style map
-//
-// Based off a technique seen on StackOverflow:
-// http://stackoverflow.com/questions/11761703/overloading-macro-on-number-of-arguments
-
-#define REDUCE_2_01(F,X,  ...) X
-#define REDUCE_2_02(F,X,Y,...) F(X,Y)
-#define REDUCE_2_03(F,X,Y,...) REDUCE_2_02(F,F(X,Y),__VA_ARGS__)
-#define REDUCE_2_04(F,X,Y,...) REDUCE_2_03(F,F(X,Y),__VA_ARGS__)
-#define REDUCE_2_05(F,X,Y,...) REDUCE_2_04(F,F(X,Y),__VA_ARGS__)
-#define REDUCE_2_06(F,X,Y,...) REDUCE_2_05(F,F(X,Y),__VA_ARGS__)
-#define REDUCE_2_07(F,X,Y,...) REDUCE_2_06(F,F(X,Y),__VA_ARGS__)
-#define REDUCE_2_08(F,X,Y,...) REDUCE_2_07(F,F(X,Y),__VA_ARGS__)
-
-
-//-----------------------------------------------------------------------------
-#define MAP_0_01(F, X)      F(X)
-#define MAP_0_02(F, X, ...) F(X)MAP_0_01(F, __VA_ARGS__)
-#define MAP_0_03(F, X, ...) F(X)MAP_0_02(F, __VA_ARGS__)
-#define MAP_0_04(F, X, ...) F(X)MAP_0_03(F, __VA_ARGS__)
-#define MAP_0_05(F, X, ...) F(X)MAP_0_04(F, __VA_ARGS__)
-#define MAP_0_06(F, X, ...) F(X)MAP_0_05(F, __VA_ARGS__)
-#define MAP_0_07(F, X, ...) F(X)MAP_0_06(F, __VA_ARGS__)
-#define MAP_0_08(F, X, ...) F(X)MAP_0_07(F, __VA_ARGS__)
-
-#define MAP_0_09(F, X, ...) F(X)MAP_0_08(F, __VA_ARGS__)
-#define MAP_0_10(F, X, ...) F(X)MAP_0_09(F, __VA_ARGS__)
-#define MAP_0_11(F, X, ...) F(X)MAP_0_10(F, __VA_ARGS__)
-#define MAP_0_12(F, X, ...) F(X)MAP_0_11(F, __VA_ARGS__)
-#define MAP_0_13(F, X, ...) F(X)MAP_0_12(F, __VA_ARGS__)
-#define MAP_0_14(F, X, ...) F(X)MAP_0_13(F, __VA_ARGS__)
-#define MAP_0_15(F, X, ...) F(X)MAP_0_14(F, __VA_ARGS__)
-#define MAP_0_16(F, X, ...) F(X)MAP_0_15(F, __VA_ARGS__)
-
-#define MAP_0_17(F, X, ...) F(X)MAP_0_16(F, __VA_ARGS__)
-#define MAP_0_18(F, X, ...) F(X)MAP_0_17(F, __VA_ARGS__)
-#define MAP_0_19(F, X, ...) F(X)MAP_0_18(F, __VA_ARGS__)
-#define MAP_0_20(F, X, ...) F(X)MAP_0_19(F, __VA_ARGS__)
-#define MAP_0_21(F, X, ...) F(X)MAP_0_20(F, __VA_ARGS__)
-#define MAP_0_22(F, X, ...) F(X)MAP_0_21(F, __VA_ARGS__)
-#define MAP_0_23(F, X, ...) F(X)MAP_0_22(F, __VA_ARGS__)
-#define MAP_0_24(F, X, ...) F(X)MAP_0_23(F, __VA_ARGS__)
-
-#define MAP_0_25(F, X, ...) F(X)MAP_0_24(F, __VA_ARGS__)
-#define MAP_0_26(F, X, ...) F(X)MAP_0_25(F, __VA_ARGS__)
-#define MAP_0_27(F, X, ...) F(X)MAP_0_26(F, __VA_ARGS__)
-#define MAP_0_28(F, X, ...) F(X)MAP_0_27(F, __VA_ARGS__)
-#define MAP_0_29(F, X, ...) F(X)MAP_0_28(F, __VA_ARGS__)
-#define MAP_0_30(F, X, ...) F(X)MAP_0_29(F, __VA_ARGS__)
-#define MAP_0_31(F, X, ...) F(X)MAP_0_30(F, __VA_ARGS__)
-#define MAP_0_32(F, X, ...) F(X)MAP_0_31(F, __VA_ARGS__)
-
-#define MAP_0_33(F, X, ...) F(X)MAP_0_32(F, __VA_ARGS__)
-#define MAP_0_34(F, X, ...) F(X)MAP_0_33(F, __VA_ARGS__)
-#define MAP_0_35(F, X, ...) F(X)MAP_0_34(F, __VA_ARGS__)
-#define MAP_0_36(F, X, ...) F(X)MAP_0_35(F, __VA_ARGS__)
-#define MAP_0_37(F, X, ...) F(X)MAP_0_36(F, __VA_ARGS__)
-#define MAP_0_38(F, X, ...) F(X)MAP_0_37(F, __VA_ARGS__)
-#define MAP_0_39(F, X, ...) F(X)MAP_0_38(F, __VA_ARGS__)
-#define MAP_0_40(F, X, ...) F(X)MAP_0_39(F, __VA_ARGS__)
-
-#define MAP_0_41(F, X, ...) F(X)MAP_0_40(F, __VA_ARGS__)
-#define MAP_0_42(F, X, ...) F(X)MAP_0_41(F, __VA_ARGS__)
-#define MAP_0_43(F, X, ...) F(X)MAP_0_42(F, __VA_ARGS__)
-#define MAP_0_44(F, X, ...) F(X)MAP_0_43(F, __VA_ARGS__)
-#define MAP_0_45(F, X, ...) F(X)MAP_0_44(F, __VA_ARGS__)
-#define MAP_0_46(F, X, ...) F(X)MAP_0_45(F, __VA_ARGS__)
-#define MAP_0_47(F, X, ...) F(X)MAP_0_46(F, __VA_ARGS__)
-#define MAP_0_48(F, X, ...) F(X)MAP_0_47(F, __VA_ARGS__)
-
-#define MAP_0_49(F, X, ...) F(X)MAP_0_48(F, __VA_ARGS__)
-#define MAP_0_50(F, X, ...) F(X)MAP_0_49(F, __VA_ARGS__)
-#define MAP_0_51(F, X, ...) F(X)MAP_0_50(F, __VA_ARGS__)
-#define MAP_0_52(F, X, ...) F(X)MAP_0_51(F, __VA_ARGS__)
-#define MAP_0_53(F, X, ...) F(X)MAP_0_52(F, __VA_ARGS__)
-#define MAP_0_54(F, X, ...) F(X)MAP_0_53(F, __VA_ARGS__)
-#define MAP_0_55(F, X, ...) F(X)MAP_0_54(F, __VA_ARGS__)
-#define MAP_0_56(F, X, ...) F(X)MAP_0_55(F, __VA_ARGS__)
-
-#define MAP_0_57(F, X, ...) F(X)MAP_0_56(F, __VA_ARGS__)
-#define MAP_0_58(F, X, ...) F(X)MAP_0_57(F, __VA_ARGS__)
-#define MAP_0_59(F, X, ...) F(X)MAP_0_58(F, __VA_ARGS__)
-#define MAP_0_60(F, X, ...) F(X)MAP_0_59(F, __VA_ARGS__)
-#define MAP_0_61(F, X, ...) F(X)MAP_0_60(F, __VA_ARGS__)
-#define MAP_0_62(F, X, ...) F(X)MAP_0_61(F, __VA_ARGS__)
-#define MAP_0_63(F, X, ...) F(X)MAP_0_62(F, __VA_ARGS__)
-#define MAP_0_64(F, X, ...) F(X)MAP_0_63(F, __VA_ARGS__)
-
-#define MAP_0_65(F, X, ...) F(X)MAP_0_64(F, __VA_ARGS__)
-#define MAP_0_66(F, X, ...) F(X)MAP_0_65(F, __VA_ARGS__)
-#define MAP_0_67(F, X, ...) F(X)MAP_0_66(F, __VA_ARGS__)
-#define MAP_0_68(F, X, ...) F(X)MAP_0_67(F, __VA_ARGS__)
-#define MAP_0_69(F, X, ...) F(X)MAP_0_68(F, __VA_ARGS__)
-#define MAP_0_70(F, X, ...) F(X)MAP_0_69(F, __VA_ARGS__)
-#define MAP_0_71(F, X, ...) F(X)MAP_0_70(F, __VA_ARGS__)
-#define MAP_0_72(F, X, ...) F(X)MAP_0_71(F, __VA_ARGS__)
-
-#define MAP_0_73(F, X, ...) F(X)MAP_0_72(F, __VA_ARGS__)
-#define MAP_0_74(F, X, ...) F(X)MAP_0_73(F, __VA_ARGS__)
-#define MAP_0_75(F, X, ...) F(X)MAP_0_74(F, __VA_ARGS__)
-#define MAP_0_76(F, X, ...) F(X)MAP_0_75(F, __VA_ARGS__)
-#define MAP_0_77(F, X, ...) F(X)MAP_0_76(F, __VA_ARGS__)
-#define MAP_0_78(F, X, ...) F(X)MAP_0_77(F, __VA_ARGS__)
-#define MAP_0_79(F, X, ...) F(X)MAP_0_78(F, __VA_ARGS__)
-#define MAP_0_80(F, X, ...) F(X)MAP_0_79(F, __VA_ARGS__)
-
-#define MAP_0_81(F, X, ...) F(X)MAP_0_80(F, __VA_ARGS__)
-#define MAP_0_82(F, X, ...) F(X)MAP_0_81(F, __VA_ARGS__)
-#define MAP_0_83(F, X, ...) F(X)MAP_0_82(F, __VA_ARGS__)
-#define MAP_0_84(F, X, ...) F(X)MAP_0_83(F, __VA_ARGS__)
-#define MAP_0_85(F, X, ...) F(X)MAP_0_84(F, __VA_ARGS__)
-#define MAP_0_86(F, X, ...) F(X)MAP_0_85(F, __VA_ARGS__)
-#define MAP_0_87(F, X, ...) F(X)MAP_0_86(F, __VA_ARGS__)
-#define MAP_0_88(F, X, ...) F(X)MAP_0_87(F, __VA_ARGS__)
-
-#define MAP_0_89(F, X, ...) F(X)MAP_0_88(F, __VA_ARGS__)
-#define MAP_0_90(F, X, ...) F(X)MAP_0_89(F, __VA_ARGS__)
-#define MAP_0_91(F, X, ...) F(X)MAP_0_90(F, __VA_ARGS__)
-#define MAP_0_92(F, X, ...) F(X)MAP_0_91(F, __VA_ARGS__)
-#define MAP_0_93(F, X, ...) F(X)MAP_0_92(F, __VA_ARGS__)
-#define MAP_0_94(F, X, ...) F(X)MAP_0_93(F, __VA_ARGS__)
-#define MAP_0_95(F, X, ...) F(X)MAP_0_94(F, __VA_ARGS__)
-#define MAP_0_96(F, X, ...) F(X)MAP_0_95(F, __VA_ARGS__)
-
-
-//-----------------------------------------------------------------------------
-#define MAP_1_01(F, A, X)      F(A, X)
-#define MAP_1_02(F, A, X, ...) F(A, X)MAP_1_01(F, A, __VA_ARGS__)
-#define MAP_1_03(F, A, X, ...) F(A, X)MAP_1_02(F, A, __VA_ARGS__)
-#define MAP_1_04(F, A, X, ...) F(A, X)MAP_1_03(F, A, __VA_ARGS__)
-#define MAP_1_05(F, A, X, ...) F(A, X)MAP_1_04(F, A, __VA_ARGS__)
-#define MAP_1_06(F, A, X, ...) F(A, X)MAP_1_05(F, A, __VA_ARGS__)
-#define MAP_1_07(F, A, X, ...) F(A, X)MAP_1_06(F, A, __VA_ARGS__)
-#define MAP_1_08(F, A, X, ...) F(A, X)MAP_1_07(F, A, __VA_ARGS__)
-
-#define MAP_1_09(F, A, X, ...) F(A, X)MAP_1_08(F, A, __VA_ARGS__)
-#define MAP_1_10(F, A, X, ...) F(A, X)MAP_1_09(F, A, __VA_ARGS__)
-#define MAP_1_11(F, A, X, ...) F(A, X)MAP_1_10(F, A, __VA_ARGS__)
-#define MAP_1_12(F, A, X, ...) F(A, X)MAP_1_11(F, A, __VA_ARGS__)
-#define MAP_1_13(F, A, X, ...) F(A, X)MAP_1_12(F, A, __VA_ARGS__)
-#define MAP_1_14(F, A, X, ...) F(A, X)MAP_1_13(F, A, __VA_ARGS__)
-#define MAP_1_15(F, A, X, ...) F(A, X)MAP_1_14(F, A, __VA_ARGS__)
-#define MAP_1_16(F, A, X, ...) F(A, X)MAP_1_15(F, A, __VA_ARGS__)
-
-#define MAP_1_17(F, A, X, ...) F(A, X)MAP_1_16(F, A, __VA_ARGS__)
-#define MAP_1_18(F, A, X, ...) F(A, X)MAP_1_17(F, A, __VA_ARGS__)
-#define MAP_1_19(F, A, X, ...) F(A, X)MAP_1_18(F, A, __VA_ARGS__)
-#define MAP_1_20(F, A, X, ...) F(A, X)MAP_1_19(F, A, __VA_ARGS__)
-#define MAP_1_21(F, A, X, ...) F(A, X)MAP_1_20(F, A, __VA_ARGS__)
-#define MAP_1_22(F, A, X, ...) F(A, X)MAP_1_21(F, A, __VA_ARGS__)
-#define MAP_1_23(F, A, X, ...) F(A, X)MAP_1_22(F, A, __VA_ARGS__)
-#define MAP_1_24(F, A, X, ...) F(A, X)MAP_1_23(F, A, __VA_ARGS__)
-
-#define MAP_1_25(F, A, X, ...) F(A, X)MAP_1_24(F, A, __VA_ARGS__)
-#define MAP_1_26(F, A, X, ...) F(A, X)MAP_1_25(F, A, __VA_ARGS__)
-#define MAP_1_27(F, A, X, ...) F(A, X)MAP_1_26(F, A, __VA_ARGS__)
-#define MAP_1_28(F, A, X, ...) F(A, X)MAP_1_27(F, A, __VA_ARGS__)
-#define MAP_1_29(F, A, X, ...) F(A, X)MAP_1_28(F, A, __VA_ARGS__)
-#define MAP_1_30(F, A, X, ...) F(A, X)MAP_1_29(F, A, __VA_ARGS__)
-#define MAP_1_31(F, A, X, ...) F(A, X)MAP_1_30(F, A, __VA_ARGS__)
-#define MAP_1_32(F, A, X, ...) F(A, X)MAP_1_31(F, A, __VA_ARGS__)
-
-#define MAP_1_33(F, A, X, ...) F(A, X)MAP_1_32(F, A, __VA_ARGS__)
-#define MAP_1_34(F, A, X, ...) F(A, X)MAP_1_33(F, A, __VA_ARGS__)
-#define MAP_1_35(F, A, X, ...) F(A, X)MAP_1_34(F, A, __VA_ARGS__)
-#define MAP_1_36(F, A, X, ...) F(A, X)MAP_1_35(F, A, __VA_ARGS__)
-#define MAP_1_37(F, A, X, ...) F(A, X)MAP_1_36(F, A, __VA_ARGS__)
-#define MAP_1_38(F, A, X, ...) F(A, X)MAP_1_37(F, A, __VA_ARGS__)
-#define MAP_1_39(F, A, X, ...) F(A, X)MAP_1_38(F, A, __VA_ARGS__)
-#define MAP_1_40(F, A, X, ...) F(A, X)MAP_1_39(F, A, __VA_ARGS__)
-
-#define MAP_1_41(F, A, X, ...) F(A, X)MAP_1_40(F, A, __VA_ARGS__)
-#define MAP_1_42(F, A, X, ...) F(A, X)MAP_1_41(F, A, __VA_ARGS__)
-#define MAP_1_43(F, A, X, ...) F(A, X)MAP_1_42(F, A, __VA_ARGS__)
-#define MAP_1_44(F, A, X, ...) F(A, X)MAP_1_43(F, A, __VA_ARGS__)
-#define MAP_1_45(F, A, X, ...) F(A, X)MAP_1_44(F, A, __VA_ARGS__)
-#define MAP_1_46(F, A, X, ...) F(A, X)MAP_1_45(F, A, __VA_ARGS__)
-#define MAP_1_47(F, A, X, ...) F(A, X)MAP_1_46(F, A, __VA_ARGS__)
-#define MAP_1_48(F, A, X, ...) F(A, X)MAP_1_47(F, A, __VA_ARGS__)
-
-#define MAP_1_49(F, A, X, ...) F(A, X)MAP_1_48(F, A, __VA_ARGS__)
-#define MAP_1_50(F, A, X, ...) F(A, X)MAP_1_49(F, A, __VA_ARGS__)
-#define MAP_1_51(F, A, X, ...) F(A, X)MAP_1_50(F, A, __VA_ARGS__)
-#define MAP_1_52(F, A, X, ...) F(A, X)MAP_1_51(F, A, __VA_ARGS__)
-#define MAP_1_53(F, A, X, ...) F(A, X)MAP_1_52(F, A, __VA_ARGS__)
-#define MAP_1_54(F, A, X, ...) F(A, X)MAP_1_53(F, A, __VA_ARGS__)
-#define MAP_1_55(F, A, X, ...) F(A, X)MAP_1_54(F, A, __VA_ARGS__)
-#define MAP_1_56(F, A, X, ...) F(A, X)MAP_1_55(F, A, __VA_ARGS__)
-
-#define MAP_1_57(F, A, X, ...) F(A, X)MAP_1_56(F, A, __VA_ARGS__)
-#define MAP_1_58(F, A, X, ...) F(A, X)MAP_1_57(F, A, __VA_ARGS__)
-#define MAP_1_59(F, A, X, ...) F(A, X)MAP_1_58(F, A, __VA_ARGS__)
-#define MAP_1_60(F, A, X, ...) F(A, X)MAP_1_59(F, A, __VA_ARGS__)
-#define MAP_1_61(F, A, X, ...) F(A, X)MAP_1_60(F, A, __VA_ARGS__)
-#define MAP_1_62(F, A, X, ...) F(A, X)MAP_1_61(F, A, __VA_ARGS__)
-#define MAP_1_63(F, A, X, ...) F(A, X)MAP_1_62(F, A, __VA_ARGS__)
-#define MAP_1_64(F, A, X, ...) F(A, X)MAP_1_63(F, A, __VA_ARGS__)
-
-#define MAP_1_65(F, A, X, ...) F(A, X)MAP_1_64(F, A, __VA_ARGS__)
-#define MAP_1_66(F, A, X, ...) F(A, X)MAP_1_65(F, A, __VA_ARGS__)
-#define MAP_1_67(F, A, X, ...) F(A, X)MAP_1_66(F, A, __VA_ARGS__)
-#define MAP_1_68(F, A, X, ...) F(A, X)MAP_1_67(F, A, __VA_ARGS__)
-#define MAP_1_69(F, A, X, ...) F(A, X)MAP_1_68(F, A, __VA_ARGS__)
-#define MAP_1_70(F, A, X, ...) F(A, X)MAP_1_69(F, A, __VA_ARGS__)
-#define MAP_1_71(F, A, X, ...) F(A, X)MAP_1_70(F, A, __VA_ARGS__)
-#define MAP_1_72(F, A, X, ...) F(A, X)MAP_1_71(F, A, __VA_ARGS__)
-
-#define MAP_1_73(F, A, X, ...) F(A, X)MAP_1_72(F, A, __VA_ARGS__)
-#define MAP_1_74(F, A, X, ...) F(A, X)MAP_1_73(F, A, __VA_ARGS__)
-#define MAP_1_75(F, A, X, ...) F(A, X)MAP_1_74(F, A, __VA_ARGS__)
-#define MAP_1_76(F, A, X, ...) F(A, X)MAP_1_75(F, A, __VA_ARGS__)
-#define MAP_1_77(F, A, X, ...) F(A, X)MAP_1_76(F, A, __VA_ARGS__)
-#define MAP_1_78(F, A, X, ...) F(A, X)MAP_1_77(F, A, __VA_ARGS__)
-#define MAP_1_79(F, A, X, ...) F(A, X)MAP_1_78(F, A, __VA_ARGS__)
-#define MAP_1_80(F, A, X, ...) F(A, X)MAP_1_79(F, A, __VA_ARGS__)
-
-#define MAP_1_81(F, A, X, ...) F(A, X)MAP_1_80(F, A, __VA_ARGS__)
-#define MAP_1_82(F, A, X, ...) F(A, X)MAP_1_81(F, A, __VA_ARGS__)
-#define MAP_1_83(F, A, X, ...) F(A, X)MAP_1_82(F, A, __VA_ARGS__)
-#define MAP_1_84(F, A, X, ...) F(A, X)MAP_1_83(F, A, __VA_ARGS__)
-#define MAP_1_85(F, A, X, ...) F(A, X)MAP_1_84(F, A, __VA_ARGS__)
-#define MAP_1_86(F, A, X, ...) F(A, X)MAP_1_85(F, A, __VA_ARGS__)
-#define MAP_1_87(F, A, X, ...) F(A, X)MAP_1_86(F, A, __VA_ARGS__)
-#define MAP_1_88(F, A, X, ...) F(A, X)MAP_1_87(F, A, __VA_ARGS__)
-
-#define MAP_1_89(F, A, X, ...) F(A, X)MAP_1_88(F, A, __VA_ARGS__)
-#define MAP_1_90(F, A, X, ...) F(A, X)MAP_1_89(F, A, __VA_ARGS__)
-#define MAP_1_91(F, A, X, ...) F(A, X)MAP_1_90(F, A, __VA_ARGS__)
-#define MAP_1_92(F, A, X, ...) F(A, X)MAP_1_91(F, A, __VA_ARGS__)
-#define MAP_1_93(F, A, X, ...) F(A, X)MAP_1_92(F, A, __VA_ARGS__)
-#define MAP_1_94(F, A, X, ...) F(A, X)MAP_1_93(F, A, __VA_ARGS__)
-#define MAP_1_95(F, A, X, ...) F(A, X)MAP_1_94(F, A, __VA_ARGS__)
-#define MAP_1_96(F, A, X, ...) F(A, X)MAP_1_95(F, A, __VA_ARGS__)
-
-
-//-----------------------------------------------------------------------------
-// Uses the sliding pairs dispatch technique: by passing __VA_ARGS__ as the
-// first set of variables and appending (reverse orderred) names of the
-// corresponding macros, we get the name of the correct arity macro.
-//
-// Ensure this is called with at least N+2 parameters otherwise GCC in
-// particular will complain about requiring at least one value for varargs
-#define ARITY_DISPATCH(                 \
-    _01,_02,_03,_04,_05,_06,_07,_08,    \
-    _09,_10,_11,_12,_13,_14,_15,_16,    \
-    _17,_18,_19,_20,_21,_22,_23,_24,    \
-    _25,_26,_27,_28,_29,_30,_31,_32,    \
-    _33,_34,_35,_36,_37,_38,_39,_40,    \
-    _41,_42,_43,_44,_45,_46,_47,_48,    \
-    _49,_50,_51,_52,_53,_54,_55,_56,    \
-    _57,_58,_59,_60,_61,_62,_63,_64,    \
-    _65,_66,_67,_68,_69,_70,_71,_72,    \
-    _73,_74,_75,_76,_77,_78,_79,_80,    \
-    _81,_82,_83,_84,_85,_86,_87,_88,    \
-    _89,_90,_91,_92,_93,_94,_95,_96,    \
-    NAME,...                            \
-) NAME
-
-
-//-----------------------------------------------------------------------------
-// reduces a series of values by repeated application of some macro 'func'.
-//
-// useful for things like variadic 'paste'
-//
-// it's only implemented for up to 8 arguments (because that's all you should
-// need you monster...) but we need to have enough arguments to make
-// ARITY_DISPATCH work so we fill it with nonces.
-#define REDUCE(FUNC,...)                                \
-ARITY_DISPATCH(__VA_ARGS__,                             \
-    _96, _95, _94, _93, _92, _91, _90, _89,             \
-    _88, _87, _86, _85, _84, _83, _82, _81,             \
-    _80, _79, _78, _77, _76, _75, _74, _73,             \
-    _72, _71, _70, _69, _68, _67, _66, _65,             \
-    _64, _63, _62, _61, _60, _59, _58, _57,             \
-    _56, _55, _54, _53, _52, _51, _50, _49,             \
-    _48, _47, _46, _45, _44, _43, _42, _41,             \
-    _40, _39, _38, _37, _36, _35, _34, _33,             \
-    _32, _31, _30, _29, _28, _27, _26, _25,             \
-    _24, _23, _22, _21, _20, _19, _18, _17,             \
-    _16, _15, _14, _13, _12, _11, _10, _09,             \
-    REDUCE_2_08, REDUCE_2_07, REDUCE_2_06, REDUCE_2_05, \
-    REDUCE_2_04, REDUCE_2_03, REDUCE_2_02, REDUCE_2_01, \
-    STATIC_ASSERT("invalid arity for REDUCE")           \
-)(FUNC,__VA_ARGS__)
-
-
-// concatenate a series of tokens
-#define PASTE(...) REDUCE(PASTE2,__VA_ARGS__)
-
-
-// Map a macro across __VA_ARGS__. Can be easily expanded, but has non-obvious
-// failure mode when supported arity is exceeded.
-//
-// Don't use this, unless you really need the stringize operator, or other
-// macro magic.
-//
-// Just use templates. Really...
-#define MAP(FUNC,...)                                                               \
-ARITY_DISPATCH(__VA_ARGS__,                                                         \
-    MAP_0_96, MAP_0_95, MAP_0_94, MAP_0_93, MAP_0_92, MAP_0_91, MAP_0_90, MAP_0_89, \
-    MAP_0_88, MAP_0_87, MAP_0_86, MAP_0_85, MAP_0_84, MAP_0_83, MAP_0_82, MAP_0_81, \
-    MAP_0_80, MAP_0_79, MAP_0_78, MAP_0_77, MAP_0_76, MAP_0_75, MAP_0_74, MAP_0_73, \
-    MAP_0_72, MAP_0_71, MAP_0_70, MAP_0_69, MAP_0_68, MAP_0_67, MAP_0_66, MAP_0_65, \
-    MAP_0_64, MAP_0_63, MAP_0_62, MAP_0_61, MAP_0_60, MAP_0_59, MAP_0_58, MAP_0_57, \
-    MAP_0_56, MAP_0_55, MAP_0_54, MAP_0_53, MAP_0_52, MAP_0_51, MAP_0_50, MAP_0_49, \
-    MAP_0_48, MAP_0_47, MAP_0_46, MAP_0_45, MAP_0_44, MAP_0_43, MAP_0_42, MAP_0_41, \
-    MAP_0_40, MAP_0_39, MAP_0_38, MAP_0_37, MAP_0_36, MAP_0_35, MAP_0_34, MAP_0_33, \
-    MAP_0_32, MAP_0_31, MAP_0_30, MAP_0_29, MAP_0_28, MAP_0_27, MAP_0_26, MAP_0_25, \
-    MAP_0_24, MAP_0_23, MAP_0_22, MAP_0_21, MAP_0_20, MAP_0_19, MAP_0_18, MAP_0_17, \
-    MAP_0_16, MAP_0_15, MAP_0_14, MAP_0_13, MAP_0_12, MAP_0_11, MAP_0_10, MAP_0_09, \
-    MAP_0_08, MAP_0_07, MAP_0_06, MAP_0_05, MAP_0_04, MAP_0_03, MAP_0_02, MAP_0_01, \
-    STATIC_ASSERT("invalid arity for MAP")                                          \
-)(FUNC, __VA_ARGS__)
-
-
-// Note: this is one fewer argument than MAP because of the leading parameter
-// passed to all invokations.
-#define MAP1(FUNC,...)                                                              \
-ARITY_DISPATCH(__VA_ARGS__,                                                         \
-              MAP_1_95, MAP_1_94, MAP_1_93, MAP_1_92, MAP_1_91, MAP_1_90, MAP_1_89, \
-    MAP_1_88, MAP_1_87, MAP_1_86, MAP_1_85, MAP_1_84, MAP_1_83, MAP_1_82, MAP_1_81, \
-    MAP_1_80, MAP_1_79, MAP_1_78, MAP_1_77, MAP_1_76, MAP_1_75, MAP_1_74, MAP_1_73, \
-    MAP_1_72, MAP_1_71, MAP_1_70, MAP_1_69, MAP_1_68, MAP_1_67, MAP_1_66, MAP_1_65, \
-    MAP_1_64, MAP_1_63, MAP_1_62, MAP_1_61, MAP_1_60, MAP_1_59, MAP_1_58, MAP_1_57, \
-    MAP_1_56, MAP_1_55, MAP_1_54, MAP_1_53, MAP_1_52, MAP_1_51, MAP_1_50, MAP_1_49, \
-    MAP_1_48, MAP_1_47, MAP_1_46, MAP_1_45, MAP_1_44, MAP_1_43, MAP_1_42, MAP_1_41, \
-    MAP_1_40, MAP_1_39, MAP_1_38, MAP_1_37, MAP_1_36, MAP_1_35, MAP_1_34, MAP_1_33, \
-    MAP_1_32, MAP_1_31, MAP_1_30, MAP_1_29, MAP_1_28, MAP_1_27, MAP_1_26, MAP_1_25, \
-    MAP_1_24, MAP_1_23, MAP_1_22, MAP_1_21, MAP_1_20, MAP_1_19, MAP_1_18, MAP_1_17, \
-    MAP_1_16, MAP_1_15, MAP_1_14, MAP_1_13, MAP_1_12, MAP_1_11, MAP_1_10, MAP_1_09, \
-    MAP_1_08, MAP_1_07, MAP_1_06, MAP_1_05, MAP_1_04, MAP_1_03, MAP_1_02, MAP_1_01, \
-    STATIC_ASSERT("invalid arity for MAP1")                                         \
-)(FUNC, __VA_ARGS__)
-
-
-
-#define LITERAL_00  0
-#define LITERAL_01  1
-#define LITERAL_02  2
-#define LITERAL_03  3
-#define LITERAL_04  4
-#define LITERAL_05  5
-#define LITERAL_06  6
-#define LITERAL_07  7
-#define LITERAL_08  8
-#define LITERAL_09  9
-#define LITERAL_10 10
-#define LITERAL_11 11
-#define LITERAL_12 12
-#define LITERAL_13 13
-#define LITERAL_14 14
-#define LITERAL_15 15
-#define LITERAL_16 16
-#define LITERAL_17 17
-#define LITERAL_18 18
-#define LITERAL_19 19
-#define LITERAL_20 20
-#define LITERAL_21 21
-#define LITERAL_22 22
-#define LITERAL_23 23
-#define LITERAL_24 24
-#define LITERAL_25 25
-#define LITERAL_26 26
-#define LITERAL_27 27
-#define LITERAL_28 28
-#define LITERAL_29 29
-#define LITERAL_30 30
-#define LITERAL_31 31
-#define LITERAL_32 32
-#define LITERAL_33 33
-#define LITERAL_34 34
-#define LITERAL_35 35
-#define LITERAL_36 36
-#define LITERAL_37 37
-#define LITERAL_38 38
-#define LITERAL_39 39
-#define LITERAL_40 40
-#define LITERAL_41 41
-#define LITERAL_42 42
-#define LITERAL_43 43
-#define LITERAL_44 44
-#define LITERAL_45 45
-#define LITERAL_46 46
-#define LITERAL_47 47
-#define LITERAL_48 48
-#define LITERAL_49 49
-#define LITERAL_50 50
-#define LITERAL_51 51
-#define LITERAL_52 52
-#define LITERAL_53 53
-#define LITERAL_54 54
-#define LITERAL_55 55
-#define LITERAL_56 56
-#define LITERAL_57 57
-#define LITERAL_58 58
-#define LITERAL_59 59
-#define LITERAL_60 60
-#define LITERAL_61 61
-#define LITERAL_62 62
-#define LITERAL_63 63
-#define LITERAL_64 64
-#define LITERAL_65 65
-#define LITERAL_66 66
-#define LITERAL_67 67
-#define LITERAL_68 68
-#define LITERAL_69 69
-#define LITERAL_70 70
-#define LITERAL_71 71
-#define LITERAL_72 72
-#define LITERAL_73 73
-#define LITERAL_74 74
-#define LITERAL_75 75
-#define LITERAL_76 76
-#define LITERAL_77 77
-#define LITERAL_78 78
-#define LITERAL_79 79
-#define LITERAL_80 80
-#define LITERAL_81 81
-#define LITERAL_82 82
-#define LITERAL_83 83
-#define LITERAL_84 84
-#define LITERAL_85 85
-#define LITERAL_86 86
-#define LITERAL_87 87
-#define LITERAL_88 88
-#define LITERAL_89 89
-#define LITERAL_90 90
-#define LITERAL_91 91
-#define LITERAL_92 92
-#define LITERAL_93 93
-#define LITERAL_94 94
-#define LITERAL_95 95
-#define LITERAL_96 96
-
-
-#define VA_ARGS_COUNT(...)                          \
-ARITY_DISPATCH(__VA_ARGS__,                         \
-    LITERAL_96, LITERAL_95, LITERAL_94, LITERAL_93, \
-    LITERAL_92, LITERAL_91, LITERAL_90, LITERAL_89, \
-    LITERAL_88, LITERAL_87, LITERAL_86, LITERAL_85, \
-    LITERAL_84, LITERAL_83, LITERAL_82, LITERAL_81, \
-    LITERAL_80, LITERAL_79, LITERAL_78, LITERAL_77, \
-    LITERAL_76, LITERAL_75, LITERAL_74, LITERAL_73, \
-    LITERAL_72, LITERAL_71, LITERAL_70, LITERAL_69, \
-    LITERAL_68, LITERAL_67, LITERAL_66, LITERAL_65, \
-    LITERAL_64, LITERAL_63, LITERAL_62, LITERAL_61, \
-    LITERAL_60, LITERAL_59, LITERAL_58, LITERAL_57, \
-    LITERAL_56, LITERAL_55, LITERAL_54, LITERAL_53, \
-    LITERAL_52, LITERAL_51, LITERAL_50, LITERAL_49, \
-    LITERAL_48, LITERAL_47, LITERAL_46, LITERAL_45, \
-    LITERAL_44, LITERAL_43, LITERAL_42, LITERAL_41, \
-    LITERAL_40, LITERAL_39, LITERAL_38, LITERAL_37, \
-    LITERAL_36, LITERAL_35, LITERAL_34, LITERAL_33, \
-    LITERAL_32, LITERAL_31, LITERAL_30, LITERAL_29, \
-    LITERAL_28, LITERAL_27, LITERAL_26, LITERAL_25, \
-    LITERAL_24, LITERAL_23, LITERAL_22, LITERAL_21, \
-    LITERAL_20, LITERAL_19, LITERAL_18, LITERAL_17, \
-    LITERAL_16, LITERAL_15, LITERAL_14, LITERAL_13, \
-    LITERAL_12, LITERAL_11, LITERAL_10, LITERAL_09, \
-    LITERAL_08, LITERAL_07, LITERAL_06, LITERAL_05, \
-    LITERAL_04, LITERAL_03, LITERAL_02, LITERAL_01, \
-    STATIC_ASSERT("invalid value for VA_ARGS_COUNT")\
-)
-
-
-#endif
diff --git a/preprocessor.py b/preprocessor.py
new file mode 100755
index 00000000..d52a6131
--- /dev/null
+++ b/preprocessor.py
@@ -0,0 +1,202 @@
+#!/usr/bin/python3
+
+import itertools
+
+
+###############################################################################
+def chunks(values, size):
+    it = iter(values)
+    item = list(itertools.islice(it, size))
+
+    while item:
+        yield item
+        item = list(itertools.islice(it, size))
+
+
+###############################################################################
+# Construct a variadic macro of the form:
+#
+# ARITY_DISPATCH(_0001, _0002, NAME, ...) NAME
+#
+# Where the numbered arguments is equal to the predefined maximum arity.
+def generate_dispatch(num):
+    values = itertools.chain(
+        ("_%04u" % n for n in range (1, num+1)),
+        ["NAME"]
+    )
+
+    yield "#define ARITY_DISPATCH(\\"
+    for group in chunks(values, 8):
+        yield ", ".join(group) + ", \\"
+    yield "...) NAME"
+
+
+###############################################################################
+# Construct a variadic macro of the form:
+#
+# define REDUCE_1_0002(F,X,Y) F(X,Y)
+# define REDUCE_1_0003(F,X,Y,...) REDUCE_2_0002(F,F(X,Y),__VA_ARGS__)
+# define REDUCE_1_0004(F,X,Y,...) REDUCE_2_0003(F,F(X,Y),__VA_ARGS__)
+#
+# and so on
+#
+# We do not provide a definition for REDUCE_1_0000 because it does not
+# actually reduce anything. Instead we define it as a static_assert to
+# simplify the general dispatch generation code.
+#
+# The macro is defined as if it were arity 1, because the dispatch generation
+# code operates in terms of the tail call and offsets the dispatch arguments
+# by the arity.
+def generate_reduce(num):
+    yield '#define REDUCE_1_0000(...) STATIC_ASSERT("REDUCE requires at least two arguments")'
+    yield "#define REDUCE_1_0001(F,X,Y) F(X,Y)"
+
+    for n in range(2, num):
+        yield "#define REDUCE_1_%04u(F,X,Y,...) REDUCE_1_%04u(F,F(X,Y),__VA_ARGS__)" % (n, n - 1)
+
+    raise StopIteration
+
+
+###############################################################################
+# Generate a variadic macro of the form:
+#
+# define MAP_ARITY_0000(F,A,B) F(A,B)
+# define MAP_ARITY_0001(F,A,B,...) F(X)(MAP_0000_0000(F,A,B,__VA_ARGS___)
+# define MAP_ARITY_0002(F,A,B,...) F(X)(MAP_0000_0001(F,A,B,__VA_ARGS___)
+#
+# and so on...
+#
+# Note: the arguments A, B, etc are replaced with a quantity of arguments
+# indicated by the `arity' parameter.
+def generate_map(num, arity):
+    args = ",".join("ARG%02u" % n for n in range(arity))
+    if args:
+        args += ','
+    yield "#define MAP_%(arity)u_0001(F,%(args)sX) F(%(args)sX)" % { 'arity': arity, 'args': args }
+
+    for n in range(2, num):
+        yield "#define %(curr)s(F,%(args)sX,...) F(%(args)sX)%(next)s(F,%(args)s__VA_ARGS__)" % {
+            'curr': 'MAP_%(arity)u_%(index)04u' % { 'arity': arity, 'index': n     },
+            'next': 'MAP_%(arity)u_%(index)04u' % { 'arity': arity, 'index': n - 1 },
+            'arity': arity,
+            'args': args,
+        }
+
+    raise StopIteration
+
+
+##-----------------------------------------------------------------------------
+def dispatch(name, num, arity):
+    yield "#define %(name)s%(arity)u(FUNC,...)\\" % { 'name': name, 'arity': arity }
+    yield "ARITY_DISPATCH(__VA_ARGS__,\\"
+
+    for group in chunks(range(num-arity,0,-1), 4):
+        yield ",".join (
+            "%(name)s_%(arity)u_%(n)04u" % {
+                'name': name,
+                'arity': arity,
+                'n': n
+            } for n in group
+        ) + ",\\"
+
+    yield ', STATIC_ASSERT("invalid arity for %s")\\' % name
+    yield ')(FUNC,__VA_ARGS__)'
+
+
+###############################################################################
+def generate_argcount(num):
+    yield "#define VA_ARGS_COUNT(...)\\"
+    yield "ARITY_DISPATCH(__VA_ARGS__,\\"
+
+    literals = ",".join(str(n) for n in range(num,0,-1))
+    for group in chunks(range(num, 0, -1), 4):
+        yield ", ".join('% 4u' % g for g in group) + ',\\'
+
+    yield ', STATIC_ASSERT("invalid value for VA_ARGS_COUNT"))'
+
+
+###############################################################################
+import argparse
+
+
+##-----------------------------------------------------------------------------
+if __name__ == '__main__':
+    #logging.getLogger().setLevel(logging.INFO)
+
+    parser = argparse.ArgumentParser(description='Generate variadic macro functions')
+    parser.add_argument('dst', type=str, help='the output path for the header')
+    parser.add_argument('num', type=int, help='the maximum argument count')
+
+    args = parser.parse_args()
+
+    dst = open(args.dst, 'w')
+    num = args.num
+    arity = 3
+
+    dst.write("""\
+#ifndef CRUFT_UTIL_PREPROCESSOR_HPP
+#define CRUFT_UTIL_PREPROCESSOR_HPP
+    
+///////////////////////////////////////////////////////////////////////////////
+//
+// This is autogenerated code, do not modify. Instead, look at preprocessor.py
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Here be dragons. For the love of God, only use these macros for token
+// pasting applications. Don't judge me...
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Token concatenation wrapper that prevents macro expansion. You should not
+// be using this outside of this header file (and probably not even then for
+// the most part).
+#define PASTE_DETAIL(x, y) x##y
+
+// A token concatenation wrapper. You should prefer PASTE over PASTE2. This
+// is defined purely so that PASTE (defined laterR) has something to give
+// REDUCE1.
+#define PASTE2(x,y) PASTE_DETAIL(x,y)
+
+// Pair token concatenation with a trailing comma.
+#define PASTE_LIST(x,y) PASTE2(x,y),
+
+// Pair token concatenation, transforming into a namespace and type.
+#define NAMESPACE_LIST(NS,KLASS) NS::KLASS,
+
+
+#define STRINGIZE_DETAIL(x) #x
+#define STRINGIZE(x) STRINGIZE_DETAIL(x)
+#define STRINGIZE_LIST(x) STRINGIZE(x),
+
+
+#define STATIC_ASSERT(MSG) static_assert(false, MSG);
+
+
+///////////////////////////////////////////////////////////////////////////////
+    """)
+
+    dst.write("#define MAX_VA_DISPATCH_ARGS %u\n" % num)
+    dst.write("#define MAX_VA_DISPATCH_ARITY %u\n" % arity)
+
+    lines = itertools.chain (
+        generate_dispatch(num),
+        generate_map(num, 0),
+        generate_map(num, 1),
+        generate_map(num, 2),
+        dispatch("MAP", num, 0),
+        dispatch("MAP", num, 1),
+        dispatch("MAP", num, 2),
+        generate_reduce(num),
+        dispatch("REDUCE", num, 1),
+        [ "#define PASTE(...) REDUCE1(PASTE2,__VA_ARGS__)" ],
+        generate_argcount(num)
+    )
+
+    for l in lines:
+        dst.write(l)
+        dst.write('\n')
+
+    dst.writelines("#endif\n")
diff --git a/test/preprocessor.cpp b/test/preprocessor.cpp
new file mode 100644
index 00000000..2e4d815b
--- /dev/null
+++ b/test/preprocessor.cpp
@@ -0,0 +1,21 @@
+#include "tap.hpp"
+#include "preprocessor.hpp"
+
+
+#define PLUS(X,Y) ((X)+(Y))
+#define SIX(...) 6
+
+int
+main (void)
+{
+    util::TAP::logger tap;
+
+    int foo = 1, bar = 2, foobar = 3;
+    tap.expect_eq (foo + bar, PASTE(foo,bar), "PASTE");
+    tap.expect_eq (REDUCE1(PLUS, 1, 2, 3, 4), 10, "REDUCE0");
+    tap.expect_eq (MAP0(SIX, 9), 6, "MAP0");
+    tap.expect_eq (MAP1(PLUS, 6, 9), 15, "MAP1");
+    tap.expect_eq (VA_ARGS_COUNT (1, 2, 3, 4, 5, , 7, 8, 9), 9, "VA_ARGS_COUNT");
+
+    return tap.status ();
+}

From c1aa0f7a3d42f0b3747f9fa8fbb6fb1254d65af9 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 12 Sep 2017 14:18:34 +1000
Subject: [PATCH 119/149] io: slurp should default to providing bytes, not
 chars

std::byte has less potential for abuse. if you want an array of chars
you should ask for it.
---
 backtrace_execinfo.cpp |  2 +-
 io.cpp                 | 34 +++++++++++++++++++++++++++-------
 io.hpp                 | 10 +++++++---
 3 files changed, 35 insertions(+), 11 deletions(-)

diff --git a/backtrace_execinfo.cpp b/backtrace_execinfo.cpp
index 4bb0c8d4..40176d78 100644
--- a/backtrace_execinfo.cpp
+++ b/backtrace_execinfo.cpp
@@ -60,7 +60,7 @@ addr2line (const void *addr)
     );
 
     // inefficient to copy from vector to string, but it's not a high priority path
-    auto data = util::slurp (stream.get ());
+    auto data = util::slurp<char> (stream.get ());
     return std::string (data.cbegin (), data.cend ());
 
 #else
diff --git a/io.cpp b/io.cpp
index f984633b..218e3a10 100644
--- a/io.cpp
+++ b/io.cpp
@@ -32,10 +32,15 @@
 using namespace util;
 
 
-//----------------------------------------------------------------------------
-std::vector<char>
+//////////////////////////////////////////////////////////////////////////////
+template <typename T>
+std::vector<T>
 util::slurp (const std::experimental::filesystem::path &path)
 {
+    static_assert (
+        sizeof (T) == 1,
+        "slurp is designed for grabbing bytes, not complex structures"
+    );
     posix::fd out (path, O_RDONLY | O_BINARY);
 
     // Calculate the total file size
@@ -47,11 +52,11 @@ util::slurp (const std::experimental::filesystem::path &path)
         throw errno_error ();
 
     // Allocate a buffer, and keep reading until it's full.
-    std::vector<char> buffer (size);
+    std::vector<T> buffer (size);
 
     CHECK_GE (size, 0);
     size_t remaining = (size_t)size;
-    char *cursor = buffer.data ();
+    T *cursor = buffer.data ();
 
     while (remaining) {
         ssize_t consumed = ::read (out, cursor, remaining);
@@ -69,9 +74,20 @@ util::slurp (const std::experimental::filesystem::path &path)
 
 
 //-----------------------------------------------------------------------------
-std::vector<char>
+template std::vector<char> util::slurp (const std::experimental::filesystem::path&);
+template std::vector<std::byte> util::slurp (const std::experimental::filesystem::path&);
+
+
+///////////////////////////////////////////////////////////////////////////////
+template <typename T>
+std::vector<T>
 util::slurp (FILE *stream)
 {
+    static_assert (
+        sizeof (T) == 1,
+        "slurp is designed for grabbing bytes, not complex structures"
+    );
+
     // find how much data is in this file
     const int desc = fileno (stream);
     if (desc < 0)
@@ -81,7 +97,7 @@ util::slurp (FILE *stream)
     if (fstat (desc, &meta) < 0)
         errno_error::throw_code ();
 
-    std::vector<char> buf;
+    std::vector<T> buf;
 
     // we think we know the size, so try to do a simple read
     if (meta.st_size) {
@@ -113,8 +129,12 @@ util::slurp (FILE *stream)
 }
 
 
-
 //-----------------------------------------------------------------------------
+template std::vector<char> util::slurp (FILE*);
+template std::vector<std::byte> util::slurp (FILE*);
+
+
+///////////////////////////////////////////////////////////////////////////////
 void
 util::write (const posix::fd &out,
              const void *restrict data,
diff --git a/io.hpp b/io.hpp
index 521109b5..f3bbe42b 100644
--- a/io.hpp
+++ b/io.hpp
@@ -20,8 +20,9 @@
 #include "platform.hpp"
 #include "posix/fd.hpp"
 
-#include <cstdio>
+#include <cstddef>
 #include <cstdint>
+#include <cstdio>
 #include <experimental/filesystem>
 #include <vector>
 #include <streambuf>
@@ -35,8 +36,11 @@
 namespace util {
     //-------------------------------------------------------------------------
     /// Reads an entire file into memory.
-    std::vector<char> slurp (const std::experimental::filesystem::path&);
-    std::vector<char> slurp (FILE *);
+    template <typename T = std::byte>
+    std::vector<T> slurp (const std::experimental::filesystem::path&);
+
+    template <typename T = std::byte>
+    std::vector<T> slurp (FILE *);
 
 
     //-------------------------------------------------------------------------

From d0e49fb1a80e1523703bac8bd971b62a3d6194ce Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Wed, 13 Sep 2017 12:37:53 +1000
Subject: [PATCH 120/149] debug: expose NDEBUG as a constexpr bool

---
 debug.hpp | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/debug.hpp b/debug.hpp
index a5e58220..39428eb3 100644
--- a/debug.hpp
+++ b/debug.hpp
@@ -24,13 +24,22 @@
 
 
 ///////////////////////////////////////////////////////////////////////////////
+// it is fractionally easier to define a constexpr variable which can be used
+// in constexpr-if to enable/disable some codepaths rather than deal with
+// macros in some scenarios. eg, templates are complicated enough without
+// (more) macros.
 #if !defined(NDEBUG)
-    #define DEBUG_ONLY(X) do { X } while (0)
+    constexpr bool debug_enabled = true;
 #else
-    #define DEBUG_ONLY(X) do {   } while (0)
+    constexpr bool debug_enabled = false;
 #endif
 
 
+///----------------------------------------------------------------------------
+/// enable some code only if assertions et al are enabled
+#define DEBUG_ONLY(X) do { if constexpr (debug_enabled) { X } } while (0)
+
+
 ///////////////////////////////////////////////////////////////////////////////
 #define EXIT_XSUCCESS        0
 #define EXIT_XSKIP          77

From 015dff80a04379fca0633ec7b5c4cbaf48241841 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Thu, 14 Sep 2017 13:13:45 +1000
Subject: [PATCH 121/149] view: add nulling move operations

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

diff --git a/view.hpp b/view.hpp
index a027ffe0..57c64fb2 100644
--- a/view.hpp
+++ b/view.hpp
@@ -39,6 +39,26 @@ namespace util {
             m_end   (last)
         { ; }
 
+
+        constexpr
+        view (const view &rhs) noexcept:
+            m_begin (rhs.m_begin),
+            m_end   (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.
+        constexpr view (view &&rhs) noexcept:
+            view (T{}, T{})
+        {
+            std::swap (m_begin, rhs.m_begin);
+            std::swap (m_end,   rhs.m_end);
+        }
+
+
         template <typename K>
         constexpr explicit
         view (K &klass):
@@ -53,6 +73,29 @@ namespace util {
             m_end   (std::end   (klass))
         { ; }
 
+
+        view&
+        operator= (const view &rhs) noexcept
+        {
+            m_begin = rhs.m_begin;
+            m_end   = rhs.m_end;
+            return *this;
+        }
+
+
+        view&
+        operator= (view &&rhs) noexcept
+        {
+            m_begin = rhs.m_begin;
+            m_end = rhs.m_end;
+
+            m_begin = T{};
+            m_end = T{};
+
+            return *this;
+        };
+
+
         constexpr T begin (void) noexcept { return m_begin; }
         constexpr T end   (void) noexcept { return m_end;   }
 

From c222e4e960909e505af620269398082ba94a074c Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Thu, 14 Sep 2017 13:24:08 +1000
Subject: [PATCH 122/149] view: constructor should take iterators by constref

who knows how big the iterators are, or if they can be moved.
---
 view.hpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/view.hpp b/view.hpp
index 57c64fb2..26d1efe4 100644
--- a/view.hpp
+++ b/view.hpp
@@ -34,7 +34,7 @@ namespace util {
         using value_type = typename std::iterator_traits<remove_restrict_t<T>>::value_type;
 
         constexpr
-        view (T first, T last) noexcept:
+        view (const T &first, const T &last) noexcept:
             m_begin (first),
             m_end   (last)
         { ; }
@@ -66,6 +66,7 @@ namespace util {
             m_end   (std::end   (klass))
         { ; }
 
+
         template <typename K>
         constexpr explicit
         view (const K &klass):

From 9c5b471b24f404be824ed5baaafea4d59f91da72 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Fri, 15 Sep 2017 15:21:25 +1000
Subject: [PATCH 123/149] iterator: modify to allow iteration over c arrays

---
 iterator.hpp      | 93 ++++++++++++++++++++++++++++++++---------------
 test/iterator.cpp | 10 +++--
 2 files changed, 71 insertions(+), 32 deletions(-)

diff --git a/iterator.hpp b/iterator.hpp
index 3c2e2bef..e9770bec 100644
--- a/iterator.hpp
+++ b/iterator.hpp
@@ -216,25 +216,31 @@ namespace util {
 
     ///////////////////////////////////////////////////////////////////////////
     namespace detail::zip {
+        // holds a tuple of iterators for begin and end, and returns an
+        // iterator that transforms these iterators into tuples of value_types.
+        //
+        // this must be expressed in terms of iterators, rather than containers,
+        // because it dramatically simplifies iterating over raw arrays.
         template <
-            typename ContainerT,
             typename IteratorT,
-            typename I = std::make_index_sequence<std::tuple_size<ContainerT>::value>
+            typename I = std::make_index_sequence<std::tuple_size<IteratorT>::value>
         >
-        struct collection;
+        class collection;
 
+
+        //---------------------------------------------------------------------
         template <
-            typename ContainerT,
             typename IteratorT,
             std::size_t ...I
         >
-        struct collection<
-            ContainerT,
+        class collection<
             IteratorT,
             std::index_sequence<I...>
         > {
-            collection (const ContainerT &_containers):
-                m_containers { _containers }
+        public:
+            collection (const IteratorT &_begin, const IteratorT &_end):
+                m_begin { _begin },
+                m_end   { _end   }
             { ; }
 
             struct iterator : std::iterator<
@@ -246,13 +252,14 @@ namespace util {
                 >,
                 std::size_t
             > {
-                IteratorT m_iterators;
-
-                iterator (IteratorT _iterators):
+            public:
+                iterator (const IteratorT &_iterators):
                     m_iterators (_iterators)
                 { ; }
 
-                iterator& operator++ (void)
+
+                iterator&
+                operator++ (void)
                 {
                     // HACK: we don't actually need to create a tuple here,
                     // but it's a zero cost method to expand the parameter
@@ -261,58 +268,86 @@ namespace util {
                     return *this;
                 }
 
+
                 iterator operator++ (int);
 
-                auto operator* (void)
+
+                auto
+                operator* (void)
                 {
                     return std::make_tuple (*std::get<I> (m_iterators)...);
                 }
 
-                bool operator== (const iterator &rhs) const
+
+                bool
+                operator== (const iterator &rhs) const
                 {
                     return m_iterators == rhs.m_iterators;
                 }
 
-                bool operator!= (const iterator &rhs) const
+
+                bool
+                operator!= (const iterator &rhs) const
                 {
                     return !(*this == rhs);
                 }
+
+            private:
+                IteratorT m_iterators;
             };
 
-            iterator begin (void)
+
+            iterator
+            begin (void)
             {
-                return iterator { { std::begin (std::get<I> (m_containers))... } };
+                return iterator { { std::get<I> (m_begin)... } };
             }
 
-            iterator end (void)
+
+            iterator
+            end (void)
             {
-                return iterator { { std::end (std::get<I> (m_containers))... } };
+                return iterator { { std::get<I> (m_end)... } };
             }
 
-            ContainerT m_containers;
+
+        private:
+            IteratorT m_begin;
+            IteratorT m_end;
         };
     }
 
 
-    //-------------------------------------------------------------------------
+    ///------------------------------------------------------------------------
+    /// takes a variable number of container arguments and returns an interable
+    /// object with a value_type of tuple of the argument's value_types.
+    ///
+    /// the returned iterator value_type is suitable for using in range-for
+    /// and structured bindings (and really, that's the entire point here).
+    ///
+    /// eg, util::zip ({1,2,3}, {4,5,6}) ~= {{1,4},{2,5},{3,6}}
     template <typename ...ContainerT>
     auto
     zip (const ContainerT&... data)
     {
-        using container = std::tuple<ContainerT...>;
-        using iterator = std::tuple<decltype(std::begin(data))...>;
+        using IteratorT = std::tuple<decltype(std::begin(data))...>;
 
         return detail::zip::collection<
-            container,
-            iterator,
+            IteratorT,
             std::make_index_sequence<sizeof...(ContainerT)>
-        > (
-            std::make_tuple (data...)
-        );
+        > {
+            std::make_tuple (std::begin (data)...),
+            std::make_tuple (std::end   (data)...)
+        };
     };
 
 
-    //-------------------------------------------------------------------------
+    ///------------------------------------------------------------------------
+    /// takes a variable number of containers and returns a zipped iterable
+    /// object where the first of the iterator's value_types is the index of
+    /// that iterator. ie, it combines container offsets with value_types.
+    ///
+    /// eg, util::izip ("abc") ~= {{0,'a'},{1,'b'},{2,'c'}}
     template <typename ...ContainerT>
     auto
     izip (const ContainerT&... data)
diff --git a/test/iterator.cpp b/test/iterator.cpp
index 78760608..bc308415 100644
--- a/test/iterator.cpp
+++ b/test/iterator.cpp
@@ -14,12 +14,16 @@ main (int, char**)
 
     std::vector<int> v_int { 1, 2, 3 };
     std::array<float,3> a_float { 1.1f, 2.2f, 3.3f };
+    char c_char[] = { 'a', 'b', 'c' };
 
     bool success = true;
-    for (auto [i, v, a]: util::izip (v_int, a_float)) {
-        success = success && v_int[i] == v && util::exactly_equal (a_float[i], a);
+    for (auto [i, v, a, c]: util::izip (v_int, a_float, c_char)) {
+        success = success &&
+                  v_int[i] == v &&
+                  util::exactly_equal (a_float[i], a) &&
+                  c_char[i] == c;
     }
 
-    tap.expect (success, "izip tuples of int and float");
+    tap.expect (success, "izip containers of int, float, and char and an initialiser_list");
     return tap.status ();
 }

From cfa272a80a1808f26f9db0a84242a3b946fe8098 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Fri, 15 Sep 2017 15:22:29 +1000
Subject: [PATCH 124/149] string: allow tokenisation of c arrays

---
 string.hpp      | 42 +++++++++++++++++++++++++++++++++++++-----
 test/string.cpp | 38 ++++++++++++++++++--------------------
 2 files changed, 55 insertions(+), 25 deletions(-)

diff --git a/string.hpp b/string.hpp
index d7c9434e..9fb0bef4 100644
--- a/string.hpp
+++ b/string.hpp
@@ -40,7 +40,20 @@ namespace util {
 
         tokeniser (Iterator first, Iterator last, value_type separator);
 
-        struct iterator {
+        template <typename ContainerT>
+        tokeniser (ContainerT &container, typename ContainerT::value_type _separator):
+            tokeniser (
+                std::begin (container),
+                std::end (container),
+                _separator
+            )
+        { ; }
+
+        struct iterator : public std::iterator<
+            std::forward_iterator_tag,
+            range_type,
+            std::size_t
+        > {
         public:
             iterator  operator++ (int);
             iterator& operator++ (void)&;
@@ -71,10 +84,29 @@ namespace util {
         const value_type m_separator;
     };
 
-    
-    tokeniser<std::string::const_iterator> make_tokeniser (const std::string&, std::string::value_type);
-    tokeniser<std::string::const_iterator> make_tokeniser (std::string&&, std::string::value_type) = delete;
-    tokeniser<const char*> make_tokeniser (const char*, char);
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename CharT, std::size_t LengthV>
+    auto
+    make_tokeniser (CharT (&data)[LengthV], CharT separator)
+    {
+        return tokeniser { std::begin (data), std::end (data), separator };
+    }
+
+
+    //-------------------------------------------------------------------------
+    tokeniser<std::string::const_iterator>
+    make_tokeniser (const std::string&, std::string::value_type);
+
+
+    //-------------------------------------------------------------------------
+    tokeniser<std::string::const_iterator>
+    make_tokeniser (std::string&&, std::string::value_type) = delete;
+
+
+    //-------------------------------------------------------------------------
+    tokeniser<const char*>
+    make_tokeniser (const char*, char);
 
 }
 
diff --git a/test/string.cpp b/test/string.cpp
index 883c577b..b3e20cd5 100644
--- a/test/string.cpp
+++ b/test/string.cpp
@@ -1,6 +1,9 @@
 #include "tap.hpp"
 #include "string.hpp"
 #include "types.hpp"
+#include "iterator.hpp"
+
+#include <vector>
 
 int
 main (int, char**)
@@ -8,28 +11,23 @@ main (int, char**)
     util::TAP::logger tap;
     
     const char csv[] = "\0,a,123,,this is a test,";
-    const std::string values[] = {
-        { "\0", 1 },
-        { "a" },
-        { "123" },
-        { "" },
-        { "this is a test" },
-        { "" }
+
+    // expected test data must be a std::string so we can check embedded
+    // nulls (which are ambiguous when using a cstr).
+    struct foo {
+        const std::string value;
+        const char *message;
+    } TESTS[] = {
+        { "\0",             "null" },
+        { "a",              "single letter" },
+        { "123",            "three digits" },
+        { "",               "empty string" },
+        { "this is a test", "string with spaces" },
+        { "",               "trailing empty" }
     };
 
-    std::string str (std::cbegin (csv), std::cbegin (csv) + std::size (csv));
-    auto tok = util::make_tokeniser (str, ',');
-    auto t_cursor = tok.cbegin ();
-    auto v_cursor = std::cbegin (values);
-
-    tap.expect_eq (*t_cursor++, *v_cursor++, "tokeniser, single letter");
-    tap.expect_eq (*t_cursor++, *v_cursor++, "tokeniser, three digits");
-    tap.expect_eq (*t_cursor++, *v_cursor++, "tokeniser, embedded null");
-    tap.expect_eq (*t_cursor++, *v_cursor++, "tokeniser, empty string");
-    tap.expect_eq (*t_cursor++, *v_cursor++, "tokeniser, string with spaces");
-    tap.expect_eq (*t_cursor++, *v_cursor++, "tokeniser, trailing empty");
-
-    tap.expect_eq (t_cursor, tok.cend (), "tokeniser iterator at end");
+    for (const auto &[tok, expected]: util::zip (util::make_tokeniser (csv, ','), TESTS))
+        tap.expect (equal (tok, expected.value), "%s", expected.message);
 
     return tap.status ();
 }

From 220e499681614e7fbb1da79480cfc9ed6c5f9726 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Fri, 15 Sep 2017 15:22:51 +1000
Subject: [PATCH 125/149] view: make equality consistent

---
 test/view.cpp |   8 +--
 view.cpp      |   4 +-
 view.hpp      | 174 +++++++++++++++++++++++++++++++++-----------------
 3 files changed, 122 insertions(+), 64 deletions(-)

diff --git a/test/view.cpp b/test/view.cpp
index 0f8cf2ec..72f9bf85 100644
--- a/test/view.cpp
+++ b/test/view.cpp
@@ -9,10 +9,10 @@ main (int, char**)
     const std::string s = "this is a test string";
     const std::string t = "not the same string";
 
-    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");
+    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");
 
     return tap.status ();
 }
diff --git a/view.cpp b/view.cpp
index 11d60ed0..2c07bc74 100644
--- a/view.cpp
+++ b/view.cpp
@@ -11,7 +11,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
- * Copyright 2016 Danny Robson <danny@nerdcruft.net>
+ * Copyright 2016-2017 Danny Robson <danny@nerdcruft.net>
  */
 
 #include "./view.hpp"
@@ -23,7 +23,7 @@
 ///////////////////////////////////////////////////////////////////////////////
 #define EQUALITY(A,B)                   \
 bool                                    \
-util::operator== (A a, B b)             \
+util::equal (A a, B b)                  \
 {                                       \
     return a.size () == a.size () &&    \
            std::equal (a.cbegin (),     \
diff --git a/view.hpp b/view.hpp
index 26d1efe4..4742d426 100644
--- a/view.hpp
+++ b/view.hpp
@@ -28,18 +28,24 @@
 #include <stdexcept>
 
 namespace util {
-    template <typename T>
+    template <typename IteratorT>
     struct view {
     public:
-        using value_type = typename std::iterator_traits<remove_restrict_t<T>>::value_type;
+        //---------------------------------------------------------------------
+        using value_type = typename std::iterator_traits<
+            remove_restrict_t<IteratorT>
+        >::value_type;
 
+
+        //---------------------------------------------------------------------
         constexpr
-        view (const T &first, const T &last) noexcept:
+        view (const IteratorT &first, const IteratorT &last) noexcept:
             m_begin (first),
             m_end   (last)
         { ; }
 
 
+        //---------------------------------------------------------------------
         constexpr
         view (const view &rhs) noexcept:
             m_begin (rhs.m_begin),
@@ -47,34 +53,38 @@ namespace util {
         { ; }
 
 
+        //---------------------------------------------------------------------
         // technically we could get away without explicitly defining a move
         // constructor here, but by nulling rhs we can more easily use this
         // class as a base for unique owning pointers without exposing
         // begin/end to them directly.
         constexpr view (view &&rhs) noexcept:
-            view (T{}, T{})
+            view (IteratorT{}, IteratorT{})
         {
             std::swap (m_begin, rhs.m_begin);
             std::swap (m_end,   rhs.m_end);
         }
 
 
-        template <typename K>
+        //---------------------------------------------------------------------
+        template <typename ContainerT>
         constexpr explicit
-        view (K &klass):
+        view (ContainerT &klass):
             m_begin (std::begin (klass)),
             m_end   (std::end   (klass))
         { ; }
 
 
-        template <typename K>
+        //---------------------------------------------------------------------
+        template <typename ContainerT>
         constexpr explicit
-        view (const K &klass):
+        view (const ContainerT &klass):
             m_begin (std::begin (klass)),
             m_end   (std::end   (klass))
         { ; }
 
 
+        //---------------------------------------------------------------------
         view&
         operator= (const view &rhs) noexcept
         {
@@ -84,43 +94,51 @@ namespace util {
         }
 
 
+        //---------------------------------------------------------------------
         view&
         operator= (view &&rhs) noexcept
         {
             m_begin = rhs.m_begin;
             m_end = rhs.m_end;
 
-            m_begin = T{};
-            m_end = T{};
+            rhs.m_begin = IteratorT{};
+            rhs.m_end = IteratorT{};
 
             return *this;
         };
 
 
-        constexpr T begin (void) noexcept { return m_begin; }
-        constexpr T end   (void) noexcept { return m_end;   }
+        //---------------------------------------------------------------------
+        constexpr IteratorT begin (void) noexcept { return m_begin; }
+        constexpr IteratorT end   (void) noexcept { return m_end;   }
 
-        constexpr const T begin (void) const noexcept { return cbegin (); }
-        constexpr const T end   (void) const noexcept { return cend   (); }
+        //---------------------------------------------------------------------
+        constexpr const IteratorT begin (void) const noexcept { return cbegin (); }
+        constexpr const IteratorT end   (void) const noexcept { return cend   (); }
 
-        constexpr const T cbegin (void) const noexcept { return m_begin; }
-        constexpr const T cend   (void) const noexcept { return m_end;   }
+        //---------------------------------------------------------------------
+        constexpr const IteratorT cbegin (void) const noexcept { return m_begin; }
+        constexpr const IteratorT cend   (void) const noexcept { return m_end;   }
 
+        //---------------------------------------------------------------------
         auto data (void)       { return begin (); }
         auto data (void) const { return begin (); }
 
+        //---------------------------------------------------------------------
         constexpr bool
         empty (void) const noexcept
         {
             return m_begin == m_end;
         }
 
+        //---------------------------------------------------------------------
         constexpr auto
         size (void) const noexcept
         {
             return std::distance (m_begin, m_end);
         }
 
+        //---------------------------------------------------------------------
         constexpr auto
         redim (int count) const
         {
@@ -130,94 +148,107 @@ namespace util {
             return view { m_begin, m_begin + count };
         };
 
+        //---------------------------------------------------------------------
         constexpr value_type&
-        operator[] (size_t idx) noexcept
+        operator[] (size_t idx)& noexcept
         {
             auto it = begin ();
             std::advance (it, idx);
             return *it;
         }
 
+        //---------------------------------------------------------------------
         constexpr const value_type&
-        operator[] (size_t idx) const noexcept
+        operator[] (size_t idx) const& noexcept
         {
             auto it = begin ();
             std::advance (it, idx);
             return *it;
         }
 
-        bool
-        operator== (const view &rhs) const noexcept
-        {
-            return rhs.m_begin == m_begin &&
-                   rhs.m_end   == m_end;
-        }
 
     private:
-        T m_begin;
-        T m_end;
+        //---------------------------------------------------------------------
+        IteratorT m_begin;
+        IteratorT m_end;
     };
 
 
-    template <typename T, size_t N>
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename ValueT, size_t N>
     auto
-    make_view (const T (&arr)[N])
+    make_view (const ValueT (&arr)[N])
     {
-        return util::view<const T*> (arr + 0, arr + N);
+        return util::view<const ValueT*> (arr + 0, arr + N);
     }
 
-    template <typename T>
+    //-------------------------------------------------------------------------
+    template <typename ContainerT>
     auto
-    make_view (T &t)
+    make_view (ContainerT &t)
     {
         return util::view<decltype(std::begin (t))> { std::begin (t), std::end (t) };
     }
 
-    template <typename T>
+    //-------------------------------------------------------------------------
+    template <typename ContainerT>
     auto
-    make_view (const T &t)
+    make_view (const ContainerT &t)
     {
         return util::view<decltype(std::cbegin (t))> { std::cbegin (t), std::cend (t) };
     }
 
-    template <typename T>
-    auto
-    make_view (T&&) = delete;
 
-    template <typename T>
+    //-------------------------------------------------------------------------
+    // disable the possibility of creating a view to a temporary. note that
+    // this only works if an lval version has already been defined otherwise
+    // universal reference rules will capture both lval and rval here.
+    template <typename ContainerT>
     auto
-    make_cview (const T &t)
+    make_view (ContainerT&&) = delete;
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename ContainerT>
+    auto
+    make_cview (const ContainerT &t)
     {
         return util::view<decltype(std::cbegin (t))> { std::cbegin (t), std::cend (t) };
     }
 
-    template <typename T>
+
+    //-------------------------------------------------------------------------
+    template <typename IteratorT>
     auto
-    make_view (T first, T last)
+    make_view (IteratorT first, IteratorT last)
     {
-        return view<T> {first, last};
+        return view<IteratorT> {first, last};
     }
 
-    template <typename T>
+    //-------------------------------------------------------------------------
+    template <typename ValueT>
     auto
-    make_cview (T *first, T *last)
+    make_cview (ValueT *first, ValueT *last)
     {
-        return view<const T*> {first, last};
+        return view<const ValueT*> {first, last};
     }
 
-    // string conversions
+    ///////////////////////////////////////////////////////////////////////////
     inline
     view<const char*> make_view (const char *str)
     {
         return { str, str + strlen (str) };
     }
 
+    //-------------------------------------------------------------------------
     inline
     view<char*> make_view (char *str)
     {
         return { str, str + strlen (str) };
     }
 
+
+    //-------------------------------------------------------------------------
     template <typename CharT, typename TraitsT, typename AllocT>
     view<const CharT*>
     make_view (const std::basic_string<CharT,TraitsT,AllocT> &str)
@@ -228,6 +259,8 @@ namespace util {
         };
     }
 
+
+    //-------------------------------------------------------------------------
     template <typename CharT, typename TraitsT, typename AllocT>
     view<CharT*>
     make_view (std::basic_string<CharT,TraitsT,AllocT> &str)
@@ -238,31 +271,56 @@ namespace util {
         };
     }
 
+
+    //-------------------------------------------------------------------------
     template <typename CharT, typename TraitsT, typename AllocT>
     view<const CharT*>
     make_view (const std::basic_string<CharT,TraitsT,AllocT>&&) = delete;
 
+
+    //-------------------------------------------------------------------------
     template <typename CharT, typename TraitsT, typename AllocT>
     view<CharT*>
     make_view (std::basic_string<CharT,TraitsT,AllocT>&&) = delete;
 
-    // boolean operationrs
-    template <typename T>
-    bool operator!= (view<T>, view<T>);
 
-    bool operator== (const std::string&, view<const char*>);
-    bool operator== (const std::string&, view<char*>);
-    bool operator== (const std::string&, view<std::string::const_iterator>);
-    bool operator== (const std::string&, view<std::string::iterator>);
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename IteratorT>
+    constexpr bool
+    operator== (const view<IteratorT> &a, const view<IteratorT> &b)
+    {
+        return std::cbegin (a) == std::cbegin (b) &&
+               std::cend   (a) == std::cend   (b);
+    }
 
-    bool operator== (view<const char*>,  const std::string&);
-    bool operator== (view<char*>,        const std::string&);
-    bool operator== (view<std::string::const_iterator>, const std::string&);
-    bool operator== (view<std::string::iterator>, const std::string&);
 
-    template <typename T>
+    //-------------------------------------------------------------------------
+    template <typename IteratorT>
+    constexpr bool
+    operator!= (const view<IteratorT> &a, const view<IteratorT> &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>
     std::ostream&
-    operator<< (std::ostream&, view<T>);
+    operator<< (std::ostream&, view<IteratorT>);
 }
 
 #endif

From 09a624bf88cd40059423983ea287d7b50570e31b Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Sun, 17 Sep 2017 12:41:23 +1000
Subject: [PATCH 126/149] debug: add `unhandled` debug function

---
 debug.hpp | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/debug.hpp b/debug.hpp
index 39428eb3..868c061f 100644
--- a/debug.hpp
+++ b/debug.hpp
@@ -392,6 +392,17 @@ constexpr void unreachable [[noreturn]] (void);
 constexpr void unreachable [[noreturn]] (const char*);
 
 
+///////////////////////////////////////////////////////////////////////////////
+/// report a fatal error induced by an unhandled value, especially in switch
+/// statements. will almost invariably abort the application.
+template <typename T>
+constexpr void
+unhandled [[noreturn]] (T &&t) noexcept
+{
+    panic ("unhandled value %!", std::forward<T> (t));
+}
+
+
 ///////////////////////////////////////////////////////////////////////////////
 void warn (void);
 void warn (const std::string&);

From f06eab9a3a28f04824b26717b61424b0d3537dbe Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Thu, 21 Sep 2017 15:06:35 +1000
Subject: [PATCH 127/149] a/r/aligned: add forgotten headers and namespace
 qualifiers

---
 alloc/raw/aligned.hpp | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

diff --git a/alloc/raw/aligned.hpp b/alloc/raw/aligned.hpp
index cd1d8fd0..683ec81f 100644
--- a/alloc/raw/aligned.hpp
+++ b/alloc/raw/aligned.hpp
@@ -17,6 +17,11 @@
 #ifndef CRUFT_UTIL_ALLOC_RAW_ALIGNED_HPP
 #define CRUFT_UTIL_ALLOC_RAW_ALIGNED_HPP
 
+#include <cstddef>
+#include <utility>
+
+#include "../../debug.hpp"
+
 namespace util::alloc::raw {
     /// wraps a child allocator and enforces a fixed alignment
     template <typename ChildT>
@@ -24,7 +29,7 @@ namespace util::alloc::raw {
     public:
         ///////////////////////////////////////////////////////////////////////
         template <typename ...Args>
-        aligned (size_t _alignment, Args &&...args):
+        aligned (std::size_t _alignment, Args &&...args):
             m_successor (std::forward<Args> (args)...),
             m_alignment (_alignment)
         { ; }
@@ -32,14 +37,14 @@ namespace util::alloc::raw {
 
         ///////////////////////////////////////////////////////////////////////
         auto
-        allocate (size_t bytes)
+        allocate (std::size_t bytes)
         {
             return m_successor.allocate (bytes, m_alignment);
         }
 
         //---------------------------------------------------------------------
         auto
-        allocate (size_t bytes, size_t alignment)
+        allocate (std::size_t bytes, std::size_t alignment)
         {
             (void)alignment;
             CHECK_EQ (alignment, m_alignment);
@@ -49,7 +54,7 @@ namespace util::alloc::raw {
 
         //---------------------------------------------------------------------
         auto
-        deallocate (void *ptr, size_t bytes)
+        deallocate (void *ptr, std::size_t bytes)
         {
             return m_successor.deallocate (ptr, bytes);
         }
@@ -57,7 +62,7 @@ namespace util::alloc::raw {
 
         //---------------------------------------------------------------------
         auto
-        deallocate (void *ptr, size_t bytes, size_t alignment)
+        deallocate (void *ptr, std::size_t bytes, std::size_t alignment)
         {
             (void)alignment;
             CHECK_EQ (alignment, m_alignment);
@@ -90,7 +95,7 @@ namespace util::alloc::raw {
 
     private:
         ChildT m_successor;
-        size_t m_alignment;
+        std::size_t m_alignment;
     };
 }
 

From b04f0b0c9ea9582ebe8712e8c163537b8c21a27d Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Thu, 21 Sep 2017 15:58:02 +1000
Subject: [PATCH 128/149] random: threadlocal generator should be inline

this avoids multiply defined symbols
---
 random.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/random.hpp b/random.hpp
index e4b97490..9c5f65ea 100644
--- a/random.hpp
+++ b/random.hpp
@@ -11,7 +11,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
- * Copyright 2016 Danny Robson <danny@nerdcruft.net>
+ * Copyright 2016-2017 Danny Robson <danny@nerdcruft.net>
  */
 
 #ifndef CRUFT_UTIL_RANDOM_HPP
@@ -24,7 +24,7 @@ namespace util::random {
     ///////////////////////////////////////////////////////////////////////////
     /// return correctly initialised thread-local generator of an unspecified,
     /// but not entirely useless, type. ie, not LCG.
-    auto&
+    inline auto&
     generator (void)
     {
         static thread_local std::mt19937_64 gen { std::random_device {}() };

From d67a990de3381be247321bb0f9ef6f6dfcbe0087 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Thu, 21 Sep 2017 15:58:26 +1000
Subject: [PATCH 129/149] random: add uniform integer generator for whole range

---
 random.hpp | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/random.hpp b/random.hpp
index 9c5f65ea..235a592d 100644
--- a/random.hpp
+++ b/random.hpp
@@ -18,6 +18,7 @@
 #define CRUFT_UTIL_RANDOM_HPP
 
 #include <random>
+#include <limits>
 
 
 namespace util::random {
@@ -52,6 +53,18 @@ namespace util::random {
     }
 
 
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename T>
+    std::enable_if_t<std::is_integral_v<T>,T>
+    uniform (void)
+    {
+        return uniform (
+            std::numeric_limits<T>::min (),
+            std::numeric_limits<T>::max ()
+        );
+    }
+
+
     ///////////////////////////////////////////////////////////////////////////
     /// choose a value at random from an array
     template <typename T, size_t N>

From d03a248138c4939430d0a7d269627711ac0e04e1 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Mon, 2 Oct 2017 14:14:39 +1100
Subject: [PATCH 130/149] tap: add unconditional 'fail' call

---
 tap.hpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/tap.hpp b/tap.hpp
index 613468bf..c517837e 100644
--- a/tap.hpp
+++ b/tap.hpp
@@ -73,6 +73,12 @@ namespace util { namespace TAP {
         void expect_throw (T&&, const char (&fmt)[N], Args&&...);
 
         //---------------------------------------------------------------------
+        template <size_t N, typename ...Args>
+        void fail (const char (&fmt)[N], Args &&...args)
+        {
+            expect (false, fmt, std::forward<Args> (args)...);
+        }
+
         void skip (const std::string &msg);
         void todo (const std::string &msg);
         void noop (void);

From 4641d43742d3b46191e390fefa2e1b1cc9cf6ef2 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Mon, 2 Oct 2017 14:14:55 +1100
Subject: [PATCH 131/149] view: comment style

---
 view.hpp | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/view.hpp b/view.hpp
index 4742d426..285edaea 100644
--- a/view.hpp
+++ b/view.hpp
@@ -108,7 +108,7 @@ namespace util {
         };
 
 
-        //---------------------------------------------------------------------
+        ///////////////////////////////////////////////////////////////////////
         constexpr IteratorT begin (void) noexcept { return m_begin; }
         constexpr IteratorT end   (void) noexcept { return m_end;   }
 
@@ -124,7 +124,7 @@ namespace util {
         auto data (void)       { return begin (); }
         auto data (void) const { return begin (); }
 
-        //---------------------------------------------------------------------
+        ///////////////////////////////////////////////////////////////////////
         constexpr bool
         empty (void) const noexcept
         {
@@ -148,7 +148,7 @@ namespace util {
             return view { m_begin, m_begin + count };
         };
 
-        //---------------------------------------------------------------------
+        ///////////////////////////////////////////////////////////////////////
         constexpr value_type&
         operator[] (size_t idx)& noexcept
         {
@@ -166,9 +166,8 @@ namespace util {
             return *it;
         }
 
-
     private:
-        //---------------------------------------------------------------------
+        ///////////////////////////////////////////////////////////////////////
         IteratorT m_begin;
         IteratorT m_end;
     };

From 7ecaaacd93eaccf8ad06ca52ff0544fc62883e15 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Mon, 2 Oct 2017 15:25:59 +1100
Subject: [PATCH 132/149] utf8: add a trivial utf8 decoder

---
 CMakeLists.txt |   3 +
 test/utf8.cpp  | 325 +++++++++++++++++++++++++++++++++++++++++++++++++
 utf8.cpp       | 148 ++++++++++++++++++++++
 utf8.hpp       |  74 +++++++++++
 4 files changed, 550 insertions(+)
 create mode 100644 test/utf8.cpp
 create mode 100644 utf8.cpp
 create mode 100644 utf8.hpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index eb847c7c..d3ae3122 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -408,6 +408,8 @@ list (
     types/traits.hpp
     uri.cpp
     uri.hpp
+    utf8.cpp
+    utf8.hpp
     variadic.cpp
     variadic.hpp
     vector.cpp
@@ -531,6 +533,7 @@ if (TESTS)
         traits
         typeidx
         uri
+        utf8
         vector
         version
         view
diff --git a/test/utf8.cpp b/test/utf8.cpp
new file mode 100644
index 00000000..09bc1297
--- /dev/null
+++ b/test/utf8.cpp
@@ -0,0 +1,325 @@
+#include "tap.hpp"
+#include "utf8.hpp"
+
+
+///////////////////////////////////////////////////////////////////////////////
+static void
+simple_valid (util::TAP::logger &tap)
+{
+    static constexpr struct {
+        const char *data;
+        size_t len;
+        const char *message;
+    } VALID[] = {
+        { "",        0, "empty string" },
+        { "a",       1, "single ANSI character" },
+        { "abc",     3, "multiple ANSI characters" },
+        { u8"κόσμε", 5, "greek kosme" },
+    };
+
+    static constexpr char fmt[] = "valid length, %s";
+
+    for (const auto &t: VALID) {
+        try {
+            tap.expect_eq (
+                t.len,
+                util::utf8::decode (util::make_view (t.data)).size (),
+                fmt,
+                t.message
+            );
+        } catch (...) {
+            tap.fail (fmt, t.message);
+        }
+    }
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+static void
+single_boundaries (util::TAP::logger &tap)
+{
+    static const struct {
+        std::vector<uint8_t> data;
+        uint32_t value;
+        const char *direction;
+    } TESTS[] {
+        { { 0x00                   }, 0x00000000, "low length boundary" },
+        { { 0xC2, 0x80             }, 0x00000080, "low length boundary" },
+        { { 0xE0, 0xA0, 0x80       }, 0x00000800, "low length boundary" },
+        { { 0xF0, 0x90, 0x80, 0x80 }, 0x00010000, "low length boundary" },
+
+        { { 0x7F                   }, 0x0000007F, "high length boundary" },
+        { { 0xDF, 0xBF             }, 0x000007FF, "high length boundary" },
+        // this is an invalid codepoint so we're going to fail to parse this
+        // whatever the case. disable it for the time being.
+        //{ { 0xEF, 0xBF, 0xBF,      }, 0x0000FFFF, "high length boundary" },
+        { { 0xF7, 0xBF, 0xBF, 0xBF }, 0x001FFFFF, "high length boundary" },
+
+        { { 0xED, 0x9F, 0xBF       }, 0x0000D7FF, "other" },
+        { { 0xEE, 0x80, 0x80       }, 0x0000E000, "other" },
+        { { 0xEF, 0xBF, 0xBD       }, 0x0000FFFD, "other" },
+        { { 0xF4, 0x8F, 0xBF, 0xBF }, 0x0010FFFF, "other" },
+        { { 0xF4, 0x90, 0x80, 0x80 }, 0x00110000, "other" },
+    };
+
+    static constexpr char fmt[] = "single character (%s), %!-byte sequence";
+
+    for (const auto &t: TESTS) {
+        auto data = util::make_view (
+            reinterpret_cast<const std::byte*> (&*t.data.cbegin ()),
+            reinterpret_cast<const std::byte*> (&*t.data.cbegin ()) + t.data.size ()
+        );
+
+        try {
+            auto codepoints = util::utf8::decode (data);
+
+            tap.expect (
+                codepoints.size () == 1 && codepoints[0] == t.value,
+                fmt,
+                t.direction,
+                t.data.size ()
+            );
+        } catch (const util::utf8::malformed_error&) {
+            tap.fail (fmt, t.direction, t.data.size ());
+        }
+    }
+};
+
+
+
+///////////////////////////////////////////////////////////////////////////////
+static void
+malformed (util::TAP::logger &tap)
+{
+    static const struct {
+        std::vector<uint8_t> data;
+        const char *message;
+    } TESTS[] = {
+        { { 0x80                   }, "first continuation" },
+        { { 0xBF                   }, "last continuation" },
+        { { 0x80, 0xBF             }, "continuation sequence" },
+        { { 0x80, 0xBF, 0x80       }, "continuation sequence" },
+        { { 0x80, 0xBF, 0x80, 0xBF }, "continuation sequence" },
+    };
+
+    static constexpr char fmt[] = "malformed %! byte sequence, %s";
+
+    for (const auto &t: TESTS) {
+        auto data = util::make_view (
+            reinterpret_cast<const std::byte*> (&*t.data.cbegin ()),
+            reinterpret_cast<const std::byte*> (&*t.data.cbegin ()) + t.data.size ()
+        );
+
+        tap.expect_throw<util::utf8::malformed_error> (
+            [&data] () {
+                util::utf8::decode (data);
+            },
+            fmt,
+            data.size (),
+            t.message
+        );
+    }
+
+    // test every continuation byte by itself. we use a boolean flag that
+    // should never reach the line where we toggle it to false due to the
+    // expected exception.
+    {
+        bool success = true;
+        for (uint8_t c = 0x80; c <= 0xbf; ++c) {
+            try {
+                const auto v = c;
+                util::utf8::decode (util::view { &v, &v+1 });
+                success = false;
+                break;
+            } catch (...) { ; }
+        }
+
+        tap.expect (success, "individual continuation bytes");
+    }
+
+    // every combination of first-byte-then-space sequences
+    static const struct {
+        uint8_t first;
+        uint8_t last;
+        int length;
+    } LONELY[] = {
+        { 0xc0, 0xdf, 2 },
+        { 0xe0, 0xef, 3 },
+        { 0xf0, 0xf7, 4 },
+    };
+
+    for (const auto &t: LONELY) {
+        union {
+            uint8_t bytes[4];
+            char    str  [4];
+        };
+
+        bool success = true;
+
+        for (auto i = t.first; i <= t.last; ++i) {
+            std::fill (std::begin (str), std::end (str), ' ');
+            bytes[0] = i;
+
+            try {
+                util::utf8::decode (util::make_cview (str));
+                success = false;
+            }
+            catch (const util::utf8::malformed_error&)
+            { ; }
+            catch (...)
+            { success = false; }
+        }
+
+        tap.expect (success, "lonely start characters, %! bytes", t.length);
+    }
+
+
+    static const std::vector<uint8_t> MISSING[] = {
+        { 0xC0 },
+        { 0xE0, 0x80 },
+        { 0xF0, 0x80, 0x80 },
+    };
+
+    for (const auto &t: MISSING) {
+        util::view<const char*> data {
+            reinterpret_cast<const char*> (&t[0]),
+            reinterpret_cast<const char*> (&t[0]) + t.size ()
+        };
+
+        tap.expect_throw<util::utf8::malformed_error> (
+            [&data] () { util::utf8::decode (data); },
+            "%! byte sequence missing the lastbyte",
+            t.size ()
+        );
+    }
+
+
+    static const std::vector<uint8_t> IMPOSSIBLE[] = {
+        { 0xfe },
+        { 0xff },
+        { 0xfe, 0xfe, 0xff, 0xff }
+    };
+
+    for (const auto &t: IMPOSSIBLE) {
+        util::view<const char*> data {
+            reinterpret_cast<const char*> (&t[0]),
+            reinterpret_cast<const char*> (&t[0]) + t.size ()
+        };
+
+        tap.expect_throw<util::utf8::malformed_error> (
+            [&data] () { util::utf8::decode (data); },
+            "impossible %! byte sequence",
+            t.size ()
+        );
+    }
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+void
+overlong (util::TAP::logger &tap)
+{
+    static const struct {
+        std::vector<uint8_t> data;
+        const char *message;
+    } TESTS[] = {
+        { { 0xc0, 0xaf             }, "simple ANSI" },
+        { { 0xe0, 0x80, 0xaf       }, "simple ANSI" },
+        { { 0xf0, 0x80, 0x80, 0xaf }, "simple ANSI" },
+
+        { { 0xc1, 0xbf             }, "maximum" },
+        { { 0xe0, 0x9f, 0xbf       }, "maximum" },
+        { { 0xf0, 0x8f, 0xbf, 0xbf }, "maximum" },
+
+        { { 0xc0, 0x80             }, "null" },
+        { { 0xe0, 0x80, 0x80       }, "null" },
+        { { 0xf0, 0x80, 0x80, 0x80 }, "null" },
+    };
+
+    for (const auto &t: TESTS) {
+        auto data = util::make_view (
+            reinterpret_cast<const char*> (&t.data[0]),
+            reinterpret_cast<const char*> (&t.data[0]) + t.data.size ()
+        );
+
+        tap.expect_throw<util::utf8::overlong_error> (
+            [&] () {
+                util::utf8::decode (data);
+            },
+            "overlong %! byte sequence, %s",
+            t.data.size (),
+            t.message
+        );
+    }
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+void
+illegal (util::TAP::logger &tap)
+{
+    static const std::array<uint8_t,3> SINGLE[] = {
+        { 0xed, 0xa0, 0x80 }, // U+D800
+        { 0xed, 0xad, 0xbf }, // U+DB7F
+        { 0xed, 0xae, 0x80 }, // U+DB80
+        { 0xed, 0xaf, 0xbf }, // U+DBFF
+        { 0xed, 0xb0, 0x80 }, // U+DC00
+        { 0xed, 0xbe, 0x80 }, // U+DF80
+        { 0xed, 0xbf, 0xbf }, // U+DFFF
+    };
+
+    for (const auto &t: SINGLE)
+        tap.expect_throw<util::utf8::error> (
+            [&t] () { util::utf8::decode (util::make_view (t)); },
+            "reject utf16 single surrogate"
+        );
+
+
+    static const std::array<uint8_t,6> DOUBLE[] = {
+        { 0xed, 0xa0, 0x80, 0xed, 0xb0, 0x80 }, // U+D800 U+DC00
+        { 0xed, 0xa0, 0x80, 0xed, 0xbf, 0xbf }, // U+D800 U+DFFF
+        { 0xed, 0xad, 0xbf, 0xed, 0xb0, 0x80 }, // U+DB7F U+DC00
+        { 0xed, 0xad, 0xbf, 0xed, 0xbf, 0xbf }, // U+DB7F U+DFFF
+        { 0xed, 0xae, 0x80, 0xed, 0xb0, 0x80 }, // U+DB80 U+DC00
+        { 0xed, 0xae, 0x80, 0xed, 0xbf, 0xbf }, // U+DB80 U+DFFF
+        { 0xed, 0xaf, 0xbf, 0xed, 0xb0, 0x80 }, // U+DBFF U+DC00
+        { 0xed, 0xaf, 0xbf, 0xed, 0xbf, 0xbf }, // U+DBFF U+DFFF
+    };
+
+    for (const auto &t: DOUBLE)
+        tap.expect_throw<util::utf8::error> (
+            [&t] () { util::utf8::decode (util::make_view (t)); },
+            "reject utf16 paired surrogate"
+        );
+
+
+    static const std::array<uint8_t,3> OTHER[] = {
+        { 0xef, 0xbf, 0xbe }, // FFFE
+        { 0xef, 0xbf, 0xbf }, // FFFF
+    };
+
+
+    for (const auto &t: OTHER)
+        tap.expect_throw<util::utf8::error> (
+            [&t] () { util::utf8::decode (util::make_view (t)); },
+            "reject BOM"
+        );
+
+
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+int
+main()
+{
+    util::TAP::logger tap;
+
+    simple_valid (tap);
+    single_boundaries (tap);
+    malformed (tap);
+    overlong (tap);
+    illegal (tap);
+
+    return tap.status ();
+};
\ No newline at end of file
diff --git a/utf8.cpp b/utf8.cpp
new file mode 100644
index 00000000..fa2dc14c
--- /dev/null
+++ b/utf8.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 "./utf8.hpp"
+
+
+///////////////////////////////////////////////////////////////////////////////
+template <typename T>
+struct test {
+    constexpr
+    test (T _mask, T _value, T _shift):
+        mask (_mask),
+        value (_value),
+        shift (_shift)
+    { ; }
+
+    constexpr bool
+    operator() (T t) const
+    {
+        return (t & mask) == value;
+    }
+
+    T mask;
+    T value;
+    T shift;
+};
+
+
+//-----------------------------------------------------------------------------
+static constexpr test<uint32_t>
+operator"" _test (const char *str, size_t len)
+{
+    uint32_t mask = 0;
+    uint32_t value = 0;
+    uint32_t shift = 0;
+
+    if (str[0] != '0' || str[1] != 'b')
+        throw std::invalid_argument ("invalid bit test prefix");
+
+    for (size_t i = 2; i < len; ++i) {
+        auto c = str[i];
+
+        mask  <<= 1;
+        value <<= 1;
+
+        switch (c) {
+        case '0': mask |= 0x1; value |= 0x0;          break;
+        case '1': mask |= 0x1; value |= 0x1;          break;
+        case 'x': mask |= 0x0; value |= 0x0; ++shift; break;
+        default:
+            throw std::invalid_argument ("invalid bit test character");
+        }
+
+    }
+
+    return { mask, value, shift };
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+std::vector<util::utf8::codepoint_t>
+util::utf8::decode (view<const std::byte*> src)
+{
+    std::vector<codepoint_t> dst;
+    dst.reserve (src.size ());
+
+    static constexpr
+    test<codepoint_t> TESTS[] = {
+        "0b0xxxxxxx"_test,
+        "0b110xxxxx"_test,
+        "0b1110xxxx"_test,
+        "0b11110xxx"_test
+    };
+
+    for (auto cursor = src.cbegin (); cursor != src.cend (); ++cursor) {
+        codepoint_t c = std::to_integer<codepoint_t> (*cursor);
+
+        int len = TESTS[0] (c) ? 0 :
+                  TESTS[1] (c) ? 1 :
+                  TESTS[2] (c) ? 2 :
+                  TESTS[3] (c) ? 3 :
+                  throw malformed_error {};
+
+        if (cursor + len >= src.cend ())
+            throw malformed_error {};
+
+        // get the simple ANSI case out of the way
+        if (!len) {
+            dst.push_back (c);
+            continue;
+        }
+
+        codepoint_t head = codepoint_t { c & ~TESTS[len].mask } << (len * 6);
+        codepoint_t accum = head;
+        codepoint_t shift = 0;
+
+        // check every following data byte has the appropriate prefix
+        for (int i = 1; i <= len; ++i) {
+            if ((std::to_integer<codepoint_t> (cursor[i]) & 0b11'000000u) != 0b10'000000u)
+                throw malformed_error {};
+        }
+
+        switch (len) {
+        case 3: accum |= (std::to_integer<codepoint_t> (cursor[3]) & 0b00111111u) << (shift++ * 6u);
+        case 2: accum |= (std::to_integer<codepoint_t> (cursor[2]) & 0b00111111u) << (shift++ * 6u);
+        case 1: accum |= (std::to_integer<codepoint_t> (cursor[1]) & 0b00111111u) << (shift++ * 6u);
+        }
+
+        // describes the bits required to be present for a valid minimally
+        // sized codepoint of a given byte length.
+        static constexpr
+        codepoint_t LEVEL_MASK[] {
+            0b00000000'00000000'01111111,
+            0b00000000'00000111'10000000,
+            0b00000000'11111000'00000000,
+            0b00011111'00000000'00000000
+        };
+
+        if (!(accum & LEVEL_MASK[len]))
+            throw overlong_error {};
+
+        // utf16 surrogates should not be present in utf8
+        if (accum >= 0xD800 && accum <= 0xDFFF)
+            throw illegal_codepoint {};
+
+        // reject the BOM
+        if (accum == 0xfffe || accum == 0xffff)
+            throw illegal_codepoint {};
+
+        dst.push_back (accum);
+        std::advance (cursor, len);
+    }
+
+    return dst;
+}
\ No newline at end of file
diff --git a/utf8.hpp b/utf8.hpp
new file mode 100644
index 00000000..b89c1b2d
--- /dev/null
+++ b/utf8.hpp
@@ -0,0 +1,74 @@
+/*
+ * 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_UTF8_HPP
+#define CRUFT_UTIL_UTF8_HPP
+
+#include "./view.hpp"
+
+#include <cstddef>
+#include <cstdint>
+#include <vector>
+
+
+namespace util::utf8 {
+    ///////////////////////////////////////////////////////////////////////////
+    using codepoint_t = uint32_t;
+
+    constexpr codepoint_t MAX_CODEPOINT = 0x10FFFF;
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    std::vector<codepoint_t>
+    decode (util::view<const std::byte*>);
+
+
+    //-------------------------------------------------------------------------
+    inline auto
+    decode (util::view<const char*> data)
+    {
+        return decode ({
+            reinterpret_cast<const std::byte*> (data.cbegin ()),
+            reinterpret_cast<const std::byte*> (data.cend   ())
+        });
+    }
+
+    inline auto
+    decode (util::view<const uint8_t*> data)
+    {
+        return decode ({
+            reinterpret_cast<const char*> (data.cbegin ()),
+            reinterpret_cast<const char*> (data.cend   ())
+        });
+    }
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    std::vector<std::byte>
+    encode (util::view<const char*>);
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    struct error : public std::exception {};
+
+    struct malformed_error : public error { };
+    struct illegal_codepoint : public malformed_error {};
+
+    struct overlong_error  : public error { };
+}
+
+#endif

From 45e2477e1bdbd71445c1bb6d95a8c4efb69636bf Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Mon, 2 Oct 2017 15:40:23 +1100
Subject: [PATCH 133/149] utf8: use a more verbose mask test name

---
 utf8.cpp | 41 ++++++++++++++++++++++-------------------
 1 file changed, 22 insertions(+), 19 deletions(-)

diff --git a/utf8.cpp b/utf8.cpp
index fa2dc14c..d66e7e9e 100644
--- a/utf8.cpp
+++ b/utf8.cpp
@@ -21,21 +21,25 @@
 template <typename T>
 struct test {
     constexpr
-    test (T _mask, T _value, T _shift):
+    test (T _mask, T _bits) noexcept:
         mask (_mask),
-        value (_value),
-        shift (_shift)
+        bits (_bits)
     { ; }
 
     constexpr bool
-    operator() (T t) const
+    valid (T t) const noexcept
     {
-        return (t & mask) == value;
+        return (t & mask) == bits;
+    }
+
+    constexpr T
+    value (T t) const noexcept
+    {
+        return t & ~mask;
     }
 
     T mask;
-    T value;
-    T shift;
+    T bits;
 };
 
 
@@ -44,8 +48,7 @@ static constexpr test<uint32_t>
 operator"" _test (const char *str, size_t len)
 {
     uint32_t mask = 0;
-    uint32_t value = 0;
-    uint32_t shift = 0;
+    uint32_t bits = 0;
 
     if (str[0] != '0' || str[1] != 'b')
         throw std::invalid_argument ("invalid bit test prefix");
@@ -53,20 +56,20 @@ operator"" _test (const char *str, size_t len)
     for (size_t i = 2; i < len; ++i) {
         auto c = str[i];
 
-        mask  <<= 1;
-        value <<= 1;
+        mask <<= 1;
+        bits <<= 1;
 
         switch (c) {
-        case '0': mask |= 0x1; value |= 0x0;          break;
-        case '1': mask |= 0x1; value |= 0x1;          break;
-        case 'x': mask |= 0x0; value |= 0x0; ++shift; break;
+        case '0': mask |= 0x1; bits |= 0x0; break;
+        case '1': mask |= 0x1; bits |= 0x1; break;
+        case 'x': mask |= 0x0; bits |= 0x0; break;
         default:
             throw std::invalid_argument ("invalid bit test character");
         }
 
     }
 
-    return { mask, value, shift };
+    return { mask, bits };
 }
 
 
@@ -88,10 +91,10 @@ util::utf8::decode (view<const std::byte*> src)
     for (auto cursor = src.cbegin (); cursor != src.cend (); ++cursor) {
         codepoint_t c = std::to_integer<codepoint_t> (*cursor);
 
-        int len = TESTS[0] (c) ? 0 :
-                  TESTS[1] (c) ? 1 :
-                  TESTS[2] (c) ? 2 :
-                  TESTS[3] (c) ? 3 :
+        int len = TESTS[0].valid (c) ? 0 :
+                  TESTS[1].valid (c) ? 1 :
+                  TESTS[2].valid (c) ? 2 :
+                  TESTS[3].valid (c) ? 3 :
                   throw malformed_error {};
 
         if (cursor + len >= src.cend ())

From 5e1fab3590abf7cf8bcb9ce8c66ba0f785689178 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Mon, 2 Oct 2017 15:40:54 +1100
Subject: [PATCH 134/149] utf8: use mask test object for continuation ops

---
 utf8.cpp | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/utf8.cpp b/utf8.cpp
index d66e7e9e..dbdb6a21 100644
--- a/utf8.cpp
+++ b/utf8.cpp
@@ -111,15 +111,16 @@ util::utf8::decode (view<const std::byte*> src)
         codepoint_t shift = 0;
 
         // check every following data byte has the appropriate prefix
+        constexpr auto CONTINUATION = "0b10xxxxxx"_test;
         for (int i = 1; i <= len; ++i) {
-            if ((std::to_integer<codepoint_t> (cursor[i]) & 0b11'000000u) != 0b10'000000u)
+            if (!CONTINUATION.valid (std::to_integer<codepoint_t> (cursor[i])))
                 throw malformed_error {};
         }
 
         switch (len) {
-        case 3: accum |= (std::to_integer<codepoint_t> (cursor[3]) & 0b00111111u) << (shift++ * 6u);
-        case 2: accum |= (std::to_integer<codepoint_t> (cursor[2]) & 0b00111111u) << (shift++ * 6u);
-        case 1: accum |= (std::to_integer<codepoint_t> (cursor[1]) & 0b00111111u) << (shift++ * 6u);
+        case 3: accum |= CONTINUATION.value (std::to_integer<codepoint_t> (cursor[3])) << (shift++ * 6u);
+        case 2: accum |= CONTINUATION.value (std::to_integer<codepoint_t> (cursor[2])) << (shift++ * 6u);
+        case 1: accum |= CONTINUATION.value (std::to_integer<codepoint_t> (cursor[1])) << (shift++ * 6u);
         }
 
         // describes the bits required to be present for a valid minimally

From 35db5f0a7a373ebc252816c1a9e0d648caa3f1ad Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Mon, 2 Oct 2017 15:41:20 +1100
Subject: [PATCH 135/149] utf8: add forgotten headers

---
 test/utf8.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/test/utf8.cpp b/test/utf8.cpp
index 09bc1297..e353e8c9 100644
--- a/test/utf8.cpp
+++ b/test/utf8.cpp
@@ -1,6 +1,9 @@
 #include "tap.hpp"
 #include "utf8.hpp"
 
+#include <vector>
+#include <array>
+
 
 ///////////////////////////////////////////////////////////////////////////////
 static void

From c61fa163168fefb1f7b33629a32b6d82060b028e Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Mon, 2 Oct 2017 16:15:19 +1100
Subject: [PATCH 136/149] utf8: use an iterator style interface internally

this will be presented to the users shortly
---
 utf8.cpp | 69 ++++++++++++++++++++++++++++++++------------------------
 utf8.hpp |  2 --
 2 files changed, 40 insertions(+), 31 deletions(-)

diff --git a/utf8.cpp b/utf8.cpp
index dbdb6a21..9d18c334 100644
--- a/utf8.cpp
+++ b/utf8.cpp
@@ -74,53 +74,52 @@ operator"" _test (const char *str, size_t len)
 
 
 ///////////////////////////////////////////////////////////////////////////////
-std::vector<util::utf8::codepoint_t>
-util::utf8::decode (view<const std::byte*> src)
+template <
+    typename InputT,
+    typename OutputT>
+static OutputT
+decode (util::view<InputT> src, OutputT dst)
 {
-    std::vector<codepoint_t> dst;
-    dst.reserve (src.size ());
+    using namespace util::utf8;
 
     static constexpr
-    test<codepoint_t> TESTS[] = {
+    test<codepoint_t> PREFIX[] = {
         "0b0xxxxxxx"_test,
         "0b110xxxxx"_test,
         "0b1110xxxx"_test,
         "0b11110xxx"_test
     };
 
-    for (auto cursor = src.cbegin (); cursor != src.cend (); ++cursor) {
-        codepoint_t c = std::to_integer<codepoint_t> (*cursor);
+    for (auto cursor = src.cbegin (); cursor != src.cend (); ) {
+        codepoint_t c = std::to_integer<codepoint_t> (*cursor++);
 
-        int len = TESTS[0].valid (c) ? 0 :
-                  TESTS[1].valid (c) ? 1 :
-                  TESTS[2].valid (c) ? 2 :
-                  TESTS[3].valid (c) ? 3 :
+        int len = PREFIX[0].valid (c) ? 0 :
+                  PREFIX[1].valid (c) ? 1 :
+                  PREFIX[2].valid (c) ? 2 :
+                  PREFIX[3].valid (c) ? 3 :
                   throw malformed_error {};
 
-        if (cursor + len >= src.cend ())
-            throw malformed_error {};
-
         // get the simple ANSI case out of the way
         if (!len) {
-            dst.push_back (c);
+            *dst++ = c;
             continue;
         }
 
-        codepoint_t head = codepoint_t { c & ~TESTS[len].mask } << (len * 6);
-        codepoint_t accum = head;
-        codepoint_t shift = 0;
+        codepoint_t accum { PREFIX[len].value (c) };
 
         // check every following data byte has the appropriate prefix
-        constexpr auto CONTINUATION = "0b10xxxxxx"_test;
-        for (int i = 1; i <= len; ++i) {
-            if (!CONTINUATION.valid (std::to_integer<codepoint_t> (cursor[i])))
-                throw malformed_error {};
-        }
+        static constexpr auto CONTINUATION = "0b10xxxxxx"_test;
 
-        switch (len) {
-        case 3: accum |= CONTINUATION.value (std::to_integer<codepoint_t> (cursor[3])) << (shift++ * 6u);
-        case 2: accum |= CONTINUATION.value (std::to_integer<codepoint_t> (cursor[2])) << (shift++ * 6u);
-        case 1: accum |= CONTINUATION.value (std::to_integer<codepoint_t> (cursor[1])) << (shift++ * 6u);
+        for (int i = 1; i <= len; ++i) {
+            if (cursor == src.cend ())
+                throw malformed_error {};
+
+            codepoint_t now = std::to_integer<codepoint_t> (*cursor++);
+            if (!CONTINUATION.valid (now))
+                throw malformed_error {};
+
+            accum <<= 6;
+            accum  |= CONTINUATION.value (now);
         }
 
         // describes the bits required to be present for a valid minimally
@@ -144,9 +143,21 @@ util::utf8::decode (view<const std::byte*> src)
         if (accum == 0xfffe || accum == 0xffff)
             throw illegal_codepoint {};
 
-        dst.push_back (accum);
-        std::advance (cursor, len);
+        *dst++ = accum;
     }
 
+
+    return dst;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+std::vector<util::utf8::codepoint_t>
+util::utf8::decode (view<const std::byte*> src)
+{
+    std::vector<codepoint_t> dst;
+    dst.reserve (src.size ());
+
+    ::decode (src, std::back_inserter (dst));
     return dst;
 }
\ No newline at end of file
diff --git a/utf8.hpp b/utf8.hpp
index b89c1b2d..bf3ea287 100644
--- a/utf8.hpp
+++ b/utf8.hpp
@@ -29,8 +29,6 @@ namespace util::utf8 {
     ///////////////////////////////////////////////////////////////////////////
     using codepoint_t = uint32_t;
 
-    constexpr codepoint_t MAX_CODEPOINT = 0x10FFFF;
-
 
     ///////////////////////////////////////////////////////////////////////////
     std::vector<codepoint_t>

From d64e3d244ee9b8be91e085e59714a70711bb2954 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 3 Oct 2017 17:48:27 +1100
Subject: [PATCH 137/149] utf8: clearer comments

---
 utf8.cpp | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/utf8.cpp b/utf8.cpp
index 9d18c334..73468ad1 100644
--- a/utf8.cpp
+++ b/utf8.cpp
@@ -107,10 +107,9 @@ decode (util::view<InputT> src, OutputT dst)
 
         codepoint_t accum { PREFIX[len].value (c) };
 
-        // check every following data byte has the appropriate prefix
-        static constexpr auto CONTINUATION = "0b10xxxxxx"_test;
-
+        // prepend each of the remaining bytes data to an accumulator
         for (int i = 1; i <= len; ++i) {
+            static constexpr auto CONTINUATION = "0b10xxxxxx"_test;
             if (cursor == src.cend ())
                 throw malformed_error {};
 
@@ -122,8 +121,11 @@ decode (util::view<InputT> src, OutputT dst)
             accum  |= CONTINUATION.value (now);
         }
 
-        // describes the bits required to be present for a valid minimally
-        // sized codepoint of a given byte length.
+        // check that the codepoint is the right size by seeing if the unique
+        // bits present in the decoded size codepoint are actually used.
+        //
+        // these could theoretically be provided to the user, but they may be
+        // misused so we will throw an error instead.
         static constexpr
         codepoint_t LEVEL_MASK[] {
             0b00000000'00000000'01111111,

From 340981dac2a153485888d64b81c7c83e3aad9290 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 3 Oct 2017 17:49:08 +1100
Subject: [PATCH 138/149] json2: initial import

---
 CMakeLists.txt                |  13 ++
 json2/event.cpp               |  90 ++++++++++
 json2/event.hpp               |  55 ++++++
 json2/except.hpp              |  40 +++++
 json2/fwd.hpp                 |  47 +++++
 json2/personality/base.cpp    | 319 ++++++++++++++++++++++++++++++++++
 json2/personality/base.hpp    |  83 +++++++++
 json2/personality/jsonish.cpp |  24 +++
 json2/personality/jsonish.hpp |  84 +++++++++
 json2/personality/rfc7519.cpp |  21 +++
 json2/personality/rfc7519.hpp |  84 +++++++++
 json2/tree.cpp                |   1 +
 json2/tree.hpp                |  22 +++
 test/json2/event.cpp          | 276 +++++++++++++++++++++++++++++
 14 files changed, 1159 insertions(+)
 create mode 100644 json2/event.cpp
 create mode 100644 json2/event.hpp
 create mode 100644 json2/except.hpp
 create mode 100644 json2/fwd.hpp
 create mode 100644 json2/personality/base.cpp
 create mode 100644 json2/personality/base.hpp
 create mode 100644 json2/personality/jsonish.cpp
 create mode 100644 json2/personality/jsonish.hpp
 create mode 100644 json2/personality/rfc7519.cpp
 create mode 100644 json2/personality/rfc7519.hpp
 create mode 100644 json2/tree.cpp
 create mode 100644 json2/tree.hpp
 create mode 100644 test/json2/event.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index d3ae3122..6dd60d49 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -318,6 +318,18 @@ list (
     json/schema.hpp
     json/tree.cpp
     json/tree.hpp
+    json2/fwd.hpp
+    json2/event.hpp
+    json2/event.cpp
+    json2/except.hpp
+    json2/personality/base.cpp
+    json2/personality/base.hpp
+    json2/personality/jsonish.cpp
+    json2/personality/jsonish.hpp
+    json2/personality/rfc7519.cpp
+    json2/personality/rfc7519.hpp
+    json2/tree.cpp
+    json2/tree.hpp
     library.hpp
     log.cpp
     log.hpp
@@ -509,6 +521,7 @@ if (TESTS)
         iterator
         job/queue
         json_types
+        json2/event
         maths
         matrix
         memory/deleter
diff --git a/json2/event.cpp b/json2/event.cpp
new file mode 100644
index 00000000..35a7a388
--- /dev/null
+++ b/json2/event.cpp
@@ -0,0 +1,90 @@
+/*
+ * 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 "./event.hpp"
+#include "./except.hpp"
+
+#include "../debug.hpp"
+
+using util::json2::event::packet;
+
+
+///////////////////////////////////////////////////////////////////////////////
+util::json2::event::type_t
+packet::type (void) const noexcept
+{
+    CHECK_NEQ (first, last);
+
+    const auto &c = *first;
+
+    switch (c) {
+    case '{': return type_t::OBJECT_BEGIN;
+    case '}': return type_t::OBJECT_END;
+    case '[': return type_t::ARRAY_BEGIN;
+    case ']': return type_t::ARRAY_END;
+    case '"': return type_t::STRING;
+    case 'n': return type_t::NONE;
+
+    case 't':
+    case 'f':
+        return type_t::BOOLEAN;
+
+    case '-':
+    case '0'...'9':
+        return type_t::NUMBER;
+    }
+
+    unhandled (c);
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+#include "./personality/rfc7519.hpp"
+#include "./personality/jsonish.hpp"
+
+template <typename PersonalityT>
+const char*
+util::json2::event::parse (const std::function<util::json2::callback_t> &cb,
+                           const char *first,
+                           const char *last)
+{
+    auto cursor = first;
+
+    PersonalityT p {};
+    cursor = p.consume_whitespace (cursor, last);
+    cursor = p.parse_value (cb, cursor, last);
+    cursor = p.consume_whitespace (cursor, last);
+
+    return cursor;
+}
+
+
+//-----------------------------------------------------------------------------
+template
+const char* util::json2::event::parse<util::json2::personality::rfc7159> (
+    const std::function<util::json2::callback_t> &,
+    const char*,
+    const char*
+);
+
+
+//-----------------------------------------------------------------------------
+template
+const char* util::json2::event::parse<util::json2::personality::jsonish> (
+    const std::function<util::json2::callback_t> &,
+    const char*,
+    const char*
+);
diff --git a/json2/event.hpp b/json2/event.hpp
new file mode 100644
index 00000000..245f3656
--- /dev/null
+++ b/json2/event.hpp
@@ -0,0 +1,55 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2017 Danny Robson <danny@nerdcruft.net>
+ */
+#ifndef CRUFT_JSON2_EVENT_HPP
+#define CRUFT_JSON2_EVENT_HPP
+
+#include "./fwd.hpp"
+
+#include <functional>
+
+
+namespace util::json2::event {
+    // It is important that scalars come after compound types because it
+    // simplifies categorisation as we can use a simple '>' to classify the
+    // types.
+    //
+    // the value of the enumerants isn't important, but they might make it
+    // fractionally easier to visualise in a debugger on some occasions.
+    enum class type_t {
+        OBJECT_BEGIN = '{',
+        OBJECT_END = '}',
+        ARRAY_BEGIN  = '[',
+        ARRAY_END  = ']',
+
+        STRING = '"',
+        NUMBER = '1',
+        BOOLEAN = 't',
+        NONE = 'n',
+    };
+
+    struct packet {
+        type_t type (void) const noexcept;
+
+        const char *first;
+        const char *last;
+    };
+
+    template <typename PersonalityT = personality::rfc7159>
+    const char*
+    parse (const std::function<callback_t>&, const char *first, const char *last);
+};
+
+#endif
\ No newline at end of file
diff --git a/json2/except.hpp b/json2/except.hpp
new file mode 100644
index 00000000..4896f6f9
--- /dev/null
+++ b/json2/except.hpp
@@ -0,0 +1,40 @@
+/*
+ * 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_JSON2_EXCEPT_HPP
+#define CRUFT_UTIL_JSON2_EXCEPT_HPP
+
+#include <exception>
+
+
+namespace util::json2 {
+    struct error : public std::exception {};
+
+
+    struct parse_error : public error {
+        parse_error (const char *_position):
+            position (_position)
+        { ; }
+
+        const char *position;
+    };
+
+
+    struct overrun_error : public parse_error {
+        using parse_error::parse_error;
+    };
+}
+#endif
diff --git a/json2/fwd.hpp b/json2/fwd.hpp
new file mode 100644
index 00000000..2111aded
--- /dev/null
+++ b/json2/fwd.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 2017 Danny Robson <danny@nerdcruft.net>
+ */
+
+#ifndef CRUFT_UTIL_JSON2_FWD_HPP
+#define CRUFT_UTIL_JSON2_FWD_HPP
+
+#include "../preprocessor.hpp"
+
+namespace util::json2 {
+    namespace personality {
+        template <typename> struct base;
+
+        struct rfc7159;
+        struct jsonish;
+
+        #define MAP_JSON2_PERSONALITY_TYPES(FUNC) \
+        MAP0(FUNC, \
+            util::json2::personality::rfc7159,\
+            util::json2::personality::jsonish)
+    }
+
+    namespace event {
+        enum class type_t;
+        struct packet;
+    }
+
+    using callback_t = void(const event::packet&);
+
+    struct error;
+    struct parse_error;
+    struct overrun_error;
+}
+
+#endif
\ No newline at end of file
diff --git a/json2/personality/base.cpp b/json2/personality/base.cpp
new file mode 100644
index 00000000..d96b3f92
--- /dev/null
+++ b/json2/personality/base.cpp
@@ -0,0 +1,319 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2017 Danny Robson <danny@nerdcruft.net>
+ */
+#include "./base.hpp"
+
+#include "../event.hpp"
+#include "../except.hpp"
+#include "../../debug.hpp"
+
+#include "./rfc7519.hpp"
+#include "./jsonish.hpp"
+
+using util::json2::personality::base;
+
+
+///////////////////////////////////////////////////////////////////////////////
+static const char*
+expect [[nodiscard]] (const char *first, const char *last, const char value)
+{
+    if (first == last || *first != value)
+        throw util::json2::parse_error {first};
+    return first + 1;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+template <typename ParentT>
+const char*
+base<ParentT>::consume_whitespace (const char *first, const char *last) noexcept
+{
+    auto cursor = first;
+
+    while (cursor != last) {
+        switch (*cursor) {
+        case 0x20:
+        case 0x09:
+        case 0x0A:
+        case 0x0D:
+            ++cursor;
+            continue;
+        }
+
+        break;
+    }
+
+    return cursor;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+template <typename ParentT>
+const char*
+base<ParentT>::parse_number (const std::function<util::json2::callback_t> &cb,
+                             const char *first,
+                             const char *last)
+{
+    (void)last;
+
+    // number: minus? int frac? exp?
+    auto cursor = first;
+
+    // minus: '-'
+    if (*cursor == '-')
+        ++cursor;
+
+    // int: '0' | [1-9] DIGIT*
+    switch (*cursor) {
+        case '1'...'9':
+        {
+            ++cursor;
+            while ('0' <= *cursor && *cursor <= '9')
+                ++cursor;
+            break;
+        }
+
+        case '0':
+            // leading zero means we _must_ be parsing a fractional value so we
+            // look ahead to ensure we're about to do so. note that we don't use
+            // `expect' here because it implies consumption of '.'
+            ++cursor;
+            if (*cursor != '.')
+                throw util::json2::parse_error { cursor };
+            break;
+
+        default:
+            throw util::json2::parse_error { cursor };
+    }
+
+    // frac: '.' digit+
+    if (*cursor == '.') {
+        ++cursor;
+
+        auto frac_start = cursor;
+        while ('0' <= *cursor && *cursor <= '9')
+            ++cursor;
+        if (frac_start == cursor)
+            throw util::json2::parse_error { cursor };
+    }
+
+    // exp: [eE] [-+]? digit+
+    if (*cursor == 'e' || *cursor == 'E') {
+        ++cursor;
+
+        if (*cursor == '-' || *cursor == '+')
+            ++cursor;
+
+        auto exp_digits = cursor;
+        while ('0' <= *cursor && *cursor <= '9')
+            ++cursor;
+        if (exp_digits == cursor)
+            throw util::json2::parse_error { cursor };
+    }
+
+    cb ({ first, cursor });
+    return cursor;
+}
+
+
+//-----------------------------------------------------------------------------
+template <typename ParentT>
+template <int N>
+const char*
+base<ParentT>::parse_literal (const std::function<util::json2::callback_t> &cb,
+                              const char *first,
+                              const char *last,
+                              const char (&value)[N])
+{
+    CHECK_LE (first, last);
+
+    if (last - first < N - 1)
+        throw util::json2::overrun_error { first };
+
+    if (!std::equal (first, first + N - 1, value))
+        throw util::json2::parse_error { first };
+
+    cb ({ first, first + N - 1 });
+    return first + N - 1;
+}
+
+
+//-----------------------------------------------------------------------------
+template <typename ParentT>
+const char*
+base<ParentT>::parse_string (const std::function<util::json2::callback_t> &cb,
+                             const char *first,
+                             const char *last)
+{
+    CHECK_LE (first, last);
+
+    auto cursor = first;
+
+    cursor = expect (cursor, last, '"');
+
+    for ( ; cursor != last && *cursor != '"'; ) {
+        // advance the simple case first; unescaped character
+        if (*cursor++ != '\\') {
+            continue;
+        }
+
+        if (*cursor++ == 'u') {
+            for (int i = 0; i < 4; ++i) {
+                switch (*cursor) {
+                    case 'a'...'f':
+                    case 'A'...'F':
+                        ++cursor;
+                        continue;
+                    default:
+                        throw util::json2::parse_error { cursor };
+                }
+            }
+        }
+    }
+
+    cursor = expect (cursor, last, '"');
+    cb ({ first, cursor });
+    return cursor;
+}
+
+
+//-----------------------------------------------------------------------------
+template <typename ParentT>
+const char*
+base<ParentT>::parse_array (const std::function<util::json2::callback_t> &cb,
+                            const char *first,
+                            const char *last)
+{
+    CHECK_LE (first, last);
+
+    auto cursor = first;
+
+    if (*cursor != '[')
+        throw util::json2::parse_error {cursor};
+    cb ({ cursor, cursor + 1 });
+    ++cursor;
+
+    cursor = ParentT::consume_whitespace (cursor, last);
+
+    if (*cursor == ']') {
+        cb ({cursor, cursor + 1});
+        return ++cursor;
+    }
+
+    cursor = ParentT::parse_value (cb, cursor, last);
+
+    if (*cursor == ']') {
+        cb ({cursor, cursor + 1});
+        return ++cursor;
+    }
+
+    do {
+        cursor = ParentT::consume_whitespace (cursor, last);
+        cursor = expect (cursor, last, ',');
+        cursor = ParentT::consume_whitespace (cursor, last);
+        cursor = ParentT::parse_value (cb, cursor, last);
+    } while (*cursor != ']');
+
+    cb ({cursor, cursor + 1});
+    ++cursor;
+
+    return cursor;
+}
+
+
+//-----------------------------------------------------------------------------
+template <typename ParentT>
+const char*
+base<ParentT>::parse_object (const std::function<util::json2::callback_t> &cb,
+                             const char *first,
+                             const char *last)
+{
+    CHECK_LE (first, last);
+
+    auto cursor = first;
+    cursor = expect (cursor, last, '{');
+    cb ({ cursor - 1, cursor });
+
+    cursor = ParentT::consume_whitespace (cursor, last);
+
+    if (*cursor == '}') {
+        cb ({cursor, cursor + 1});
+        return ++cursor;
+    };
+
+    auto parse_member = [] (auto _cb, auto _cursor, auto _last) {
+        _cursor = parse_string (_cb, _cursor, _last);
+
+        _cursor = ParentT::consume_whitespace (_cursor, _last);
+        _cursor = expect (_cursor, _last, ':');
+        _cursor = ParentT::consume_whitespace (_cursor, _last);
+
+        _cursor = ParentT::parse_value (_cb, _cursor, _last);
+        _cursor = ParentT::consume_whitespace (_cursor, _last);
+
+        return _cursor;
+    };
+
+    cursor = parse_member (cb, cursor, last);
+
+    if (*cursor == '}') {
+        cb ({cursor, cursor + 1});
+        return ++cursor;
+    }
+
+    do {
+        cursor = expect (cursor, last, ',');
+        cursor = ParentT::consume_whitespace (cursor, last);
+        cursor = parse_member (cb, cursor, last);
+    } while (*cursor != '}');
+
+    cursor = expect (cursor, last, '}');
+    cb ({cursor - 1, cursor});
+    return cursor;
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////////
+template <typename ParentT>
+const char*
+base<ParentT>::parse_value (const std::function<util::json2::callback_t> &cb,
+                            const char *first,
+                            const char *last)
+{
+    switch (*first) {
+    case '-':
+    case '0'...'9':
+        return ParentT::parse_number (cb, first, last);
+
+    case '"':
+        return ParentT::parse_string (cb, first, last);
+
+    case 't': return ParentT::parse_literal (cb, first, last, "true");
+    case 'f': return ParentT::parse_literal (cb, first, last, "false");
+    case 'n': return ParentT::parse_literal (cb, first, last, "null");
+
+    case '[': return ParentT::parse_array (cb, first, last);
+    case '{': return ParentT::parse_object (cb, first, last);
+    }
+
+    throw util::json2::parse_error (first);
+}
+
+
+
+//-----------------------------------------------------------------------------
+#define INSTANTIATE(KLASS) template struct util::json2::personality::base<KLASS>;
+MAP_JSON2_PERSONALITY_TYPES (INSTANTIATE)
diff --git a/json2/personality/base.hpp b/json2/personality/base.hpp
new file mode 100644
index 00000000..116d9f0f
--- /dev/null
+++ b/json2/personality/base.hpp
@@ -0,0 +1,83 @@
+/*
+ * 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_JSON2_PERSONALITY_BASE_HPP
+#define CRUFT_UTIL_JSON2_PERSONALITY_BASE_HPP
+
+#include "../fwd.hpp"
+
+#include <functional>
+
+
+namespace util::json2::personality {
+    template <typename T>
+    struct base {
+        static const char*
+        consume_whitespace [[nodiscard]] (const char *first, const char *last) noexcept;
+
+
+        static const char*
+        parse_number [[nodiscard]] (
+            const std::function<callback_t>&,
+            const char *first,
+            const char *last
+        );
+
+
+        template <int N>
+        static const char*
+        parse_literal [[nodiscard]] (
+            const std::function<callback_t>&,
+            const char *first,
+            const char *last,
+            const char (&value)[N]
+        );
+
+
+        static const char*
+        parse_string [[nodiscard]] (
+            const std::function<callback_t>&,
+            const char *first,
+            const char *last
+        );
+
+
+        static const char*
+        parse_array [[nodiscard]] (
+            const std::function<callback_t>&,
+            const char *first,
+            const char *last
+        );
+
+
+        static const char*
+        parse_object [[nodiscard]] (
+            const std::function<callback_t>&,
+            const char *first,
+            const char *last
+        );
+
+
+        static const char*
+        parse_value [[nodiscard]] (
+            const std::function<callback_t>&,
+            const char *first,
+            const char *last
+        );
+    };
+};
+
+#endif
diff --git a/json2/personality/jsonish.cpp b/json2/personality/jsonish.cpp
new file mode 100644
index 00000000..653645f9
--- /dev/null
+++ b/json2/personality/jsonish.cpp
@@ -0,0 +1,24 @@
+/*
+ * 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 "./jsonish.hpp"
+
+#include "./base.hpp"
+
+using util::json2::personality::jsonish;
+
+
+///////////////////////////////////////////////////////////////////////////////
diff --git a/json2/personality/jsonish.hpp b/json2/personality/jsonish.hpp
new file mode 100644
index 00000000..74b16351
--- /dev/null
+++ b/json2/personality/jsonish.hpp
@@ -0,0 +1,84 @@
+/*
+ * 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_JSON2_PERSONALITY_JSONISH_HPP
+#define CRUFT_UTIL_JSON2_PERSONALITY_JSONISH_HPP
+
+#include "../fwd.hpp"
+
+#include "./base.hpp"
+
+#include <functional>
+
+
+namespace util::json2::personality {
+    struct jsonish {
+        static const char*
+        consume_whitespace [[nodiscard]] (const char *first, const char *last) noexcept
+        { return base<jsonish>::consume_whitespace (first, last); }
+
+
+        static const char*
+        parse_value [[nodiscard]] (
+            const std::function<callback_t> &cb,
+            const char *first, const char *last
+        ) { return base<jsonish>::parse_value (cb, first, last); }
+
+
+        static const char*
+        parse_number [[nodiscard]] (
+            const std::function<callback_t> &cb,
+            const char *first,
+            const char *last
+        ) { return base<jsonish>::parse_number (cb, first, last); }
+
+
+        template <int N>
+        static const char*
+        parse_literal [[nodiscard]] (
+            const std::function<callback_t> &cb,
+            const char *first,
+            const char *last,
+            const char (&value)[N]
+        ) { return base<jsonish>::parse_literal (cb, first, last, value); }
+
+
+        static const char*
+        parse_string [[nodiscard]] (
+            const std::function<callback_t> &cb,
+            const char *first,
+            const char *last
+        ) { return base<jsonish>::parse_string (cb, first, last); }
+
+
+        static const char*
+        parse_array [[nodiscard]] (
+            const std::function<callback_t> &cb,
+            const char *first,
+            const char *last
+        ) { return base<jsonish>::parse_array (cb, first, last); }
+
+
+        static const char*
+        parse_object [[nodiscard]] (
+            const std::function<callback_t> &cb,
+            const char *first,
+            const char *last
+        ) { return base<jsonish>::parse_object (cb, first, last); }
+    };
+};
+
+#endif
diff --git a/json2/personality/rfc7519.cpp b/json2/personality/rfc7519.cpp
new file mode 100644
index 00000000..041c6cdd
--- /dev/null
+++ b/json2/personality/rfc7519.cpp
@@ -0,0 +1,21 @@
+/*
+ * 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 "./rfc7519.hpp"
+
+#include "./base.hpp"
+
+using util::json2::personality::rfc7159;
diff --git a/json2/personality/rfc7519.hpp b/json2/personality/rfc7519.hpp
new file mode 100644
index 00000000..20a71fe9
--- /dev/null
+++ b/json2/personality/rfc7519.hpp
@@ -0,0 +1,84 @@
+/*
+ * 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_JSON2_PERSONALITY_RFC7159_HPP
+#define CRUFT_UTIL_JSON2_PERSONALITY_RFC7159_HPP
+
+#include "./base.hpp"
+
+#include "../fwd.hpp"
+
+#include <functional>
+
+namespace util::json2::personality {
+    struct rfc7159 {
+        static const char*
+        consume_whitespace [[nodiscard]] (const char *first, const char *last) noexcept
+        { return base<rfc7159>::consume_whitespace (first, last); }
+
+
+        static const char*
+        parse_value [[nodiscard]] (
+            const std::function<callback_t> &cb,
+            const char *first, const char *last
+        ) { return base<rfc7159>::parse_value (cb, first, last); }
+
+
+        static const char*
+        parse_number [[nodiscard]] (
+            const std::function<callback_t> &cb,
+            const char *first,
+            const char *last
+        ) { return base<rfc7159>::parse_number (cb, first, last); }
+
+
+        template <int N>
+        static const char*
+        parse_literal [[nodiscard]] (
+            const std::function<callback_t> &cb,
+            const char *first,
+            const char *last,
+            const char (&value)[N]
+        ) { return base<rfc7159>::parse_literal (cb, first, last, value); }
+
+
+        static const char*
+        parse_string [[nodiscard]] (
+            const std::function<callback_t> &cb,
+            const char *first,
+            const char *last
+        ) { return base<rfc7159>::parse_string (cb, first, last); }
+
+
+        static const char*
+        parse_array [[nodiscard]] (
+            const std::function<callback_t> &cb,
+            const char *first,
+            const char *last
+        ) { return base<rfc7159>::parse_array (cb, first, last); }
+
+
+        static const char*
+        parse_object [[nodiscard]] (
+            const std::function<callback_t> &cb,
+            const char *first,
+            const char *last
+        ) { return base<rfc7159>::parse_object (cb, first, last); }
+    };
+};
+
+
+#endif
\ No newline at end of file
diff --git a/json2/tree.cpp b/json2/tree.cpp
new file mode 100644
index 00000000..0ca18b6f
--- /dev/null
+++ b/json2/tree.cpp
@@ -0,0 +1 @@
+#include "./tree.hpp"
\ No newline at end of file
diff --git a/json2/tree.hpp b/json2/tree.hpp
new file mode 100644
index 00000000..f9049603
--- /dev/null
+++ b/json2/tree.hpp
@@ -0,0 +1,22 @@
+/*
+ * 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_JSON2_TREE_HPP
+#define CRUFT_JSON2_TREE_HPP
+
+
+
+#endif
\ No newline at end of file
diff --git a/test/json2/event.cpp b/test/json2/event.cpp
new file mode 100644
index 00000000..c7bc7021
--- /dev/null
+++ b/test/json2/event.cpp
@@ -0,0 +1,276 @@
+#include "json2/event.hpp"
+#include "json2/except.hpp"
+#include "tap.hpp"
+
+#include <vector>
+#include <cstring>
+#include <functional>
+
+
+void
+test_numbers (util::TAP::logger &tap)
+{
+    static const struct {
+        const char *data;
+        bool good;
+        const char *message;
+    } TESTS[] = {
+        { "1", true, "single digit" },
+        { "01", false, "leading zero" },
+        { "-1", true, "leading minus" },
+        { "1.", false, "truncated fraction" },
+        { "1.0", true, "fraction" },
+        { "1.0e", false, "truncated exponential" },
+        { "1.0e1", true, "lower exponential" },
+        { "1.0E1", true, "upper exponential" },
+        { "1.0e+1", true, "positive exponential" },
+        { "1.0e+", false, "truncated positive exponential" },
+        { "1.0e-1", true, "negative exponential" },
+        { "1.0e-", false, "truncated negative exponential" },
+    };
+
+    for (const auto &t: TESTS) {
+        auto first = t.data;
+        auto last  = first + strlen (first);
+
+        if (!t.good) {
+            tap.expect_throw<util::json2::error> (
+                [&] () {
+                    util::json2::event::parse ([] (auto) {}, first, last);
+                },
+                "number, %s",
+                t.message
+            );
+        } else {
+            util::json2::event::type_t type;
+            auto end = util::json2::event::parse (
+                [&type] (auto p) { type = p.type (); }, first, last
+            );
+
+            tap.expect (
+                last == end && type == util::json2::event::type_t::NUMBER,
+                "number, %s",
+                t.message
+            );
+        }
+    }
+}
+
+
+void
+test_literals (util::TAP::logger &tap)
+{
+    static const struct {
+        const char *data;
+        bool good;
+        util::json2::event::type_t type;
+        const char *message;
+    } TESTS[] = {
+        { "true", true,  util::json2::event::type_t::BOOLEAN, "lower true" },
+        { "TRUE", false, util::json2::event::type_t::BOOLEAN, "upper true" },
+        { "truE", false, util::json2::event::type_t::BOOLEAN, "mixed true" },
+        { "tru",  false, util::json2::event::type_t::BOOLEAN, "truncated true" },
+
+        { "false", true, util::json2::event::type_t::BOOLEAN, "lower false" },
+        { "FALSE", false, util::json2::event::type_t::BOOLEAN, "upper false" },
+        { "falSe", false, util::json2::event::type_t::BOOLEAN, "mixed false" },
+        { "fals",  false, util::json2::event::type_t::BOOLEAN, "truncated false" },
+
+        { "null", true, util::json2::event::type_t::NONE, "lower null" },
+        { "NULL", false, util::json2::event::type_t::NONE, "upper null" },
+        { "nUll", false, util::json2::event::type_t::NONE, "mixed null" },
+        { "nul",  false, util::json2::event::type_t::NONE, "truncated null" },
+    };
+
+    for (const auto &t: TESTS) {
+        auto first = t.data;
+        auto last  = first + strlen (first);
+
+        if (t.good) {
+            util::json2::event::type_t type;
+            util::json2::event::parse ([&type] (auto p) { type = p.type (); }, first, last);
+            tap.expect_eq (type, t.type, "literal, %s", t.message);
+        } else {
+            tap.expect_throw<util::json2::parse_error> (
+                [first,last] () {
+                    util::json2::event::parse ([] (auto) {}, first, last);
+                },
+                "literal, %s",
+                t.message
+            );
+        }
+    }
+}
+
+
+void
+test_strings (util::TAP::logger &tap)
+{
+    static const struct {
+        const char *data;
+        bool good;
+        const char *message;
+    } TESTS[] = {
+        { "\"abc\"", true, "abc" },
+        { "\"\"", true, "empty" },
+        { "\"", false, "unbalanced quote" },
+        { "\"\\n\"", true, "newline escape" },
+        { "\"\\a\"", true, "valid unnecessary escape" },
+        { "\"\\uABCD\"", true, "upper unicode hex escape" },
+        { "\"\\uabcd\"", true, "lower unicode hex escape" },
+        { "\"\\uab\"", false, "truncated unicode hex escape" },
+        { "\"\\uabxy\"", false, "invalid unicode hex escape" },
+    };
+
+    for (const auto &t: TESTS) {
+        auto first = t.data;
+        auto last  = first + strlen (first);
+
+        if (t.good) {
+            util::json2::event::type_t type;
+            util::json2::event::parse ([&type] (auto p) { type = p.type (); }, first, last);
+            tap.expect_eq (type, util::json2::event::type_t::STRING, "string, %s", t.message);
+        } else {
+            tap.expect_throw<util::json2::parse_error> (
+                [first,last] () {
+                    util::json2::event::parse ([] (auto) {}, first, last);
+                },
+                "string, %s",
+                t.message
+            );
+        }
+    }
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+void
+test_arrays (util::TAP::logger &tap)
+{
+    using util::json2::event::type_t;
+
+    static const struct {
+        const char *data;
+        bool good;
+        std::vector<util::json2::event::type_t> types;
+        const char *message;
+    } TESTS[] = {
+        { "[]", true, { type_t::ARRAY_BEGIN, type_t::ARRAY_END }, "empty" },
+        { "[1]", true, { type_t::ARRAY_BEGIN, type_t::NUMBER, type_t::ARRAY_END }, "single number" },
+        { "[1true]", false, { type_t::ARRAY_BEGIN, type_t::NUMBER }, "contatenated number/bool" },
+        { "[1,2]", true, { type_t::ARRAY_BEGIN, type_t::NUMBER, type_t::NUMBER, type_t::ARRAY_END }, "two numbers" },
+        { "[1,]", false, { type_t::ARRAY_BEGIN, type_t::NUMBER }, "single trailing comma" },
+        { "[1,2,]", false, { type_t::ARRAY_BEGIN, type_t::NUMBER, type_t::NUMBER }, "double trailing comma" },
+        { "[,]", false, { type_t::ARRAY_BEGIN }, "only comma" },
+        { "[", false, { type_t::ARRAY_BEGIN }, "missing terminator" },
+        { "[[]]", true, { type_t::ARRAY_BEGIN, type_t::ARRAY_BEGIN, type_t::ARRAY_END, type_t::ARRAY_END }, "nested array" },
+        { "[[]", false, { type_t::ARRAY_BEGIN, type_t::ARRAY_END }, "unbalanced nested array" },
+    };
+
+    for (const auto &t: TESTS) {
+        auto first = t.data;
+        auto last  = first + strlen (first);
+
+        if (t.good) {
+            std::vector<type_t> types;
+            util::json2::event::parse ([&types] (auto p) { types.push_back (p.type ()); }, first, last);
+            tap.expect_eq (types, t.types, "array, %s", t.message);
+        } else {
+            tap.expect_throw<util::json2::parse_error> (
+                [&] () {
+                    util::json2::event::parse ([] (auto) { }, first, last);
+                }, "array, %s", t.message
+            );
+        }
+    }
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+void
+test_objects (util::TAP::logger &tap)
+{
+    using util::json2::event::type_t;
+
+    static const struct {
+        const char *data;
+        bool good;
+        std::vector<type_t> types;
+        std::vector<std::string> strings;
+        const char *message;
+    } TESTS[] = {
+        { "{}", true, { type_t::OBJECT_BEGIN, type_t::OBJECT_END }, {}, "empty" },
+        { "{", false, { type_t::OBJECT_BEGIN }, {}, "missing terminator" },
+        { "{\"a\":1}", true, { type_t::OBJECT_BEGIN, type_t::STRING, type_t::NUMBER, type_t::OBJECT_END }, {"\"a\""}, "empty" },
+        { "{1:1}", false, { type_t::OBJECT_BEGIN }, {}, "integer key" },
+        { "{:1}", false, { type_t::OBJECT_BEGIN }, {}, "no key" },
+        { "{\"a\":}", false, { type_t::OBJECT_BEGIN, type_t::STRING }, {}, "no value" },
+        {
+            R"json({"a":[]})json",
+            true,
+            {
+                type_t::OBJECT_BEGIN,
+                type_t::STRING,
+                type_t::ARRAY_BEGIN,
+                type_t::ARRAY_END,
+                type_t::OBJECT_END
+            },
+            { "\"a\"" },
+            "array value" },
+        {
+            R"json({ "a": { "b": null } })json",
+            true,
+            {
+                type_t::OBJECT_BEGIN,
+                type_t::STRING,
+                type_t::OBJECT_BEGIN,
+                type_t::STRING,
+                type_t::NONE,
+                type_t::OBJECT_END,
+                type_t::OBJECT_END
+            },
+            { "\"a\"", "\"b\"" },
+            "recursive object"
+        }
+    };
+
+    for (const auto &t: TESTS) {
+        auto first = t.data;
+        auto last  = first + strlen (first);
+
+        if (t.good) {
+            std::vector<type_t> types;
+            std::vector<std::string> strings;
+
+            util::json2::event::parse ([&] (auto p) {
+                types.push_back (p.type ());
+                if (p.type () == type_t::STRING)
+                    strings.push_back (std::string {p.first, p.last});
+            }, first, last);
+
+            tap.expect (types == t.types && strings == t.strings, "object, %s", t.message);
+        } else {
+            tap.expect_throw<util::json2::parse_error> (
+                [&] () {
+                    util::json2::event::parse ([] (auto) {}, first, last);
+                }, "object, %s", t.message
+            );
+        }
+    }
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+int
+main (void)
+{
+    util::TAP::logger tap;
+
+    test_numbers (tap);
+    test_literals (tap);
+    test_strings (tap);
+    test_arrays (tap);
+    test_objects (tap);
+
+    return tap.status ();
+}
\ No newline at end of file

From 32f32401863bed020c0c7904b3128a4526a19165 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Thu, 5 Oct 2017 11:44:37 +1100
Subject: [PATCH 139/149] json2: initial 'jsonish' support

---
 json2/event.cpp               |   4 +
 json2/personality/base.cpp    |  17 ++-
 json2/personality/base.hpp    |   7 ++
 json2/personality/jsonish.cpp | 177 +++++++++++++++++++++++++++
 json2/personality/jsonish.hpp |  25 +++-
 json2/personality/rfc7519.hpp |  16 +++
 test/json2/event.cpp          | 221 +++++++++++++++++++++++++++++++---
 7 files changed, 444 insertions(+), 23 deletions(-)

diff --git a/json2/event.cpp b/json2/event.cpp
index 35a7a388..b2170d3b 100644
--- a/json2/event.cpp
+++ b/json2/event.cpp
@@ -42,7 +42,11 @@ packet::type (void) const noexcept
     case 'f':
         return type_t::BOOLEAN;
 
+    // TODO: leading plus isn't valid json, but other similar formats support
+    // this syntax and it's easier to claim it as a number globally here until
+    // we do a little refactoring.
     case '-':
+    case '+':
     case '0'...'9':
         return type_t::NUMBER;
     }
diff --git a/json2/personality/base.cpp b/json2/personality/base.cpp
index d96b3f92..a8e00d81 100644
--- a/json2/personality/base.cpp
+++ b/json2/personality/base.cpp
@@ -254,7 +254,7 @@ base<ParentT>::parse_object (const std::function<util::json2::callback_t> &cb,
     };
 
     auto parse_member = [] (auto _cb, auto _cursor, auto _last) {
-        _cursor = parse_string (_cb, _cursor, _last);
+        _cursor = ParentT::parse_key (_cb, _cursor, _last);
 
         _cursor = ParentT::consume_whitespace (_cursor, _last);
         _cursor = expect (_cursor, _last, ':');
@@ -294,6 +294,7 @@ base<ParentT>::parse_value (const std::function<util::json2::callback_t> &cb,
                             const char *last)
 {
     switch (*first) {
+    case '+':
     case '-':
     case '0'...'9':
         return ParentT::parse_number (cb, first, last);
@@ -309,10 +310,22 @@ base<ParentT>::parse_value (const std::function<util::json2::callback_t> &cb,
     case '{': return ParentT::parse_object (cb, first, last);
     }
 
-    throw util::json2::parse_error (first);
+    return ParentT::parse_unknown (cb, first, last);
 }
 
 
+///////////////////////////////////////////////////////////////////////////////
+template <typename ParentT>
+const char*
+base<ParentT>::parse_unknown (const std::function<util::json2::callback_t>&,
+                              const char *first,
+                              const char *last)
+{
+    (void)last;
+    throw parse_error {first};
+};
+
+
 
 //-----------------------------------------------------------------------------
 #define INSTANTIATE(KLASS) template struct util::json2::personality::base<KLASS>;
diff --git a/json2/personality/base.hpp b/json2/personality/base.hpp
index 116d9f0f..4e20e14a 100644
--- a/json2/personality/base.hpp
+++ b/json2/personality/base.hpp
@@ -77,6 +77,13 @@ namespace util::json2::personality {
             const char *first,
             const char *last
         );
+
+        static const char*
+        parse_unknown [[noreturn]] (
+            const std::function<callback_t>&,
+            const char *first,
+            const char *last
+        );
     };
 };
 
diff --git a/json2/personality/jsonish.cpp b/json2/personality/jsonish.cpp
index 653645f9..87fd7db9 100644
--- a/json2/personality/jsonish.cpp
+++ b/json2/personality/jsonish.cpp
@@ -17,8 +17,185 @@
 #include "./jsonish.hpp"
 
 #include "./base.hpp"
+#include "../event.hpp"
+#include "../except.hpp"
+#include "../../debug.hpp"
 
 using util::json2::personality::jsonish;
 
 
 ///////////////////////////////////////////////////////////////////////////////
+const char*
+jsonish::consume_whitespace (const char *first, const char *last) noexcept
+{
+    auto cursor = base<jsonish>::consume_whitespace (first, last);
+
+    // consume a comment
+    if (cursor != last && *cursor == '#') {
+        while (cursor != last && *cursor != '\n')
+            ++cursor;
+
+        return consume_whitespace (cursor, last);
+    }
+
+    return cursor;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+// format is:
+//   int: '0x' hex+ | '0' oct+ | '0b' bit+
+//
+//   float: significand exp?
+//   significand: digit+ ('.' digit*)?
+//   exp: [eE] sign? digit+
+//
+//   number: [+-] (int | float)
+const char*
+jsonish::parse_number (const std::function<callback_t> &cb,
+                       const char *first,
+                       const char *last)
+{
+    auto cursor = first;
+
+    if (cursor != last && (*cursor == '+' || *cursor == '-'))
+        ++cursor;
+
+    if (cursor != last && *cursor == '0') {
+        ++cursor;
+
+        if (cursor == last)
+            throw parse_error {cursor};
+
+        char max = '9';
+        switch (*cursor) {
+        case 'x': {
+            // parse the hex integer here because we can simplify the
+            // remaining cases somewhat if we don't need to care about the
+            // multiple ranges of valid digits.
+            ++cursor;
+
+            auto digit_start = cursor;
+            while (cursor != last && ('0' <= *cursor && *cursor <= '9' ||
+                                      'a' <= *cursor && *cursor <= 'f' ||
+                                      'A' <= *cursor && *cursor <= 'F'))
+                ++cursor;
+            if (digit_start == cursor)
+                throw parse_error {cursor};
+
+            cb ({first, cursor});
+            return cursor;
+        };
+
+        case 'b': max = '1'; break;
+        case '0'...'7': max = '7'; break;
+
+        case '.':
+            goto frac;
+        }
+
+        auto digit_start = ++cursor;
+        while (cursor != last && '0' <= *cursor && *cursor <= max)
+            ++cursor;
+        if (digit_start == cursor)
+            throw parse_error {cursor};
+
+        cb ({first, cursor});
+        return cursor;
+    }
+
+    while (cursor != last && '0' <= *cursor && *cursor <= '9')
+        ++cursor;
+    if (cursor == last)
+        goto done;
+
+    if (*cursor != '.')
+        goto exp;
+
+frac:
+    ++cursor;
+    while (cursor != last && *cursor >= '0' && *cursor <= '9')
+        ++cursor;
+    if (cursor == last)
+        goto done;
+
+exp:
+    if (cursor != last && (*cursor == 'e'  || *cursor == 'E')) {
+        ++cursor;
+
+        if (cursor != last && (*cursor == '+' || *cursor == '-'))
+            ++cursor;
+
+        auto digit_start = cursor;
+        while (cursor != last && '0' <= *cursor && *cursor <= '9')
+            ++cursor;
+        if (digit_start == cursor)
+            throw parse_error {cursor};
+    }
+
+    if (first == cursor)
+        throw parse_error {cursor};
+
+done:
+    cb ({first, cursor});
+    return cursor;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+const char*
+jsonish::parse_key (const std::function<callback_t> &cb,
+                    const char *first,
+                    const char *last)
+{
+    auto cursor = first;
+    if (cursor == last)
+        throw parse_error {cursor};
+
+    // must start with alpha or underscore
+    switch (*cursor) {
+    case 'a'...'z':
+    case 'A'...'Z':
+    case '_':
+        ++cursor;
+        break;
+
+    default:
+        throw parse_error {cursor};
+    }
+
+
+    while (cursor != last) {
+        switch (*cursor) {
+        case 'a'...'z':
+        case 'A'...'Z':
+        case '_':
+        case '0'...'9':
+            ++cursor;
+            break;
+
+        default:
+            cb ({first, cursor});
+            return cursor;
+        }
+    }
+
+    cb ({first, cursor});
+    return cursor;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+const char*
+jsonish::parse_string (const std::function<callback_t> &cb,
+                       const char *first,
+                       const char *last)
+{
+    if (first == last)
+        throw parse_error {first};
+
+    if (*first == '"')
+        return base<jsonish>::parse_string (cb, first, last);
+    else
+        return parse_key (cb, first, last);
+}
diff --git a/json2/personality/jsonish.hpp b/json2/personality/jsonish.hpp
index 74b16351..fd44f61c 100644
--- a/json2/personality/jsonish.hpp
+++ b/json2/personality/jsonish.hpp
@@ -27,8 +27,10 @@
 namespace util::json2::personality {
     struct jsonish {
         static const char*
-        consume_whitespace [[nodiscard]] (const char *first, const char *last) noexcept
-        { return base<jsonish>::consume_whitespace (first, last); }
+        consume_whitespace [[nodiscard]] (
+            const char *first,
+            const char *last
+        ) noexcept;
 
 
         static const char*
@@ -43,7 +45,7 @@ namespace util::json2::personality {
             const std::function<callback_t> &cb,
             const char *first,
             const char *last
-        ) { return base<jsonish>::parse_number (cb, first, last); }
+        );
 
 
         template <int N>
@@ -61,7 +63,7 @@ namespace util::json2::personality {
             const std::function<callback_t> &cb,
             const char *first,
             const char *last
-        ) { return base<jsonish>::parse_string (cb, first, last); }
+        );
 
 
         static const char*
@@ -72,12 +74,27 @@ namespace util::json2::personality {
         ) { return base<jsonish>::parse_array (cb, first, last); }
 
 
+        static const char*
+        parse_key [[nodiscard]] (
+            const std::function<callback_t> &cb,
+            const char *first,
+            const char *last);
+
+
         static const char*
         parse_object [[nodiscard]] (
             const std::function<callback_t> &cb,
             const char *first,
             const char *last
         ) { return base<jsonish>::parse_object (cb, first, last); }
+
+
+        static const char*
+        parse_unknown [[nodiscard]] (
+            const std::function<callback_t> &cb,
+            const char *first,
+            const char *last
+        ) { return parse_string (cb, first, last); }
     };
 };
 
diff --git a/json2/personality/rfc7519.hpp b/json2/personality/rfc7519.hpp
index 20a71fe9..cf26e0ad 100644
--- a/json2/personality/rfc7519.hpp
+++ b/json2/personality/rfc7519.hpp
@@ -71,12 +71,28 @@ namespace util::json2::personality {
         ) { return base<rfc7159>::parse_array (cb, first, last); }
 
 
+        static const char*
+        parse_key [[nodiscard]] (
+            const std::function<callback_t> &cb,
+            const char *first,
+            const char *last)
+        { return parse_string (cb, first, last); }
+
+
         static const char*
         parse_object [[nodiscard]] (
             const std::function<callback_t> &cb,
             const char *first,
             const char *last
         ) { return base<rfc7159>::parse_object (cb, first, last); }
+
+
+        static const char *
+        parse_unknown [[noreturn]] (
+            const std::function<callback_t> &cb,
+            const char *first,
+            const char *last)
+        { throw base<rfc7159>::parse_unknown (cb, first, last); }
     };
 };
 
diff --git a/test/json2/event.cpp b/test/json2/event.cpp
index c7bc7021..f0159519 100644
--- a/test/json2/event.cpp
+++ b/test/json2/event.cpp
@@ -7,6 +7,7 @@
 #include <functional>
 
 
+///////////////////////////////////////////////////////////////////////////////
 void
 test_numbers (util::TAP::logger &tap)
 {
@@ -18,6 +19,7 @@ test_numbers (util::TAP::logger &tap)
         { "1", true, "single digit" },
         { "01", false, "leading zero" },
         { "-1", true, "leading minus" },
+        { "+1", false, "leading plus" },
         { "1.", false, "truncated fraction" },
         { "1.0", true, "fraction" },
         { "1.0e", false, "truncated exponential" },
@@ -57,6 +59,7 @@ test_numbers (util::TAP::logger &tap)
 }
 
 
+///////////////////////////////////////////////////////////////////////////////
 void
 test_literals (util::TAP::logger &tap)
 {
@@ -103,6 +106,7 @@ test_literals (util::TAP::logger &tap)
 }
 
 
+///////////////////////////////////////////////////////////////////////////////
 void
 test_strings (util::TAP::logger &tap)
 {
@@ -155,16 +159,100 @@ test_arrays (util::TAP::logger &tap)
         std::vector<util::json2::event::type_t> types;
         const char *message;
     } TESTS[] = {
-        { "[]", true, { type_t::ARRAY_BEGIN, type_t::ARRAY_END }, "empty" },
-        { "[1]", true, { type_t::ARRAY_BEGIN, type_t::NUMBER, type_t::ARRAY_END }, "single number" },
-        { "[1true]", false, { type_t::ARRAY_BEGIN, type_t::NUMBER }, "contatenated number/bool" },
-        { "[1,2]", true, { type_t::ARRAY_BEGIN, type_t::NUMBER, type_t::NUMBER, type_t::ARRAY_END }, "two numbers" },
-        { "[1,]", false, { type_t::ARRAY_BEGIN, type_t::NUMBER }, "single trailing comma" },
-        { "[1,2,]", false, { type_t::ARRAY_BEGIN, type_t::NUMBER, type_t::NUMBER }, "double trailing comma" },
-        { "[,]", false, { type_t::ARRAY_BEGIN }, "only comma" },
-        { "[", false, { type_t::ARRAY_BEGIN }, "missing terminator" },
-        { "[[]]", true, { type_t::ARRAY_BEGIN, type_t::ARRAY_BEGIN, type_t::ARRAY_END, type_t::ARRAY_END }, "nested array" },
-        { "[[]", false, { type_t::ARRAY_BEGIN, type_t::ARRAY_END }, "unbalanced nested array" },
+        {
+            "[]",
+            true,
+            {
+                type_t::ARRAY_BEGIN,
+                type_t::ARRAY_END
+            },
+            "empty"
+        },
+        {
+            "[1]",
+            true,
+            {
+                type_t::ARRAY_BEGIN,
+                type_t::NUMBER,
+                type_t::ARRAY_END
+            },
+            "single number"
+        },
+        {
+            "[1true]",
+            false,
+            {
+                type_t::ARRAY_BEGIN,
+                type_t::NUMBER
+            },
+            "contatenated number/bool"
+        },
+        {
+            "[1,2]",
+            true,
+            {
+                type_t::ARRAY_BEGIN,
+                type_t::NUMBER,
+                type_t::NUMBER,
+                type_t::ARRAY_END
+            },
+            "two numbers"
+        },
+        {
+            "[1,]",
+            false,
+            {
+                type_t::ARRAY_BEGIN,
+                type_t::NUMBER
+            },
+            "single trailing comma"
+        },
+        {
+            "[1,2,]",
+            false,
+            {
+                type_t::ARRAY_BEGIN,
+                type_t::NUMBER,
+                type_t::NUMBER
+            },
+            "double trailing comma"
+        },
+        {
+            "[,]",
+            false,
+            {
+                type_t::ARRAY_BEGIN
+            },
+            "only comma"
+        },
+        {
+            "[",
+            false,
+            {
+                type_t::ARRAY_BEGIN
+            },
+            "missing terminator"
+        },
+        {
+            "[[]]",
+            true,
+            {
+                type_t::ARRAY_BEGIN,
+                type_t::ARRAY_BEGIN,
+                type_t::ARRAY_END,
+                type_t::ARRAY_END
+            },
+            "nested array"
+        },
+        {
+            "[[]",
+            false,
+            {
+                type_t::ARRAY_BEGIN,
+                type_t::ARRAY_END
+            },
+            "unbalanced nested array"
+        },
     };
 
     for (const auto &t: TESTS) {
@@ -199,12 +287,65 @@ test_objects (util::TAP::logger &tap)
         std::vector<std::string> strings;
         const char *message;
     } TESTS[] = {
-        { "{}", true, { type_t::OBJECT_BEGIN, type_t::OBJECT_END }, {}, "empty" },
-        { "{", false, { type_t::OBJECT_BEGIN }, {}, "missing terminator" },
-        { "{\"a\":1}", true, { type_t::OBJECT_BEGIN, type_t::STRING, type_t::NUMBER, type_t::OBJECT_END }, {"\"a\""}, "empty" },
-        { "{1:1}", false, { type_t::OBJECT_BEGIN }, {}, "integer key" },
-        { "{:1}", false, { type_t::OBJECT_BEGIN }, {}, "no key" },
-        { "{\"a\":}", false, { type_t::OBJECT_BEGIN, type_t::STRING }, {}, "no value" },
+        {
+            "{}",
+            true,
+            {
+                type_t::OBJECT_BEGIN,
+                type_t::OBJECT_END
+            },
+            {},
+            "empty"
+        },
+        {
+            "{",
+            false,
+            { type_t::OBJECT_BEGIN },
+            {},
+            "missing terminator"
+        },
+        {
+            R"json({"a":1})json",
+            true,
+            {
+                type_t::OBJECT_BEGIN,
+                type_t::STRING,
+                type_t::NUMBER,
+                type_t::OBJECT_END
+            },
+            {
+                "\"a\""
+            },
+            "empty"
+        },
+        {
+            "{1:1}",
+            false,
+            {
+                type_t::OBJECT_BEGIN
+            },
+            {},
+            "integer key"
+        },
+        {
+            "{:1}",
+            false,
+            {
+                type_t::OBJECT_BEGIN
+            },
+            {},
+            "no key"
+        },
+        {
+            R"json({"a":})json",
+            false,
+            {
+                type_t::OBJECT_BEGIN,
+                type_t::STRING
+            },
+            {},
+            "no value"
+        },
         {
             R"json({"a":[]})json",
             true,
@@ -229,7 +370,10 @@ test_objects (util::TAP::logger &tap)
                 type_t::OBJECT_END,
                 type_t::OBJECT_END
             },
-            { "\"a\"", "\"b\"" },
+            {
+                "\"a\"",
+                "\"b\""
+            },
             "recursive object"
         }
     };
@@ -260,6 +404,47 @@ test_objects (util::TAP::logger &tap)
 };
 
 
+///////////////////////////////////////////////////////////////////////////////
+void
+test_jsonish (util::TAP::logger &tap)
+{
+    static const struct {
+        const char *data;
+        const char *message;
+    } TESTS[] = {
+        //{ "{}", "empty object" },
+        //{ "0xdeadbeef", "hex literal" },
+        //{ "0b11011100", "binary literal" },
+        //{ "0666", "octal literal" },
+        //{ "0.", "float without frac" },
+        //{ "+0.", "float with leading +" },
+        //{ "-0.", "float with leading -" },
+        //{ "string", "bare literal string" },
+        //{ "{foo: 1}", "bare string key" },
+        //{ "{foo: bar}", "bare string key and value" },
+        //{ "{foo: bar,}", "trailing object comma" },
+        //{ "[1,]", "trailing array comma" },
+        //{ "1 #comment", "trailing comment" },
+        { "#comment\n1", "leading comment" },
+    };
+
+    for (const auto &t: TESTS) {
+        bool success = true;
+        try {
+            util::json2::event::parse<util::json2::personality::jsonish> (
+                [] (auto) {},
+                t.data,
+                t.data + strlen (t.data)
+            );
+        } catch (const util::json2::error&) {
+            success = false;
+        }
+
+        tap.expect (success, "jsonish, %s", t.message);
+    }
+};
+
+
 ///////////////////////////////////////////////////////////////////////////////
 int
 main (void)
@@ -272,5 +457,7 @@ main (void)
     test_arrays (tap);
     test_objects (tap);
 
+    test_jsonish (tap);
+
     return tap.status ();
 }
\ No newline at end of file

From a36991fc832f862211e6d04d2c684350b0ea385f Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Thu, 5 Oct 2017 12:45:48 +1100
Subject: [PATCH 140/149] maths: prefer int for `digits' types

---
 format.ipp | 6 +++---
 maths.hpp  | 8 +++++---
 2 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/format.ipp b/format.ipp
index a8258323..5ae7f17b 100644
--- a/format.ipp
+++ b/format.ipp
@@ -60,7 +60,7 @@ namespace util::format::detail {
         //
         // other values are theoretically supportable, but do not form part of
         // the printf specification.
-        unsigned base = 10;
+        int base = 10;
 
         enum class repr {
             FIXED,
@@ -81,7 +81,7 @@ namespace util::format::detail {
             OSTREAM
         } k;
 
-        unsigned width = 0; // field width, ie: how many characters
+        int width = 0; // field width, ie: how many characters
         int precision = -1; // how many digits after the decimal
 
         size_t length = 0; // bytesize of underlying type
@@ -619,7 +619,7 @@ namespace util::format::detail {
 
         const auto len = spec.precision < 0                  ? spec.precision :
                          (size_t)spec.precision < strlen (t) ? spec.precision :
-                                                               strlen (t);
+                                                               (int)strlen (t);
 
         // perform left padding
         if (spec.width > len && !spec.left_adjusted)
diff --git a/maths.hpp b/maths.hpp
index a921deab..ab0eaec0 100644
--- a/maths.hpp
+++ b/maths.hpp
@@ -347,15 +347,17 @@ namespace util {
     template <typename ValueT, typename BaseT>
     constexpr
     std::enable_if_t<
-        std::is_integral<ValueT>::value && std::is_unsigned<BaseT>::value,
-        unsigned
+        std::is_integral_v<ValueT> && std::is_integral_v<BaseT>,
+        int
     >
     digits (ValueT value, BaseT base) noexcept
     {
+        assert (base > 0);
+
         if (value < 0)
             value *= -1;
 
-        unsigned tally = 1;
+        int tally = 1;
         while (value /= base)
             ++tally;
 

From f33ec13b5034f34f39c3b995a196d33a2d8f9368 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 10 Oct 2017 13:52:46 +1100
Subject: [PATCH 141/149] format: don't accidentally cast local variable types

---
 format.ipp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/format.ipp b/format.ipp
index 5ae7f17b..6bd06082 100644
--- a/format.ipp
+++ b/format.ipp
@@ -788,7 +788,7 @@ namespace util::format::detail {
                 "0123456789abcdef";
 
             char buffer[numerals];
-            size_t remain = numerals;
+            auto remain = numerals;
 
             for (auto cursor = buffer; remain--; t /= spec.base)
                 *cursor++ = NUMERALS[t % spec.base];

From 720a45deb8a86aae81e2a00e78ee2880e8fa54cc Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 10 Oct 2017 14:08:41 +1100
Subject: [PATCH 142/149] matrix: move some implementation from ipp to cpp

this makes debugging under some IDEs slightly easier
---
 matrix.hpp |  88 +++++++++++++++++++++++++++++++++++++++------
 matrix.ipp | 102 -----------------------------------------------------
 2 files changed, 77 insertions(+), 113 deletions(-)

diff --git a/matrix.hpp b/matrix.hpp
index 417ecb59..270f6742 100644
--- a/matrix.hpp
+++ b/matrix.hpp
@@ -31,22 +31,81 @@ namespace util {
 
         T values[Rows][Cols];
 
+        ///////////////////////////////////////////////////////////////////////
         // index operators return a pointer into the data array so that
         // multidimensional array syntax can be used transparently on this
         // type.
-        T* operator[] (size_t);
-        const T* operator[] (size_t) const;
+        constexpr T*
+        operator[] (size_t idx) noexcept
+        {
+            return this->values[idx];
+        }
 
-        T* data (void);
-        const T* data (void) const;
+        //---------------------------------------------------------------------
+        constexpr const T*
+        operator[] (size_t idx) const noexcept
+        {
+            return this->values[idx];
+        }
 
-        const T* begin (void) const;
-        const T* end   (void) const;
-        T* begin (void);
-        T* end   (void);
-        const T* cbegin (void) const;
-        const T* cend   (void) const;
+        //---------------------------------------------------------------------
+        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];
+        }
+
+        //---------------------------------------------------------------------
+        constexpr auto
+        cbegin (void) const noexcept
+        {
+            return begin ();
+        }
+
+        //---------------------------------------------------------------------
+        constexpr auto
+        cend (void) const noexcept
+        {
+            return end ();
+        }
+
+
+        ///////////////////////////////////////////////////////////////////////
         T determinant (void) const;
 
         matrix inverse (void) const;
@@ -58,6 +117,8 @@ namespace util {
             return inverse ();
         }
 
+
+        ///////////////////////////////////////////////////////////////////////
         vector<Rows,T> operator* (const vector<Rows,T>&) const;
         point<Rows,T>  operator* (const point<Rows,T> &) const;
 
@@ -65,7 +126,12 @@ namespace util {
 
         template <typename U>
         matrix<Rows,Cols,U>
-        cast (void) const;
+        cast (void) const
+        {
+            util::matrix<Rows,Cols,T> 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);
diff --git a/matrix.ipp b/matrix.ipp
index 1f3f53f8..7a2e0b69 100644
--- a/matrix.ipp
+++ b/matrix.ipp
@@ -22,108 +22,6 @@
 #define __UTIL_MATRIX_IPP
 
 
-///////////////////////////////////////////////////////////////////////////////
-template <size_t Rows, size_t Cols, typename T>
-T*
-util::matrix<Rows,Cols,T>::operator[] (size_t idx)
-{
-    return this->values[idx];
-}
-
-
-//-----------------------------------------------------------------------------
-template <size_t Rows, size_t Cols, typename T>
-const T*
-util::matrix<Rows,Cols,T>::operator[] (size_t idx) const
-{
-    return this->values[idx];
-}
-
-
-//-----------------------------------------------------------------------------
-template <size_t Rows, size_t Cols, typename T>
-T*
-util::matrix<Rows,Cols,T>::data (void)
-{
-    return begin ();
-}
-
-
-//-----------------------------------------------------------------------------
-template <size_t Rows, size_t Cols, typename T>
-const T*
-util::matrix<Rows,Cols,T>::data (void) const
-{
-    return begin ();
-}
-
-
-//-----------------------------------------------------------------------------
-template <size_t Rows, size_t Cols, typename T>
-const T*
-util::matrix<Rows,Cols,T>::begin (void) const
-{
-    return &(*this)[0][0];
-}
-
-
-//-----------------------------------------------------------------------------
-template <size_t Rows, size_t Cols, typename T>
-const T*
-util::matrix<Rows,Cols,T>::end (void) const
-{
-    return &(*this)[Rows][0];
-}
-
-
-//-----------------------------------------------------------------------------
-template <size_t Rows, size_t Cols, typename T>
-const T*
-util::matrix<Rows,Cols,T>::cbegin (void) const
-{
-    return begin ();
-}
-
-
-//-----------------------------------------------------------------------------
-template <size_t Rows, size_t Cols, typename T>
-const T*
-util::matrix<Rows,Cols,T>::cend (void) const
-{
-    return end ();
-}
-
-
-//-----------------------------------------------------------------------------
-template <size_t Rows, size_t Cols, typename T>
-T*
-util::matrix<Rows,Cols,T>::begin (void)
-{
-    return &(*this)[0][0];
-}
-
-
-//-----------------------------------------------------------------------------
-template <size_t Rows, size_t Cols, typename T>
-T*
-util::matrix<Rows,Cols,T>::end (void)
-{
-    return &(*this)[Rows][0];
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-template <size_t Rows, size_t Cols, typename T>
-template <typename U>
-util::matrix<Rows,Cols,U>
-util::matrix<Rows,Cols,T>::cast (void) const
-{
-    util::matrix<Rows,Cols,T> out;
-    std::copy (cbegin (), cend (), std::begin (out));
-    return out;
-}
-
-
 ///////////////////////////////////////////////////////////////////////////////
 #define MATRIX_ELEMENT_OP(OP)                                       \
 template <size_t Rows, size_t Cols, typename T>                     \

From 2e5d69c095d1f3c14211806c1b396c001e36e68d Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 10 Oct 2017 14:09:07 +1100
Subject: [PATCH 143/149] matrix: work around instruction selection bug in
 clang

---
 matrix.hpp | 26 +++++++++++++++++++++++++-
 matrix.ipp | 23 -----------------------
 2 files changed, 25 insertions(+), 24 deletions(-)

diff --git a/matrix.hpp b/matrix.hpp
index 270f6742..c3cc4f77 100644
--- a/matrix.hpp
+++ b/matrix.hpp
@@ -216,7 +216,31 @@ namespace util {
     >
     constexpr
     matrix<R1,C2,T>
-    operator* (const matrix<R1,C1,T>&, const matrix<R2,C2,T>&);
+    operator* (const matrix<R1,C1,T> &a, const matrix<R2,C2,T> &b) noexcept
+    {
+        static_assert (R2 == C1);
+
+        matrix<R1,C2,T> res {0};
+
+        // TODO: iterating over r,c rather than c,r will cause an ICE with
+        // clang#xxxx: 'X86 DAG->DAG Instruction Selection'.
+        //
+        // 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 (size_t i = 0; i < R2; ++i)
+                    accum += a[r][i] * b[i][c];
+
+                res[r][c] = accum;
+            }
+        }
+
+        return res;
+    }
 
 
     //-------------------------------------------------------------------------
diff --git a/matrix.ipp b/matrix.ipp
index 7a2e0b69..e934426e 100644
--- a/matrix.ipp
+++ b/matrix.ipp
@@ -99,29 +99,6 @@ MATRIX_SCALAR_OP(-)
 #undef MATRIX_SCALAR_OP
 
 
-///////////////////////////////////////////////////////////////////////////////
-template <
-    std::size_t R1, std::size_t C1,
-    std::size_t R2, std::size_t C2,
-    typename T
->
-constexpr
-util::matrix<R1,C2,T>
-util::operator* (const matrix<R1,C1,T> &a, const matrix<R2,C2,T> &b)
-{
-    static_assert (R2 == C1);
-
-    matrix<R1,C2,T> res {0};
-
-    for (size_t r = 0; r < R1; ++r)
-        for (size_t c = 0; c < C2; ++c)
-            for (size_t i = 0; i < R2; ++i)
-                res[r][c] += a[r][i] * b[i][c];
-
-    return res;
-}
-
-
 ///////////////////////////////////////////////////////////////////////////////
 template <size_t Rows, size_t Cols, typename T>
 constexpr

From ba2eb48d63fbdaf5934a997f119177ae49677979 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 10 Oct 2017 16:49:56 +1100
Subject: [PATCH 144/149] iterator: add numeric_iterator for ostream output

---
 iterator.hpp | 65 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 65 insertions(+)

diff --git a/iterator.hpp b/iterator.hpp
index e9770bec..c288e7af 100644
--- a/iterator.hpp
+++ b/iterator.hpp
@@ -20,6 +20,7 @@
 
 #include "types/traits.hpp"
 #include "variadic.hpp"
+#include "view.hpp"
 
 
 template <typename Base>
@@ -153,6 +154,70 @@ namespace util {
     };
 
 
+    ///////////////////////////////////////////////////////////////////////////
+    //
+    template <typename IteratorT>
+    struct numeric_iterator : public std::iterator<
+        typename std::iterator_traits<IteratorT>::iterator_category,
+        decltype (+std::declval<typename std::iterator_traits<IteratorT>::value_type> ()),
+        typename std::iterator_traits<IteratorT>::difference_type,
+        typename std::iterator_traits<IteratorT>::pointer,
+        typename std::iterator_traits<IteratorT>::reference
+    > {
+        static_assert (std::is_arithmetic_v<typename std::iterator_traits<numeric_iterator>::value_type>);
+
+        explicit numeric_iterator (IteratorT _inner):
+            m_inner (_inner)
+        { ; }
+
+        auto operator++ (void) { ++m_inner; return *this; }
+
+        auto
+        operator- (const numeric_iterator &rhs) const
+        {
+            return typename std::iterator_traits<IteratorT>::difference_type { m_inner - rhs.m_inner };
+        }
+
+        auto
+        operator* (void) const
+        {
+            return +*m_inner;
+        }
+
+        auto operator== (const numeric_iterator &rhs) const { return m_inner == rhs.m_inner; }
+        auto operator!= (const numeric_iterator &rhs) const { return m_inner != rhs.m_inner; }
+
+    private:
+        IteratorT m_inner;
+    };
+
+
+    //-------------------------------------------------------------------------
+    // convenience function that constructs a view of numeric_iterators for a
+    // provided container
+    template <typename ContainerT>
+    auto
+    numeric_view (ContainerT &data)
+    {
+        return util::view {
+            numeric_iterator (std::begin (data)),
+            numeric_iterator (std::end   (data))
+        };
+    }
+
+
+    //-------------------------------------------------------------------------
+    template <typename ContainerT>
+    auto
+    numeric_view (const ContainerT &data)
+    {
+        return util::view {
+            numeric_iterator (std::begin (data)),
+            numeric_iterator (std::end   (data))
+        };
+    }
+
+
     ///////////////////////////////////////////////////////////////////////////
     template <typename ContainerT>
     class indices {

From c0e8a947d0e4711b5876e0b2bf220cf8970cb6b1 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 10 Oct 2017 16:50:15 +1100
Subject: [PATCH 145/149] colour: use numeric_iterator and make_infix for
 ostream

---
 colour.cpp | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/colour.cpp b/colour.cpp
index ff11cb4b..238bcc53 100644
--- a/colour.cpp
+++ b/colour.cpp
@@ -384,12 +384,9 @@ namespace json::tree {
 ///////////////////////////////////////////////////////////////////////////////
 template <size_t S, typename T>
 std::ostream&
-util::operator<< (std::ostream &os, util::colour<S,T> c) {
-    os << "colour(";
-    for (size_t i = 0; i < S - 1; ++i)
-        os << +c[i] << ", ";
-    os << +c[S-1] << ")";
-    return os;
+util::operator<< (std::ostream &os, util::colour<S,T> c)
+{
+    return os << "[ " << util::make_infix (util::numeric_view (c), ", ") << ']';
 }
 
 
@@ -438,8 +435,10 @@ util::operator>> (std::istream &is, util::colour<S,T> &c)
     return is;
 }
 
+//-----------------------------------------------------------------------------
 template std::istream& util::operator>> (std::istream&, util::colour<3,uint8_t>&);
 
+
 ///////////////////////////////////////////////////////////////////////////////
 #define INSTANTIATE_S_T(S,T)                            \
 template                                                \

From f0193ee82574d6beaeffac6e10c5d3108d7ae094 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Tue, 10 Oct 2017 16:50:26 +1100
Subject: [PATCH 146/149] colour: instantiate for u16

---
 colour.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/colour.cpp b/colour.cpp
index 238bcc53..f8a0fd7c 100644
--- a/colour.cpp
+++ b/colour.cpp
@@ -456,6 +456,7 @@ 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)
 

From fb2888d2d58b53a35abd2f372da5eb9b0d86cc39 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Wed, 11 Oct 2017 17:15:24 +1100
Subject: [PATCH 147/149] maths: workaround clang lto ICE in renormalise

---
 maths.hpp | 52 ++++++++++++++++++++++++++++++++++------------------
 1 file changed, 34 insertions(+), 18 deletions(-)

diff --git a/maths.hpp b/maths.hpp
index ab0eaec0..6ec300e7 100644
--- a/maths.hpp
+++ b/maths.hpp
@@ -764,32 +764,48 @@ namespace util {
 
     //-------------------------------------------------------------------------
     // lo_uint -> hi_uint
-    template <typename T, typename U>
-    constexpr
-    typename std::enable_if<
-        std::is_unsigned<T>::value &&
-        std::is_unsigned<U>::value &&
-        sizeof (T) < sizeof (U), U
-    >::type
-    renormalise (T t)
+    template <
+        typename SrcT,
+        typename DstT,
+        typename = std::enable_if_t<
+            std::is_unsigned<SrcT>::value &&
+            std::is_unsigned<DstT>::value &&
+            sizeof (SrcT) < sizeof (DstT), DstT
+        >
+    >
+    constexpr DstT
+    renormalise (SrcT src)
     {
-        static_assert (sizeof (T) < sizeof (U),
+        // we can make some simplifying assumptions for the shift distances if
+        // we assume the integers are powers of two. this is probably going to
+        // be the case for every conceivable input type, but we don't want to
+        // get caught out if we extend this routine to more general types
+        // (eg, OpenGL DEPTH24).
+        static_assert (is_pow2 (sizeof (SrcT)));
+        static_assert (is_pow2 (sizeof (DstT)));
+
+        static_assert (sizeof (SrcT) < sizeof (DstT),
                        "assumes bit creation is required to fill space");
 
         // we need to create bits. fill the output integer with copies of ourself.
         // this is approximately correct in the general case (introducing a small
-        // linear positive bias), but allows us to fill the output space in the
-        // case of input maximum.
-
-        static_assert (sizeof (U) % sizeof (T) == 0,
+        // linear positive bias), but it allows us to set all output bits high
+        // when we receive the maximum allowable input value.
+        static_assert (sizeof (DstT) % sizeof (SrcT) == 0,
                        "assumes integer multiple of sizes");
 
-        U out = 0;
 
-        for (size_t i = 0; i < sizeof (U) / sizeof (T); ++i)
-            out |= U (t) << sizeof (T) * 8 * i;
-
-        return out;
+        // clang#xxxx: ideally we wouldn't use a multiplication here, but we
+        // trigger a segfault in clang-5.0 when using ld.gold+lto;
+        // 'X86 DAG->DAG Instruction Selection'
+        //
+        // create a mask of locations we'd like copies of the src bit pattern.
+        //
+        // this replicates repeatedly or'ing and shifting dst with itself.
+        DstT dst { 1 };
+        for (unsigned i = sizeof (SrcT) * 8; i < sizeof (DstT) * 8; i *= 2)
+            dst |= dst << i;
+        return dst * src;
     }
 
 

From aff478640968762ac59985da68757a9b5e560a24 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Wed, 11 Oct 2017 17:15:47 +1100
Subject: [PATCH 148/149] traits: add bodies to test objects for ODR-used
 symbols

---
 test/traits.cpp | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/test/traits.cpp b/test/traits.cpp
index 674a9f86..90d5e4bc 100644
--- a/test/traits.cpp
+++ b/test/traits.cpp
@@ -27,11 +27,12 @@ struct has_return_type<
 
 
 ///////////////////////////////////////////////////////////////////////////////
-int plain (char, float);
-int with_noexcept (char, float) noexcept;
+extern int plain (char, float) { return 0; }
+extern int with_noexcept (char, float) noexcept { return 0; }
+
 struct foo {
-    int bar (double, char) const;
-    int with_noexcept (double, char) noexcept;
+    int bar (double, char) const { return 0; }
+    int with_noexcept (double, char) noexcept { return 0; }
 };
 
 

From d8bb00c9c338d39012ca19587391cb089ddda115 Mon Sep 17 00:00:00 2001
From: Danny Robson <danny@nerdcruft.net>
Date: Thu, 12 Oct 2017 17:36:46 +1100
Subject: [PATCH 149/149] endian: add float byteswap specialisation

---
 CMakeLists.txt  |  1 +
 endian.hpp      | 33 ++++++++++++++++++++++++++-------
 test/endian.cpp | 31 +++++++++++++++++++++++++++++++
 3 files changed, 58 insertions(+), 7 deletions(-)
 create mode 100644 test/endian.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 6dd60d49..1832f8f3 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -495,6 +495,7 @@ if (TESTS)
         crypto/tea
         crypto/xtea
         crypto/xxtea
+        endian
         exe
         extent
         fixed
diff --git a/endian.hpp b/endian.hpp
index aef5087e..e63d7ff9 100644
--- a/endian.hpp
+++ b/endian.hpp
@@ -33,7 +33,7 @@ namespace util {
     //-------------------------------------------------------------------------
     template <typename T>
     constexpr T
-    bswap (T);
+    bswap (T) noexcept;
 
     // CXX: Update using "if constexpr" when available. It doesn't seem to be
     // worth the dicking about to use enable_if_t to differentiate the
@@ -42,7 +42,7 @@ namespace util {
     template <>                             \
     constexpr                               \
     int##S##_t                              \
-    bswap (int##S##_t v) {                  \
+    bswap (int##S##_t v) noexcept {         \
         const union {                       \
              int##S##_t s;                  \
             uint##S##_t u;                  \
@@ -55,12 +55,31 @@ namespace util {
     SIGNED_BSWAP(32)
     SIGNED_BSWAP(64)
 
-    template <> constexpr  int8_t bswap ( int8_t v) { return v; }
-    template <> constexpr uint8_t bswap (uint8_t v) { return v; }
+    template <> constexpr  int8_t bswap ( int8_t v) noexcept { return v; }
+    template <> constexpr uint8_t bswap (uint8_t v) noexcept { return v; }
 
-    template <> constexpr uint16_t bswap (uint16_t v) { return __builtin_bswap16 (v); }
-    template <> constexpr uint32_t bswap (uint32_t v) { return __builtin_bswap32 (v); }
-    template <> constexpr uint64_t bswap (uint64_t v) { return __builtin_bswap64 (v); }
+    template <> constexpr uint16_t bswap (uint16_t v) noexcept { return __builtin_bswap16 (v); }
+    template <> constexpr uint32_t bswap (uint32_t v) noexcept { return __builtin_bswap32 (v); }
+    template <> constexpr uint64_t bswap (uint64_t v) noexcept { return __builtin_bswap64 (v); }
+
+
+    // use a type-punning union to punt the byte swapping operation to the
+    // unsigned integer code.
+    //
+    // this is debatably safe under production compilers like gcc + clang
+    // despite what the standard may say about unions.
+    template <>
+    constexpr float
+    bswap (float v) noexcept
+    {
+        union {
+            float f;
+            uint32_t u;
+        } temp { .f = v };
+
+        temp.u = bswap (temp.u);
+        return temp.f;
+    }
 
 
     //-------------------------------------------------------------------------
diff --git a/test/endian.cpp b/test/endian.cpp
new file mode 100644
index 00000000..d91f4ad2
--- /dev/null
+++ b/test/endian.cpp
@@ -0,0 +1,31 @@
+#include "tap.hpp"
+
+#include "endian.hpp"
+
+
+///////////////////////////////////////////////////////////////////////////////
+int
+main (void)
+{
+    util::TAP::logger tap;
+
+    {
+        uint32_t a = 0x12345678, b = 0x78563412;
+        tap.expect_eq (a, util::bswap (b), "u32 byteswap");
+    }
+
+    {
+        // try to byte swap the pattern for 1.0f
+        //
+        // it may not be the most robust test, but it'll catch the most
+        // egregious errors for the time being.
+        union {
+            uint32_t u;
+            float f;
+        } data { .u = 0x0000803f /* 0x3f800000 == 1.f */ };
+
+        tap.expect_eq (util::bswap (data.f), 1.f, "f32 byteswap");
+    };
+
+    return tap.status ();
+}
\ No newline at end of file