diff --git a/AK/Result.h b/AK/Result.h
index e6bdbba9a4..f8521bcee5 100644
--- a/AK/Result.h
+++ b/AK/Result.h
@@ -27,78 +27,65 @@
 #pragma once
 
 #include <AK/Assertions.h>
-#include <AK/Platform.h>
 #include <AK/Optional.h>
 
 namespace AK {
 
-template<typename T, typename E>
-class CONSUMABLE(unknown) Result {
+template<typename ValueType, typename ErrorType>
+class Result {
 public:
-    RETURN_TYPESTATE(unknown)
-    Result(const T& res)
+    Result(const ValueType& res)
         : m_result(res)
-    {}
+    {
+    }
 
-    RETURN_TYPESTATE(unknown)
-    Result(const E& error)
+    Result(const ErrorType& error)
         : m_error(error)
     {
     }
 
-    RETURN_TYPESTATE(unknown)
-    Result(const T& res, const E& error)
+    Result(const ValueType& res, const ErrorType& error)
         : m_result(res)
         , m_error(error)
     {
     }
 
-    RETURN_TYPESTATE(unknown)
     Result(Result&& other)
         : m_result(move(other.m_result))
         , m_error(move(other.m_error))
     {
     }
 
-    RETURN_TYPESTATE(unknown)
     Result(Result& other)
         : m_result(other.m_result)
         , m_error(other.m_error)
     {
     }
 
-    CALLABLE_WHEN("unknown", "consumed")
     ~Result()
-    {}
+    {
+    }
 
-    CALLABLE_WHEN(consumed)
-    T& unwrap() {
+    ValueType& value()
+    {
         return m_result.value();
     }
 
-    CALLABLE_WHEN(consumed)
-    E& error() {
+    ErrorType& error()
+    {
         return m_error.value();
     }
 
-    bool has_error() const {
+    bool is_error() const
+    {
         return m_error.has_value();
     }
-    bool has_value() const {
-        return m_result.has_value();
-    }
-
-    SET_TYPESTATE(consumed)
-    bool failed() const {
-        return m_error.value().failed();
-    }
 
 private:
-    Optional<T> m_result;
-    Optional<E> m_error;
+    Optional<ValueType> m_result;
+    Optional<ErrorType> m_error;
 };
 
 }
 
 using AK::Result;
-