diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index ebb3ffa4..7b654f63 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,2 +1,2 @@
-add_subdirectory(smd)
+add_subdirectory(beman)
 add_subdirectory(examples)
diff --git a/src/smd/CMakeLists.txt b/src/beman/CMakeLists.txt
similarity index 100%
rename from src/smd/CMakeLists.txt
rename to src/beman/CMakeLists.txt
diff --git a/src/smd/optional/CMakeLists.txt b/src/beman/optional/CMakeLists.txt
similarity index 100%
rename from src/smd/optional/CMakeLists.txt
rename to src/beman/optional/CMakeLists.txt
diff --git a/src/beman/optional/optional.cpp b/src/beman/optional/optional.cpp
new file mode 100644
index 00000000..53eedff3
--- /dev/null
+++ b/src/beman/optional/optional.cpp
@@ -0,0 +1 @@
+#include <beman/optional/optional.h>
diff --git a/src/smd/optional/optional.h b/src/beman/optional/optional.h
similarity index 98%
rename from src/smd/optional/optional.h
rename to src/beman/optional/optional.h
index e00ed07f..baf48cd0 100644
--- a/src/smd/optional/optional.h
+++ b/src/beman/optional/optional.h
@@ -1,6 +1,6 @@
-// smd/optional/optional.h                                            -*-C++-*-
-#ifndef INCLUDED_SMD_OPTIONAL_OPTIONAL
-#define INCLUDED_SMD_OPTIONAL_OPTIONAL
+// beman/optional/optional.h                                            -*-C++-*-
+#ifndef INCLUDED_BEMAN_OPTIONAL_OPTIONAL
+#define INCLUDED_BEMAN_OPTIONAL_OPTIONAL
 
 /*
 22.5.2 Header <optional> synopsis[optional.syn]
@@ -170,7 +170,7 @@ namespace std {
 #include <type_traits>
 #include <ranges>
 
-namespace smd::optional {
+namespace beman::optional {
 
 class monostate {};
 
@@ -201,26 +201,26 @@ template <class T>
     requires(!std::is_same_v<T, in_place_t>) && (!std::is_same_v<std::decay_t<T>, nullopt_t>)
 class optional;
 
-} // namespace smd::optional
+} // namespace beman::optional
 namespace std {
 template <typename T>
-inline constexpr bool ranges::enable_view<smd::optional::optional<T>> = true;
+inline constexpr bool ranges::enable_view<beman::optional::optional<T>> = true;
 
 template <typename T>
-inline constexpr bool ranges::enable_view<smd::optional::optional<T&>> = true;
+inline constexpr bool ranges::enable_view<beman::optional::optional<T&>> = true;
 
 template <typename T>
-inline constexpr bool ranges::enable_borrowed_range<smd::optional::optional<T*>> = true;
+inline constexpr bool ranges::enable_borrowed_range<beman::optional::optional<T*>> = true;
 
 template <typename T>
-inline constexpr bool ranges::enable_borrowed_range<smd::optional::optional<std::reference_wrapper<T>>> = true;
+inline constexpr bool ranges::enable_borrowed_range<beman::optional::optional<std::reference_wrapper<T>>> = true;
 
 template <typename T>
-inline constexpr bool ranges::enable_borrowed_range<smd::optional::optional<T&>> = true;
+inline constexpr bool ranges::enable_borrowed_range<beman::optional::optional<T&>> = true;
 
 } // namespace std
 
-namespace smd::optional {
+namespace beman::optional {
 template <class T>
 concept is_derived_from_optional = requires(const T& t) { []<class U>(const optional<U>&) {}(t); };
 
@@ -1152,5 +1152,5 @@ class optional<T&> {
     constexpr std::reverse_iterator<const T*> crbegin() const noexcept { return rbegin(); }
     constexpr std::reverse_iterator<const T*> crend() const noexcept { return rend(); }
 };
-} // namespace smd::optional
+} // namespace beman::optional
 #endif
diff --git a/src/smd/optional/optional.t.cpp b/src/beman/optional/optional.t.cpp
similarity index 58%
rename from src/smd/optional/optional.t.cpp
rename to src/beman/optional/optional.t.cpp
index 3faf1315..e7bf03b7 100644
--- a/src/smd/optional/optional.t.cpp
+++ b/src/beman/optional/optional.t.cpp
@@ -1,6 +1,6 @@
-#include <smd/optional/optional.h>
+#include <beman/optional/optional.h>
 
-#include <smd/optional/optional.h>
+#include <beman/optional/optional.h> // test 2nd include OK
 
 #include <functional>
 #include <ranges>
@@ -35,88 +35,88 @@ struct derived : public base {
 } // namespace
 
 TEST(OptionalTest, Constructors) {
-    smd::optional::optional<int> i1;
-    smd::optional::optional<int> i2{smd::optional::nullopt};
+    beman::optional::optional<int> i1;
+    beman::optional::optional<int> i2{beman::optional::nullopt};
 
     int                          i  = 0;
-    smd::optional::optional<int> i3 = i;
+    beman::optional::optional<int> i3 = i;
     (void)i3;
 
-    smd::optional::optional<empty> e1;
-    smd::optional::optional<int>   e2{smd::optional::nullopt};
+    beman::optional::optional<empty> e1;
+    beman::optional::optional<int>   e2{beman::optional::nullopt};
 
     empty                          e{};
-    smd::optional::optional<empty> e3 = e;
+    beman::optional::optional<empty> e3 = e;
     (void)e3;
 }
 
 
 TEST(OptionalTest, Constructors2) {
-    smd::optional::optional<int> o1;
+    beman::optional::optional<int> o1;
     EXPECT_TRUE(!o1);
 
-    smd::optional::optional<int> o2 = smd::optional::nullopt;
+    beman::optional::optional<int> o2 = beman::optional::nullopt;
     EXPECT_TRUE(!o2);
 
-    smd::optional::optional<int> o3 = 42;
+    beman::optional::optional<int> o3 = 42;
     EXPECT_TRUE(*o3 == 42);
 
-    smd::optional::optional<int> o4 = o3;
+    beman::optional::optional<int> o4 = o3;
     EXPECT_TRUE(*o4 == 42);
 
-    smd::optional::optional<int> o5 = o1;
+    beman::optional::optional<int> o5 = o1;
     EXPECT_TRUE(!o5);
 
-    smd::optional::optional<int> o6 = std::move(o3);
+    beman::optional::optional<int> o6 = std::move(o3);
     EXPECT_TRUE(*o6 == 42);
 
-    smd::optional::optional<short> o7 = 42;
+    beman::optional::optional<short> o7 = 42;
     EXPECT_TRUE(*o7 == 42);
 
-    smd::optional::optional<int> o8 = o7;
+    beman::optional::optional<int> o8 = o7;
     EXPECT_TRUE(*o8 == 42);
 
-    smd::optional::optional<int> o9 = std::move(o7);
+    beman::optional::optional<int> o9 = std::move(o7);
     EXPECT_TRUE(*o9 == 42);
 
     {
-        smd::optional::optional<int&> o;
+        beman::optional::optional<int&> o;
         EXPECT_TRUE(!o);
 
-        smd::optional::optional<int&> oo = o;
+        beman::optional::optional<int&> oo = o;
         EXPECT_TRUE(!oo);
     }
 
     {
         auto                                    i = 42;
-        smd::optional::optional<int&> o = i;
+        beman::optional::optional<int&> o = i;
         EXPECT_TRUE(o);
         EXPECT_TRUE(*o == 42);
 
-        smd::optional::optional<int&> oo = o;
+        beman::optional::optional<int&> oo = o;
         EXPECT_TRUE(oo);
         EXPECT_TRUE(*oo == 42);
     }
 
     std::vector<base> v;
     v.emplace_back();
-    smd::optional::optional<std::vector<base>> ov = std::move(v);
+    beman::optional::optional<std::vector<base>> ov = std::move(v);
     EXPECT_TRUE(ov->size() == 1);
 }
 
 TEST(OptionalTest, Constructors3) {
-    smd::optional::optional<int> ie;
-    smd::optional::optional<int> i4 = ie;
+    beman::optional::optional<int> ie;
+    beman::optional::optional<int> i4 = ie;
     EXPECT_FALSE(i4);
 
     base                           b{1};
     derived                        d(1, 2);
-    smd::optional::optional<base> b1{b};
-    smd::optional::optional<base> b2{d};
+    beman::optional::optional<base> b1{b};
+    beman::optional::optional<base> b2{d};
 
-    smd::optional::optional<derived> d2{d};
-    smd::optional::optional<base>    b3 = d2;
-    smd::optional::optional<base>    b4{d2};
+    beman::optional::optional<derived> d2{d};
+    beman::optional::optional<base>    b3 = d2;
+    beman::optional::optional<base>    b4{d2};
 }
 
 namespace {
@@ -130,14 +130,14 @@ class NoDefault {
 
 TEST(OptionalTest, NonDefaultConstruct) {
     NoDefault                          i = 7;
-    smd::optional::optional<NoDefault> v1{};
-    smd::optional::optional<NoDefault> v2{i};
+    beman::optional::optional<NoDefault> v1{};
+    beman::optional::optional<NoDefault> v2{i};
 }
 
 TEST(OptionalTest, AssignmentValue) {
-    smd::optional::optional<int> o1 = 42;
-    smd::optional::optional<int> o2 = 12;
-    smd::optional::optional<int> o3;
+    beman::optional::optional<int> o1 = 42;
+    beman::optional::optional<int> o2 = 12;
+    beman::optional::optional<int> o3;
 
     o1 = o1;
     EXPECT_TRUE(*o1 == 42);
@@ -151,13 +151,13 @@ TEST(OptionalTest, AssignmentValue) {
     o1 = 42;
     EXPECT_TRUE(*o1 == 42);
 
-    o1 = smd::optional::nullopt;
+    o1 = beman::optional::nullopt;
     EXPECT_TRUE(!o1);
 
     o1 = std::move(o2);
     EXPECT_TRUE(*o1 == 12);
 
-    smd::optional::optional<short> o4 = 42;
+    beman::optional::optional<short> o4 = 42;
 
     o1 = o4;
     EXPECT_TRUE(*o1 == 42);
@@ -168,15 +168,15 @@ TEST(OptionalTest, AssignmentValue) {
 
 TEST(OptionalTest, Triviality) {
     EXPECT_TRUE(std::is_trivially_copy_constructible<
-                smd::optional::optional<int>>::value);
+                beman::optional::optional<int>>::value);
     EXPECT_TRUE(std::is_trivially_copy_assignable<
-                smd::optional::optional<int>>::value);
+                beman::optional::optional<int>>::value);
     EXPECT_TRUE(std::is_trivially_move_constructible<
-                smd::optional::optional<int>>::value);
+                beman::optional::optional<int>>::value);
     EXPECT_TRUE(std::is_trivially_move_assignable<
-                smd::optional::optional<int>>::value);
+                beman::optional::optional<int>>::value);
     EXPECT_TRUE(
-        std::is_trivially_destructible<smd::optional::optional<int>>::value);
+        std::is_trivially_destructible<beman::optional::optional<int>>::value);
 
     {
         struct T {
@@ -187,15 +187,15 @@ TEST(OptionalTest, Triviality) {
             ~T()                   = default;
         };
         EXPECT_TRUE(std::is_trivially_copy_constructible<
-                    smd::optional::optional<T>>::value);
+                    beman::optional::optional<T>>::value);
         EXPECT_TRUE(std::is_trivially_copy_assignable<
-                    smd::optional::optional<T>>::value);
+                    beman::optional::optional<T>>::value);
         EXPECT_TRUE(std::is_trivially_move_constructible<
-                    smd::optional::optional<T>>::value);
+                    beman::optional::optional<T>>::value);
         EXPECT_TRUE(std::is_trivially_move_assignable<
-                    smd::optional::optional<T>>::value);
+                    beman::optional::optional<T>>::value);
         EXPECT_TRUE(
-            std::is_trivially_destructible<smd::optional::optional<T>>::value);
+            std::is_trivially_destructible<beman::optional::optional<T>>::value);
     }
 
     {
@@ -207,26 +207,26 @@ TEST(OptionalTest, Triviality) {
             ~T() {}
         };
         EXPECT_TRUE(!std::is_trivially_copy_constructible<
-                    smd::optional::optional<T>>::value);
+                    beman::optional::optional<T>>::value);
         EXPECT_TRUE(!std::is_trivially_copy_assignable<
-                    smd::optional::optional<T>>::value);
+                    beman::optional::optional<T>>::value);
         EXPECT_TRUE(!std::is_trivially_move_constructible<
-                    smd::optional::optional<T>>::value);
+                    beman::optional::optional<T>>::value);
         EXPECT_TRUE(!std::is_trivially_move_assignable<
-                    smd::optional::optional<T>>::value);
+                    beman::optional::optional<T>>::value);
         EXPECT_TRUE(!std::is_trivially_destructible<
-                    smd::optional::optional<T>>::value);
+                    beman::optional::optional<T>>::value);
     }
 }
 
 TEST(OptionalTest, Deletion) {
     EXPECT_TRUE(
-        std::is_copy_constructible<smd::optional::optional<int>>::value);
-    EXPECT_TRUE(std::is_copy_assignable<smd::optional::optional<int>>::value);
+        std::is_copy_constructible<beman::optional::optional<int>>::value);
+    EXPECT_TRUE(std::is_copy_assignable<beman::optional::optional<int>>::value);
     EXPECT_TRUE(
-        std::is_move_constructible<smd::optional::optional<int>>::value);
-    EXPECT_TRUE(std::is_move_assignable<smd::optional::optional<int>>::value);
-    EXPECT_TRUE(std::is_destructible<smd::optional::optional<int>>::value);
+        std::is_move_constructible<beman::optional::optional<int>>::value);
+    EXPECT_TRUE(std::is_move_assignable<beman::optional::optional<int>>::value);
+    EXPECT_TRUE(std::is_destructible<beman::optional::optional<int>>::value);
 
     {
         struct T {
@@ -237,14 +237,14 @@ TEST(OptionalTest, Deletion) {
             ~T()                   = default;
         };
         EXPECT_TRUE(
-            std::is_copy_constructible<smd::optional::optional<T>>::value);
+            std::is_copy_constructible<beman::optional::optional<T>>::value);
         EXPECT_TRUE(
-            std::is_copy_assignable<smd::optional::optional<T>>::value);
+            std::is_copy_assignable<beman::optional::optional<T>>::value);
         EXPECT_TRUE(
-            std::is_move_constructible<smd::optional::optional<T>>::value);
+            std::is_move_constructible<beman::optional::optional<T>>::value);
         EXPECT_TRUE(
-            std::is_move_assignable<smd::optional::optional<T>>::value);
-        EXPECT_TRUE(std::is_destructible<smd::optional::optional<T>>::value);
+            std::is_move_assignable<beman::optional::optional<T>>::value);
+        EXPECT_TRUE(std::is_destructible<beman::optional::optional<T>>::value);
     }
 
     {
@@ -255,13 +255,13 @@ TEST(OptionalTest, Deletion) {
             T& operator=(T&&)      = delete;
         };
         EXPECT_TRUE(
-            !std::is_copy_constructible<smd::optional::optional<T>>::value);
+            !std::is_copy_constructible<beman::optional::optional<T>>::value);
         EXPECT_TRUE(
-            !std::is_copy_assignable<smd::optional::optional<T>>::value);
+            !std::is_copy_assignable<beman::optional::optional<T>>::value);
         EXPECT_TRUE(
-            !std::is_move_constructible<smd::optional::optional<T>>::value);
+            !std::is_move_constructible<beman::optional::optional<T>>::value);
         EXPECT_TRUE(
-            !std::is_move_assignable<smd::optional::optional<T>>::value);
+            !std::is_move_assignable<beman::optional::optional<T>>::value);
     }
 
     {
@@ -272,13 +272,13 @@ TEST(OptionalTest, Deletion) {
             T& operator=(T&&)      = default;
         };
         EXPECT_TRUE(
-            !std::is_copy_constructible<smd::optional::optional<T>>::value);
+            !std::is_copy_constructible<beman::optional::optional<T>>::value);
         EXPECT_TRUE(
-            !std::is_copy_assignable<smd::optional::optional<T>>::value);
+            !std::is_copy_assignable<beman::optional::optional<T>>::value);
         EXPECT_TRUE(
-            std::is_move_constructible<smd::optional::optional<T>>::value);
+            std::is_move_constructible<beman::optional::optional<T>>::value);
         EXPECT_TRUE(
-            std::is_move_assignable<smd::optional::optional<T>>::value);
+            std::is_move_assignable<beman::optional::optional<T>>::value);
     }
 
     {
@@ -289,9 +289,9 @@ TEST(OptionalTest, Deletion) {
             T& operator=(T&&)      = delete;
         };
         EXPECT_TRUE(
-            std::is_copy_constructible<smd::optional::optional<T>>::value);
+            std::is_copy_constructible<beman::optional::optional<T>>::value);
         EXPECT_TRUE(
-            std::is_copy_assignable<smd::optional::optional<T>>::value);
+            std::is_copy_assignable<beman::optional::optional<T>>::value);
     }
 }
 
@@ -304,30 +304,30 @@ struct takes_init_and_variadic {
 };
 
 TEST(OptionalTest, InPlace) {
-    smd::optional::optional<int> o1{smd::optional::in_place};
-    smd::optional::optional<int> o2(smd::optional::in_place);
+    beman::optional::optional<int> o1{beman::optional::in_place};
+    beman::optional::optional<int> o2(beman::optional::in_place);
     EXPECT_TRUE(o1);
     EXPECT_TRUE(o1 == 0);
     EXPECT_TRUE(o2);
     EXPECT_TRUE(o2 == 0);
 
-    smd::optional::optional<int> o3(smd::optional::in_place, 42);
+    beman::optional::optional<int> o3(beman::optional::in_place, 42);
     EXPECT_TRUE(o3 == 42);
 
-    smd::optional::optional<std::tuple<int, int>> o4(
-        smd::optional::in_place, 0, 1);
+    beman::optional::optional<std::tuple<int, int>> o4(
+        beman::optional::in_place, 0, 1);
     EXPECT_TRUE(o4);
     EXPECT_TRUE(std::get<0>(*o4) == 0);
     EXPECT_TRUE(std::get<1>(*o4) == 1);
 
-    smd::optional::optional<std::vector<int>> o5(smd::optional::in_place,
+    beman::optional::optional<std::vector<int>> o5(beman::optional::in_place,
                                                  {0, 1});
     EXPECT_TRUE(o5);
     EXPECT_TRUE((*o5)[0] == 0);
     EXPECT_TRUE((*o5)[1] == 1);
 
-    smd::optional::optional<takes_init_and_variadic> o6(
-        smd::optional::in_place, {0, 1}, 2, 3);
+    beman::optional::optional<takes_init_and_variadic> o6(
+        beman::optional::in_place, {0, 1}, 2, 3);
     EXPECT_TRUE(o6->v[0] == 0);
     EXPECT_TRUE(o6->v[1] == 1);
     EXPECT_TRUE(std::get<0>(o6->t) == 2);
@@ -335,49 +335,49 @@ TEST(OptionalTest, InPlace) {
 }
 
 TEST(OptionalTest, MakeOptional) {
-    auto o1 = smd::optional::make_optional(42);
-    auto o2 = smd::optional::optional<int>(42);
+    auto o1 = beman::optional::make_optional(42);
+    auto o2 = beman::optional::optional<int>(42);
 
     constexpr bool is_same =
-        std::is_same<decltype(o1), smd::optional::optional<int>>::value;
+        std::is_same<decltype(o1), beman::optional::optional<int>>::value;
     EXPECT_TRUE(is_same);
     EXPECT_TRUE(o1 == o2);
 
-    auto o3 = smd::optional::make_optional<std::tuple<int, int, int, int>>(
+    auto o3 = beman::optional::make_optional<std::tuple<int, int, int, int>>(
         0, 1, 2, 3);
     EXPECT_TRUE(std::get<0>(*o3) == 0);
     EXPECT_TRUE(std::get<1>(*o3) == 1);
     EXPECT_TRUE(std::get<2>(*o3) == 2);
     EXPECT_TRUE(std::get<3>(*o3) == 3);
 
-    auto o4 = smd::optional::make_optional<std::vector<int>>({0, 1, 2, 3});
+    auto o4 = beman::optional::make_optional<std::vector<int>>({0, 1, 2, 3});
     EXPECT_TRUE(o4.value()[0] == 0);
     EXPECT_TRUE(o4.value()[1] == 1);
     EXPECT_TRUE(o4.value()[2] == 2);
     EXPECT_TRUE(o4.value()[3] == 3);
 
     auto o5 =
-        smd::optional::make_optional<takes_init_and_variadic>({0, 1}, 2, 3);
+        beman::optional::make_optional<takes_init_and_variadic>({0, 1}, 2, 3);
     EXPECT_TRUE(o5->v[0] == 0);
     EXPECT_TRUE(o5->v[1] == 1);
     EXPECT_TRUE(std::get<0>(o5->t) == 2);
     EXPECT_TRUE(std::get<1>(o5->t) == 3);
 
     auto i  = 42;
-    auto o6 = smd::optional::make_optional<int&>(i);
-    static_assert(std::is_same<decltype(o6), smd::optional::optional<int>>::value);
+    auto o6 = beman::optional::make_optional<int&>(i);
+    static_assert(std::is_same<decltype(o6), beman::optional::optional<int>>::value);
 
     EXPECT_TRUE(
-        (std::is_same<decltype(o6), smd::optional::optional<int>>::value));
+        (std::is_same<decltype(o6), beman::optional::optional<int>>::value));
     EXPECT_TRUE(o6);
     EXPECT_TRUE(*o6 == 42);
 }
 
 TEST(OptionalTest, Nullopt) {
-    smd::optional::optional<int> o1 = smd::optional::nullopt;
-    smd::optional::optional<int> o2{smd::optional::nullopt};
-    smd::optional::optional<int> o3(smd::optional::nullopt);
-    smd::optional::optional<int> o4 = {smd::optional::nullopt};
+    beman::optional::optional<int> o1 = beman::optional::nullopt;
+    beman::optional::optional<int> o2{beman::optional::nullopt};
+    beman::optional::optional<int> o3(beman::optional::nullopt);
+    beman::optional::optional<int> o4 = {beman::optional::nullopt};
 
     EXPECT_TRUE(!o1);
     EXPECT_TRUE(!o2);
@@ -385,7 +385,7 @@ TEST(OptionalTest, Nullopt) {
     EXPECT_TRUE(!o4);
 
     EXPECT_TRUE(
-        !std::is_default_constructible<smd::optional::nullopt_t>::value);
+        !std::is_default_constructible<beman::optional::nullopt_t>::value);
 }
 
 struct move_detector {
@@ -395,9 +395,9 @@ struct move_detector {
 };
 
 TEST(OptionalTest, Observers) {
-    smd::optional::optional<int>       o1 = 42;
-    smd::optional::optional<int>       o2;
-    const smd::optional::optional<int> o3 = 42;
+    beman::optional::optional<int>       o1 = 42;
+    beman::optional::optional<int>       o2;
+    const beman::optional::optional<int> o3 = 42;
 
     EXPECT_TRUE(*o1 == 42);
     EXPECT_TRUE(*o1 == o1.value());
@@ -410,16 +410,16 @@ TEST(OptionalTest, Observers) {
     success = std::is_same<decltype(std::move(o1).value()), int&&>::value;
     EXPECT_TRUE(success);
 
-    smd::optional::optional<move_detector> o4{smd::optional::in_place};
+    beman::optional::optional<move_detector> o4{beman::optional::in_place};
     move_detector                          o5 = std::move(o4).value();
     EXPECT_TRUE(o4->been_moved);
     EXPECT_TRUE(!o5.been_moved);
 }
 
 TEST(OptionalTest, RelationalOps) {
-    smd::optional::optional<int> o1{4};
-    smd::optional::optional<int> o2{42};
-    smd::optional::optional<int> o3{};
+    beman::optional::optional<int> o1{4};
+    beman::optional::optional<int> o2{42};
+    beman::optional::optional<int> o3{};
 
     //  SECTION("self simple")
     {
@@ -438,31 +438,31 @@ TEST(OptionalTest, RelationalOps) {
     }
     //  SECTION("nullopt simple")
     {
-        EXPECT_TRUE(!(o1 == smd::optional::nullopt));
-        EXPECT_TRUE(!(smd::optional::nullopt == o1));
-        EXPECT_TRUE(o1 != smd::optional::nullopt);
-        EXPECT_TRUE(smd::optional::nullopt != o1);
-        EXPECT_TRUE(!(o1 < smd::optional::nullopt));
-        EXPECT_TRUE(smd::optional::nullopt < o1);
-        EXPECT_TRUE(o1 > smd::optional::nullopt);
-        EXPECT_TRUE(!(smd::optional::nullopt > o1));
-        EXPECT_TRUE(!(o1 <= smd::optional::nullopt));
-        EXPECT_TRUE(smd::optional::nullopt <= o1);
-        EXPECT_TRUE(o1 >= smd::optional::nullopt);
-        EXPECT_TRUE(!(smd::optional::nullopt >= o1));
-
-        EXPECT_TRUE(o3 == smd::optional::nullopt);
-        EXPECT_TRUE(smd::optional::nullopt == o3);
-        EXPECT_TRUE(!(o3 != smd::optional::nullopt));
-        EXPECT_TRUE(!(smd::optional::nullopt != o3));
-        EXPECT_TRUE(!(o3 < smd::optional::nullopt));
-        EXPECT_TRUE(!(smd::optional::nullopt < o3));
-        EXPECT_TRUE(!(o3 > smd::optional::nullopt));
-        EXPECT_TRUE(!(smd::optional::nullopt > o3));
-        EXPECT_TRUE(o3 <= smd::optional::nullopt);
-        EXPECT_TRUE(smd::optional::nullopt <= o3);
-        EXPECT_TRUE(o3 >= smd::optional::nullopt);
-        EXPECT_TRUE(smd::optional::nullopt >= o3);
+        EXPECT_TRUE(!(o1 == beman::optional::nullopt));
+        EXPECT_TRUE(!(beman::optional::nullopt == o1));
+        EXPECT_TRUE(o1 != beman::optional::nullopt);
+        EXPECT_TRUE(beman::optional::nullopt != o1);
+        EXPECT_TRUE(!(o1 < beman::optional::nullopt));
+        EXPECT_TRUE(beman::optional::nullopt < o1);
+        EXPECT_TRUE(o1 > beman::optional::nullopt);
+        EXPECT_TRUE(!(beman::optional::nullopt > o1));
+        EXPECT_TRUE(!(o1 <= beman::optional::nullopt));
+        EXPECT_TRUE(beman::optional::nullopt <= o1);
+        EXPECT_TRUE(o1 >= beman::optional::nullopt);
+        EXPECT_TRUE(!(beman::optional::nullopt >= o1));
+
+        EXPECT_TRUE(o3 == beman::optional::nullopt);
+        EXPECT_TRUE(beman::optional::nullopt == o3);
+        EXPECT_TRUE(!(o3 != beman::optional::nullopt));
+        EXPECT_TRUE(!(beman::optional::nullopt != o3));
+        EXPECT_TRUE(!(o3 < beman::optional::nullopt));
+        EXPECT_TRUE(!(beman::optional::nullopt < o3));
+        EXPECT_TRUE(!(o3 > beman::optional::nullopt));
+        EXPECT_TRUE(!(beman::optional::nullopt > o3));
+        EXPECT_TRUE(o3 <= beman::optional::nullopt);
+        EXPECT_TRUE(beman::optional::nullopt <= o3);
+        EXPECT_TRUE(o3 >= beman::optional::nullopt);
+        EXPECT_TRUE(beman::optional::nullopt >= o3);
     }
     //  SECTION("with T simple")
     {
@@ -492,8 +492,8 @@ TEST(OptionalTest, RelationalOps) {
         EXPECT_TRUE(o1 >= 4);
         EXPECT_TRUE(4 >= o1);
     }
-    smd::optional::optional<std::string> o4{"hello"};
-    smd::optional::optional<std::string> o5{"xyz"};
+    beman::optional::optional<std::string> o4{"hello"};
+    beman::optional::optional<std::string> o5{"xyz"};
 
     //  SECTION("self complex")
     {
@@ -512,31 +512,31 @@ TEST(OptionalTest, RelationalOps) {
     }
     //  SECTION("nullopt complex")
     {
-        EXPECT_TRUE(!(o4 == smd::optional::nullopt));
-        EXPECT_TRUE(!(smd::optional::nullopt == o4));
-        EXPECT_TRUE(o4 != smd::optional::nullopt);
-        EXPECT_TRUE(smd::optional::nullopt != o4);
-        EXPECT_TRUE(!(o4 < smd::optional::nullopt));
-        EXPECT_TRUE(smd::optional::nullopt < o4);
-        EXPECT_TRUE(o4 > smd::optional::nullopt);
-        EXPECT_TRUE(!(smd::optional::nullopt > o4));
-        EXPECT_TRUE(!(o4 <= smd::optional::nullopt));
-        EXPECT_TRUE(smd::optional::nullopt <= o4);
-        EXPECT_TRUE(o4 >= smd::optional::nullopt);
-        EXPECT_TRUE(!(smd::optional::nullopt >= o4));
-
-        EXPECT_TRUE(o3 == smd::optional::nullopt);
-        EXPECT_TRUE(smd::optional::nullopt == o3);
-        EXPECT_TRUE(!(o3 != smd::optional::nullopt));
-        EXPECT_TRUE(!(smd::optional::nullopt != o3));
-        EXPECT_TRUE(!(o3 < smd::optional::nullopt));
-        EXPECT_TRUE(!(smd::optional::nullopt < o3));
-        EXPECT_TRUE(!(o3 > smd::optional::nullopt));
-        EXPECT_TRUE(!(smd::optional::nullopt > o3));
-        EXPECT_TRUE(o3 <= smd::optional::nullopt);
-        EXPECT_TRUE(smd::optional::nullopt <= o3);
-        EXPECT_TRUE(o3 >= smd::optional::nullopt);
-        EXPECT_TRUE(smd::optional::nullopt >= o3);
+        EXPECT_TRUE(!(o4 == beman::optional::nullopt));
+        EXPECT_TRUE(!(beman::optional::nullopt == o4));
+        EXPECT_TRUE(o4 != beman::optional::nullopt);
+        EXPECT_TRUE(beman::optional::nullopt != o4);
+        EXPECT_TRUE(!(o4 < beman::optional::nullopt));
+        EXPECT_TRUE(beman::optional::nullopt < o4);
+        EXPECT_TRUE(o4 > beman::optional::nullopt);
+        EXPECT_TRUE(!(beman::optional::nullopt > o4));
+        EXPECT_TRUE(!(o4 <= beman::optional::nullopt));
+        EXPECT_TRUE(beman::optional::nullopt <= o4);
+        EXPECT_TRUE(o4 >= beman::optional::nullopt);
+        EXPECT_TRUE(!(beman::optional::nullopt >= o4));
+
+        EXPECT_TRUE(o3 == beman::optional::nullopt);
+        EXPECT_TRUE(beman::optional::nullopt == o3);
+        EXPECT_TRUE(!(o3 != beman::optional::nullopt));
+        EXPECT_TRUE(!(beman::optional::nullopt != o3));
+        EXPECT_TRUE(!(o3 < beman::optional::nullopt));
+        EXPECT_TRUE(!(beman::optional::nullopt < o3));
+        EXPECT_TRUE(!(o3 > beman::optional::nullopt));
+        EXPECT_TRUE(!(beman::optional::nullopt > o3));
+        EXPECT_TRUE(o3 <= beman::optional::nullopt);
+        EXPECT_TRUE(beman::optional::nullopt <= o3);
+        EXPECT_TRUE(o3 >= beman::optional::nullopt);
+        EXPECT_TRUE(beman::optional::nullopt >= o3);
     }
 
     //  SECTION("with T complex")
@@ -570,31 +570,31 @@ TEST(OptionalTest, RelationalOps) {
 }
 
 TEST(OptionalTest, SwapValue) {
-    smd::optional::optional<int> o1 = 42;
-    smd::optional::optional<int> o2 = 12;
+    beman::optional::optional<int> o1 = 42;
+    beman::optional::optional<int> o2 = 12;
     o1.swap(o2);
     EXPECT_EQ(o1.value(), 12);
     EXPECT_EQ(o2.value(), 42);
 }
 
 TEST(OptionalTest, SwapWNull) {
-    smd::optional::optional<int> o1 = 42;
-    smd::optional::optional<int> o2 = smd::optional::nullopt;
+    beman::optional::optional<int> o1 = 42;
+    beman::optional::optional<int> o2 = beman::optional::nullopt;
     o1.swap(o2);
     EXPECT_TRUE(!o1.has_value());
     EXPECT_EQ(o2.value(), 42);
 }
 
 TEST(OptionalTest, SwapNullIntializedWithValue) {
-    smd::optional::optional<int> o1 = smd::optional::nullopt;
-    smd::optional::optional<int> o2 = 42;
+    beman::optional::optional<int> o1 = beman::optional::nullopt;
+    beman::optional::optional<int> o2 = 42;
     o1.swap(o2);
     EXPECT_EQ(o1.value(), 42);
     EXPECT_TRUE(!o2.has_value());
 }
 
 TEST(OptionalTest, Emplace) {
-    smd::optional::optional<
+    beman::optional::optional<
         std::pair<std::pair<int, int>, std::pair<double, double>>>
         i;
     i.emplace(std::piecewise_construct,
@@ -611,13 +611,13 @@ struct A {
 };
 
 TEST(OptionalTest, EmplaceWithExceptionThrown) {
-    smd::optional::optional<A> a;
+    beman::optional::optional<A> a;
     EXPECT_ANY_THROW(a.emplace());
 }
 
 TEST(OptionalTest, RangeTest) {
-    smd::optional::optional<int> o1 = smd::optional::nullopt;
-    smd::optional::optional<int> o2 = 42;
+    beman::optional::optional<int> o1 = beman::optional::nullopt;
+    beman::optional::optional<int> o2 = 42;
     EXPECT_EQ(*o2, 42);
     for(auto k : o1) {
         (void)k;
@@ -633,91 +633,91 @@ TEST(ViewMaybeTest, Constructors) {
     std::ranges::single_view<std::optional<int>> s2{s};
     std::ranges::single_view<std::optional<int>> s3{std::optional<int>{}};
 
-    smd::optional::optional<std::optional<int>> n;
-    smd::optional::optional<std::optional<int>> n2{n};
-    smd::optional::optional<std::optional<int>> n3{std::optional<int>{}};
+    beman::optional::optional<std::optional<int>> n;
+    beman::optional::optional<std::optional<int>> n2{n};
+    beman::optional::optional<std::optional<int>> n3{std::optional<int>{}};
 }
 
 TEST(ViewMaybeTest, ConceptCheck) {
-    static_assert(std::ranges::range<smd::optional::optional<int>>);
-    static_assert(std::ranges::view<smd::optional::optional<int>>);
-    static_assert(std::ranges::input_range<smd::optional::optional<int>>);
-    static_assert(std::ranges::forward_range<smd::optional::optional<int>>);
-    static_assert(std::ranges::bidirectional_range<smd::optional::optional<int>>);
-    static_assert(std::ranges::contiguous_range<smd::optional::optional<int>>);
-    static_assert(std::ranges::common_range<smd::optional::optional<int>>);
-    static_assert(std::ranges::viewable_range<smd::optional::optional<int>>);
-    static_assert(!std::ranges::borrowed_range<smd::optional::optional<int>>);
-    static_assert(std::ranges::random_access_range<smd::optional::optional<int>>);
-    static_assert(std::ranges::sized_range<smd::optional::optional<int>>);
-
-    static_assert(std::ranges::range<smd::optional::optional<int*>>);
-    static_assert(std::ranges::view<smd::optional::optional<int*>>);
-    static_assert(std::ranges::input_range<smd::optional::optional<int*>>);
-    static_assert(std::ranges::forward_range<smd::optional::optional<int*>>);
-    static_assert(std::ranges::bidirectional_range<smd::optional::optional<int*>>);
-    static_assert(std::ranges::contiguous_range<smd::optional::optional<int*>>);
-    static_assert(std::ranges::common_range<smd::optional::optional<int*>>);
-    static_assert(std::ranges::viewable_range<smd::optional::optional<int*>>);
-    static_assert(std::ranges::borrowed_range<smd::optional::optional<int*>>);
-    static_assert(std::ranges::random_access_range<smd::optional::optional<int*>>);
+    static_assert(std::ranges::range<beman::optional::optional<int>>);
+    static_assert(std::ranges::view<beman::optional::optional<int>>);
+    static_assert(std::ranges::input_range<beman::optional::optional<int>>);
+    static_assert(std::ranges::forward_range<beman::optional::optional<int>>);
+    static_assert(std::ranges::bidirectional_range<beman::optional::optional<int>>);
+    static_assert(std::ranges::contiguous_range<beman::optional::optional<int>>);
+    static_assert(std::ranges::common_range<beman::optional::optional<int>>);
+    static_assert(std::ranges::viewable_range<beman::optional::optional<int>>);
+    static_assert(!std::ranges::borrowed_range<beman::optional::optional<int>>);
+    static_assert(std::ranges::random_access_range<beman::optional::optional<int>>);
+    static_assert(std::ranges::sized_range<beman::optional::optional<int>>);
+
+    static_assert(std::ranges::range<beman::optional::optional<int*>>);
+    static_assert(std::ranges::view<beman::optional::optional<int*>>);
+    static_assert(std::ranges::input_range<beman::optional::optional<int*>>);
+    static_assert(std::ranges::forward_range<beman::optional::optional<int*>>);
+    static_assert(std::ranges::bidirectional_range<beman::optional::optional<int*>>);
+    static_assert(std::ranges::contiguous_range<beman::optional::optional<int*>>);
+    static_assert(std::ranges::common_range<beman::optional::optional<int*>>);
+    static_assert(std::ranges::viewable_range<beman::optional::optional<int*>>);
+    static_assert(std::ranges::borrowed_range<beman::optional::optional<int*>>);
+    static_assert(std::ranges::random_access_range<beman::optional::optional<int*>>);
 
     using ref = std::reference_wrapper<int>;
-    static_assert(std::ranges::range<smd::optional::optional<ref>>);
-    static_assert(std::ranges::view<smd::optional::optional<ref>>);
-    static_assert(std::ranges::input_range<smd::optional::optional<ref>>);
-    static_assert(std::ranges::forward_range<smd::optional::optional<ref>>);
-    static_assert(std::ranges::bidirectional_range<smd::optional::optional<ref>>);
-    static_assert(std::ranges::contiguous_range<smd::optional::optional<ref>>);
-    static_assert(std::ranges::common_range<smd::optional::optional<ref>>);
-    static_assert(std::ranges::viewable_range<smd::optional::optional<ref>>);
-    static_assert(std::ranges::borrowed_range<smd::optional::optional<ref>>);
-    static_assert(std::ranges::random_access_range<smd::optional::optional<ref>>);
+    static_assert(std::ranges::range<beman::optional::optional<ref>>);
+    static_assert(std::ranges::view<beman::optional::optional<ref>>);
+    static_assert(std::ranges::input_range<beman::optional::optional<ref>>);
+    static_assert(std::ranges::forward_range<beman::optional::optional<ref>>);
+    static_assert(std::ranges::bidirectional_range<beman::optional::optional<ref>>);
+    static_assert(std::ranges::contiguous_range<beman::optional::optional<ref>>);
+    static_assert(std::ranges::common_range<beman::optional::optional<ref>>);
+    static_assert(std::ranges::viewable_range<beman::optional::optional<ref>>);
+    static_assert(std::ranges::borrowed_range<beman::optional::optional<ref>>);
+    static_assert(std::ranges::random_access_range<beman::optional::optional<ref>>);
 }
 
 TEST(ViewMaybeTest, ConceptCheckRef) {
-    static_assert(std::ranges::range<smd::optional::optional<int&>>);
-    static_assert(std::ranges::view<smd::optional::optional<int&>>);
-    static_assert(std::ranges::input_range<smd::optional::optional<int&>>);
-    static_assert(std::ranges::forward_range<smd::optional::optional<int&>>);
-    static_assert(std::ranges::bidirectional_range<smd::optional::optional<int&>>);
-    static_assert(std::ranges::contiguous_range<smd::optional::optional<int&>>);
-    static_assert(std::ranges::common_range<smd::optional::optional<int&>>);
-    static_assert(std::ranges::viewable_range<smd::optional::optional<int&>>);
-    static_assert(std::ranges::borrowed_range<smd::optional::optional<int&>>);
-    static_assert(std::ranges::random_access_range<smd::optional::optional<int&>>);
-
-    static_assert(std::ranges::range<smd::optional::optional<int*&>>);
-    static_assert(std::ranges::view<smd::optional::optional<int*&>>);
-    static_assert(std::ranges::input_range<smd::optional::optional<int*&>>);
-    static_assert(std::ranges::forward_range<smd::optional::optional<int*&>>);
-    static_assert(std::ranges::bidirectional_range<smd::optional::optional<int*&>>);
-    static_assert(std::ranges::contiguous_range<smd::optional::optional<int*&>>);
-    static_assert(std::ranges::common_range<smd::optional::optional<int*&>>);
-    static_assert(std::ranges::viewable_range<smd::optional::optional<int*&>>);
-    static_assert(std::ranges::borrowed_range<smd::optional::optional<int*&>>);
-    static_assert(std::ranges::random_access_range<smd::optional::optional<int*&>>);
+    static_assert(std::ranges::range<beman::optional::optional<int&>>);
+    static_assert(std::ranges::view<beman::optional::optional<int&>>);
+    static_assert(std::ranges::input_range<beman::optional::optional<int&>>);
+    static_assert(std::ranges::forward_range<beman::optional::optional<int&>>);
+    static_assert(std::ranges::bidirectional_range<beman::optional::optional<int&>>);
+    static_assert(std::ranges::contiguous_range<beman::optional::optional<int&>>);
+    static_assert(std::ranges::common_range<beman::optional::optional<int&>>);
+    static_assert(std::ranges::viewable_range<beman::optional::optional<int&>>);
+    static_assert(std::ranges::borrowed_range<beman::optional::optional<int&>>);
+    static_assert(std::ranges::random_access_range<beman::optional::optional<int&>>);
+
+    static_assert(std::ranges::range<beman::optional::optional<int*&>>);
+    static_assert(std::ranges::view<beman::optional::optional<int*&>>);
+    static_assert(std::ranges::input_range<beman::optional::optional<int*&>>);
+    static_assert(std::ranges::forward_range<beman::optional::optional<int*&>>);
+    static_assert(std::ranges::bidirectional_range<beman::optional::optional<int*&>>);
+    static_assert(std::ranges::contiguous_range<beman::optional::optional<int*&>>);
+    static_assert(std::ranges::common_range<beman::optional::optional<int*&>>);
+    static_assert(std::ranges::viewable_range<beman::optional::optional<int*&>>);
+    static_assert(std::ranges::borrowed_range<beman::optional::optional<int*&>>);
+    static_assert(std::ranges::random_access_range<beman::optional::optional<int*&>>);
 
     using ref = std::reference_wrapper<int>&;
-    static_assert(std::ranges::range<smd::optional::optional<ref>>);
-    static_assert(std::ranges::view<smd::optional::optional<ref>>);
-    static_assert(std::ranges::input_range<smd::optional::optional<ref>>);
-    static_assert(std::ranges::forward_range<smd::optional::optional<ref>>);
-    static_assert(std::ranges::bidirectional_range<smd::optional::optional<ref>>);
-    static_assert(std::ranges::contiguous_range<smd::optional::optional<ref>>);
-    static_assert(std::ranges::common_range<smd::optional::optional<ref>>);
-    static_assert(std::ranges::viewable_range<smd::optional::optional<ref>>);
-    static_assert(std::ranges::borrowed_range<smd::optional::optional<ref>>);
-    static_assert(std::ranges::random_access_range<smd::optional::optional<ref>>);
+    static_assert(std::ranges::range<beman::optional::optional<ref>>);
+    static_assert(std::ranges::view<beman::optional::optional<ref>>);
+    static_assert(std::ranges::input_range<beman::optional::optional<ref>>);
+    static_assert(std::ranges::forward_range<beman::optional::optional<ref>>);
+    static_assert(std::ranges::bidirectional_range<beman::optional::optional<ref>>);
+    static_assert(std::ranges::contiguous_range<beman::optional::optional<ref>>);
+    static_assert(std::ranges::common_range<beman::optional::optional<ref>>);
+    static_assert(std::ranges::viewable_range<beman::optional::optional<ref>>);
+    static_assert(std::ranges::borrowed_range<beman::optional::optional<ref>>);
+    static_assert(std::ranges::random_access_range<beman::optional::optional<ref>>);
 }
 
 TEST(ViewMaybeTest, BreathingTest) {
-    smd::optional::optional<int> m;
+    beman::optional::optional<int> m;
     // ASSERT_TRUE(m.empty());
     // ASSERT_TRUE(m.size() == 0);
     // ASSERT_TRUE(m.data() == nullptr);
 
-    smd::optional::optional<int> m1{1};
+    beman::optional::optional<int> m1{1};
     // ASSERT_TRUE(!m1.empty());
     // ASSERT_TRUE(m1.size() == 1);
     // ASSERT_TRUE(m1.data() != nullptr);
@@ -730,10 +730,10 @@ TEST(ViewMaybeTest, BreathingTest) {
     // ASSERT_TRUE(m.size() == 0);
     // ASSERT_TRUE(m1.size() == 1);
 
-    smd::optional::optional<double> d0{0};
+    beman::optional::optional<double> d0{0};
     // ASSERT_TRUE(!d0.empty());
 
-    smd::optional::optional<double> d1{1};
+    beman::optional::optional<double> d1{1};
     // ASSERT_TRUE(!d1.empty());
 
     d0 = d1;
@@ -741,13 +741,13 @@ TEST(ViewMaybeTest, BreathingTest) {
 }
 
 TEST(ViewMaybeTest, BreathingTestRef) {
-    smd::optional::optional<int&> m;
+    beman::optional::optional<int&> m;
     // ASSERT_TRUE(m.empty());
     // ASSERT_TRUE(m.size() == 0);
     // ASSERT_TRUE(m.data() == nullptr);
 
     int              one = 1;
-    smd::optional::optional<int&> m1{one};
+    beman::optional::optional<int&> m1{one};
     // ASSERT_TRUE(!m1.empty());
     // ASSERT_TRUE(m1.size() == 1);
     // ASSERT_TRUE(m1.data() != nullptr);
@@ -761,11 +761,11 @@ TEST(ViewMaybeTest, BreathingTestRef) {
     // ASSERT_TRUE(m1.size() == 1);
 
     double              zero = 0.0;
-    smd::optional::optional<double&> d0{zero};
+    beman::optional::optional<double&> d0{zero};
     // ASSERT_TRUE(!d0.empty());
 
     double              one_d = 1.0;
-    smd::optional::optional<double&> d1{one_d};
+    beman::optional::optional<double&> d1{one_d};
     // ASSERT_TRUE(!d1.empty());
 
     d0 = d1;
@@ -773,10 +773,10 @@ TEST(ViewMaybeTest, BreathingTestRef) {
 }
 
 TEST(ViewMaybe, CompTest) {
-    smd::optional::optional<int> m;
-    smd::optional::optional<int> m0{0};
-    smd::optional::optional<int> m1{1};
-    smd::optional::optional<int> m1a{1};
+    beman::optional::optional<int> m;
+    beman::optional::optional<int> m0{0};
+    beman::optional::optional<int> m1{1};
+    beman::optional::optional<int> m1a{1};
 
     ASSERT_EQ(m, m);
     ASSERT_EQ(m0, m0);
@@ -793,13 +793,13 @@ TEST(ViewMaybe, CompTest) {
 }
 
 TEST(ViewMaybe, CompTestRef) {
-    smd::optional::optional<int&> m;
+    beman::optional::optional<int&> m;
     int              zero  = 0;
     int              one   = 1;
     int              one_a = 1;
-    smd::optional::optional<int&> m0{zero};
-    smd::optional::optional<int&> m1{one};
-    smd::optional::optional<int&> m1a{one_a};
+    beman::optional::optional<int&> m0{zero};
+    beman::optional::optional<int&> m1{one};
+    beman::optional::optional<int&> m1a{one_a};
 
     ASSERT_EQ(m, m);
     ASSERT_EQ(m0, m0);
@@ -831,8 +831,8 @@ inline constexpr auto and_then = [](auto&& r, auto fun) {
 // returns a view of zero or one elements.
 inline constexpr auto yield_if = []<class T>(bool b, T x) {
     return b ?
-           smd::optional::optional<T>{move(x)} :
-           smd::optional::nullopt;
+           beman::optional::optional<T>{move(x)} :
+           beman::optional::nullopt;
 };
 
 
@@ -850,14 +850,14 @@ TEST(ViewMaybeTest, PythTripleTest) {
     ASSERT_EQ(*std::ranges::begin(triples), std::make_tuple(3, 4, 5));
 }
 
-using namespace smd;
+using namespace beman;
 
 TEST(ViewMaybeTest, ValueBase) {
     int             i = 7;
-    smd::optional::optional<int> v1{};
+    beman::optional::optional<int> v1{};
     // ASSERT_TRUE(v1.size() == 0);
 
-    smd::optional::optional<int> v2{i};
+    beman::optional::optional<int> v2{i};
     // ASSERT_TRUE(v2.size() == 1);
     for (auto i : v1)
         ASSERT_TRUE(i != i); // tautology so i is used and not warned
@@ -881,7 +881,7 @@ TEST(ViewMaybeTest, ValueBase) {
 TEST(ViewMaybeTest, RefWrapper) {
     int i = 7;
 
-    smd::optional::optional<int> v2{std::ref(i)};
+    beman::optional::optional<int> v2{std::ref(i)};
 
     for (auto i : v2)
         ASSERT_EQ(i, 7);
@@ -898,16 +898,16 @@ TEST(ViewMaybeTest, RefWrapper) {
 
 TEST(ViewMaybeTest, ValueNonDefaultConstruct) {
     NoDefault             i = 7;
-    smd::optional::optional<NoDefault> v1{};
-    smd::optional::optional<NoDefault> v2{i};
+    beman::optional::optional<NoDefault> v1{};
+    beman::optional::optional<NoDefault> v2{i};
 }
 
 TEST(ViewMaybeTest, RefBase) {
     int              i = 7;
-    smd::optional::optional<int&> v1{};
+    beman::optional::optional<int&> v1{};
     // ASSERT_TRUE(v1.size() == 0);
 
-    smd::optional::optional<int&> v2{i};
+    beman::optional::optional<int&> v2{i};
     // ASSERT_TRUE(v2.size() == 1);
     for (auto i : v1)
         ASSERT_TRUE(i != i); // tautology so i is used and not warned
@@ -934,7 +934,7 @@ TEST(ViewMaybeTest, RefBase) {
     // }
     // ASSERT_EQ(s, 4);
 
-    for (auto&& i : smd::optional::optional<int&>(s)) {
+    for (auto&& i : beman::optional::optional<int&>(s)) {
         ASSERT_EQ(i, 4);
         i = 9;
         ASSERT_EQ(i, 9);
@@ -943,8 +943,8 @@ TEST(ViewMaybeTest, RefBase) {
 }
 
 // TEST(ViewMaybeTest, MonadicAndThen) {
-//     smd::optional::optional<int> mv{40};
-//     auto            r = mv.and_then([](int i) { return smd::optional::optional{i + 2}; });
+//     beman::optional::optional<int> mv{40};
+//     auto            r = mv.and_then([](int i) { return beman::optional::optional{i + 2}; });
 //     ASSERT_TRUE(!r.empty());
 //     ASSERT_TRUE(r.size() == 1);
 //     ASSERT_TRUE(r.data() != nullptr);
@@ -952,28 +952,28 @@ TEST(ViewMaybeTest, RefBase) {
 //     ASSERT_TRUE(!mv.empty());
 //     ASSERT_TRUE(*(mv.data()) == 40);
 
-//     auto r2 = mv.and_then([](int) { return smd::optional::optional<int>{}; });
+//     auto r2 = mv.and_then([](int) { return beman::optional::optional<int>{}; });
 //     ASSERT_TRUE(r2.empty());
 //     ASSERT_TRUE(r2.size() == 0);
 //     ASSERT_TRUE(r2.data() == nullptr);
 //     ASSERT_TRUE(!mv.empty());
 //     ASSERT_TRUE(*(mv.data()) == 40);
 
-//     smd::optional::optional<int> empty{};
+//     beman::optional::optional<int> empty{};
 
-//     auto r3 = empty.and_then([](int i) { return smd::optional::optional{i + 2}; });
+//     auto r3 = empty.and_then([](int i) { return beman::optional::optional{i + 2}; });
 //     ASSERT_TRUE(r3.empty());
 //     ASSERT_TRUE(r3.size() == 0);
 //     ASSERT_TRUE(r3.data() == nullptr);
 //     ASSERT_TRUE(empty.empty());
 
-//     auto r4 = mv.and_then([](double d) { return smd::optional::optional{d + 2}; });
+//     auto r4 = mv.and_then([](double d) { return beman::optional::optional{d + 2}; });
 //     ASSERT_TRUE(!r4.empty());
 //     ASSERT_TRUE(r4.size() == 1);
 //     ASSERT_TRUE(*(r4.data()) == 42.0);
-//     static_assert(std::is_same_v<decltype(r4), smd::optional::optional<double>>);
+//     static_assert(std::is_same_v<decltype(r4), beman::optional::optional<double>>);
 
-//     auto r5 = std::move(mv).and_then([](int i) { return smd::optional::optional{i + 2}; });
+//     auto r5 = std::move(mv).and_then([](int i) { return beman::optional::optional{i + 2}; });
 //     ASSERT_TRUE(!r5.empty());
 //     ASSERT_TRUE(r5.size() == 1);
 //     ASSERT_TRUE(r5.data() != nullptr);
@@ -984,7 +984,7 @@ TEST(ViewMaybeTest, RefBase) {
 //     auto r6 = std::move(mv).and_then([](int&& i) {
 //         int k = i;
 //         i     = 0;
-//         return smd::optional::optional{k + 2};
+//         return beman::optional::optional{k + 2};
 //     });
 //     ASSERT_TRUE(!r6.empty());
 //     ASSERT_TRUE(r6.size() == 1);
@@ -993,8 +993,8 @@ TEST(ViewMaybeTest, RefBase) {
 //     ASSERT_TRUE(!mv.empty());
 //     ASSERT_TRUE(*(mv.data()) == 0);
 
-//     const smd::optional::optional<int> cmv{40};
-//     auto r7 = cmv.and_then([](int i) { return smd::optional::optional{i + 2}; });
+//     const beman::optional::optional<int> cmv{40};
+//     auto r7 = cmv.and_then([](int i) { return beman::optional::optional{i + 2}; });
 //     ASSERT_TRUE(!r7.empty());
 //     ASSERT_TRUE(r7.size() == 1);
 //     ASSERT_TRUE(r7.data() != nullptr);
@@ -1002,7 +1002,7 @@ TEST(ViewMaybeTest, RefBase) {
 //     ASSERT_TRUE(!cmv.empty());
 //     ASSERT_TRUE(*(cmv.data()) == 40);
 
-//     auto r8 = std::move(cmv).and_then([](int i) { return smd::optional::optional{i + 2}; });
+//     auto r8 = std::move(cmv).and_then([](int i) { return beman::optional::optional{i + 2}; });
 //     ASSERT_TRUE(!r8.empty());
 //     ASSERT_TRUE(r8.size() == 1);
 //     ASSERT_TRUE(r8.data() != nullptr);
@@ -1012,7 +1012,7 @@ TEST(ViewMaybeTest, RefBase) {
 // }
 
 // TEST(MaybeView, MonadicTransform) {
-//     smd::optional::optional<int> mv{40};
+//     beman::optional::optional<int> mv{40};
 //     auto            r = mv.transform([](int i) { return i + 2; });
 //     ASSERT_TRUE(!r.empty());
 //     ASSERT_TRUE(r.size() == 1);
@@ -1032,7 +1032,7 @@ TEST(ViewMaybeTest, RefBase) {
 //     ASSERT_TRUE(!mv.empty());
 //     ASSERT_TRUE(*(mv.data()) == 42);
 
-//     smd::optional::optional<int> empty{};
+//     beman::optional::optional<int> empty{};
 
 //     auto r3 = empty.transform([](int i) { return i + 2; });
 //     ASSERT_TRUE(r3.empty());
@@ -1044,7 +1044,7 @@ TEST(ViewMaybeTest, RefBase) {
 //     ASSERT_TRUE(!r4.empty());
 //     ASSERT_TRUE(r4.size() == 1);
 //     ASSERT_TRUE(*(r4.data()) == 44.0);
-//     static_assert(std::is_same_v<decltype(r4), smd::optional::optional<double>>);
+//     static_assert(std::is_same_v<decltype(r4), beman::optional::optional<double>>);
 
 //     auto r5 = std::move(mv).transform([](int i) { return i + 2; });
 //     ASSERT_TRUE(!r5.empty());
@@ -1066,7 +1066,7 @@ TEST(ViewMaybeTest, RefBase) {
 //     ASSERT_TRUE(!mv.empty());
 //     ASSERT_TRUE(*(mv.data()) == 0);
 
-//     const smd::optional::optional<int> cmv{40};
+//     const beman::optional::optional<int> cmv{40};
 //     auto                  r7 = cmv.transform([](int i) { return i + 2; });
 //     ASSERT_TRUE(!r7.empty());
 //     ASSERT_TRUE(r7.size() == 1);
@@ -1085,25 +1085,25 @@ TEST(ViewMaybeTest, RefBase) {
 // }
 
 // TEST(MaybeView, MonadicOrElse) {
-//     smd::optional::optional<int> o1(42);
-//     auto            r = o1.or_else([] { return smd::optional::optional<int>(13); });
+//     beman::optional::optional<int> o1(42);
+//     auto            r = o1.or_else([] { return beman::optional::optional<int>(13); });
 //     ASSERT_TRUE(*(r.data()) == 42);
 
-//     smd::optional::optional<int> o2;
-//     ASSERT_TRUE(*(o2.or_else([] { return smd::optional::optional<int>(13); })).data() ==
+//     beman::optional::optional<int> o2;
+//     ASSERT_TRUE(*(o2.or_else([] { return beman::optional::optional<int>(13); })).data() ==
 //                 13);
 
-//     auto r2 = std::move(o1).or_else([] { return smd::optional::optional<int>(13); });
+//     auto r2 = std::move(o1).or_else([] { return beman::optional::optional<int>(13); });
 //     ASSERT_TRUE(*(r2.data()) == 42);
 
-//     auto r3 = std::move(o2).or_else([] { return smd::optional::optional<int>(13); });
+//     auto r3 = std::move(o2).or_else([] { return beman::optional::optional<int>(13); });
 //     ASSERT_TRUE(*(r3.data()) == 13);
 // }
 
 // TEST(ViewMaybeTest, MonadicAndThenRef) {
 //     int              forty{40};
-//     smd::optional::optional<int&> mv{forty};
-//     auto             r = mv.and_then([](int i) { return smd::optional::optional{i + 2}; });
+//     beman::optional::optional<int&> mv{forty};
+//     auto             r = mv.and_then([](int i) { return beman::optional::optional{i + 2}; });
 //     ASSERT_TRUE(!r.empty());
 //     ASSERT_TRUE(r.size() == 1);
 //     ASSERT_TRUE(r.data() != nullptr);
@@ -1111,28 +1111,28 @@ TEST(ViewMaybeTest, RefBase) {
 //     ASSERT_TRUE(!mv.empty());
 //     ASSERT_TRUE(*(mv.data()) == 40);
 
-//     auto r2 = mv.and_then([](int) { return smd::optional::optional<int&>{}; });
+//     auto r2 = mv.and_then([](int) { return beman::optional::optional<int&>{}; });
 //     ASSERT_TRUE(r2.empty());
 //     ASSERT_TRUE(r2.size() == 0);
 //     ASSERT_TRUE(r2.data() == nullptr);
 //     ASSERT_TRUE(!mv.empty());
 //     ASSERT_TRUE(*(mv.data()) == 40);
 
-//     smd::optional::optional<int&> empty{};
+//     beman::optional::optional<int&> empty{};
 
-//     auto r3 = empty.and_then([](int i) { return smd::optional::optional{i + 2}; });
+//     auto r3 = empty.and_then([](int i) { return beman::optional::optional{i + 2}; });
 //     ASSERT_TRUE(r3.empty());
 //     ASSERT_TRUE(r3.size() == 0);
 //     ASSERT_TRUE(r3.data() == nullptr);
 //     ASSERT_TRUE(empty.empty());
 
-//     auto r4 = mv.and_then([](double d) { return smd::optional::optional{d + 2}; });
+//     auto r4 = mv.and_then([](double d) { return beman::optional::optional{d + 2}; });
 //     ASSERT_TRUE(!r4.empty());
 //     ASSERT_TRUE(r4.size() == 1);
 //     ASSERT_TRUE(*(r4.data()) == 42.0);
-//     static_assert(std::is_same_v<decltype(r4), smd::optional::optional<double>>);
+//     static_assert(std::is_same_v<decltype(r4), beman::optional::optional<double>>);
 
-//     auto r5 = std::move(mv).and_then([](int i) { return smd::optional::optional{i + 2}; });
+//     auto r5 = std::move(mv).and_then([](int i) { return beman::optional::optional{i + 2}; });
 //     ASSERT_TRUE(!r5.empty());
 //     ASSERT_TRUE(r5.size() == 1);
 //     ASSERT_TRUE(r5.data() != nullptr);
@@ -1143,7 +1143,7 @@ TEST(ViewMaybeTest, RefBase) {
 //     auto r6 = std::move(mv).and_then([](int&& i) {
 //         int k = i;
 //         i     = 0;
-//         return smd::optional::optional{k + 2};
+//         return beman::optional::optional{k + 2};
 //     });
 //     ASSERT_TRUE(!r6.empty());
 //     ASSERT_TRUE(r6.size() == 1);
@@ -1154,8 +1154,8 @@ TEST(ViewMaybeTest, RefBase) {
 //     ASSERT_EQ(forty, 0);
 //     forty = 40;
 
-//     const smd::optional::optional<int&> cmv{forty};
-//     auto r7 = cmv.and_then([](int i) { return smd::optional::optional{i + 2}; });
+//     const beman::optional::optional<int&> cmv{forty};
+//     auto r7 = cmv.and_then([](int i) { return beman::optional::optional{i + 2}; });
 //     ASSERT_TRUE(!r7.empty());
 //     ASSERT_TRUE(r7.size() == 1);
 //     ASSERT_TRUE(r7.data() != nullptr);
@@ -1163,7 +1163,7 @@ TEST(ViewMaybeTest, RefBase) {
 //     ASSERT_TRUE(!cmv.empty());
 //     ASSERT_TRUE(*(cmv.data()) == 40);
 
-//     auto r8 = std::move(cmv).and_then([](int i) { return smd::optional::optional{i + 2}; });
+//     auto r8 = std::move(cmv).and_then([](int i) { return beman::optional::optional{i + 2}; });
 //     ASSERT_TRUE(!r8.empty());
 //     ASSERT_TRUE(r8.size() == 1);
 //     ASSERT_TRUE(r8.data() != nullptr);
@@ -1174,7 +1174,7 @@ TEST(ViewMaybeTest, RefBase) {
 
 // TEST(MaybeView, MonadicTransformRef) {
 //     int              forty{40};
-//     smd::optional::optional<int&> mv{forty};
+//     beman::optional::optional<int&> mv{forty};
 //     auto             r = mv.transform([](int i) { return i + 2; });
 //     ASSERT_TRUE(!r.empty());
 //     ASSERT_TRUE(r.size() == 1);
@@ -1183,7 +1183,7 @@ TEST(ViewMaybeTest, RefBase) {
 //     ASSERT_TRUE(!mv.empty());
 //     ASSERT_TRUE(*(mv.data()) == 40);
 
-//     smd::optional::optional<int&> empty{};
+//     beman::optional::optional<int&> empty{};
 
 //     auto r3 = empty.transform([](int i) { return i + 2; });
 //     ASSERT_TRUE(r3.empty());
@@ -1195,7 +1195,7 @@ TEST(ViewMaybeTest, RefBase) {
 //     ASSERT_TRUE(!r4.empty());
 //     ASSERT_TRUE(r4.size() == 1);
 //     ASSERT_TRUE(*(r4.data()) == 42.0);
-//     static_assert(std::is_same_v<decltype(r4), smd::optional::optional<double>>);
+//     static_assert(std::is_same_v<decltype(r4), beman::optional::optional<double>>);
 
 //     auto r5 = std::move(mv).transform([](int i) { return i + 2; });
 //     ASSERT_TRUE(!r5.empty());
@@ -1219,7 +1219,7 @@ TEST(ViewMaybeTest, RefBase) {
 //     ASSERT_EQ(forty, 0);
 //     forty = 40;
 
-//     const smd::optional::optional<int&> cmv{forty};
+//     const beman::optional::optional<int&> cmv{forty};
 //     ASSERT_EQ(*(cmv.data()), 40);
 //     auto r7 = cmv.transform([](int i) { return i + 2; });
 //     ASSERT_TRUE(!r7.empty());
@@ -1259,20 +1259,20 @@ TEST(ViewMaybeTest, RefBase) {
 // TEST(MaybeView, MonadicOrElseRef) {
 //     int              fortytwo{42};
 //     int              thirteen{13};
-//     smd::optional::optional<int&> o1(fortytwo);
-//     auto r = o1.or_else([&thirteen] { return smd::optional::optional<int&>(thirteen); });
+//     beman::optional::optional<int&> o1(fortytwo);
+//     auto r = o1.or_else([&thirteen] { return beman::optional::optional<int&>(thirteen); });
 //     ASSERT_TRUE(*(r.data()) == 42);
 
-//     smd::optional::optional<int&> o2;
+//     beman::optional::optional<int&> o2;
 //     ASSERT_TRUE(*(o2.or_else([&thirteen] {
-//                      return smd::optional::optional<int&>(thirteen);
+//                      return beman::optional::optional<int&>(thirteen);
 //                  })).data() == 13);
 
 //     auto r2 = std::move(o1).or_else(
-//         [&thirteen] { return smd::optional::optional<int&>(thirteen); });
+//         [&thirteen] { return beman::optional::optional<int&>(thirteen); });
 //     ASSERT_TRUE(*(r2.data()) == 42);
 
 //     auto r3 = std::move(o2).or_else(
-//         [&thirteen] { return smd::optional::optional<int&>(thirteen); });
+//         [&thirteen] { return beman::optional::optional<int&>(thirteen); });
 //     ASSERT_TRUE(*(r3.data()) == 13);
 // }
diff --git a/src/beman/optional/optional_monadic.t.cpp b/src/beman/optional/optional_monadic.t.cpp
new file mode 100644
index 00000000..d6dcc394
--- /dev/null
+++ b/src/beman/optional/optional_monadic.t.cpp
@@ -0,0 +1,315 @@
+#include <beman/optional/optional.h>
+
+#include <beman/optional/optional.h>
+
+#include <gtest/gtest.h>
+
+constexpr int get_int(int) { return 42; }
+constexpr beman::optional::optional<int> get_opt_int(int) { return 42; }
+
+
+TEST(OptionalMonadicTest, Transform) {
+  // lhs is empty
+    beman::optional::optional<int> o1;
+    auto o1r = o1.transform([](int i) { return i + 2; });
+    static_assert((std::is_same<decltype(o1r), beman::optional::optional<int>>::value));
+    EXPECT_TRUE(!o1r);
+
+    // lhs has value
+    beman::optional::optional<int> o2 = 40;
+    auto o2r = o2.transform([](int i) { return i + 2; });
+    static_assert((std::is_same<decltype(o2r), beman::optional::optional<int>>::value));
+    EXPECT_TRUE(o2r.value() == 42);
+
+    struct rval_call_transform {
+      double operator()(int) && { return 42.0; };
+    };
+
+    // ensure that function object is forwarded
+    beman::optional::optional<int> o3 = 42;
+    auto o3r = o3.transform(rval_call_transform{});
+    static_assert((std::is_same<decltype(o3r), beman::optional::optional<double>>::value));
+    EXPECT_TRUE(o3r.value() == 42);
+
+    // ensure that lhs is forwarded
+    beman::optional::optional<int> o4 = 40;
+    auto o4r = std::move(o4).transform([](int &&i) { return i + 2; });
+    static_assert((std::is_same<decltype(o4r), beman::optional::optional<int>>::value));
+    EXPECT_TRUE(o4r.value() == 42);
+
+    // ensure that lhs is const-propagated
+    const beman::optional::optional<int> o5 = 40;
+    auto o5r = o5.transform([](const int &i) { return i + 2; });
+    static_assert((std::is_same<decltype(o5r), beman::optional::optional<int>>::value));
+    EXPECT_TRUE(o5r.value() == 42);
+
+
+    // test each overload in turn
+    beman::optional::optional<int> o8 = 42;
+    auto o8r = o8.transform([](int) { return 42; });
+    EXPECT_TRUE(*o8r == 42);
+
+    beman::optional::optional<int> o12 = 42;
+    auto o12r = std::move(o12).transform([](int) { return 42; });
+    EXPECT_TRUE(*o12r == 42);
+
+    const beman::optional::optional<int> o16 = 42;
+    auto o16r = o16.transform([](int) { return 42; });
+    EXPECT_TRUE(*o16r == 42);
+
+    const beman::optional::optional<int> o20 = 42;
+    auto o20r = std::move(o20).transform([](int) { return 42; });
+    EXPECT_TRUE(*o20r == 42);
+
+    beman::optional::optional<int> o24 = beman::optional::nullopt;
+    auto o24r = o24.transform([](int) { return 42; });
+    EXPECT_TRUE(!o24r);
+
+    beman::optional::optional<int> o28 = beman::optional::nullopt;
+    auto o28r = std::move(o28).transform([](int) { return 42; });
+    EXPECT_TRUE(!o28r);
+
+    const beman::optional::optional<int> o32 = beman::optional::nullopt;
+    auto o32r = o32.transform([](int) { return 42; });
+    EXPECT_TRUE(!o32r);
+
+    const beman::optional::optional<int> o36 = beman::optional::nullopt;
+    auto o36r = std::move(o36).transform([](int) { return 42; });
+    EXPECT_TRUE(!o36r);
+
+    // callable which returns a reference
+    beman::optional::optional<int> o38 = 42;
+    auto o38r = o38.transform([](int &i) -> const int & { return i; });
+    EXPECT_TRUE(o38r);
+    EXPECT_TRUE(*o38r == 42);
+
+  }
+
+TEST(OptionalMonadicTest, TransformConstexpr) {
+
+    // test each overload in turn
+    constexpr beman::optional::optional<int> o16 = 42;
+    constexpr auto o16r = o16.transform(get_int);
+    static_assert(*o16r == 42);
+
+    constexpr beman::optional::optional<int> o20 = 42;
+    constexpr auto o20r = std::move(o20).transform(get_int);
+    static_assert(*o20r == 42);
+
+    constexpr beman::optional::optional<int> o32 = beman::optional::nullopt;
+    constexpr auto o32r = o32.transform(get_int);
+    static_assert(!o32r);
+    constexpr beman::optional::optional<int> o36 = beman::optional::nullopt;
+    constexpr auto o36r = std::move(o36).transform(get_int);
+    static_assert(!o36r);
+  }
+
+TEST(OptionalMonadicTest, Transform2) {
+  // lhs is empty
+    beman::optional::optional<int> o1;
+    auto o1r = o1.transform([](int i) { return i + 2; });
+    static_assert((std::is_same<decltype(o1r), beman::optional::optional<int>>::value));
+    EXPECT_TRUE(!o1r);
+
+    // lhs has value
+    beman::optional::optional<int> o2 = 40;
+    auto o2r = o2.transform([](int i) { return i + 2; });
+    static_assert((std::is_same<decltype(o2r), beman::optional::optional<int>>::value));
+    EXPECT_TRUE(o2r.value() == 42);
+
+    struct rval_call_transform {
+      double operator()(int) && { return 42.0; };
+    };
+
+    // ensure that function object is forwarded
+    beman::optional::optional<int> o3 = 42;
+    auto o3r = o3.transform(rval_call_transform{});
+    static_assert((std::is_same<decltype(o3r), beman::optional::optional<double>>::value));
+    EXPECT_TRUE(o3r.value() == 42);
+
+    // ensure that lhs is forwarded
+    beman::optional::optional<int> o4 = 40;
+    auto o4r = std::move(o4).transform([](int&& i) { return i + 2; });
+    static_assert((std::is_same<decltype(o4r), beman::optional::optional<int>>::value));
+    EXPECT_TRUE(o4r.value() == 42);
+
+    // ensure that lhs is const-propagated
+    const beman::optional::optional<int> o5 = 40;
+    auto o5r = o5.transform([](const int& i) { return i + 2; });
+    static_assert((std::is_same<decltype(o5r), beman::optional::optional<int>>::value));
+    EXPECT_TRUE(o5r.value() == 42);
+
+    // test each overload in turn
+    beman::optional::optional<int> o8 = 42;
+    auto o8r = o8.transform([](int) { return 42; });
+    EXPECT_TRUE(*o8r == 42);
+
+    beman::optional::optional<int> o12 = 42;
+    auto o12r = std::move(o12).transform([](int) { return 42; });
+    EXPECT_TRUE(*o12r == 42);
+
+    const beman::optional::optional<int> o16 = 42;
+    auto o16r = o16.transform([](int) { return 42; });
+    EXPECT_TRUE(*o16r == 42);
+
+    const beman::optional::optional<int> o20 = 42;
+    auto o20r = std::move(o20).transform([](int) { return 42; });
+    EXPECT_TRUE(*o20r == 42);
+
+    beman::optional::optional<int> o24 = beman::optional::nullopt;
+    auto o24r = o24.transform([](int) { return 42; });
+    EXPECT_TRUE(!o24r);
+
+    beman::optional::optional<int> o28 = beman::optional::nullopt;
+    auto o28r = std::move(o28).transform([](int) { return 42; });
+    EXPECT_TRUE(!o28r);
+
+    const beman::optional::optional<int> o32 = beman::optional::nullopt;
+    auto o32r = o32.transform([](int) { return 42; });
+    EXPECT_TRUE(!o32r);
+
+    const beman::optional::optional<int> o36 = beman::optional::nullopt;
+    auto o36r = std::move(o36).transform([](int) { return 42; });
+    EXPECT_TRUE(!o36r);
+  }
+
+TEST(OptionalMonadicTest, TransformConstxpr)
+ {
+    // test each overload in turn
+    constexpr beman::optional::optional<int> o16 = 42;
+    constexpr auto o16r = o16.transform(get_int);
+    static_assert(*o16r == 42);
+
+    constexpr beman::optional::optional<int> o20 = 42;
+    constexpr auto o20r = std::move(o20).transform(get_int);
+    static_assert(*o20r == 42);
+
+    constexpr beman::optional::optional<int> o32 = beman::optional::nullopt;
+    constexpr auto o32r = o32.transform(get_int);
+    static_assert(!o32r);
+    constexpr beman::optional::optional<int> o36 = beman::optional::nullopt;
+    constexpr auto o36r = std::move(o36).transform(get_int);
+    static_assert(!o36r);
+  }
+
+TEST(OptionalMonadicTest, and_then)
+ {
+    // lhs is empty
+    beman::optional::optional<int> o1;
+    auto o1r = o1.and_then([](int) { return beman::optional::optional<float>{42}; });
+    static_assert((std::is_same<decltype(o1r), beman::optional::optional<float>>::value));
+    EXPECT_TRUE(!o1r);
+
+    // lhs has value
+    beman::optional::optional<int> o2 = 12;
+    auto o2r = o2.and_then([](int) { return beman::optional::optional<float>{42}; });
+    static_assert((std::is_same<decltype(o2r), beman::optional::optional<float>>::value));
+    EXPECT_TRUE(o2r.value() == 42.f);
+
+    // lhs is empty, rhs returns empty
+    beman::optional::optional<int> o3;
+    auto o3r = o3.and_then([](int) { return beman::optional::optional<float>{}; });
+    static_assert((std::is_same<decltype(o3r), beman::optional::optional<float>>::value));
+    EXPECT_TRUE(!o3r);
+
+    // rhs returns empty
+    beman::optional::optional<int> o4 = 12;
+    auto o4r = o4.and_then([](int) { return beman::optional::optional<float>{}; });
+    static_assert((std::is_same<decltype(o4r), beman::optional::optional<float>>::value));
+    EXPECT_TRUE(!o4r);
+
+    struct rval_call_and_then {
+      beman::optional::optional<double> operator()(int) && {
+        return beman::optional::optional<double>(42.0);
+      };
+    };
+
+    // ensure that function object is forwarded
+    beman::optional::optional<int> o5 = 42;
+    auto o5r = o5.and_then(rval_call_and_then{});
+    static_assert((std::is_same<decltype(o5r), beman::optional::optional<double>>::value));
+    EXPECT_TRUE(o5r.value() == 42);
+
+    // ensure that lhs is forwarded
+    beman::optional::optional<int> o6 = 42;
+    auto o6r =
+        std::move(o6).and_then([](int &&i) { return beman::optional::optional<double>(i); });
+    static_assert((std::is_same<decltype(o6r), beman::optional::optional<double>>::value));
+    EXPECT_TRUE(o6r.value() == 42);
+
+    // ensure that function object is const-propagated
+    const beman::optional::optional<int> o7 = 42;
+    auto o7r =
+        o7.and_then([](const int &i) { return beman::optional::optional<double>(i); });
+    static_assert((std::is_same<decltype(o7r), beman::optional::optional<double>>::value));
+    EXPECT_TRUE(o7r.value() == 42);
+
+    // test each overload in turn
+    beman::optional::optional<int> o8 = 42;
+    auto o8r = o8.and_then([](int) { return beman::optional::make_optional(42); });
+    EXPECT_TRUE(*o8r == 42);
+
+    beman::optional::optional<int> o9 = 42;
+    auto o9r =
+        std::move(o9).and_then([](int) { return beman::optional::make_optional(42); });
+    EXPECT_TRUE(*o9r == 42);
+
+    const beman::optional::optional<int> o10 = 42;
+    auto o10r = o10.and_then([](int) { return beman::optional::make_optional(42); });
+    EXPECT_TRUE(*o10r == 42);
+
+    const beman::optional::optional<int> o11 = 42;
+    auto o11r =
+        std::move(o11).and_then([](int) { return beman::optional::make_optional(42); });
+    EXPECT_TRUE(*o11r == 42);
+
+    beman::optional::optional<int> o16 = beman::optional::nullopt;
+    auto o16r = o16.and_then([](int) { return beman::optional::make_optional(42); });
+    EXPECT_TRUE(!o16r);
+
+    beman::optional::optional<int> o17 = beman::optional::nullopt;
+    auto o17r =
+        std::move(o17).and_then([](int) { return beman::optional::make_optional(42); });
+    EXPECT_TRUE(!o17r);
+
+    const beman::optional::optional<int> o18 = beman::optional::nullopt;
+    auto o18r = o18.and_then([](int) { return beman::optional::make_optional(42); });
+    EXPECT_TRUE(!o18r);
+
+    const beman::optional::optional<int> o19 = beman::optional::nullopt;
+    auto o19r = std::move(o19).and_then([](int) { return beman::optional::make_optional(42); });
+    EXPECT_TRUE(!o19r);
+
+    int i = 3;
+    beman::optional::optional<int&> o20{i};
+    std::move(o20).and_then([](int& r){return beman::optional::optional<int&>{++r};});
+    EXPECT_TRUE(o20);
+    EXPECT_TRUE(i == 4);
+  }
+
+TEST(OptionalMonadicTest, Constexpr_and_then)
+{
+    constexpr beman::optional::optional<int> o10 = 42;
+    constexpr auto o10r = o10.and_then(get_opt_int);
+    EXPECT_TRUE(*o10r == 42);
+
+    constexpr beman::optional::optional<int> o11 = 42;
+    constexpr auto o11r = std::move(o11).and_then(get_opt_int);
+    EXPECT_TRUE(*o11r == 42);
+
+    constexpr beman::optional::optional<int> o18 = beman::optional::nullopt;
+    constexpr auto o18r = o18.and_then(get_opt_int);
+    EXPECT_TRUE(!o18r);
+
+    constexpr beman::optional::optional<int> o19 = beman::optional::nullopt;
+    constexpr auto o19r = std::move(o19).and_then(get_opt_int);
+    EXPECT_TRUE(!o19r);
+  }
+
+TEST(OptionalMonadicTest, or_else){
+    beman::optional::optional<int> o1 = 42;
+    EXPECT_TRUE(*(o1.or_else([] { return beman::optional::make_optional(13); })) == 42);
+
+    beman::optional::optional<int> o2;
+    EXPECT_EQ(*(o2.or_else([] { return beman::optional::make_optional(13); })),  13);
+  }
diff --git a/src/smd/optional/optional_ref.t.cpp b/src/beman/optional/optional_ref.t.cpp
similarity index 54%
rename from src/smd/optional/optional_ref.t.cpp
rename to src/beman/optional/optional_ref.t.cpp
index 4e1b5665..35979ec0 100644
--- a/src/smd/optional/optional_ref.t.cpp
+++ b/src/beman/optional/optional_ref.t.cpp
@@ -1,6 +1,6 @@
-#include <smd/optional/optional.h>
+#include <beman/optional/optional.h>
 
-#include <smd/optional/optional.h>
+#include <beman/optional/optional.h>
 
 #include <gtest/gtest.h>
 
@@ -31,54 +31,54 @@ struct derived : public base {
 } // namespace
 
 TEST(OptionalRefTest, Constructors) {
-    smd::optional::optional<int&> i1;
-    smd::optional::optional<int&> i2{smd::optional::nullopt};
+    beman::optional::optional<int&> i1;
+    beman::optional::optional<int&> i2{beman::optional::nullopt};
     (void)i1;
     (void)i2;
 
     int                           i  = 0;
-    smd::optional::optional<int&> i3 = i;
+    beman::optional::optional<int&> i3 = i;
     (void)i3;
 
-    smd::optional::optional<empty&> e1;
-    smd::optional::optional<empty&> e2{smd::optional::nullopt};
+    beman::optional::optional<empty&> e1;
+    beman::optional::optional<empty&> e2{beman::optional::nullopt};
     (void)e1;
     (void)e2;
 
     empty                           e{};
-    smd::optional::optional<empty&> e3 = e;
+    beman::optional::optional<empty&> e3 = e;
     (void)e3;
 
-    smd::optional::optional<no_default&> nd1;
-    smd::optional::optional<no_default&> nd2{smd::optional::nullopt};
+    beman::optional::optional<no_default&> nd1;
+    beman::optional::optional<no_default&> nd2{beman::optional::nullopt};
     (void)nd1;
     (void)nd2;
 
     no_default nd{e};
 
-    smd::optional::optional<no_default&> nd3 = nd;
+    beman::optional::optional<no_default&> nd3 = nd;
     (void)nd3;
 
-    smd::optional::optional<int&> ie;
-    smd::optional::optional<int&> i4 = ie;
+    beman::optional::optional<int&> ie;
+    beman::optional::optional<int&> i4 = ie;
     EXPECT_FALSE(i4);
 
     base                           b{1};
     derived                        d(1, 2);
-    smd::optional::optional<base&> b1 = b;
-    smd::optional::optional<base&> b2 = d;
+    beman::optional::optional<base&> b1 = b;
+    beman::optional::optional<base&> b2 = d;
 
-    smd::optional::optional<derived&> d2 = d;
-    smd::optional::optional<base&>    b3 = d2;
-    smd::optional::optional<base&>    b4{d2};
+    beman::optional::optional<derived&> d2 = d;
+    beman::optional::optional<base&>    b3 = d2;
+    beman::optional::optional<base&>    b4{d2};
 
-    smd::optional::optional<derived&> empty;
-    smd::optional::optional<base&> fromEmpty(empty);
-    smd::optional::optional<base&> fromEmpty2 = empty;
+    beman::optional::optional<derived&> empty;
+    beman::optional::optional<base&> fromEmpty(empty);
+    beman::optional::optional<base&> fromEmpty2 = empty;
 }
 
 TEST(OptionalRefTest, Assignment) {
-    smd::optional::optional<int&> i1;
+    beman::optional::optional<int&> i1;
     EXPECT_FALSE(i1);
     int i = 5;
     i1    = i;
@@ -88,13 +88,13 @@ TEST(OptionalRefTest, Assignment) {
 
     double d;
     // i1 = d;  // ill-formed by mandate
-    smd::optional::optional<double&> d1 = d;
+    beman::optional::optional<double&> d1 = d;
     // i1 = d1; // ill-formed by mandate
-    smd::optional::optional<int&> i2 = i1;
+    beman::optional::optional<int&> i2 = i1;
     EXPECT_TRUE(i2);
     EXPECT_TRUE(*i2 = 7);
 
-    smd::optional::optional<int&> empty;
+    beman::optional::optional<int&> empty;
     EXPECT_FALSE(empty);
     i2 = empty;
     EXPECT_FALSE(i2);
@@ -107,9 +107,9 @@ TEST(OptionalRefTest, Assignment) {
 TEST(OptionalRefTest, RelationalOps) {
     int                           i1 = 4;
     int                           i2 = 42;
-    smd::optional::optional<int&> o1{i1};
-    smd::optional::optional<int&> o2{i2};
-    smd::optional::optional<int&> o3{};
+    beman::optional::optional<int&> o1{i1};
+    beman::optional::optional<int&> o2{i2};
+    beman::optional::optional<int&> o3{};
 
     //  SECTION("self simple")
     {
@@ -128,31 +128,31 @@ TEST(OptionalRefTest, RelationalOps) {
     }
     //  SECTION("nullopt simple")
     {
-        EXPECT_TRUE(!(o1 == smd::optional::nullopt));
-        EXPECT_TRUE(!(smd::optional::nullopt == o1));
-        EXPECT_TRUE(o1 != smd::optional::nullopt);
-        EXPECT_TRUE(smd::optional::nullopt != o1);
-        EXPECT_TRUE(!(o1 < smd::optional::nullopt));
-        EXPECT_TRUE(smd::optional::nullopt < o1);
-        EXPECT_TRUE(o1 > smd::optional::nullopt);
-        EXPECT_TRUE(!(smd::optional::nullopt > o1));
-        EXPECT_TRUE(!(o1 <= smd::optional::nullopt));
-        EXPECT_TRUE(smd::optional::nullopt <= o1);
-        EXPECT_TRUE(o1 >= smd::optional::nullopt);
-        EXPECT_TRUE(!(smd::optional::nullopt >= o1));
-
-        EXPECT_TRUE(o3 == smd::optional::nullopt);
-        EXPECT_TRUE(smd::optional::nullopt == o3);
-        EXPECT_TRUE(!(o3 != smd::optional::nullopt));
-        EXPECT_TRUE(!(smd::optional::nullopt != o3));
-        EXPECT_TRUE(!(o3 < smd::optional::nullopt));
-        EXPECT_TRUE(!(smd::optional::nullopt < o3));
-        EXPECT_TRUE(!(o3 > smd::optional::nullopt));
-        EXPECT_TRUE(!(smd::optional::nullopt > o3));
-        EXPECT_TRUE(o3 <= smd::optional::nullopt);
-        EXPECT_TRUE(smd::optional::nullopt <= o3);
-        EXPECT_TRUE(o3 >= smd::optional::nullopt);
-        EXPECT_TRUE(smd::optional::nullopt >= o3);
+        EXPECT_TRUE(!(o1 == beman::optional::nullopt));
+        EXPECT_TRUE(!(beman::optional::nullopt == o1));
+        EXPECT_TRUE(o1 != beman::optional::nullopt);
+        EXPECT_TRUE(beman::optional::nullopt != o1);
+        EXPECT_TRUE(!(o1 < beman::optional::nullopt));
+        EXPECT_TRUE(beman::optional::nullopt < o1);
+        EXPECT_TRUE(o1 > beman::optional::nullopt);
+        EXPECT_TRUE(!(beman::optional::nullopt > o1));
+        EXPECT_TRUE(!(o1 <= beman::optional::nullopt));
+        EXPECT_TRUE(beman::optional::nullopt <= o1);
+        EXPECT_TRUE(o1 >= beman::optional::nullopt);
+        EXPECT_TRUE(!(beman::optional::nullopt >= o1));
+
+        EXPECT_TRUE(o3 == beman::optional::nullopt);
+        EXPECT_TRUE(beman::optional::nullopt == o3);
+        EXPECT_TRUE(!(o3 != beman::optional::nullopt));
+        EXPECT_TRUE(!(beman::optional::nullopt != o3));
+        EXPECT_TRUE(!(o3 < beman::optional::nullopt));
+        EXPECT_TRUE(!(beman::optional::nullopt < o3));
+        EXPECT_TRUE(!(o3 > beman::optional::nullopt));
+        EXPECT_TRUE(!(beman::optional::nullopt > o3));
+        EXPECT_TRUE(o3 <= beman::optional::nullopt);
+        EXPECT_TRUE(beman::optional::nullopt <= o3);
+        EXPECT_TRUE(o3 >= beman::optional::nullopt);
+        EXPECT_TRUE(beman::optional::nullopt >= o3);
     }
     //  SECTION("with T simple")
     {
@@ -184,8 +184,8 @@ TEST(OptionalRefTest, RelationalOps) {
     }
     std::string                           s4 = "hello";
     std::string                           s5 = "xyz";
-    smd::optional::optional<std::string&> o4{s4};
-    smd::optional::optional<std::string&> o5{s5};
+    beman::optional::optional<std::string&> o4{s4};
+    beman::optional::optional<std::string&> o5{s5};
 
     //  SECTION("self complex")
     {
@@ -204,31 +204,31 @@ TEST(OptionalRefTest, RelationalOps) {
     }
     //  SECTION("nullopt complex")
     {
-        EXPECT_TRUE(!(o4 == smd::optional::nullopt));
-        EXPECT_TRUE(!(smd::optional::nullopt == o4));
-        EXPECT_TRUE(o4 != smd::optional::nullopt);
-        EXPECT_TRUE(smd::optional::nullopt != o4);
-        EXPECT_TRUE(!(o4 < smd::optional::nullopt));
-        EXPECT_TRUE(smd::optional::nullopt < o4);
-        EXPECT_TRUE(o4 > smd::optional::nullopt);
-        EXPECT_TRUE(!(smd::optional::nullopt > o4));
-        EXPECT_TRUE(!(o4 <= smd::optional::nullopt));
-        EXPECT_TRUE(smd::optional::nullopt <= o4);
-        EXPECT_TRUE(o4 >= smd::optional::nullopt);
-        EXPECT_TRUE(!(smd::optional::nullopt >= o4));
-
-        EXPECT_TRUE(o3 == smd::optional::nullopt);
-        EXPECT_TRUE(smd::optional::nullopt == o3);
-        EXPECT_TRUE(!(o3 != smd::optional::nullopt));
-        EXPECT_TRUE(!(smd::optional::nullopt != o3));
-        EXPECT_TRUE(!(o3 < smd::optional::nullopt));
-        EXPECT_TRUE(!(smd::optional::nullopt < o3));
-        EXPECT_TRUE(!(o3 > smd::optional::nullopt));
-        EXPECT_TRUE(!(smd::optional::nullopt > o3));
-        EXPECT_TRUE(o3 <= smd::optional::nullopt);
-        EXPECT_TRUE(smd::optional::nullopt <= o3);
-        EXPECT_TRUE(o3 >= smd::optional::nullopt);
-        EXPECT_TRUE(smd::optional::nullopt >= o3);
+        EXPECT_TRUE(!(o4 == beman::optional::nullopt));
+        EXPECT_TRUE(!(beman::optional::nullopt == o4));
+        EXPECT_TRUE(o4 != beman::optional::nullopt);
+        EXPECT_TRUE(beman::optional::nullopt != o4);
+        EXPECT_TRUE(!(o4 < beman::optional::nullopt));
+        EXPECT_TRUE(beman::optional::nullopt < o4);
+        EXPECT_TRUE(o4 > beman::optional::nullopt);
+        EXPECT_TRUE(!(beman::optional::nullopt > o4));
+        EXPECT_TRUE(!(o4 <= beman::optional::nullopt));
+        EXPECT_TRUE(beman::optional::nullopt <= o4);
+        EXPECT_TRUE(o4 >= beman::optional::nullopt);
+        EXPECT_TRUE(!(beman::optional::nullopt >= o4));
+
+        EXPECT_TRUE(o3 == beman::optional::nullopt);
+        EXPECT_TRUE(beman::optional::nullopt == o3);
+        EXPECT_TRUE(!(o3 != beman::optional::nullopt));
+        EXPECT_TRUE(!(beman::optional::nullopt != o3));
+        EXPECT_TRUE(!(o3 < beman::optional::nullopt));
+        EXPECT_TRUE(!(beman::optional::nullopt < o3));
+        EXPECT_TRUE(!(o3 > beman::optional::nullopt));
+        EXPECT_TRUE(!(beman::optional::nullopt > o3));
+        EXPECT_TRUE(o3 <= beman::optional::nullopt);
+        EXPECT_TRUE(beman::optional::nullopt <= o3);
+        EXPECT_TRUE(o3 >= beman::optional::nullopt);
+        EXPECT_TRUE(beman::optional::nullopt >= o3);
     }
 
     //  SECTION("with T complex")
@@ -262,11 +262,11 @@ TEST(OptionalRefTest, RelationalOps) {
 }
 
 TEST(OptionalRefTest, Triviality) {
-    EXPECT_TRUE(std::is_trivially_copy_constructible<smd::optional::optional<int&>>::value);
-    EXPECT_TRUE(std::is_trivially_copy_assignable<smd::optional::optional<int&>>::value);
-    EXPECT_TRUE(std::is_trivially_move_constructible<smd::optional::optional<int&>>::value);
-    EXPECT_TRUE(std::is_trivially_move_assignable<smd::optional::optional<int&>>::value);
-    EXPECT_TRUE(std::is_trivially_destructible<smd::optional::optional<int&>>::value);
+    EXPECT_TRUE(std::is_trivially_copy_constructible<beman::optional::optional<int&>>::value);
+    EXPECT_TRUE(std::is_trivially_copy_assignable<beman::optional::optional<int&>>::value);
+    EXPECT_TRUE(std::is_trivially_move_constructible<beman::optional::optional<int&>>::value);
+    EXPECT_TRUE(std::is_trivially_move_assignable<beman::optional::optional<int&>>::value);
+    EXPECT_TRUE(std::is_trivially_destructible<beman::optional::optional<int&>>::value);
 
     {
         struct T {
@@ -276,11 +276,11 @@ TEST(OptionalRefTest, Triviality) {
             T& operator=(T&&)      = default;
             ~T()                   = default;
         };
-        EXPECT_TRUE(std::is_trivially_copy_constructible<smd::optional::optional<T&>>::value);
-        EXPECT_TRUE(std::is_trivially_copy_assignable<smd::optional::optional<T&>>::value);
-        EXPECT_TRUE(std::is_trivially_move_constructible<smd::optional::optional<T&>>::value);
-        EXPECT_TRUE(std::is_trivially_move_assignable<smd::optional::optional<T&>>::value);
-        EXPECT_TRUE(std::is_trivially_destructible<smd::optional::optional<T&>>::value);
+        EXPECT_TRUE(std::is_trivially_copy_constructible<beman::optional::optional<T&>>::value);
+        EXPECT_TRUE(std::is_trivially_copy_assignable<beman::optional::optional<T&>>::value);
+        EXPECT_TRUE(std::is_trivially_move_constructible<beman::optional::optional<T&>>::value);
+        EXPECT_TRUE(std::is_trivially_move_assignable<beman::optional::optional<T&>>::value);
+        EXPECT_TRUE(std::is_trivially_destructible<beman::optional::optional<T&>>::value);
     }
 
     {
@@ -291,20 +291,20 @@ TEST(OptionalRefTest, Triviality) {
             T& operator=(T&&) { return *this; };
             ~T() {}
         };
-        EXPECT_TRUE(std::is_trivially_copy_constructible<smd::optional::optional<T&>>::value);
-        EXPECT_TRUE(std::is_trivially_copy_assignable<smd::optional::optional<T&>>::value);
-        EXPECT_TRUE(std::is_trivially_move_constructible<smd::optional::optional<T&>>::value);
-        EXPECT_TRUE(std::is_trivially_move_assignable<smd::optional::optional<T&>>::value);
-        EXPECT_TRUE(std::is_trivially_destructible<smd::optional::optional<T&>>::value);
+        EXPECT_TRUE(std::is_trivially_copy_constructible<beman::optional::optional<T&>>::value);
+        EXPECT_TRUE(std::is_trivially_copy_assignable<beman::optional::optional<T&>>::value);
+        EXPECT_TRUE(std::is_trivially_move_constructible<beman::optional::optional<T&>>::value);
+        EXPECT_TRUE(std::is_trivially_move_assignable<beman::optional::optional<T&>>::value);
+        EXPECT_TRUE(std::is_trivially_destructible<beman::optional::optional<T&>>::value);
     }
 }
 
 TEST(OptionalRefTest, Deletion) {
-    EXPECT_TRUE(std::is_copy_constructible<smd::optional::optional<int&>>::value);
-    EXPECT_TRUE(std::is_copy_assignable<smd::optional::optional<int&>>::value);
-    EXPECT_TRUE(std::is_move_constructible<smd::optional::optional<int&>>::value);
-    EXPECT_TRUE(std::is_move_assignable<smd::optional::optional<int&>>::value);
-    EXPECT_TRUE(std::is_destructible<smd::optional::optional<int&>>::value);
+    EXPECT_TRUE(std::is_copy_constructible<beman::optional::optional<int&>>::value);
+    EXPECT_TRUE(std::is_copy_assignable<beman::optional::optional<int&>>::value);
+    EXPECT_TRUE(std::is_move_constructible<beman::optional::optional<int&>>::value);
+    EXPECT_TRUE(std::is_move_assignable<beman::optional::optional<int&>>::value);
+    EXPECT_TRUE(std::is_destructible<beman::optional::optional<int&>>::value);
 
     {
         struct T {
@@ -314,11 +314,11 @@ TEST(OptionalRefTest, Deletion) {
             T& operator=(T&&)      = default;
             ~T()                   = default;
         };
-        EXPECT_TRUE(std::is_copy_constructible<smd::optional::optional<T&>>::value);
-        EXPECT_TRUE(std::is_copy_assignable<smd::optional::optional<T&>>::value);
-        EXPECT_TRUE(std::is_move_constructible<smd::optional::optional<T&>>::value);
-        EXPECT_TRUE(std::is_move_assignable<smd::optional::optional<T&>>::value);
-        EXPECT_TRUE(std::is_destructible<smd::optional::optional<T&>>::value);
+        EXPECT_TRUE(std::is_copy_constructible<beman::optional::optional<T&>>::value);
+        EXPECT_TRUE(std::is_copy_assignable<beman::optional::optional<T&>>::value);
+        EXPECT_TRUE(std::is_move_constructible<beman::optional::optional<T&>>::value);
+        EXPECT_TRUE(std::is_move_assignable<beman::optional::optional<T&>>::value);
+        EXPECT_TRUE(std::is_destructible<beman::optional::optional<T&>>::value);
     }
 
     {
@@ -328,10 +328,10 @@ TEST(OptionalRefTest, Deletion) {
             T& operator=(const T&) = delete;
             T& operator=(T&&)      = delete;
         };
-        EXPECT_TRUE(std::is_copy_constructible<smd::optional::optional<T&>>::value);
-        EXPECT_TRUE(std::is_copy_assignable<smd::optional::optional<T&>>::value);
-        EXPECT_TRUE(std::is_move_constructible<smd::optional::optional<T&>>::value);
-        EXPECT_TRUE(std::is_move_assignable<smd::optional::optional<T&>>::value);
+        EXPECT_TRUE(std::is_copy_constructible<beman::optional::optional<T&>>::value);
+        EXPECT_TRUE(std::is_copy_assignable<beman::optional::optional<T&>>::value);
+        EXPECT_TRUE(std::is_move_constructible<beman::optional::optional<T&>>::value);
+        EXPECT_TRUE(std::is_move_assignable<beman::optional::optional<T&>>::value);
     }
 
     {
@@ -341,10 +341,10 @@ TEST(OptionalRefTest, Deletion) {
             T& operator=(const T&) = delete;
             T& operator=(T&&)      = default;
         };
-        EXPECT_TRUE(std::is_copy_constructible<smd::optional::optional<T&>>::value);
-        EXPECT_TRUE(std::is_copy_assignable<smd::optional::optional<T&>>::value);
-        EXPECT_TRUE(std::is_move_constructible<smd::optional::optional<T&>>::value);
-        EXPECT_TRUE(std::is_move_assignable<smd::optional::optional<T&>>::value);
+        EXPECT_TRUE(std::is_copy_constructible<beman::optional::optional<T&>>::value);
+        EXPECT_TRUE(std::is_copy_assignable<beman::optional::optional<T&>>::value);
+        EXPECT_TRUE(std::is_move_constructible<beman::optional::optional<T&>>::value);
+        EXPECT_TRUE(std::is_move_assignable<beman::optional::optional<T&>>::value);
     }
 
     {
@@ -354,8 +354,8 @@ TEST(OptionalRefTest, Deletion) {
             T& operator=(const T&) = default;
             T& operator=(T&&)      = delete;
         };
-        EXPECT_TRUE(std::is_copy_constructible<smd::optional::optional<T&>>::value);
-        EXPECT_TRUE(std::is_copy_assignable<smd::optional::optional<T&>>::value);
+        EXPECT_TRUE(std::is_copy_constructible<beman::optional::optional<T&>>::value);
+        EXPECT_TRUE(std::is_copy_assignable<beman::optional::optional<T&>>::value);
     }
 }
 
@@ -368,55 +368,55 @@ struct takes_init_and_variadic {
 
 TEST(OptionalRefTest, MakeOptional) {
     int  var{42};
-    auto o1 = smd::optional::make_optional<int&>(var);
-    auto o2 = smd::optional::optional<int&>(var);
+    auto o1 = beman::optional::make_optional<int&>(var);
+    auto o2 = beman::optional::optional<int&>(var);
 
-    constexpr bool is_same = std::is_same<decltype(o1), smd::optional::optional<int>>::value;
+    constexpr bool is_same = std::is_same<decltype(o1), beman::optional::optional<int>>::value;
     EXPECT_TRUE(is_same);
     EXPECT_TRUE(o1 == o2);
 
     std::tuple<int, int, int, int> tvar{0, 1, 2, 3};
-    auto o3 = smd::optional::make_optional<std::tuple<int, int, int, int>&>(tvar);
+    auto o3 = beman::optional::make_optional<std::tuple<int, int, int, int>&>(tvar);
     EXPECT_TRUE(std::get<0>(*o3) == 0);
     EXPECT_TRUE(std::get<1>(*o3) == 1);
     EXPECT_TRUE(std::get<2>(*o3) == 2);
     EXPECT_TRUE(std::get<3>(*o3) == 3);
 
     std::vector<int> ivec{0, 1, 2, 3};
-    auto o4 = smd::optional::make_optional<std::vector<int>&>(ivec);
+    auto o4 = beman::optional::make_optional<std::vector<int>&>(ivec);
     EXPECT_TRUE(o4.value()[0] == 0);
     EXPECT_TRUE(o4.value()[1] == 1);
     EXPECT_TRUE(o4.value()[2] == 2);
     EXPECT_TRUE(o4.value()[3] == 3);
 
     takes_init_and_variadic tiv{{0, 1}, 2, 3};
-    auto o5 = smd::optional::make_optional<takes_init_and_variadic&>(tiv);
+    auto o5 = beman::optional::make_optional<takes_init_and_variadic&>(tiv);
     EXPECT_TRUE(o5->v[0] == 0);
     EXPECT_TRUE(o5->v[1] == 1);
     EXPECT_TRUE(std::get<0>(o5->t) == 2);
     EXPECT_TRUE(std::get<1>(o5->t) == 3);
 
     auto i  = 42;
-    auto o6 = smd::optional::make_optional<int&>(i);
-    static_assert(std::is_same_v<decltype(o6), smd::optional::optional<int>>);
+    auto o6 = beman::optional::make_optional<int&>(i);
+    static_assert(std::is_same_v<decltype(o6), beman::optional::optional<int>>);
 
-    EXPECT_TRUE((std::is_same_v<decltype(o6), smd::optional::optional<int>>));
+    EXPECT_TRUE((std::is_same_v<decltype(o6), beman::optional::optional<int>>));
     EXPECT_TRUE(o6);
     EXPECT_TRUE(*o6 == 42);
 }
 
 TEST(OptionalRefTest, Nullopt) {
-    smd::optional::optional<int&> o1 = smd::optional::nullopt;
-    smd::optional::optional<int&> o2{smd::optional::nullopt};
-    smd::optional::optional<int&> o3(smd::optional::nullopt);
-    smd::optional::optional<int&> o4 = {smd::optional::nullopt};
+    beman::optional::optional<int&> o1 = beman::optional::nullopt;
+    beman::optional::optional<int&> o2{beman::optional::nullopt};
+    beman::optional::optional<int&> o3(beman::optional::nullopt);
+    beman::optional::optional<int&> o4 = {beman::optional::nullopt};
 
     EXPECT_TRUE(!o1);
     EXPECT_TRUE(!o2);
     EXPECT_TRUE(!o3);
     EXPECT_TRUE(!o4);
 
-    EXPECT_TRUE(!std::is_default_constructible<smd::optional::nullopt_t>::value);
+    EXPECT_TRUE(!std::is_default_constructible<beman::optional::nullopt_t>::value);
 }
 
 struct move_detector {
@@ -427,10 +427,10 @@ struct move_detector {
 
 TEST(OptionalRefTest, Observers) {
     int                                 var = 42;
-    smd::optional::optional<int&>       o1  = var;
-    smd::optional::optional<int&>       o2;
-    const smd::optional::optional<int&> o3 = var;
-    const smd::optional::optional<int&> o4;
+    beman::optional::optional<int&>       o1  = var;
+    beman::optional::optional<int&>       o2;
+    const beman::optional::optional<int&> o3 = var;
+    const beman::optional::optional<int&> o4;
     int var2 = 42;
     int var3 = 6*9;
     EXPECT_TRUE(*o1 == 42);
@@ -445,9 +445,9 @@ TEST(OptionalRefTest, Observers) {
     // EXPECT_TRUE(j == 88);
     int var99 = 99;
     j = 88;
-    EXPECT_TRUE([&](){smd::optional::optional<int&> o(j);return o; }().value_or(var99) == 88);
+    EXPECT_TRUE([&](){beman::optional::optional<int&> o(j);return o; }().value_or(var99) == 88);
 
-    EXPECT_TRUE([&](){smd::optional::optional<int&> o;return o; }().value_or(var99) == 99);
+    EXPECT_TRUE([&](){beman::optional::optional<int&> o;return o; }().value_or(var99) == 99);
 
 
     EXPECT_TRUE(o3.value_or([&]()->int&{return var3;}()) == 42);
@@ -455,8 +455,8 @@ TEST(OptionalRefTest, Observers) {
 
     std::string meow{"meow"};
     std::string bark{"bark"};
-    smd::optional::optional<std::string&> so1;
-    smd::optional::optional<std::string&> so2{meow};
+    beman::optional::optional<std::string&> so1;
+    beman::optional::optional<std::string&> so2{meow};
     auto t1 = so1.value_or(bark);
     auto t2 = so2.value_or(bark);
     // auto t3 = so1.value_or("bark");
@@ -504,9 +504,9 @@ TEST(OptionalRefTest, Observers) {
 
     struct int_box {int i_;};
     int_box i1{3};
-    smd::optional::optional<int_box&>       ob1  = i1;
-    smd::optional::optional<int_box&>       ob2;
-    const smd::optional::optional<int_box&> ob3 = i1;
+    beman::optional::optional<int_box&>       ob1  = i1;
+    beman::optional::optional<int_box&>       ob2;
+    const beman::optional::optional<int_box&> ob3 = i1;
     success = std::is_same<decltype(ob1->i_), int>::value;
     static_assert(std::is_same<decltype(ob1->i_), int>::value);
     EXPECT_TRUE(success);
@@ -524,10 +524,10 @@ TEST(OptionalRefTest, Observers) {
 
 TEST(OptionalRefTest, MoveCheck) {
     int x = 0;
-    int& y =  std::move(smd::optional::optional<int&>(x)).value();
+    int& y =  std::move(beman::optional::optional<int&>(x)).value();
     EXPECT_EQ(&y, &x);
 
-    int& z =  *std::move(smd::optional::optional<int&>(x));
+    int& z =  *std::move(beman::optional::optional<int&>(x));
     EXPECT_EQ(&z, &x);
 
 }
@@ -535,8 +535,8 @@ TEST(OptionalRefTest, MoveCheck) {
 TEST(OptionalRefTest, SwapValue) {
     int                           var    = 42;
     int                           twelve = 12;
-    smd::optional::optional<int&> o1     = var;
-    smd::optional::optional<int&> o2     = twelve;
+    beman::optional::optional<int&> o1     = var;
+    beman::optional::optional<int&> o2     = twelve;
     o1.swap(o2);
     EXPECT_EQ(o1.value(), 12);
     EXPECT_EQ(o2.value(), 42);
@@ -545,8 +545,8 @@ TEST(OptionalRefTest, SwapValue) {
 TEST(OptionalRefTest, SwapWNull) {
     int var = 42;
 
-    smd::optional::optional<int&> o1 = var;
-    smd::optional::optional<int&> o2 = smd::optional::nullopt;
+    beman::optional::optional<int&> o1 = var;
+    beman::optional::optional<int&> o2 = beman::optional::nullopt;
     o1.swap(o2);
     EXPECT_TRUE(!o1.has_value());
     EXPECT_EQ(o2.value(), 42);
@@ -554,8 +554,8 @@ TEST(OptionalRefTest, SwapWNull) {
 
 TEST(OptionalRefTest, SwapNullIntializedWithValue) {
     int                           var = 42;
-    smd::optional::optional<int&> o1  = smd::optional::nullopt;
-    smd::optional::optional<int&> o2  = var;
+    beman::optional::optional<int&> o1  = beman::optional::nullopt;
+    beman::optional::optional<int&> o2  = var;
     o1.swap(o2);
     EXPECT_EQ(o1.value(), 42);
     EXPECT_TRUE(!o2.has_value());
diff --git a/src/smd/optional/optional_ref_monadic.t.cpp b/src/beman/optional/optional_ref_monadic.t.cpp
similarity index 55%
rename from src/smd/optional/optional_ref_monadic.t.cpp
rename to src/beman/optional/optional_ref_monadic.t.cpp
index 68acba49..4f63882d 100644
--- a/src/smd/optional/optional_ref_monadic.t.cpp
+++ b/src/beman/optional/optional_ref_monadic.t.cpp
@@ -1,27 +1,27 @@
-#include <smd/optional/optional.h>
+#include <beman/optional/optional.h>
 
-#include <smd/optional/optional.h>
+#include <beman/optional/optional.h>
 
 #include <gtest/gtest.h>
 
 namespace {
 inline constexpr int                          constexpr_fortytwo = 42;
 constexpr int                                 get_int(int) { return constexpr_fortytwo; }
-constexpr smd::optional::optional<const int&> get_opt_int(int) { return constexpr_fortytwo; }
+constexpr beman::optional::optional<const int&> get_opt_int(int) { return constexpr_fortytwo; }
 } // namespace
 
 TEST(OptionalRefMonadicTest, Transform) {
     // lhs is empty
-    smd::optional::optional<int&> o1;
+    beman::optional::optional<int&> o1;
     auto                          o1r = o1.transform([](int i) { return i + 2; });
-    static_assert((std::is_same<decltype(o1r), smd::optional::optional<int>>::value));
+    static_assert((std::is_same<decltype(o1r), beman::optional::optional<int>>::value));
     EXPECT_TRUE(!o1r);
 
     // lhs has value
     int                           forty = 40;
-    smd::optional::optional<int&> o2    = forty;
+    beman::optional::optional<int&> o2    = forty;
     auto                          o2r   = o2.transform([](int i) { return i + 2; });
-    static_assert((std::is_same<decltype(o2r), smd::optional::optional<int>>::value));
+    static_assert((std::is_same<decltype(o2r), beman::optional::optional<int>>::value));
     EXPECT_TRUE(o2r.value() == 42);
 
     struct rval_call_transform {
@@ -30,61 +30,61 @@ TEST(OptionalRefMonadicTest, Transform) {
 
     // ensure that function object is forwarded
     int                           fortytwo = 42;
-    smd::optional::optional<int&> o3       = fortytwo;
+    beman::optional::optional<int&> o3       = fortytwo;
     auto                          o3r      = o3.transform(rval_call_transform{});
-    static_assert((std::is_same<decltype(o3r), smd::optional::optional<double>>::value));
+    static_assert((std::is_same<decltype(o3r), beman::optional::optional<double>>::value));
     EXPECT_TRUE(o3r.value() == 42);
 
     // // ensure that lhs is forwarded
     // forty = 40;
-    // smd::optional::optional<int&> o4 = forty;
+    // beman::optional::optional<int&> o4 = forty;
     // auto o4r = std::move(o4).transform([](int &&i) { return i + 2; });
-    // static_assert((std::is_same<decltype(o4r), smd::optional::optional<int&>>::value));
+    // static_assert((std::is_same<decltype(o4r), beman::optional::optional<int&>>::value));
     // EXPECT_TRUE(o4r.value() == 42);
 
     // ensure that lhs is const-propagated
     forty                                   = 40;
-    const smd::optional::optional<int&> o5  = forty;
+    const beman::optional::optional<int&> o5  = forty;
     auto                                o5r = o5.transform([](const int& i) { return i + 2; });
-    static_assert((std::is_same<decltype(o5r), smd::optional::optional<int>>::value));
+    static_assert((std::is_same<decltype(o5r), beman::optional::optional<int>>::value));
     EXPECT_TRUE(o5r.value() == 42);
 
     // test each overload in turn
     fortytwo                          = 42;
-    smd::optional::optional<int&> o8  = fortytwo;
+    beman::optional::optional<int&> o8  = fortytwo;
     auto                          o8r = o8.transform([](int) { return 42; });
     EXPECT_TRUE(*o8r == 42);
 
-    smd::optional::optional<int&> o12  = fortytwo;
+    beman::optional::optional<int&> o12  = fortytwo;
     auto                          o12r = std::move(o12).transform([](int) { return 42; });
     EXPECT_TRUE(*o12r == 42);
 
-    const smd::optional::optional<int&> o16  = fortytwo;
+    const beman::optional::optional<int&> o16  = fortytwo;
     auto                                o16r = o16.transform([](int) { return 42; });
     EXPECT_TRUE(*o16r == 42);
 
-    const smd::optional::optional<int&> o20  = fortytwo;
+    const beman::optional::optional<int&> o20  = fortytwo;
     auto                                o20r = std::move(o20).transform([](int) { return 42; });
     EXPECT_TRUE(*o20r == 42);
 
-    smd::optional::optional<int&> o24  = smd::optional::nullopt;
+    beman::optional::optional<int&> o24  = beman::optional::nullopt;
     auto                          o24r = o24.transform([](int) { return 42; });
     EXPECT_TRUE(!o24r);
 
-    smd::optional::optional<int&> o28  = smd::optional::nullopt;
+    beman::optional::optional<int&> o28  = beman::optional::nullopt;
     auto                          o28r = std::move(o28).transform([](int) { return 42; });
     EXPECT_TRUE(!o28r);
 
-    const smd::optional::optional<int&> o32  = smd::optional::nullopt;
+    const beman::optional::optional<int&> o32  = beman::optional::nullopt;
     auto                                o32r = o32.transform([](int) { return 42; });
     EXPECT_TRUE(!o32r);
 
-    const smd::optional::optional<int&> o36  = smd::optional::nullopt;
+    const beman::optional::optional<int&> o36  = beman::optional::nullopt;
     auto                                o36r = std::move(o36).transform([](int) { return 42; });
     EXPECT_TRUE(!o36r);
 
     // callable which returns a reference
-    smd::optional::optional<int&> o38  = fortytwo;
+    beman::optional::optional<int&> o38  = fortytwo;
     auto                          o38r = o38.transform([](int& i) -> const int& { return i; });
     EXPECT_TRUE(o38r);
     EXPECT_TRUE(*o38r == 42);
@@ -93,34 +93,34 @@ TEST(OptionalRefMonadicTest, Transform) {
 TEST(OptionalRefMonadicTest, TransformConstexpr) {
 
     // test each overload in turn
-    constexpr smd::optional::optional<const int&> o16  = constexpr_fortytwo;
+    constexpr beman::optional::optional<const int&> o16  = constexpr_fortytwo;
     constexpr auto                                o16r = o16.transform(get_int);
     static_assert(*o16r == 42);
 
-    constexpr smd::optional::optional<const int&> o20  = constexpr_fortytwo;
+    constexpr beman::optional::optional<const int&> o20  = constexpr_fortytwo;
     constexpr auto                                o20r = std::move(o20).transform(get_int);
     static_assert(*o20r == 42);
 
-    constexpr smd::optional::optional<int&> o32  = smd::optional::nullopt;
+    constexpr beman::optional::optional<int&> o32  = beman::optional::nullopt;
     constexpr auto                          o32r = o32.transform(get_int);
     static_assert(!o32r);
-    constexpr smd::optional::optional<int&> o36  = smd::optional::nullopt;
+    constexpr beman::optional::optional<int&> o36  = beman::optional::nullopt;
     constexpr auto                          o36r = std::move(o36).transform(get_int);
     static_assert(!o36r);
 }
 
 TEST(OptionalRefMonadicTest, Transform2) {
     // lhs is empty
-    smd::optional::optional<int&> o1;
+    beman::optional::optional<int&> o1;
     auto                          o1r = o1.transform([](int i) { return i + 2; });
-    static_assert((std::is_same<decltype(o1r), smd::optional::optional<int>>::value));
+    static_assert((std::is_same<decltype(o1r), beman::optional::optional<int>>::value));
     EXPECT_TRUE(!o1r);
 
     // lhs has value
     int                           forty = 40;
-    smd::optional::optional<int&> o2    = forty;
+    beman::optional::optional<int&> o2    = forty;
     auto                          o2r   = o2.transform([](int i) { return i + 2; });
-    static_assert((std::is_same<decltype(o2r), smd::optional::optional<int>>::value));
+    static_assert((std::is_same<decltype(o2r), beman::optional::optional<int>>::value));
     EXPECT_TRUE(o2r.value() == 42);
 
     struct rval_call_transform {
@@ -129,182 +129,182 @@ TEST(OptionalRefMonadicTest, Transform2) {
 
     // ensure that function object is forwarded
     int                           fortytwo = 42;
-    smd::optional::optional<int&> o3       = fortytwo;
+    beman::optional::optional<int&> o3       = fortytwo;
     auto                          o3r      = o3.transform(rval_call_transform{});
-    static_assert((std::is_same<decltype(o3r), smd::optional::optional<double>>::value));
+    static_assert((std::is_same<decltype(o3r), beman::optional::optional<double>>::value));
     EXPECT_TRUE(o3r.value() == 42);
 
     // // ensure that lhs is forwarded
     // int forty = 40;
-    // smd::optional::optional<int&> o4 = forty;
+    // beman::optional::optional<int&> o4 = forty;
     // auto o4r = std::move(o4).transform([](int&& i) { return i + 2; });
-    // static_assert((std::is_same<decltype(o4r), smd::optional::optional<int&>>::value));
+    // static_assert((std::is_same<decltype(o4r), beman::optional::optional<int&>>::value));
     // EXPECT_TRUE(o4r.value() == 42);
 
     // ensure that lhs is const-propagated
     forty                                   = 40;
-    const smd::optional::optional<int&> o5  = forty;
+    const beman::optional::optional<int&> o5  = forty;
     auto                                o5r = o5.transform([](const int& i) { return i + 2; });
-    static_assert((std::is_same<decltype(o5r), smd::optional::optional<int>>::value));
+    static_assert((std::is_same<decltype(o5r), beman::optional::optional<int>>::value));
     EXPECT_TRUE(o5r.value() == 42);
 
     // test each overload in turn
     fortytwo                          = 42;
-    smd::optional::optional<int&> o8  = fortytwo;
+    beman::optional::optional<int&> o8  = fortytwo;
     auto                          o8r = o8.transform([](int) { return 42; });
     EXPECT_TRUE(*o8r == 42);
 
-    smd::optional::optional<int&> o12  = fortytwo;
+    beman::optional::optional<int&> o12  = fortytwo;
     auto                          o12r = std::move(o12).transform([](int) { return 42; });
     EXPECT_TRUE(*o12r == 42);
 
-    const smd::optional::optional<int&> o16  = fortytwo;
+    const beman::optional::optional<int&> o16  = fortytwo;
     auto                                o16r = o16.transform([](int) { return 42; });
     EXPECT_TRUE(*o16r == 42);
 
-    const smd::optional::optional<int&> o20  = fortytwo;
+    const beman::optional::optional<int&> o20  = fortytwo;
     auto                                o20r = std::move(o20).transform([](int) { return 42; });
     EXPECT_TRUE(*o20r == 42);
 
-    smd::optional::optional<int&> o24  = smd::optional::nullopt;
+    beman::optional::optional<int&> o24  = beman::optional::nullopt;
     auto                          o24r = o24.transform([](int) { return 42; });
     EXPECT_TRUE(!o24r);
 
-    smd::optional::optional<int&> o28  = smd::optional::nullopt;
+    beman::optional::optional<int&> o28  = beman::optional::nullopt;
     auto                          o28r = std::move(o28).transform([](int) { return 42; });
     EXPECT_TRUE(!o28r);
 
-    const smd::optional::optional<int&> o32  = smd::optional::nullopt;
+    const beman::optional::optional<int&> o32  = beman::optional::nullopt;
     auto                                o32r = o32.transform([](int) { return 42; });
     EXPECT_TRUE(!o32r);
 
-    const smd::optional::optional<int&> o36  = smd::optional::nullopt;
+    const beman::optional::optional<int&> o36  = beman::optional::nullopt;
     auto                                o36r = std::move(o36).transform([](int) { return 42; });
     EXPECT_TRUE(!o36r);
 }
 
 TEST(OptionalRefMonadicTest, TransformConstxpr) {
     // test each overload in turn
-    constexpr smd::optional::optional<const int&> o16  = constexpr_fortytwo;
+    constexpr beman::optional::optional<const int&> o16  = constexpr_fortytwo;
     constexpr auto                                o16r = o16.transform(get_int);
     static_assert(*o16r == 42);
 
-    constexpr smd::optional::optional<const int&> o20  = constexpr_fortytwo;
+    constexpr beman::optional::optional<const int&> o20  = constexpr_fortytwo;
     constexpr auto                                o20r = std::move(o20).transform(get_int);
     static_assert(*o20r == 42);
 
-    constexpr smd::optional::optional<const int&> o32  = smd::optional::nullopt;
+    constexpr beman::optional::optional<const int&> o32  = beman::optional::nullopt;
     constexpr auto                                o32r = o32.transform(get_int);
     static_assert(!o32r);
-    constexpr smd::optional::optional<int&> o36  = smd::optional::nullopt;
+    constexpr beman::optional::optional<int&> o36  = beman::optional::nullopt;
     constexpr auto                          o36r = std::move(o36).transform(get_int);
     static_assert(!o36r);
 }
 
 TEST(OptionalRefMonadicTest, and_then) {
     // lhs is empty
-    smd::optional::optional<int&> o1;
-    auto                          o1r = o1.and_then([](int) { return smd::optional::optional<float>{42}; });
-    static_assert((std::is_same<decltype(o1r), smd::optional::optional<float>>::value));
+    beman::optional::optional<int&> o1;
+    auto                          o1r = o1.and_then([](int) { return beman::optional::optional<float>{42}; });
+    static_assert((std::is_same<decltype(o1r), beman::optional::optional<float>>::value));
     EXPECT_TRUE(!o1r);
 
     // lhs has value
     int                           twelve = 12;
-    smd::optional::optional<int&> o2     = twelve;
-    auto                          o2r    = o2.and_then([](int) { return smd::optional::optional<float>{42}; });
-    static_assert((std::is_same<decltype(o2r), smd::optional::optional<float>>::value));
+    beman::optional::optional<int&> o2     = twelve;
+    auto                          o2r    = o2.and_then([](int) { return beman::optional::optional<float>{42}; });
+    static_assert((std::is_same<decltype(o2r), beman::optional::optional<float>>::value));
     EXPECT_TRUE(o2r.value() == 42.f);
 
     // lhs is empty, rhs returns empty
-    smd::optional::optional<int&> o3;
-    auto                          o3r = o3.and_then([](int) { return smd::optional::optional<float>{}; });
-    static_assert((std::is_same<decltype(o3r), smd::optional::optional<float>>::value));
+    beman::optional::optional<int&> o3;
+    auto                          o3r = o3.and_then([](int) { return beman::optional::optional<float>{}; });
+    static_assert((std::is_same<decltype(o3r), beman::optional::optional<float>>::value));
     EXPECT_TRUE(!o3r);
 
     // rhs returns empty
-    smd::optional::optional<int&> o4  = twelve;
-    auto                          o4r = o4.and_then([](int) { return smd::optional::optional<float>{}; });
-    static_assert((std::is_same<decltype(o4r), smd::optional::optional<float>>::value));
+    beman::optional::optional<int&> o4  = twelve;
+    auto                          o4r = o4.and_then([](int) { return beman::optional::optional<float>{}; });
+    static_assert((std::is_same<decltype(o4r), beman::optional::optional<float>>::value));
     EXPECT_TRUE(!o4r);
 
     struct rval_call_and_then {
-        smd::optional::optional<double> operator()(int) && { return smd::optional::optional<double>(42.0); };
+        beman::optional::optional<double> operator()(int) && { return beman::optional::optional<double>(42.0); };
     };
 
     // ensure that function object is forwarded
     int                           fortytwo = 42;
-    smd::optional::optional<int&> o5       = fortytwo;
+    beman::optional::optional<int&> o5       = fortytwo;
     auto                          o5r      = o5.and_then(rval_call_and_then{});
-    static_assert((std::is_same<decltype(o5r), smd::optional::optional<double>>::value));
+    static_assert((std::is_same<decltype(o5r), beman::optional::optional<double>>::value));
     EXPECT_TRUE(o5r.value() == 42);
 
     // // ensure that lhs is forwarded
-    // smd::optional::optional<int&> o6 = fortytwo;
+    // beman::optional::optional<int&> o6 = fortytwo;
     // auto o6r =
-    //     std::move(o6).and_then([](int &&i) { return smd::optional::optional<double>(i); });
-    // static_assert((std::is_same<decltype(o6r), smd::optional::optional<double>>::value));
+    //     std::move(o6).and_then([](int &&i) { return beman::optional::optional<double>(i); });
+    // static_assert((std::is_same<decltype(o6r), beman::optional::optional<double>>::value));
     // EXPECT_TRUE(o6r.value() == 42);
 
     // ensure that function object is const-propagated
-    const smd::optional::optional<int&> o7 = fortytwo;
-    auto o7r = o7.and_then([](const int& i) { return smd::optional::optional<double>(i); });
-    static_assert((std::is_same<decltype(o7r), smd::optional::optional<double>>::value));
+    const beman::optional::optional<int&> o7 = fortytwo;
+    auto o7r = o7.and_then([](const int& i) { return beman::optional::optional<double>(i); });
+    static_assert((std::is_same<decltype(o7r), beman::optional::optional<double>>::value));
     EXPECT_TRUE(o7r.value() == 42);
 
     // test each overload in turn
-    smd::optional::optional<int&> o8  = fortytwo;
-    auto                          o8r = o8.and_then([](int) { return smd::optional::make_optional(42); });
+    beman::optional::optional<int&> o8  = fortytwo;
+    auto                          o8r = o8.and_then([](int) { return beman::optional::make_optional(42); });
     EXPECT_TRUE(*o8r == 42);
 
-    smd::optional::optional<int&> o9  = fortytwo;
-    auto                          o9r = std::move(o9).and_then([](int) { return smd::optional::make_optional(42); });
+    beman::optional::optional<int&> o9  = fortytwo;
+    auto                          o9r = std::move(o9).and_then([](int) { return beman::optional::make_optional(42); });
     EXPECT_TRUE(*o9r == 42);
 
-    const smd::optional::optional<int&> o10  = fortytwo;
-    auto                                o10r = o10.and_then([](int) { return smd::optional::make_optional(42); });
+    const beman::optional::optional<int&> o10  = fortytwo;
+    auto                                o10r = o10.and_then([](int) { return beman::optional::make_optional(42); });
     EXPECT_TRUE(*o10r == 42);
 
-    const smd::optional::optional<int&> o11 = fortytwo;
-    auto o11r = std::move(o11).and_then([](int) { return smd::optional::make_optional(42); });
+    const beman::optional::optional<int&> o11 = fortytwo;
+    auto o11r = std::move(o11).and_then([](int) { return beman::optional::make_optional(42); });
     EXPECT_TRUE(*o11r == 42);
 
-    smd::optional::optional<int&> o16  = smd::optional::nullopt;
-    auto                          o16r = o16.and_then([](int) { return smd::optional::make_optional(42); });
+    beman::optional::optional<int&> o16  = beman::optional::nullopt;
+    auto                          o16r = o16.and_then([](int) { return beman::optional::make_optional(42); });
     EXPECT_TRUE(!o16r);
 
-    smd::optional::optional<int&> o17  = smd::optional::nullopt;
-    auto                          o17r = std::move(o17).and_then([](int) { return smd::optional::make_optional(42); });
+    beman::optional::optional<int&> o17  = beman::optional::nullopt;
+    auto                          o17r = std::move(o17).and_then([](int) { return beman::optional::make_optional(42); });
     EXPECT_TRUE(!o17r);
 
-    const smd::optional::optional<int&> o18  = smd::optional::nullopt;
-    auto                                o18r = o18.and_then([](int) { return smd::optional::make_optional(42); });
+    const beman::optional::optional<int&> o18  = beman::optional::nullopt;
+    auto                                o18r = o18.and_then([](int) { return beman::optional::make_optional(42); });
     EXPECT_TRUE(!o18r);
 
-    const smd::optional::optional<int&> o19 = smd::optional::nullopt;
-    auto o19r = std::move(o19).and_then([](int) { return smd::optional::make_optional(42); });
+    const beman::optional::optional<int&> o19 = beman::optional::nullopt;
+    auto o19r = std::move(o19).and_then([](int) { return beman::optional::make_optional(42); });
     EXPECT_TRUE(!o19r);
 
     int                           i = 3;
-    smd::optional::optional<int&> o20{i};
-    std::move(o20).and_then([](int& r) { return smd::optional::optional<int&>{++r}; });
+    beman::optional::optional<int&> o20{i};
+    std::move(o20).and_then([](int& r) { return beman::optional::optional<int&>{++r}; });
     EXPECT_TRUE(o20);
     EXPECT_TRUE(i == 4);
 }
 
 TEST(OptionalRefMonadicTest, Constexpr_and_then) {
-    constexpr smd::optional::optional<const int&> o10  = constexpr_fortytwo;
+    constexpr beman::optional::optional<const int&> o10  = constexpr_fortytwo;
     constexpr auto                                o10r = o10.and_then(get_opt_int);
     EXPECT_TRUE(*o10r == 42);
 
-    constexpr smd::optional::optional<const int&> o11  = constexpr_fortytwo;
+    constexpr beman::optional::optional<const int&> o11  = constexpr_fortytwo;
     constexpr auto                                o11r = std::move(o11).and_then(get_opt_int);
     EXPECT_TRUE(*o11r == 42);
 
-    constexpr smd::optional::optional<int&> o18  = smd::optional::nullopt;
+    constexpr beman::optional::optional<int&> o18  = beman::optional::nullopt;
     constexpr auto                          o18r = o18.and_then(get_opt_int);
     EXPECT_TRUE(!o18r);
 
-    constexpr smd::optional::optional<int&> o19  = smd::optional::nullopt;
+    constexpr beman::optional::optional<int&> o19  = beman::optional::nullopt;
     constexpr auto                          o19r = std::move(o19).and_then(get_opt_int);
     EXPECT_TRUE(!o19r);
 }
@@ -312,9 +312,9 @@ TEST(OptionalRefMonadicTest, Constexpr_and_then) {
 TEST(OptionalRefMonadicTest, or_else) {
     int                           fortytwo = 42;
     int                           thirteen = 13;
-    smd::optional::optional<int&> o1       = fortytwo;
-    EXPECT_TRUE(*(o1.or_else([&] { return smd::optional::optional<int&>(thirteen); })) == 42);
+    beman::optional::optional<int&> o1       = fortytwo;
+    EXPECT_TRUE(*(o1.or_else([&] { return beman::optional::optional<int&>(thirteen); })) == 42);
 
-    smd::optional::optional<int&> o2;
-    EXPECT_EQ(*(o2.or_else([&] { return smd::optional::optional<int&>(thirteen); })), 13);
+    beman::optional::optional<int&> o2;
+    EXPECT_EQ(*(o2.or_else([&] { return beman::optional::optional<int&>(thirteen); })), 13);
 }
diff --git a/src/examples/before_after.cpp b/src/examples/before_after.cpp
index ce9dc88f..1da59777 100644
--- a/src/examples/before_after.cpp
+++ b/src/examples/before_after.cpp
@@ -1,4 +1,4 @@
-#include <smd/optional/optional.h>
+#include <beman/optional/optional.h>
 
 int main() {
 }
diff --git a/src/examples/main.cpp b/src/examples/main.cpp
index ce9dc88f..1da59777 100644
--- a/src/examples/main.cpp
+++ b/src/examples/main.cpp
@@ -1,4 +1,4 @@
-#include <smd/optional/optional.h>
+#include <beman/optional/optional.h>
 
 int main() {
 }
diff --git a/src/smd/optional/optional.cpp b/src/smd/optional/optional.cpp
deleted file mode 100644
index 89b028f0..00000000
--- a/src/smd/optional/optional.cpp
+++ /dev/null
@@ -1 +0,0 @@
-#include <smd/optional/optional.h>
diff --git a/src/smd/optional/optional_monadic.t.cpp b/src/smd/optional/optional_monadic.t.cpp
deleted file mode 100644
index 939b548a..00000000
--- a/src/smd/optional/optional_monadic.t.cpp
+++ /dev/null
@@ -1,315 +0,0 @@
-#include <smd/optional/optional.h>
-
-#include <smd/optional/optional.h>
-
-#include <gtest/gtest.h>
-
-constexpr int get_int(int) { return 42; }
-constexpr smd::optional::optional<int> get_opt_int(int) { return 42; }
-
-
-TEST(OptionalMonadicTest, Transform) {
-  // lhs is empty
-    smd::optional::optional<int> o1;
-    auto o1r = o1.transform([](int i) { return i + 2; });
-    static_assert((std::is_same<decltype(o1r), smd::optional::optional<int>>::value));
-    EXPECT_TRUE(!o1r);
-
-    // lhs has value
-    smd::optional::optional<int> o2 = 40;
-    auto o2r = o2.transform([](int i) { return i + 2; });
-    static_assert((std::is_same<decltype(o2r), smd::optional::optional<int>>::value));
-    EXPECT_TRUE(o2r.value() == 42);
-
-    struct rval_call_transform {
-      double operator()(int) && { return 42.0; };
-    };
-
-    // ensure that function object is forwarded
-    smd::optional::optional<int> o3 = 42;
-    auto o3r = o3.transform(rval_call_transform{});
-    static_assert((std::is_same<decltype(o3r), smd::optional::optional<double>>::value));
-    EXPECT_TRUE(o3r.value() == 42);
-
-    // ensure that lhs is forwarded
-    smd::optional::optional<int> o4 = 40;
-    auto o4r = std::move(o4).transform([](int &&i) { return i + 2; });
-    static_assert((std::is_same<decltype(o4r), smd::optional::optional<int>>::value));
-    EXPECT_TRUE(o4r.value() == 42);
-
-    // ensure that lhs is const-propagated
-    const smd::optional::optional<int> o5 = 40;
-    auto o5r = o5.transform([](const int &i) { return i + 2; });
-    static_assert((std::is_same<decltype(o5r), smd::optional::optional<int>>::value));
-    EXPECT_TRUE(o5r.value() == 42);
-
-
-    // test each overload in turn
-    smd::optional::optional<int> o8 = 42;
-    auto o8r = o8.transform([](int) { return 42; });
-    EXPECT_TRUE(*o8r == 42);
-
-    smd::optional::optional<int> o12 = 42;
-    auto o12r = std::move(o12).transform([](int) { return 42; });
-    EXPECT_TRUE(*o12r == 42);
-
-    const smd::optional::optional<int> o16 = 42;
-    auto o16r = o16.transform([](int) { return 42; });
-    EXPECT_TRUE(*o16r == 42);
-
-    const smd::optional::optional<int> o20 = 42;
-    auto o20r = std::move(o20).transform([](int) { return 42; });
-    EXPECT_TRUE(*o20r == 42);
-
-    smd::optional::optional<int> o24 = smd::optional::nullopt;
-    auto o24r = o24.transform([](int) { return 42; });
-    EXPECT_TRUE(!o24r);
-
-    smd::optional::optional<int> o28 = smd::optional::nullopt;
-    auto o28r = std::move(o28).transform([](int) { return 42; });
-    EXPECT_TRUE(!o28r);
-
-    const smd::optional::optional<int> o32 = smd::optional::nullopt;
-    auto o32r = o32.transform([](int) { return 42; });
-    EXPECT_TRUE(!o32r);
-
-    const smd::optional::optional<int> o36 = smd::optional::nullopt;
-    auto o36r = std::move(o36).transform([](int) { return 42; });
-    EXPECT_TRUE(!o36r);
-
-    // callable which returns a reference
-    smd::optional::optional<int> o38 = 42;
-    auto o38r = o38.transform([](int &i) -> const int & { return i; });
-    EXPECT_TRUE(o38r);
-    EXPECT_TRUE(*o38r == 42);
-
-  }
-
-TEST(OptionalMonadicTest, TransformConstexpr) {
-
-    // test each overload in turn
-    constexpr smd::optional::optional<int> o16 = 42;
-    constexpr auto o16r = o16.transform(get_int);
-    static_assert(*o16r == 42);
-
-    constexpr smd::optional::optional<int> o20 = 42;
-    constexpr auto o20r = std::move(o20).transform(get_int);
-    static_assert(*o20r == 42);
-
-    constexpr smd::optional::optional<int> o32 = smd::optional::nullopt;
-    constexpr auto o32r = o32.transform(get_int);
-    static_assert(!o32r);
-    constexpr smd::optional::optional<int> o36 = smd::optional::nullopt;
-    constexpr auto o36r = std::move(o36).transform(get_int);
-    static_assert(!o36r);
-  }
-
-TEST(OptionalMonadicTest, Transform2) {
-  // lhs is empty
-    smd::optional::optional<int> o1;
-    auto o1r = o1.transform([](int i) { return i + 2; });
-    static_assert((std::is_same<decltype(o1r), smd::optional::optional<int>>::value));
-    EXPECT_TRUE(!o1r);
-
-    // lhs has value
-    smd::optional::optional<int> o2 = 40;
-    auto o2r = o2.transform([](int i) { return i + 2; });
-    static_assert((std::is_same<decltype(o2r), smd::optional::optional<int>>::value));
-    EXPECT_TRUE(o2r.value() == 42);
-
-    struct rval_call_transform {
-      double operator()(int) && { return 42.0; };
-    };
-
-    // ensure that function object is forwarded
-    smd::optional::optional<int> o3 = 42;
-    auto o3r = o3.transform(rval_call_transform{});
-    static_assert((std::is_same<decltype(o3r), smd::optional::optional<double>>::value));
-    EXPECT_TRUE(o3r.value() == 42);
-
-    // ensure that lhs is forwarded
-    smd::optional::optional<int> o4 = 40;
-    auto o4r = std::move(o4).transform([](int&& i) { return i + 2; });
-    static_assert((std::is_same<decltype(o4r), smd::optional::optional<int>>::value));
-    EXPECT_TRUE(o4r.value() == 42);
-
-    // ensure that lhs is const-propagated
-    const smd::optional::optional<int> o5 = 40;
-    auto o5r = o5.transform([](const int& i) { return i + 2; });
-    static_assert((std::is_same<decltype(o5r), smd::optional::optional<int>>::value));
-    EXPECT_TRUE(o5r.value() == 42);
-
-    // test each overload in turn
-    smd::optional::optional<int> o8 = 42;
-    auto o8r = o8.transform([](int) { return 42; });
-    EXPECT_TRUE(*o8r == 42);
-
-    smd::optional::optional<int> o12 = 42;
-    auto o12r = std::move(o12).transform([](int) { return 42; });
-    EXPECT_TRUE(*o12r == 42);
-
-    const smd::optional::optional<int> o16 = 42;
-    auto o16r = o16.transform([](int) { return 42; });
-    EXPECT_TRUE(*o16r == 42);
-
-    const smd::optional::optional<int> o20 = 42;
-    auto o20r = std::move(o20).transform([](int) { return 42; });
-    EXPECT_TRUE(*o20r == 42);
-
-    smd::optional::optional<int> o24 = smd::optional::nullopt;
-    auto o24r = o24.transform([](int) { return 42; });
-    EXPECT_TRUE(!o24r);
-
-    smd::optional::optional<int> o28 = smd::optional::nullopt;
-    auto o28r = std::move(o28).transform([](int) { return 42; });
-    EXPECT_TRUE(!o28r);
-
-    const smd::optional::optional<int> o32 = smd::optional::nullopt;
-    auto o32r = o32.transform([](int) { return 42; });
-    EXPECT_TRUE(!o32r);
-
-    const smd::optional::optional<int> o36 = smd::optional::nullopt;
-    auto o36r = std::move(o36).transform([](int) { return 42; });
-    EXPECT_TRUE(!o36r);
-  }
-
-TEST(OptionalMonadicTest, TransformConstxpr)
- {
-    // test each overload in turn
-    constexpr smd::optional::optional<int> o16 = 42;
-    constexpr auto o16r = o16.transform(get_int);
-    static_assert(*o16r == 42);
-
-    constexpr smd::optional::optional<int> o20 = 42;
-    constexpr auto o20r = std::move(o20).transform(get_int);
-    static_assert(*o20r == 42);
-
-    constexpr smd::optional::optional<int> o32 = smd::optional::nullopt;
-    constexpr auto o32r = o32.transform(get_int);
-    static_assert(!o32r);
-    constexpr smd::optional::optional<int> o36 = smd::optional::nullopt;
-    constexpr auto o36r = std::move(o36).transform(get_int);
-    static_assert(!o36r);
-  }
-
-TEST(OptionalMonadicTest, and_then)
- {
-    // lhs is empty
-    smd::optional::optional<int> o1;
-    auto o1r = o1.and_then([](int) { return smd::optional::optional<float>{42}; });
-    static_assert((std::is_same<decltype(o1r), smd::optional::optional<float>>::value));
-    EXPECT_TRUE(!o1r);
-
-    // lhs has value
-    smd::optional::optional<int> o2 = 12;
-    auto o2r = o2.and_then([](int) { return smd::optional::optional<float>{42}; });
-    static_assert((std::is_same<decltype(o2r), smd::optional::optional<float>>::value));
-    EXPECT_TRUE(o2r.value() == 42.f);
-
-    // lhs is empty, rhs returns empty
-    smd::optional::optional<int> o3;
-    auto o3r = o3.and_then([](int) { return smd::optional::optional<float>{}; });
-    static_assert((std::is_same<decltype(o3r), smd::optional::optional<float>>::value));
-    EXPECT_TRUE(!o3r);
-
-    // rhs returns empty
-    smd::optional::optional<int> o4 = 12;
-    auto o4r = o4.and_then([](int) { return smd::optional::optional<float>{}; });
-    static_assert((std::is_same<decltype(o4r), smd::optional::optional<float>>::value));
-    EXPECT_TRUE(!o4r);
-
-    struct rval_call_and_then {
-      smd::optional::optional<double> operator()(int) && {
-        return smd::optional::optional<double>(42.0);
-      };
-    };
-
-    // ensure that function object is forwarded
-    smd::optional::optional<int> o5 = 42;
-    auto o5r = o5.and_then(rval_call_and_then{});
-    static_assert((std::is_same<decltype(o5r), smd::optional::optional<double>>::value));
-    EXPECT_TRUE(o5r.value() == 42);
-
-    // ensure that lhs is forwarded
-    smd::optional::optional<int> o6 = 42;
-    auto o6r =
-        std::move(o6).and_then([](int &&i) { return smd::optional::optional<double>(i); });
-    static_assert((std::is_same<decltype(o6r), smd::optional::optional<double>>::value));
-    EXPECT_TRUE(o6r.value() == 42);
-
-    // ensure that function object is const-propagated
-    const smd::optional::optional<int> o7 = 42;
-    auto o7r =
-        o7.and_then([](const int &i) { return smd::optional::optional<double>(i); });
-    static_assert((std::is_same<decltype(o7r), smd::optional::optional<double>>::value));
-    EXPECT_TRUE(o7r.value() == 42);
-
-    // test each overload in turn
-    smd::optional::optional<int> o8 = 42;
-    auto o8r = o8.and_then([](int) { return smd::optional::make_optional(42); });
-    EXPECT_TRUE(*o8r == 42);
-
-    smd::optional::optional<int> o9 = 42;
-    auto o9r =
-        std::move(o9).and_then([](int) { return smd::optional::make_optional(42); });
-    EXPECT_TRUE(*o9r == 42);
-
-    const smd::optional::optional<int> o10 = 42;
-    auto o10r = o10.and_then([](int) { return smd::optional::make_optional(42); });
-    EXPECT_TRUE(*o10r == 42);
-
-    const smd::optional::optional<int> o11 = 42;
-    auto o11r =
-        std::move(o11).and_then([](int) { return smd::optional::make_optional(42); });
-    EXPECT_TRUE(*o11r == 42);
-
-    smd::optional::optional<int> o16 = smd::optional::nullopt;
-    auto o16r = o16.and_then([](int) { return smd::optional::make_optional(42); });
-    EXPECT_TRUE(!o16r);
-
-    smd::optional::optional<int> o17 = smd::optional::nullopt;
-    auto o17r =
-        std::move(o17).and_then([](int) { return smd::optional::make_optional(42); });
-    EXPECT_TRUE(!o17r);
-
-    const smd::optional::optional<int> o18 = smd::optional::nullopt;
-    auto o18r = o18.and_then([](int) { return smd::optional::make_optional(42); });
-    EXPECT_TRUE(!o18r);
-
-    const smd::optional::optional<int> o19 = smd::optional::nullopt;
-    auto o19r = std::move(o19).and_then([](int) { return smd::optional::make_optional(42); });
-    EXPECT_TRUE(!o19r);
-
-    int i = 3;
-    smd::optional::optional<int&> o20{i};
-    std::move(o20).and_then([](int& r){return smd::optional::optional<int&>{++r};});
-    EXPECT_TRUE(o20);
-    EXPECT_TRUE(i == 4);
-  }
-
-TEST(OptionalMonadicTest, Constexpr_and_then)
-{
-    constexpr smd::optional::optional<int> o10 = 42;
-    constexpr auto o10r = o10.and_then(get_opt_int);
-    EXPECT_TRUE(*o10r == 42);
-
-    constexpr smd::optional::optional<int> o11 = 42;
-    constexpr auto o11r = std::move(o11).and_then(get_opt_int);
-    EXPECT_TRUE(*o11r == 42);
-
-    constexpr smd::optional::optional<int> o18 = smd::optional::nullopt;
-    constexpr auto o18r = o18.and_then(get_opt_int);
-    EXPECT_TRUE(!o18r);
-
-    constexpr smd::optional::optional<int> o19 = smd::optional::nullopt;
-    constexpr auto o19r = std::move(o19).and_then(get_opt_int);
-    EXPECT_TRUE(!o19r);
-  }
-
-TEST(OptionalMonadicTest, or_else){
-    smd::optional::optional<int> o1 = 42;
-    EXPECT_TRUE(*(o1.or_else([] { return smd::optional::make_optional(13); })) == 42);
-
-    smd::optional::optional<int> o2;
-    EXPECT_EQ(*(o2.or_else([] { return smd::optional::make_optional(13); })),  13);
-  }