First implementation of the Expected monad

1 files changed, 246 insertions, 0 deletions

diff --git a/framework/src/errors.h b/framework/src/errors.h
new file mode 100644
index 00000000..f6c6cfab
--- /dev/null
+++ b/framework/src/errors.h
@@ -0,0 +1,246 @@
+#pragma once
+
+#include <type_traits>
+
+// A somewhat implementation of the expected monad, proposed here:
+// https://isocpp.org/files/papers/n4015.pdf
+
+// A class used to differentiate errors and values when they are of the same type.
+template <typename Error>
+class Unexpected
+{
+
+    static_assert(!std::is_same<Error, void>::value, "Cannot have an Unexpected void");
+
+public:
+    Unexpected() = delete;
+
+    constexpr explicit Unexpected(const Error &error) : mValue(error) {}
+    constexpr explicit Unexpected(Error &&error) : mValue(std::move(error)) {}
+
+    // For implicit conversions when doing makeUnexpected(other)
+    template <typename Other>
+    constexpr explicit Unexpected(const Unexpected<Other> &error) : mValue(error.value()) {}
+    template <typename Other>
+    constexpr explicit Unexpected(Unexpected<Other> &&error) : mValue(std::move(error.value())) {}
+
+    constexpr const Error &value() const &
+    {
+        return mValue;
+    }
+    Error &value() &
+    {
+        return mValue;
+    }
+
+    constexpr const Error &&value() const &&
+    {
+        return std::move(mValue);
+    }
+    Error &&value() &&
+    {
+        return std::move(mValue);
+    }
+
+private:
+    Error mValue;
+};
+
+template <class Error>
+Unexpected<typename std::decay<Error>::type> makeUnexpected(Error &&e)
+{
+    return Unexpected<typename std::decay<Error>::type>(std::forward<Error>(e));
+}
+
+template <typename Error>
+bool operator==(const Unexpected<Error> &lhs, const Unexpected<Error> &rhs)
+{
+    return lhs.value() == rhs.value();
+}
+
+template <typename Error>
+bool operator!=(const Unexpected<Error> &lhs, const Unexpected<Error> &rhs)
+{
+    return lhs.value() != rhs.value();
+}
+
+namespace detail {
+
+namespace tags {
+struct Expected
+{};
+struct Unexpected
+{};
+} // namespace tags
+
+// Write functions here when storage related and when Type != void
+template <typename Error, typename Type>
+struct StorageBase
+{
+protected:
+    // Rule of 5 {{{
+
+    constexpr void copyPartFromOther(const StorageBase &other)
+    {
+        if (isValue) {
+            mValue = other.mValue;
+        } else {
+            mError = other.mError;
+        }
+    }
+
+    void movePartFromOther(StorageBase &&other)
+    {
+        if (isValue) {
+            mValue = std::move(other.mValue);
+        } else {
+            mError = std::move(other.mError);
+        }
+    }
+
+    StorageBase(const StorageBase &other) : isValue(other.isValue)
+    {
+        copyPartFromOther(other);
+    }
+
+    StorageBase(StorageBase &&other) : isValue(other.isValue)
+    {
+        movePartFromOther(std::move(other));
+    }
+
+    constexpr StorageBase &operator=(const StorageBase &other)
+    {
+        isValue = other.isValue;
+        copyPartFromOther(other);
+        return *this;
+    }
+
+    constexpr StorageBase &operator=(StorageBase &&other)
+    {
+        isValue = other.isValue;
+        movePartFromOther(other);
+        return *this;
+    }
+
+    ~StorageBase()
+    {
+        if (isValue) {
+            mValue.~Type();
+        } else {
+            mError.~Unexpected<Error>();
+        }
+    }
+
+    // }}}
+
+    template <typename... Args>
+    constexpr StorageBase(tags::Expected, Args &&... args)
+        : mValue(std::forward<Args>(args)...), isValue(true)
+    {
+    }
+
+    template <typename... Args>
+    constexpr StorageBase(tags::Unexpected, Args &&... args)
+        : mError(std::forward<Args>(args)...), isValue(false)
+    {
+    }
+
+    union
+    {
+        Unexpected<Error> mError;
+        Type mValue;
+    };
+    bool isValue;
+};
+
+// Write functions here when storage related and when Type == void
+template <typename Error>
+struct StorageBase<Error, void>
+{
+protected:
+    constexpr StorageBase(tags::Expected) : isValue(true) {}
+
+    template <typename... Args>
+    constexpr StorageBase(tags::Unexpected, Args &&... args)
+        : mError(std::forward<Args>(args)...), isValue(false)
+    {
+    }
+
+    Unexpected<Error> mError;
+    bool isValue;
+};
+
+// Write functions here when storage related, whether Type is void or not
+template <typename Error, typename Type>
+struct Storage : StorageBase<Error, Type>
+{
+protected:
+    // Forward the construction to StorageBase
+    using StorageBase<Error, Type>::StorageBase;
+};
+
+// Write functions here when dev API related and when Type != void
+template <typename Error, typename Type>
+struct ExpectedBase : detail::Storage<Error, Type>
+{
+    constexpr ExpectedBase() : detail::Storage<Error, Type>(detail::tags::Expected{}) {}
+
+    template <typename OtherError>
+    constexpr ExpectedBase(const Unexpected<OtherError> &error)
+        : detail::Storage<Error, Type>(detail::tags::Unexpected{}, error)
+    {
+    }
+    template <typename OtherError>
+    constexpr ExpectedBase(Unexpected<OtherError> &&error)
+        : detail::Storage<Error, Type>(detail::tags::Unexpected{}, std::move(error))
+    {
+    }
+
+    constexpr ExpectedBase(const Type &value)
+        : detail::Storage<Error, Type>(detail::tags::Expected{}, value)
+    {
+    }
+    constexpr ExpectedBase(Type &&value)
+        : detail::Storage<Error, Type>(detail::tags::Expected{}, std::move(value))
+    {
+    }
+
+    constexpr const Type &value() const &
+    {
+        return this->mValue;
+    }
+};
+
+// Write functions here when dev API related and when Type == void
+template <typename Error>
+struct ExpectedBase<Error, void> : detail::Storage<Error, void>
+{
+    // Rewrite constructors for unexpected because Expected doesn't have direct access to it.
+    template <typename OtherError>
+    constexpr ExpectedBase(const Unexpected<OtherError> &error)
+        : detail::Storage<Error, void>(detail::tags::Unexpected{}, error)
+    {
+    }
+    template <typename OtherError>
+    constexpr ExpectedBase(Unexpected<OtherError> &&error)
+        : detail::Storage<Error, void>(detail::tags::Unexpected{}, std::move(error))
+    {
+    }
+};
+
+} // namespace detail
+
+// Write functions here when dev API related, whether Type is void or not
+template <typename Error, typename Type = void>
+class Expected : public detail::ExpectedBase<Error, Type>
+{
+    static_assert(!std::is_same<Error, void>::value, "Expected with void Error is not implemented");
+
+public:
+    using detail::ExpectedBase<Error, Type>::ExpectedBase;
+
+    constexpr const Error &error() const &
+    {
+        return this->mError.value();
+    }
+};