From a77f983015ad46fb970101779809eca6850f584c Mon Sep 17 00:00:00 2001
From: q66 <daniel@octaforge.org>
Date: Sat, 11 Jul 2015 16:07:52 +0100
Subject: [PATCH] more complete relational operator sets + add lexicographical
 comparison

---
 octa/algorithm.hh  | 24 ++++++++++++++
 octa/array.hh      | 30 +++++++++++++++++
 octa/format.hh     | 54 ++++++++++++++----------------
 octa/functional.hh |  2 +-
 octa/io.hh         | 24 +++++++-------
 octa/maybe.hh      | 62 +++++++++++++++++------------------
 octa/platform.hh   | 18 +++++-----
 octa/string.hh     | 82 +++++++++++++++++++++++++++++++++++++---------
 octa/utility.hh    | 52 ++++++++++++++++++++++++-----
 9 files changed, 243 insertions(+), 105 deletions(-)

diff --git a/octa/algorithm.hh b/octa/algorithm.hh
index b436f1f..57c018f 100644
--- a/octa/algorithm.hh
+++ b/octa/algorithm.hh
@@ -214,6 +214,30 @@ inline T clamp(const T &v, const U &lo, const U &hi, C compare) {
     return octa::max(T(lo), octa::min(v, T(hi), compare), compare);
 }
 
+/* lexicographical compare */
+
+template<typename R1, typename R2>
+bool lexicographical_compare(R1 range1, R2 range2) {
+    while (!range1.empty() && !range2.empty()) {
+        if (range1.front() < range2.front()) return true;
+        if (range2.front() < range1.front()) return false;
+        range1.pop_front();
+        range2.pop_front();
+    }
+    return (range1.empty() && !range2.empty());
+}
+
+template<typename R1, typename R2, typename C>
+bool lexicographical_compare(R1 range1, R2 range2, C compare) {
+    while (!range1.empty() && !range2.empty()) {
+        if (compare(range1.front(), range2.front())) return true;
+        if (compare(range2.front(), range1.front())) return false;
+        range1.pop_front();
+        range2.pop_front();
+    }
+    return (range1.empty() && !range2.empty());
+}
+
 /* algos that don't change the range */
 
 template<typename R, typename F>
diff --git a/octa/array.hh b/octa/array.hh
index 7555679..28b6864 100644
--- a/octa/array.hh
+++ b/octa/array.hh
@@ -99,6 +99,36 @@ TupleElement<I, Array<T, N>> &&get(Array<T, N> &&a) {
     return a[I];
 }
 
+template<typename T, Size N>
+inline bool operator==(const Array<T, N> &x, const Array<T, N> &y) {
+    return equal(x.iter(), y.iter());
+}
+
+template<typename T, Size N>
+inline bool operator!=(const Array<T, N> &x, const Array<T, N> &y) {
+    return !(x == y);
+}
+
+template<typename T, Size N>
+inline bool operator<(const Array<T, N> &x, const Array<T, N> &y) {
+    return lexicographical_compare(x.iter(), y.iter());
+}
+
+template<typename T, Size N>
+inline bool operator>(const Array<T, N> &x, const Array<T, N> &y) {
+    return (y < x);
+}
+
+template<typename T, Size N>
+inline bool operator<=(const Array<T, N> &x, const Array<T, N> &y) {
+    return !(y < x);
+}
+
+template<typename T, Size N>
+inline bool operator>=(const Array<T, N> &x, const Array<T, N> &y) {
+    return !(x < y);
+}
+
 } /* namespace octa */
 
 #endif
\ No newline at end of file
diff --git a/octa/format.hh b/octa/format.hh
index 4a8d989..f92d4ef 100644
--- a/octa/format.hh
+++ b/octa/format.hh
@@ -26,7 +26,7 @@ enum FormatFlags {
 };
 
 namespace detail {
-    static inline int parse_fmt_flags(const char *&fmt, int ret) {
+    inline int parse_fmt_flags(const char *&fmt, int ret) {
         while (*fmt) {
             switch (*fmt) {
             case '-': ret |= FMT_FLAG_DASH; ++fmt; break;
@@ -41,7 +41,7 @@ namespace detail {
         return ret;
     }
 
-    static inline Size read_digits(const char *&fmt, char *buf) {
+    inline Size read_digits(const char *&fmt, char *buf) {
         Size ret = 0;
         for (; isdigit(*fmt); ++ret)
             *buf++ = *fmt++;
@@ -398,8 +398,7 @@ protected:
 
 namespace detail {
     template<typename R, typename T>
-    static inline Ptrdiff write_u(R &writer, const FormatSpec *fl,
-                                  bool neg, T val) {
+    inline Ptrdiff write_u(R &writer, const FormatSpec *fl, bool neg, T val) {
         char buf[20];
         Ptrdiff r = 0;
         Size n = 0;
@@ -460,17 +459,15 @@ namespace detail {
     using FmtRangeTest = decltype(test_fmt_range<T>(0));
 
     template<typename R, typename T>
-    static inline Ptrdiff format_ritem(R &writer, Size &fmtn, bool esc,
-                                       bool, const char *fmt,
-                                       const T &item) {
+    inline Ptrdiff format_ritem(R &writer, Size &fmtn, bool esc, bool,
+                                const char *fmt, const T &item) {
         return format_impl(writer, fmtn, esc, fmt, item);
     }
 
     template<typename R, typename T, typename U>
-    static inline Ptrdiff format_ritem(R &writer, Size &fmtn, bool esc,
-                                       bool expandval,
-                                       const char *fmt,
-                                       const Pair<T, U> &pair) {
+    inline Ptrdiff format_ritem(R &writer, Size &fmtn, bool esc,
+                                bool expandval, const char *fmt,
+                                const Pair<T, U> &pair) {
         if (expandval) {
             return format_impl(writer, fmtn, esc, fmt, pair.first,
                 pair.second);
@@ -479,12 +476,12 @@ namespace detail {
     }
 
     template<typename R, typename T>
-    static inline Ptrdiff write_range(R &writer, const FormatSpec *fl,
-                                      bool escape, bool expandval,
-                                      const char *sep, Size seplen,
-                                      const T &val,
-                                      EnableIf<FmtRangeTest<T>::value,
-                                               bool> = true) {
+    inline Ptrdiff write_range(R &writer, const FormatSpec *fl,
+                               bool escape, bool expandval,
+                               const char *sep, Size seplen,
+                               const T &val,
+                               EnableIf<FmtRangeTest<T>::value, bool>
+                                   = true) {
         auto range = octa::iter(val);
         if (range.empty()) return 0;
         Ptrdiff ret = 0;
@@ -510,10 +507,10 @@ namespace detail {
     }
 
     template<typename R, typename T>
-    static inline Ptrdiff write_range(R &, const FormatSpec *, bool, bool,
-                                      const char *, Size, const T &,
-                                      EnableIf<!FmtRangeTest<T>::value,
-                                               bool> = true) {
+    inline Ptrdiff write_range(R &, const FormatSpec *, bool, bool,
+                               const char *, Size, const T &,
+                               EnableIf<!FmtRangeTest<T>::value, bool>
+                                   = true) {
         assert(false && "invalid value for ranged format");
         return -1;
     }
@@ -539,7 +536,7 @@ namespace detail {
         nullptr, "\\\'"
     };
 
-    static inline const char *escape_fmt_char(char v, char quote) {
+    inline const char *escape_fmt_char(char v, char quote) {
         if ((v >= 0 && v < 0x20) || (v == quote)) {
             return fmt_escapes[Size(v)];
         } else if (v == 0x7F) {
@@ -548,7 +545,7 @@ namespace detail {
         return nullptr;
     }
 
-    static inline String escape_fmt_str(const char *val) {
+    inline String escape_fmt_str(const char *val) {
         String ret;
         ret.push('"');
         while (*val) {
@@ -808,8 +805,8 @@ namespace detail {
     };
 
     template<typename R, typename ...A>
-    static inline Ptrdiff format_impl(R &writer, Size &fmtn, bool escape,
-                                      const char *fmt, const A &...args) {
+    inline Ptrdiff format_impl(R &writer, Size &fmtn, bool escape,
+                               const char *fmt, const A &...args) {
         Size argidx = 1, retn = 0, twr = 0;
         Ptrdiff written = 0;
         detail::WriteSpec spec(fmt, escape);
@@ -871,8 +868,7 @@ namespace detail {
     }
 
     template<typename R, typename ...A>
-    static inline Ptrdiff format_impl(R &writer, Size &fmtn, bool,
-                                      const char *fmt) {
+    inline Ptrdiff format_impl(R &writer, Size &fmtn, bool, const char *fmt) {
         Size written = 0;
         detail::WriteSpec spec(fmt, false);
         if (spec.read_until_spec(writer, &written)) return -1;
@@ -882,8 +878,8 @@ namespace detail {
 } /* namespace detail */
 
 template<typename R, typename ...A>
-static inline Ptrdiff format(R &&writer, Size &fmtn, const char *fmt,
-                             const A &...args) {
+inline Ptrdiff format(R &&writer, Size &fmtn, const char *fmt,
+                      const A &...args) {
     return detail::format_impl(writer, fmtn, false, fmt, args...);
 }
 
diff --git a/octa/functional.hh b/octa/functional.hh
index 8118d25..8aad5f6 100644
--- a/octa/functional.hh
+++ b/octa/functional.hh
@@ -218,7 +218,7 @@ OCTA_HASH_BASIC(Wchar)
 #undef OCTA_HASH_BASIC
 
 namespace detail {
-    static inline Size mem_hash(const void *p, Size l) {
+    inline Size mem_hash(const void *p, Size l) {
         const byte *d = (const byte *)p;
         Size h = 5381;
         for (Size i = 0; i < l; ++i) h = ((h << 5) + h) ^ d[i];
diff --git a/octa/io.hh b/octa/io.hh
index 4395e2d..334b62e 100644
--- a/octa/io.hh
+++ b/octa/io.hh
@@ -142,44 +142,44 @@ static FileStream err(::stderr);
 
 /* no need to call anything from FileStream, prefer simple calls... */
 
-static inline void write(const char *s) {
+inline void write(const char *s) {
     fputs(s, ::stdout);
 }
 
 template<typename A>
-static inline void write(const AnyString<A> &s) {
+inline void write(const AnyString<A> &s) {
     fwrite(s.data(), 1, s.size(), ::stdout);
 }
 
 template<typename T>
-static inline void write(const T &v) {
+inline void write(const T &v) {
     write(octa::to_string(v));
 }
 
 template<typename T, typename ...A>
-static inline void write(const T &v, const A &...args) {
+inline void write(const T &v, const A &...args) {
     write(v);
     write(args...);
 }
 
-static inline void writeln(const char *s) {
+inline void writeln(const char *s) {
     write(s);
     putc('\n', ::stdout);
 }
 
 template<typename A>
-static inline void writeln(const AnyString<A> &s) {
+inline void writeln(const AnyString<A> &s) {
     write(s);
     putc('\n', ::stdout);
 }
 
 template<typename T>
-static inline void writeln(const T &v) {
+inline void writeln(const T &v) {
     writeln(octa::to_string(v));
 }
 
 template<typename T, typename ...A>
-static inline void writeln(const T &v, const A &...args) {
+inline void writeln(const T &v, const A &...args) {
     write(v);
     write(args...);
     putc('\n', ::stdout);
@@ -197,7 +197,7 @@ namespace detail {
 }
 
 template<typename ...A>
-static inline void writef(const char *fmt, const A &...args) {
+inline void writef(const char *fmt, const A &...args) {
     char buf[512];
     Ptrdiff need = format(detail::FormatOutRange<sizeof(buf)>(buf),
         fmt, args...);
@@ -213,19 +213,19 @@ static inline void writef(const char *fmt, const A &...args) {
 }
 
 template<typename AL, typename ...A>
-static inline void writef(const AnyString<AL> &fmt,
+inline void writef(const AnyString<AL> &fmt,
                           const A &...args) {
     writef(fmt.data(), args...);
 }
 
 template<typename ...A>
-static inline void writefln(const char *fmt, const A &...args) {
+inline void writefln(const char *fmt, const A &...args) {
     writef(fmt, args...);
     putc('\n', ::stdout);
 }
 
 template<typename AL, typename ...A>
-static inline void writefln(const AnyString<AL> &fmt,
+inline void writefln(const AnyString<AL> &fmt,
                             const A &...args) {
     writef(fmt, args...);
     putc('\n', ::stdout);
diff --git a/octa/maybe.hh b/octa/maybe.hh
index ec37f36..f7625ac 100644
--- a/octa/maybe.hh
+++ b/octa/maybe.hh
@@ -261,163 +261,163 @@ public:
 /* maybe vs maybe */
 
 template<typename T>
-static inline constexpr bool operator==(const Maybe<T> &a, const Maybe<T> &b) {
+inline constexpr bool operator==(const Maybe<T> &a, const Maybe<T> &b) {
     return (bool(a) != bool(b)) ? false : (!bool(a) ? true : (*a == *b));
 }
 
 template<typename T>
-static inline constexpr bool operator!=(const Maybe<T> &a, const Maybe<T> &b) {
+inline constexpr bool operator!=(const Maybe<T> &a, const Maybe<T> &b) {
     return !(a == b);
 }
 
 template<typename T>
-static inline constexpr bool operator<(const Maybe<T> &a, const Maybe<T> &b) {
+inline constexpr bool operator<(const Maybe<T> &a, const Maybe<T> &b) {
     return !bool(b) ? false : (!bool(a) ? true : (*a < *b));
 }
 
 template<typename T>
-static inline constexpr bool operator>(const Maybe<T> &a, const Maybe<T> &b) {
+inline constexpr bool operator>(const Maybe<T> &a, const Maybe<T> &b) {
     return b < a;
 }
 
 template<typename T>
-static inline constexpr bool operator<=(const Maybe<T> &a, const Maybe<T> &b) {
+inline constexpr bool operator<=(const Maybe<T> &a, const Maybe<T> &b) {
     return !(b < a);
 }
 
 template<typename T>
-static inline constexpr bool operator>=(const Maybe<T> &a, const Maybe<T> &b) {
+inline constexpr bool operator>=(const Maybe<T> &a, const Maybe<T> &b) {
     return !(a < b);
 }
 
 /* maybe vs nothing */
 
 template<typename T>
-static inline constexpr bool operator==(const Maybe<T> &v, Nothing) {
+inline constexpr bool operator==(const Maybe<T> &v, Nothing) {
     return !bool(v);
 }
 
 template<typename T>
-static inline constexpr bool operator==(Nothing, const Maybe<T> &v) {
+inline constexpr bool operator==(Nothing, const Maybe<T> &v) {
     return !bool(v);
 }
 
 template<typename T>
-static inline constexpr bool operator!=(const Maybe<T> &v, Nothing) {
+inline constexpr bool operator!=(const Maybe<T> &v, Nothing) {
     return bool(v);
 }
 
 template<typename T>
-static inline constexpr bool operator!=(Nothing, const Maybe<T> &v) {
+inline constexpr bool operator!=(Nothing, const Maybe<T> &v) {
     return bool(v);
 }
 
 template<typename T>
-static inline constexpr bool operator<(const Maybe<T> &, Nothing) {
+inline constexpr bool operator<(const Maybe<T> &, Nothing) {
     return false;
 }
 
 template<typename T>
-static inline constexpr bool operator<(Nothing, const Maybe<T> &v) {
+inline constexpr bool operator<(Nothing, const Maybe<T> &v) {
     return bool(v);
 }
 
 template<typename T>
-static inline constexpr bool operator<=(const Maybe<T> &v, Nothing) {
+inline constexpr bool operator<=(const Maybe<T> &v, Nothing) {
     return !bool(v);
 }
 
 template<typename T>
-static inline constexpr bool operator<=(Nothing, const Maybe<T> &) {
+inline constexpr bool operator<=(Nothing, const Maybe<T> &) {
     return true;
 }
 
 template<typename T>
-static inline constexpr bool operator>(const Maybe<T> &v, Nothing) {
+inline constexpr bool operator>(const Maybe<T> &v, Nothing) {
     return bool(v);
 }
 
 template<typename T>
-static inline constexpr bool operator>(Nothing, const Maybe<T> &) {
+inline constexpr bool operator>(Nothing, const Maybe<T> &) {
     return false;
 }
 
 template<typename T>
-static inline constexpr bool operator>=(const Maybe<T> &, Nothing) {
+inline constexpr bool operator>=(const Maybe<T> &, Nothing) {
     return true;
 }
 
 template<typename T>
-static inline constexpr bool operator>=(Nothing, const Maybe<T> &v) {
+inline constexpr bool operator>=(Nothing, const Maybe<T> &v) {
     return !bool(v);
 }
 
 /* maybe vs T */
 
 template<typename T>
-static inline constexpr bool operator==(const Maybe<T> &a, const T &b) {
+inline constexpr bool operator==(const Maybe<T> &a, const T &b) {
     return bool(a) ? (*a == b) : false;
 }
 
 template<typename T>
-static inline constexpr bool operator==(const T &b, const Maybe<T> &a) {
+inline constexpr bool operator==(const T &b, const Maybe<T> &a) {
     return bool(a) ? (*a == b) : false;
 }
 
 template<typename T>
-static inline constexpr bool operator!=(const Maybe<T> &a, const T &b) {
+inline constexpr bool operator!=(const Maybe<T> &a, const T &b) {
     return bool(a) ? !(*a == b) : true;
 }
 
 template<typename T>
-static inline constexpr bool operator!=(const T &b, const Maybe<T> &a) {
+inline constexpr bool operator!=(const T &b, const Maybe<T> &a) {
     return bool(a) ? !(*a == b) : true;
 }
 
 template<typename T>
-static inline constexpr bool operator<(const Maybe<T> &a, const T &b) {
+inline constexpr bool operator<(const Maybe<T> &a, const T &b) {
     return bool(a) ? Less<T>()(*a, b) : true;
 }
 
 template<typename T>
-static inline constexpr bool operator<(const T &b, const Maybe<T> &a) {
+inline constexpr bool operator<(const T &b, const Maybe<T> &a) {
     return bool(a) ? Less<T>()(b, *a) : false;
 }
 
 template<typename T>
-static inline constexpr bool operator<=(const Maybe<T> &a, const T &b) {
+inline constexpr bool operator<=(const Maybe<T> &a, const T &b) {
     return !(a > b);
 }
 
 template<typename T>
-static inline constexpr bool operator<=(const T &b, const Maybe<T> &a) {
+inline constexpr bool operator<=(const T &b, const Maybe<T> &a) {
     return !(b > a);
 }
 
 template<typename T>
-static inline constexpr bool operator>(const Maybe<T> &a, const T &b) {
+inline constexpr bool operator>(const Maybe<T> &a, const T &b) {
     return bool(a) ? (b < a) : true;
 }
 
 template<typename T>
-static inline constexpr bool operator>(const T &b, const Maybe<T> &a) {
+inline constexpr bool operator>(const T &b, const Maybe<T> &a) {
     return bool(a) ? (a < b) : true;
 }
 
 template<typename T>
-static inline constexpr bool operator>=(const Maybe<T> &a, const T &b) {
+inline constexpr bool operator>=(const Maybe<T> &a, const T &b) {
     return !(a < b);
 }
 
 template<typename T>
-static inline constexpr bool operator>=(const T &b, const Maybe<T> &a) {
+inline constexpr bool operator>=(const T &b, const Maybe<T> &a) {
     return !(b < a);
 }
 
 /* make maybe */
 
 template<typename T>
-constexpr Maybe<Decay<T>> make_maybe(T &&v) {
+inline constexpr Maybe<Decay<T>> make_maybe(T &&v) {
     return Maybe<Decay<T>>(forward<T>(v));
 }
 
diff --git a/octa/platform.hh b/octa/platform.hh
index 87043c2..dec5355 100644
--- a/octa/platform.hh
+++ b/octa/platform.hh
@@ -76,40 +76,40 @@ namespace octa {
 #if defined(OCTA_TOOLCHAIN_GNU)
 
 /* using gcc/clang builtins */
-static inline uint16_t endian_swap16(uint16_t x) {
+inline uint16_t endian_swap16(uint16_t x) {
     return __builtin_bswap16(x);
 }
-static inline uint32_t endian_swap32(uint32_t x) {
+inline uint32_t endian_swap32(uint32_t x) {
     return __builtin_bswap32(x);
 }
-static inline uint64_t endian_swap64(uint64_t x) {
+inline uint64_t endian_swap64(uint64_t x) {
     return __builtin_bswap64(x);
 }
 
 #elif defined(OCTA_TOOLCHAIN_MSVC)
 
 /* using msvc builtins */
-static inline uint16_t endian_swap16(uint16_t x) {
+inline uint16_t endian_swap16(uint16_t x) {
     return _byteswap_ushort(x);
 }
-static inline uint32_t endian_swap32(uint32_t x) {
+inline uint32_t endian_swap32(uint32_t x) {
     /* win64 is llp64 */
     return _byteswap_ulong(x);
 }
-static inline uint64_t endian_swap64(uint64_t x) {
+inline uint64_t endian_swap64(uint64_t x) {
     return _byteswap_uint64(x);
 }
 
 #else
 
 /* fallback */
-static inline uint16_t endian_swap16(uint16_t x) {
+inline uint16_t endian_swap16(uint16_t x) {
     return (x << 8) | (x >> 8);
 }
-static inline uint32_t endian_swap32(uint32_t x) {
+inline uint32_t endian_swap32(uint32_t x) {
     return (x << 24) | (x >> 24) | ((x >> 8) & 0xFF00) | ((x << 8) & 0xFF0000);
 }
-static inline uint64_t endian_swap64(uint64_t x) {
+inline uint64_t endian_swap64(uint64_t x) {
     return endian_swap32(uint32_t(x >> 32)) | (uint64_t(endian_swap32(uint32_t(x))) << 32);
 }
 
diff --git a/octa/string.hh b/octa/string.hh
index f54dfb8..25cd68b 100644
--- a/octa/string.hh
+++ b/octa/string.hh
@@ -352,35 +352,87 @@ using ConstStringRange = StringRangeBase<const char>;
 template<typename A> using AnyString = StringBase<char, A>;
 
 template<typename T, typename A>
-static inline bool operator==(const StringBase<T, A> &lhs,
-                              const StringBase<T, A> &rhs) {
+inline bool operator==(const StringBase<T, A> &lhs,
+                       const StringBase<T, A> &rhs) {
     return !lhs.compare(rhs);
 }
 template<typename T, typename A>
-static inline bool operator==(const StringBase<T, A> &lhs,
-                              const char *rhs) {
+inline bool operator==(const StringBase<T, A> &lhs, const char *rhs) {
     return !lhs.compare(rhs);
 }
 template<typename T, typename A>
-static inline bool operator==(const char *lhs,
-                              const StringBase<T, A> &rhs) {
+inline bool operator==(const char *lhs, const StringBase<T, A> &rhs) {
     return !rhs.compare(lhs);
 }
 
 template<typename T, typename A>
-static inline bool operator!=(const StringBase<T, A> &lhs,
-                              const StringBase<T, A> &rhs) {
-    return !!lhs.compare(rhs);
+inline bool operator!=(const StringBase<T, A> &lhs,
+                       const StringBase<T, A> &rhs) {
+    return !(lhs == rhs);
 }
 template<typename T, typename A>
-static inline bool operator!=(const StringBase<T, A> &lhs,
-                              const char *rhs) {
-    return !!lhs.compare(rhs);
+inline bool operator!=(const StringBase<T, A> &lhs, const char *rhs) {
+    return !(lhs == rhs);
 }
 template<typename T, typename A>
-static inline bool operator!=(const char *lhs,
-                              const StringBase<T, A> &rhs) {
-    return !!rhs.compare(lhs);
+inline bool operator!=(const char *lhs,  const StringBase<T, A> &rhs) {
+    return !(rhs == lhs);
+}
+
+template<typename T, typename A>
+inline bool operator<(const StringBase<T, A> &lhs,
+                      const StringBase<T, A> &rhs) {
+    return lhs.compare(rhs) < 0;
+}
+template<typename T, typename A>
+inline bool operator<(const StringBase<T, A> &lhs, const char *rhs) {
+    return lhs.compare(rhs) < 0;
+}
+template<typename T, typename A>
+inline bool operator<(const char *lhs, const StringBase<T, A> &rhs) {
+    return rhs.compare(lhs) > 0;
+}
+
+template<typename T, typename A>
+inline bool operator>(const StringBase<T, A> &lhs,
+                      const StringBase<T, A> &rhs) {
+    return rhs < lhs;
+}
+template<typename T, typename A>
+inline bool operator>(const StringBase<T, A> &lhs, const char *rhs) {
+    return rhs < lhs;
+}
+template<typename T, typename A>
+inline bool operator>(const char *lhs, const StringBase<T, A> &rhs) {
+    return rhs < lhs;
+}
+
+template<typename T, typename A>
+inline bool operator<=(const StringBase<T, A> &lhs,
+                       const StringBase<T, A> &rhs) {
+    return !(rhs < lhs);
+}
+template<typename T, typename A>
+inline bool operator<=(const StringBase<T, A> &lhs, const char *rhs) {
+    return !(rhs < lhs);
+}
+template<typename T, typename A>
+inline bool operator<=(const char *lhs, const StringBase<T, A> &rhs) {
+    return !(rhs < lhs);
+}
+
+template<typename T, typename A>
+inline bool operator>=(const StringBase<T, A> &lhs,
+                       const StringBase<T, A> &rhs) {
+    return !(lhs < rhs);
+}
+template<typename T, typename A>
+inline bool operator>=(const StringBase<T, A> &lhs, const char *rhs) {
+    return !(lhs < rhs);
+}
+template<typename T, typename A>
+inline bool operator>=(const char *lhs, const StringBase<T, A> &rhs) {
+    return !(lhs < rhs);
 }
 
 template<typename T, typename F, typename S = const char *,
diff --git a/octa/utility.hh b/octa/utility.hh
index ed39f49..bc703f2 100644
--- a/octa/utility.hh
+++ b/octa/utility.hh
@@ -16,26 +16,26 @@ namespace octa {
 /* move */
 
 template<typename T>
-static inline constexpr RemoveReference<T> &&move(T &&v) {
+inline constexpr RemoveReference<T> &&move(T &&v) {
     return static_cast<RemoveReference<T> &&>(v);
 }
 
 /* forward */
 
 template<typename T>
-static inline constexpr T &&forward(RemoveReference<T> &v) {
+inline constexpr T &&forward(RemoveReference<T> &v) {
     return static_cast<T &&>(v);
 }
 
 template<typename T>
-static inline constexpr T &&forward(RemoveReference<T> &&v) {
+inline constexpr T &&forward(RemoveReference<T> &&v) {
     return static_cast<T &&>(v);
 }
 
 /* exchange */
 
 template<typename T, typename U = T>
-T exchange(T &v, U &&nv) {
+inline T exchange(T &v, U &&nv) {
     T old = move(v);
     v = forward<U>(nv);
     return old;
@@ -71,11 +71,11 @@ namespace detail {
     }
 }
 
-template<typename T> void swap(T &a, T &b) {
+template<typename T> inline void swap(T &a, T &b) {
    detail::swap(a, b);
 }
 
-template<typename T, Size N> void swap(T (&a)[N], T (&b)[N]) {
+template<typename T, Size N> inline void swap(T (&a)[N], T (&b)[N]) {
     for (Size i = 0; i < N; ++i) {
         octa::swap(a[i], b[i]);
     }
@@ -159,14 +159,50 @@ namespace detail {
 } /* namespace detail */
 
 template<typename T, typename U>
-Pair<typename detail::MakePairRet<T>::Type,
-     typename detail::MakePairRet<U>::Type
+inline Pair<typename detail::MakePairRet<T>::Type,
+            typename detail::MakePairRet<U>::Type
  > make_pair(T &&a, U &&b) {
     return Pair<typename detail::MakePairRet<T>::Type,
                 typename detail::MakePairRet<U>::Type
     >(forward<T>(a), forward<U>(b));;
 }
 
+template<typename T, typename U>
+inline constexpr bool operator==(const Pair<T, U> &x, const Pair<T, U> &y) {
+    return (x.first == y.first) && (x.second == y.second);
+}
+
+template<typename T, typename U>
+inline constexpr bool operator!=(const Pair<T, U> &x, const Pair<T, U> &y) {
+    return (x.first != y.first) || (x.second != y.second);
+}
+
+template<typename T, typename U>
+inline constexpr bool operator<(const Pair<T, U> &x, const Pair<T, U> &y) {
+    return (x.first < y.first)
+        ? true
+        : ((y.first < x.first)
+            ? false
+            : ((x.second < y.second)
+                ? true
+                : false));
+}
+
+template<typename T, typename U>
+inline constexpr bool operator>(const Pair<T, U> &x, const Pair<T, U> &y) {
+    return (y < x);
+}
+
+template<typename T, typename U>
+inline constexpr bool operator<=(const Pair<T, U> &x, const Pair<T, U> &y) {
+    return !(y < x);
+}
+
+template<typename T, typename U>
+inline constexpr bool operator>=(const Pair<T, U> &x, const Pair<T, U> &y) {
+    return !(x < y);
+}
+
 template<typename T, typename U>
 struct TupleSize<Pair<T, U>>: IntegralConstant<Size, 2> {};