diff --git a/.travis.yml b/.travis.yml
index 739cd3b..2c000ad 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -24,10 +24,6 @@ matrix:
       after_success: ./scripts/upload_coverage.sh
 before_install:
   - eval "${MATRIX_EVAL}"
-  - if [ "$TRAVIS_OS_NAME" == 'osx' ]; then
-    brew update;
-    brew upgrade cmake;
-    fi
   - if [ "$TRAVIS_OS_NAME" == 'linux' ]; then
     mkdir $HOME/cmake;
     export PATH="$HOME/cmake/bin:$PATH";
diff --git a/README.md b/README.md
index 4c47476..2dd0812 100644
--- a/README.md
+++ b/README.md
@@ -23,6 +23,12 @@
 
 [enum]: https://github.com/BlackMATov/enum.hpp
 
+## Requirements
+
+- [gcc](https://www.gnu.org/software/gcc/) **>= 7**
+- [clang](https://clang.llvm.org/) **>= 7.0**
+- [msvc](https://visualstudio.microsoft.com/) **>= 2017**
+
 ## Installation
 
 [enum.hpp][enum] is a header-only library. All you need to do is copy the headers files from `headers` directory into your project and include them:
@@ -57,6 +63,7 @@ enum debug_level : int {
 };
 
 struct debug_level_traits {
+    using underlying_type = int;
     static constexpr std::size_t size = 3;
 
     static constexpr const debug_level values[] = {
@@ -71,15 +78,13 @@ struct debug_level_traits {
         "level_warning"
     };
 
-    static constexpr std::string_view to_string(
-        debug_level e) noexcept;
+    static constexpr underlying_type to_underlying(debug_level e) noexcept;
 
-    static debug_level from_string(
-        std::string_view name);
+    static constexpr std::optional<std::string_view> to_string(debug_level e) noexcept;
+    static constexpr std::optional<debug_level> from_string(std::string_view name) noexcept;
 
-    static constexpr bool from_string_nothrow(
-        std::string_view name,
-        debug_level& result) noexcept;
+    static constexpr std::optional<std::size_t> to_index(debug_level e) noexcept;
+    static constexpr std::optional<debug_level> from_index(std::size_t index) noexcept;
 };
 ```
 
@@ -100,6 +105,7 @@ enum class color : unsigned {
 };
 
 struct color_traits {
+    using underlying_type = unsigned;
     static constexpr std::size_t size = 4;
 
     static constexpr const color values[] = {
@@ -116,44 +122,56 @@ struct color_traits {
         "white"
     };
 
-    static constexpr std::string_view to_string(
-        color e) noexcept;
+    static constexpr underlying_type to_underlying(color e) noexcept;
 
-    static color from_string(
-        std::string_view name);
+    static constexpr std::optional<std::string_view> to_string(color e) noexcept;
+    static constexpr std::optional<color> from_string(std::string_view name) noexcept;
 
-    static constexpr bool from_string_nothrow(
-        std::string_view name,
-        color& result) noexcept;
+    static constexpr std::optional<std::size_t> to_index(color e) noexcept;
+    static constexpr std::optional<color> from_index(std::size_t index) noexcept;
 };
 ```
 
 ### Traits using
 
 ```cpp
-ENUM_HPP_CLASS_DECL(color, unsigned, red, green, blue)
-
-// size
-color_traits::size; // 3
-
-// to_string
-color_traits::to_string(color::red); // returns "red";
-color_traits::to_string(color(42)); // returns "";
-
-// from_string
-color_traits::from_string("green"); // returns color::green;
-color_traits::from_string("error"); // throws enum_hpp::exception
-
-// from_string_nothrow
-color result;
-bool success = color_traits::from_string_nothrow("blue", result);
-// success == true, result == color::blue
-
-// names
-for ( auto n : color_traits::names ) {
-    std::cout << n << ",";
+namespace
+{
+    ENUM_HPP_CLASS_DECL(color, unsigned,
+        (red = 0xFF0000)
+        (green = 0x00FF00)
+        (blue = 0x0000FF)
+        (white = red | green | blue))
+}
+
+SECTION("traits_using") {
+    // size
+    STATIC_REQUIRE(color_traits::size == 4);
+
+    // to_underlying
+    STATIC_REQUIRE(color_traits::to_underlying(color::white) == 0xFFFFFF);
+
+    // to_string
+    STATIC_REQUIRE(color_traits::to_string(color::red) == "red");
+    STATIC_REQUIRE(color_traits::to_string(color(42)) == std::nullopt);
+
+    // from_string
+    STATIC_REQUIRE(color_traits::from_string("green") == color::green);
+    STATIC_REQUIRE(color_traits::from_string("error") == std::nullopt);
+
+    // to_index
+    STATIC_REQUIRE(color_traits::to_index(color::blue) == 2);
+    STATIC_REQUIRE(color_traits::to_index(color(42)) == std::nullopt);
+
+    // from_index
+    STATIC_REQUIRE(color_traits::from_index(2) == color::blue);
+    STATIC_REQUIRE(color_traits::from_index(42) == std::nullopt);
+
+    // names
+    for ( auto n : color_traits::names ) {
+        std::cout << n << ",";
+    } // stdout: red,green,blue,
 }
-// prints red,green,blue
 ```
 
 ## Alternatives
diff --git a/headers/enum.hpp/enum.hpp b/headers/enum.hpp/enum.hpp
index d4a6013..40b8731 100644
--- a/headers/enum.hpp/enum.hpp
+++ b/headers/enum.hpp/enum.hpp
@@ -6,17 +6,9 @@
 
 #pragma once
 
-#include <stdexcept>
+#include <optional>
 #include <string_view>
-
-namespace enum_hpp
-{
-    class exception final : public std::runtime_error {
-    public:
-        explicit exception(const char* what)
-        : std::runtime_error(what) {}
-    };
-}
+#include <type_traits>
 
 namespace enum_hpp::detail
 {
@@ -94,7 +86,7 @@ namespace enum_hpp::detail
     enum Enum : Type {\
         ENUM_HPP_GENERATE_ENUM_FIELDS(Fields)\
     };\
-    ENUM_HPP_TRAITS_IMPL(Enum, Type, Fields)
+    ENUM_HPP_TRAITS_DECL(Enum, Fields)
 
 //
 // ENUM_HPP_CLASS_DECL
@@ -104,47 +96,58 @@ namespace enum_hpp::detail
     enum class Enum : Type {\
         ENUM_HPP_GENERATE_ENUM_FIELDS(Fields)\
     };\
-    ENUM_HPP_TRAITS_IMPL(Enum, Type, Fields)
+    ENUM_HPP_TRAITS_DECL(Enum, Fields)
 
 //
-// ENUM_HPP_TRAITS_IMPL
+// ENUM_HPP_TRAITS_DECL
 //
 
-#define ENUM_HPP_TRAITS_IMPL(Enum, Type, Fields)\
+#define ENUM_HPP_TRAITS_DECL(Enum, Fields)\
     struct Enum##_traits {\
     private:\
         enum enum_names_for_this_score_ { ENUM_HPP_GENERATE_ENUM_FIELDS(Fields) };\
     public:\
+        using underlying_type = std::underlying_type_t<Enum>;\
         static constexpr std::size_t size = ENUM_HPP_PP_SEQ_SIZE(Fields);\
         static constexpr const Enum values[] = { ENUM_HPP_GENERATE_VALUES(Enum, Fields) };\
         static constexpr const std::string_view names[] = { ENUM_HPP_GENERATE_NAMES(Fields) };\
     public:\
-        static constexpr std::string_view to_string(Enum e) noexcept {\
+        static constexpr underlying_type to_underlying(Enum e) noexcept {\
+            return static_cast<underlying_type>(e);\
+        }\
+        \
+        static constexpr std::optional<std::string_view> to_string(Enum e) noexcept {\
             for ( std::size_t i = 0; i < size; ++i) {\
                 if ( e == values[i] ) {\
                     return names[i];\
                 }\
             }\
-            return std::string_view();\
+            return std::nullopt;\
         }\
         \
-        static Enum from_string(std::string_view name){\
+        static constexpr std::optional<Enum> from_string(std::string_view name) noexcept {\
             for ( std::size_t i = 0; i < size; ++i) {\
                 if ( name == names[i] ) {\
                     return values[i];\
                 }\
             }\
-            throw ::enum_hpp::exception(#Enum "_traits::from_string(): invalid argument");\
+            return std::nullopt;\
         }\
         \
-        static constexpr bool from_string_nothrow(std::string_view name, Enum& result) noexcept {\
-            for ( std::size_t i = 0; i < size; ++i) {\
-                if ( name == names[i] ) {\
-                    result = values[i];\
-                    return true;\
+        static constexpr std::optional<std::size_t> to_index(Enum e) noexcept {\
+            for ( std::size_t i = 0; i < size; ++i ) {\
+                if ( e == values[i] ) {\
+                    return i;\
                 }\
             }\
-            return false;\
+            return std::nullopt;\
+        }\
+        \
+        static constexpr std::optional<Enum> from_index(std::size_t index) noexcept {\
+            if ( index < size ) {\
+                return values[index];\
+            }\
+            return std::nullopt;\
         }\
     };
 
diff --git a/untests/enum_examples.cpp b/untests/enum_examples.cpp
new file mode 100644
index 0000000..877f6bf
--- /dev/null
+++ b/untests/enum_examples.cpp
@@ -0,0 +1,53 @@
+/*******************************************************************************
+ * This file is part of the "https://github.com/blackmatov/enum.hpp"
+ * For conditions of distribution and use, see copyright notice in LICENSE.md
+ * Copyright (C) 2019, by Matvey Cherevko (blackmatov@gmail.com)
+ ******************************************************************************/
+
+#define CATCH_CONFIG_FAST_COMPILE
+#include <catch2/catch.hpp>
+
+#include <enum.hpp/enum.hpp>
+
+#include <string>
+#include <iostream>
+
+namespace
+{
+    ENUM_HPP_CLASS_DECL(color, unsigned,
+        (red = 0xFF0000)
+        (green = 0x00FF00)
+        (blue = 0x0000FF)
+        (white = red | green | blue))
+}
+
+TEST_CASE("examples") {
+    SECTION("traits_using") {
+        // size
+        STATIC_REQUIRE(color_traits::size == 4);
+
+        // to_underlying
+        STATIC_REQUIRE(color_traits::to_underlying(color::white) == 0xFFFFFF);
+
+        // to_string
+        STATIC_REQUIRE(color_traits::to_string(color::red) == "red");
+        STATIC_REQUIRE(color_traits::to_string(color(42)) == std::nullopt);
+
+        // from_string
+        STATIC_REQUIRE(color_traits::from_string("green") == color::green);
+        STATIC_REQUIRE(color_traits::from_string("error") == std::nullopt);
+
+        // to_index
+        STATIC_REQUIRE(color_traits::to_index(color::blue) == 2u);
+        STATIC_REQUIRE(color_traits::to_index(color(42)) == std::nullopt);
+
+        // from_index
+        STATIC_REQUIRE(color_traits::from_index(2) == color::blue);
+        STATIC_REQUIRE(color_traits::from_index(42) == std::nullopt);
+
+        // names
+        for ( auto n : color_traits::names ) {
+            std::cout << n << ",";
+        }
+    }
+}
diff --git a/untests/enum_tests.cpp b/untests/enum_tests.cpp
index 64aea69..348693e 100644
--- a/untests/enum_tests.cpp
+++ b/untests/enum_tests.cpp
@@ -64,19 +64,19 @@ TEST_CASE("enum") {
                 std::underlying_type_t<sn::color>,
                 unsigned>);
 
-            REQUIRE(enum_to_underlying(sn::color::red) == 2);
-            REQUIRE(enum_to_underlying(sn::color::green) == 3);
-            REQUIRE(enum_to_underlying(sn::color::blue) == 6);
+            REQUIRE(enum_to_underlying(sn::color::red) == 2u);
+            REQUIRE(enum_to_underlying(sn::color::green) == 3u);
+            REQUIRE(enum_to_underlying(sn::color::blue) == 6u);
         }
         {
             STATIC_REQUIRE(std::is_same_v<
                 std::underlying_type_t<sn::render::mask>,
                 unsigned char>);
 
-            REQUIRE(enum_to_underlying(sn::render::mask::none) == 0);
-            REQUIRE(enum_to_underlying(sn::render::mask::color) == 1);
-            REQUIRE(enum_to_underlying(sn::render::mask::alpha) == 2);
-            REQUIRE(enum_to_underlying(sn::render::mask::all) == 3);
+            REQUIRE(enum_to_underlying(sn::render::mask::none) == 0u);
+            REQUIRE(enum_to_underlying(sn::render::mask::color) == 1u);
+            REQUIRE(enum_to_underlying(sn::render::mask::alpha) == 2u);
+            REQUIRE(enum_to_underlying(sn::render::mask::all) == 3u);
         }
         {
             STATIC_REQUIRE(std::is_same_v<
@@ -91,28 +91,49 @@ TEST_CASE("enum") {
 
     SECTION("size") {
         {
-            REQUIRE(sn::color_traits::size == 3);
+            REQUIRE(sn::color_traits::size == 3u);
             REQUIRE(sn::color_traits::size == std::size(sn::color_traits::names));
             REQUIRE(sn::color_traits::size == std::size(sn::color_traits::values));
         }
         {
-            REQUIRE(sn::render::mask_traits::size == 4);
+            REQUIRE(sn::render::mask_traits::size == 4u);
             REQUIRE(sn::render::mask_traits::size == std::size(sn::render::mask_traits::names));
             REQUIRE(sn::render::mask_traits::size == std::size(sn::render::mask_traits::values));
         }
         {
-            REQUIRE(sn::numbers_traits::size == 241);
+            REQUIRE(sn::numbers_traits::size == 241u);
             REQUIRE(sn::numbers_traits::size == std::size(sn::numbers_traits::names));
             REQUIRE(sn::numbers_traits::size == std::size(sn::numbers_traits::values));
         }
     }
 
+    SECTION("to_underlying") {
+        {
+            STATIC_REQUIRE(sn::color_traits::to_underlying(sn::color::red) == enum_to_underlying(sn::color::red));
+            STATIC_REQUIRE(sn::color_traits::to_underlying(sn::color::green) == enum_to_underlying(sn::color::green));
+            STATIC_REQUIRE(sn::color_traits::to_underlying(sn::color::blue) == enum_to_underlying(sn::color::blue));
+            STATIC_REQUIRE(sn::color_traits::to_underlying(sn::color(42)) == 42);
+        }
+        {
+            STATIC_REQUIRE(sn::render::mask_traits::to_underlying(sn::render::mask::none) == enum_to_underlying(sn::render::mask::none));
+            STATIC_REQUIRE(sn::render::mask_traits::to_underlying(sn::render::mask::color) == enum_to_underlying(sn::render::mask::color));
+            STATIC_REQUIRE(sn::render::mask_traits::to_underlying(sn::render::mask::alpha) == enum_to_underlying(sn::render::mask::alpha));
+            STATIC_REQUIRE(sn::render::mask_traits::to_underlying(sn::render::mask::all) == enum_to_underlying(sn::render::mask::all));
+        }
+        {
+            STATIC_REQUIRE(sn::numbers_traits::to_underlying(sn::_0) == enum_to_underlying(sn::_0));
+            STATIC_REQUIRE(sn::numbers_traits::to_underlying(sn::_180) == enum_to_underlying(sn::_180));
+            STATIC_REQUIRE(sn::numbers_traits::to_underlying(sn::_240) == enum_to_underlying(sn::_240));
+            STATIC_REQUIRE(sn::numbers_traits::to_underlying(sn::numbers(100500)) == 100500);
+        }
+    }
+
     SECTION("to_string") {
         {
             STATIC_REQUIRE(sn::color_traits::to_string(sn::color::red) == "red");
             STATIC_REQUIRE(sn::color_traits::to_string(sn::color::green) == "green");
             STATIC_REQUIRE(sn::color_traits::to_string(sn::color::blue) == "blue");
-            STATIC_REQUIRE(sn::color_traits::to_string(sn::color(42)) == "");
+            STATIC_REQUIRE_FALSE(sn::color_traits::to_string(sn::color(42)));
         }
         {
             STATIC_REQUIRE(sn::render::mask_traits::to_string(sn::render::mask::none) == "none");
@@ -124,62 +145,70 @@ TEST_CASE("enum") {
             STATIC_REQUIRE(sn::numbers_traits::to_string(sn::_0) == "_0");
             STATIC_REQUIRE(sn::numbers_traits::to_string(sn::_180) == "_180");
             STATIC_REQUIRE(sn::numbers_traits::to_string(sn::_240) == "_240");
-            STATIC_REQUIRE(sn::numbers_traits::to_string(sn::numbers(100500)) == "");
+            STATIC_REQUIRE_FALSE(sn::numbers_traits::to_string(sn::numbers(100500)));
         }
     }
 
     SECTION("from_string") {
         {
-            REQUIRE(sn::color_traits::from_string("red") == sn::color::red);
-            REQUIRE(sn::color_traits::from_string("green") == sn::color::green);
-            REQUIRE(sn::color_traits::from_string("blue") == sn::color::blue);
-            REQUIRE_THROWS_AS(sn::color_traits::from_string("42"), enum_hpp::exception);
+            STATIC_REQUIRE(sn::color_traits::from_string("red") == sn::color::red);
+            STATIC_REQUIRE(sn::color_traits::from_string("green") == sn::color::green);
+            STATIC_REQUIRE(sn::color_traits::from_string("blue") == sn::color::blue);
+            STATIC_REQUIRE_FALSE(sn::color_traits::from_string("42"));
         }
         {
-            REQUIRE(sn::render::mask_traits::from_string("none") == sn::render::mask::none);
-            REQUIRE(sn::render::mask_traits::from_string("color") == sn::render::mask::color);
-            REQUIRE(sn::render::mask_traits::from_string("alpha") == sn::render::mask::alpha);
-            REQUIRE(sn::render::mask_traits::from_string("all") == sn::render::mask::all);
-            REQUIRE_THROWS_AS(sn::render::mask_traits::from_string("42"), enum_hpp::exception);
+            STATIC_REQUIRE(sn::render::mask_traits::from_string("none") == sn::render::mask::none);
+            STATIC_REQUIRE(sn::render::mask_traits::from_string("color") == sn::render::mask::color);
+            STATIC_REQUIRE(sn::render::mask_traits::from_string("alpha") == sn::render::mask::alpha);
+            STATIC_REQUIRE(sn::render::mask_traits::from_string("all") == sn::render::mask::all);
+            STATIC_REQUIRE_FALSE(sn::render::mask_traits::from_string("42"));
         }
         {
-            REQUIRE(sn::numbers_traits::from_string("_10") == sn::_10);
-            REQUIRE(sn::numbers_traits::from_string("_240") == sn::_240);
-            REQUIRE_THROWS_AS(sn::numbers_traits::from_string("error"), enum_hpp::exception);
+            STATIC_REQUIRE(sn::numbers_traits::from_string("_10") == sn::_10);
+            STATIC_REQUIRE(sn::numbers_traits::from_string("_240") == sn::_240);
+            STATIC_REQUIRE_FALSE(sn::numbers_traits::from_string("error"));
         }
     }
 
-    SECTION("from_string_nothrow") {
+    SECTION("to_index") {
         {
-            sn::color result{42};
-            REQUIRE(sn::color_traits::from_string_nothrow("red", result));
-            REQUIRE(result == sn::color::red);
-            REQUIRE(sn::color_traits::from_string_nothrow("green", result));
-            REQUIRE(result == sn::color::green);
-            REQUIRE(sn::color_traits::from_string_nothrow("blue", result));
-            REQUIRE(result == sn::color::blue);
-            REQUIRE_FALSE(sn::color_traits::from_string_nothrow("42", result));
-            REQUIRE(result == sn::color::blue);
+            STATIC_REQUIRE(sn::color_traits::to_index(sn::color::red) == 0u);
+            STATIC_REQUIRE(sn::color_traits::to_index(sn::color::green) == 1u);
+            STATIC_REQUIRE(sn::color_traits::to_index(sn::color::blue) == 2u);
+            STATIC_REQUIRE_FALSE(sn::color_traits::to_index(sn::color(42)));
         }
         {
-            sn::render::mask result{42};
-            REQUIRE(sn::render::mask_traits::from_string_nothrow("none", result));
-            REQUIRE(result == sn::render::mask::none);
-            REQUIRE(sn::render::mask_traits::from_string_nothrow("color", result));
-            REQUIRE(result == sn::render::mask::color);
-            REQUIRE(sn::render::mask_traits::from_string_nothrow("alpha", result));
-            REQUIRE(result == sn::render::mask::alpha);
-            REQUIRE(sn::render::mask_traits::from_string_nothrow("all", result));
-            REQUIRE(result == sn::render::mask::all);
-            REQUIRE_FALSE(sn::render::mask_traits::from_string_nothrow("42", result));
-            REQUIRE(result == sn::render::mask::all);
+            STATIC_REQUIRE(sn::render::mask_traits::to_index(sn::render::mask::none) == 0u);
+            STATIC_REQUIRE(sn::render::mask_traits::to_index(sn::render::mask::color) == 1u);
+            STATIC_REQUIRE(sn::render::mask_traits::to_index(sn::render::mask::alpha) == 2u);
+            STATIC_REQUIRE(sn::render::mask_traits::to_index(sn::render::mask::all) == 3u);
         }
         {
-            sn::numbers result{100500};
-            REQUIRE(sn::numbers_traits::from_string_nothrow("_240", result));
-            REQUIRE(result == sn::_240);
-            REQUIRE_FALSE(sn::numbers_traits::from_string_nothrow("error", result));
-            REQUIRE(result == sn::_240);
+            STATIC_REQUIRE(sn::numbers_traits::to_index(sn::_0) == 0u);
+            STATIC_REQUIRE(sn::numbers_traits::to_index(sn::_180) == 180u);
+            STATIC_REQUIRE(sn::numbers_traits::to_index(sn::_240) == 240u);
+            STATIC_REQUIRE_FALSE(sn::numbers_traits::to_index(sn::numbers(100500)));
+        }
+    }
+
+    SECTION("from_index") {
+        {
+            STATIC_REQUIRE(sn::color_traits::from_index(0) == sn::color::red);
+            STATIC_REQUIRE(sn::color_traits::from_index(1) == sn::color::green);
+            STATIC_REQUIRE(sn::color_traits::from_index(2) == sn::color::blue);
+            STATIC_REQUIRE_FALSE(sn::color_traits::from_index(42));
+        }
+        {
+            STATIC_REQUIRE(sn::render::mask_traits::from_index(0) == sn::render::mask::none);
+            STATIC_REQUIRE(sn::render::mask_traits::from_index(1) == sn::render::mask::color);
+            STATIC_REQUIRE(sn::render::mask_traits::from_index(2) == sn::render::mask::alpha);
+            STATIC_REQUIRE(sn::render::mask_traits::from_index(3) == sn::render::mask::all);
+            STATIC_REQUIRE_FALSE(sn::render::mask_traits::from_index(42));
+        }
+        {
+            STATIC_REQUIRE(sn::numbers_traits::from_index(10) == sn::_10);
+            STATIC_REQUIRE(sn::numbers_traits::from_index(240) == sn::_240);
+            STATIC_REQUIRE_FALSE(sn::numbers_traits::from_index(100500));
         }
     }
 }