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