use result in entity_query_builder

include/matador/utils/result.hpp

@@ -18,11 +18,13 @@ template < typename ValueType >
 class ok
 {
 public:
+  using value_type = ValueType;
   explicit constexpr ok(const ValueType &value) : value_(value) {}
   explicit constexpr ok(ValueType &&value) : value_(std::move(value)) {}
 
   constexpr ValueType&& release() { return std::move(value_); }
   const ValueType& value() const { return value_; }
+  ValueType& value() { return value_; }
 
 private:
   ValueType value_;
@@ -32,11 +34,14 @@ template < typename ErrorType >
 class error
 {
 public:
+  using value_type = ErrorType;
+
   explicit constexpr error(const ErrorType &error) : error_(error) {}
   explicit constexpr error(ErrorType &&error) : error_(std::move(error)) {}
 
   constexpr ErrorType&& release() { return std::move(error_); }
   const ErrorType& value() const { return error_; }
+  ErrorType value() { return error_; }
 
 private:
   ErrorType error_;
@@ -49,8 +54,13 @@ public:
   using value_type = ok<ValueType>;
   using error_type = error<ErrorType>;
 
-  result(value_type value) : result_(value) {} // NOLINT(*-explicit-constructor)
-  result(error_type error) : result_(error) {} // NOLINT(*-explicit-constructor)
+  result() : result_(ValueType{}) {}
+  result(value_type value) : result_(std::move(value)) {} // NOLINT(*-explicit-constructor)
+  result(error_type error) : result_(std::move(error)) {} // NOLINT(*-explicit-constructor)
+  result(const result<ValueType, ErrorType> &x) = default;
+  result& operator=(const result<ValueType, ErrorType> &x) = default;
+  result(result<ValueType, ErrorType> &&x) = default;
+  result& operator=(result<ValueType, ErrorType> &&x) = default;
 
   operator bool() const { return is_ok(); } // NOLINT(*-explicit-constructor)
 
@@ -65,15 +75,33 @@ public:
   ErrorType err() { return std::get<error_type>(result_).value(); }
 
   constexpr const ValueType* operator->() const { return &value(); }
-  constexpr ValueType* operator->() { return &value(); }
+  constexpr ValueType* operator->() { return &std::get<value_type>(result_).value(); }
 
-  template<typename SecondValueType, typename SecondErrorType, typename Func>
-  result<SecondValueType, SecondErrorType> and_then(Func f) {
+  template<typename Func, typename SecondValueType = typename std::invoke_result_t<Func, ValueType >>
+  result<SecondValueType, ErrorType> transform(Func &&f) {
     if (is_ok()) {
-      return f(value());
+      return result<SecondValueType, ErrorType>(ok(f(release())));
     }
 
-    return *this;
+    return result<SecondValueType, ErrorType>(error(release_error()));
+  }
+
+  template<typename Func, typename SecondValueType = typename std::invoke_result_t<Func, ValueType >::value_type::value_type>
+  result<SecondValueType, ErrorType> and_then(Func &&f) {
+    if (is_ok()) {
+      return f(release());
+    }
+
+    return result<SecondValueType, ErrorType>(error(release_error()));
+  }
+
+  template<typename Func, typename SecondErrorType = typename std::invoke_result_t<Func, ErrorType >::error_type::value_type>
+  result<ValueType, SecondErrorType> or_else(Func &&f) {
+    if (is_error()) {
+      return f(err());
+    }
+
+    return result<ValueType, SecondErrorType>(ok(release()));
   }
 
 private: