refactor: consolidate result type

src/iceberg/arrow/arrow_error_transform_internal.h

@@ -22,8 +22,8 @@
 #include <arrow/result.h>
 #include <arrow/status.h>
 
-#include "iceberg/error.h"
 #include "iceberg/expected.h"
+#include "iceberg/result.h"
 
 namespace iceberg::arrow {
 

src/iceberg/arrow/arrow_fs_file_io.cc

@@ -26,8 +26,8 @@
 namespace iceberg::arrow {
 
 /// \brief Read the content of the file at the given location.
-expected<std::string, Error> ArrowFileSystemFileIO::ReadFile(
-    const std::string& file_location, std::optional<size_t> length) {
+Result<std::string> ArrowFileSystemFileIO::ReadFile(const std::string& file_location,
+                                                    std::optional<size_t> length) {
   ::arrow::fs::FileInfo file_info(file_location);
   if (length.has_value()) {
     file_info.set_size(length.value());
@@ -52,8 +52,8 @@ expected<std::string, Error> ArrowFileSystemFileIO::ReadFile(
 }
 
 /// \brief Write the given content to the file at the given location.
-expected<void, Error> ArrowFileSystemFileIO::WriteFile(const std::string& file_location,
-                                                       std::string_view content) {
+Status ArrowFileSystemFileIO::WriteFile(const std::string& file_location,
+                                        std::string_view content) {
   ICEBERG_ARROW_ASSIGN_OR_RETURN(auto file, arrow_fs_->OpenOutputStream(file_location));
   ICEBERG_ARROW_RETURN_NOT_OK(file->Write(content.data(), content.size()));
   ICEBERG_ARROW_RETURN_NOT_OK(file->Flush());
@@ -62,8 +62,7 @@ expected<void, Error> ArrowFileSystemFileIO::WriteFile(const std::string& file_l
 }
 
 /// \brief Delete a file at the given location.
-expected<void, Error> ArrowFileSystemFileIO::DeleteFile(
-    const std::string& file_location) {
+Status ArrowFileSystemFileIO::DeleteFile(const std::string& file_location) {
   ICEBERG_ARROW_RETURN_NOT_OK(arrow_fs_->DeleteFile(file_location));
   return {};
 }

src/iceberg/arrow/arrow_fs_file_io.h

@@ -37,15 +37,14 @@ class ICEBERG_BUNDLE_EXPORT ArrowFileSystemFileIO : public FileIO {
   ~ArrowFileSystemFileIO() override = default;
 
   /// \brief Read the content of the file at the given location.
-  expected<std::string, Error> ReadFile(const std::string& file_location,
-                                        std::optional<size_t> length) override;
+  Result<std::string> ReadFile(const std::string& file_location,
+                               std::optional<size_t> length) override;
 
   /// \brief Write the given content to the file at the given location.
-  expected<void, Error> WriteFile(const std::string& file_location,
-                                  std::string_view content) override;
+  Status WriteFile(const std::string& file_location, std::string_view content) override;
 
   /// \brief Delete a file at the given location.
-  expected<void, Error> DeleteFile(const std::string& file_location) override;
+  Status DeleteFile(const std::string& file_location) override;
 
  private:
   std::shared_ptr<::arrow::fs::FileSystem> arrow_fs_;

src/iceberg/catalog.h

@@ -19,14 +19,13 @@
 
 #pragma once
 
-#include <map>
 #include <memory>
 #include <string>
 #include <string_view>
+#include <unordered_map>
 #include <vector>
 
-#include "iceberg/error.h"
-#include "iceberg/expected.h"
+#include "iceberg/result.h"
 #include "iceberg/table_identifier.h"
 #include "iceberg/type_fwd.h"
 
@@ -48,8 +47,7 @@ class ICEBERG_EXPORT Catalog {
   /// \param ns a namespace
   /// \return a list of identifiers for tables or ErrorKind::kNoSuchNamespace
   /// if the namespace does not exist
-  virtual expected<std::vector<TableIdentifier>, Error> ListTables(
-      const Namespace& ns) const = 0;
+  virtual Result<std::vector<TableIdentifier>> ListTables(const Namespace& ns) const = 0;
 
   /// \brief Create a table
   ///
@@ -59,18 +57,18 @@ class ICEBERG_EXPORT Catalog {
   /// \param location a location for the table; leave empty if unspecified
   /// \param properties a string map of table properties
   /// \return a Table instance or ErrorKind::kAlreadyExists if the table already exists
-  virtual expected<std::unique_ptr<Table>, Error> CreateTable(
+  virtual Result<std::unique_ptr<Table>> CreateTable(
       const TableIdentifier& identifier, const Schema& schema, const PartitionSpec& spec,
       const std::string& location,
-      const std::map<std::string, std::string>& properties) = 0;
+      const std::unordered_map<std::string, std::string>& properties) = 0;
 
   /// \brief Update a table
   ///
   /// \param identifier a table identifier
   /// \param requirements a list of table requirements
   /// \param updates a list of table updates
   /// \return a Table instance or ErrorKind::kAlreadyExists if the table already exists
-  virtual expected<std::unique_ptr<Table>, Error> UpdateTable(
+  virtual Result<std::unique_ptr<Table>> UpdateTable(
       const TableIdentifier& identifier,
       const std::vector<std::unique_ptr<UpdateRequirement>>& requirements,
       const std::vector<std::unique_ptr<MetadataUpdate>>& updates) = 0;
@@ -84,10 +82,10 @@ class ICEBERG_EXPORT Catalog {
   /// \param properties a string map of table properties
   /// \return a Transaction to create the table or ErrorKind::kAlreadyExists if the table
   /// already exists
-  virtual expected<std::shared_ptr<Transaction>, Error> StageCreateTable(
+  virtual Result<std::shared_ptr<Transaction>> StageCreateTable(
       const TableIdentifier& identifier, const Schema& schema, const PartitionSpec& spec,
       const std::string& location,
-      const std::map<std::string, std::string>& properties) = 0;
+      const std::unordered_map<std::string, std::string>& properties) = 0;
 
   /// \brief Check whether table exists
   ///
@@ -110,15 +108,15 @@ class ICEBERG_EXPORT Catalog {
   /// \param identifier a table identifier
   /// \return instance of Table implementation referred to by identifier or
   /// ErrorKind::kNoSuchTable if the table does not exist
-  virtual expected<std::shared_ptr<Table>, Error> LoadTable(
+  virtual Result<std::shared_ptr<Table>> LoadTable(
       const TableIdentifier& identifier) const = 0;
 
   /// \brief Register a table with the catalog if it does not exist
   ///
   /// \param identifier a table identifier
   /// \param metadata_file_location the location of a metadata file
   /// \return a Table instance or ErrorKind::kAlreadyExists if the table already exists
-  virtual expected<std::shared_ptr<Table>, Error> RegisterTable(
+  virtual Result<std::shared_ptr<Table>> RegisterTable(
       const TableIdentifier& identifier, const std::string& metadata_file_location) = 0;
 
   /// \brief Initialize a catalog given a custom name and a map of catalog properties
@@ -129,8 +127,9 @@ class ICEBERG_EXPORT Catalog {
   ///
   /// \param name a custom name for the catalog
   /// \param properties catalog properties
-  virtual void Initialize(const std::string& name,
-                          const std::map<std::string, std::string>& properties) = 0;
+  virtual void Initialize(
+      const std::string& name,
+      const std::unordered_map<std::string, std::string>& properties) = 0;
 
   /// \brief Instantiate a builder to either create a table or start a create/replace
   /// transaction
@@ -169,7 +168,7 @@ class ICEBERG_EXPORT Catalog {
     /// \param properties key/value properties
     /// \return this for method chaining
     virtual TableBuilder& WithProperties(
-        const std::map<std::string, std::string>& properties) = 0;
+        const std::unordered_map<std::string, std::string>& properties) = 0;
 
     /// \brief Adds a key/value property to the table
     ///

src/iceberg/file_io.h

@@ -23,9 +23,8 @@
 #include <string>
 #include <string_view>
 
-#include "iceberg/error.h"
-#include "iceberg/expected.h"
 #include "iceberg/iceberg_export.h"
+#include "iceberg/result.h"
 
 namespace iceberg {
 
@@ -50,8 +49,8 @@ class ICEBERG_EXPORT FileIO {
   /// the length to read, e.g. S3 `GetObject` has a Range parameter.
   /// \return The content of the file if the read succeeded, an error code if the read
   /// failed.
-  virtual expected<std::string, Error> ReadFile(const std::string& file_location,
-                                                std::optional<size_t> length) {
+  virtual Result<std::string> ReadFile(const std::string& file_location,
+                                       std::optional<size_t> length) {
     // We provide a default implementation to avoid Windows linker error LNK2019.
     return unexpected<Error>{
         {.kind = ErrorKind::kNotImplemented, .message = "ReadFile not implemented"}};
@@ -64,8 +63,7 @@ class ICEBERG_EXPORT FileIO {
   /// \param overwrite If true, overwrite the file if it exists. If false, fail if the
   /// file exists.
   /// \return void if the write succeeded, an error code if the write failed.
-  virtual expected<void, Error> WriteFile(const std::string& file_location,
-                                          std::string_view content) {
+  virtual Status WriteFile(const std::string& file_location, std::string_view content) {
     return unexpected<Error>{
         {.kind = ErrorKind::kNotImplemented, .message = "WriteFile not implemented"}};
   }
@@ -74,7 +72,7 @@ class ICEBERG_EXPORT FileIO {
   ///
   /// \param file_location The location of the file to delete.
   /// \return void if the delete succeeded, an error code if the delete failed.
-  virtual expected<void, Error> DeleteFile(const std::string& file_location) {
+  virtual Status DeleteFile(const std::string& file_location) {
     return unexpected<Error>{
         {.kind = ErrorKind::kNotImplemented, .message = "DeleteFile not implemented"}};
   }

src/iceberg/json_internal.cc

@@ -24,8 +24,8 @@
 
 #include <nlohmann/json.hpp>
 
-#include "iceberg/error.h"
 #include "iceberg/expected.h"
+#include "iceberg/result.h"
 #include "iceberg/schema.h"
 #include "iceberg/schema_internal.h"
 #include "iceberg/sort_order.h"
@@ -69,7 +69,7 @@ constexpr std::string_view kElementRequired = "element-required";
 constexpr std::string_view kValueRequired = "value-required";
 
 template <typename T>
-expected<T, Error> GetJsonValue(const nlohmann::json& json, std::string_view key) {
+Result<T> GetJsonValue(const nlohmann::json& json, std::string_view key) {
   if (!json.contains(key)) {
     return unexpected<Error>({
         .kind = ErrorKind::kJsonParseError,
@@ -109,8 +109,7 @@ nlohmann::json ToJson(const SortOrder& sort_order) {
   return json;
 }
 
-expected<std::unique_ptr<SortField>, Error> SortFieldFromJson(
-    const nlohmann::json& json) {
+Result<std::unique_ptr<SortField>> SortFieldFromJson(const nlohmann::json& json) {
   ICEBERG_ASSIGN_OR_RAISE(auto source_id, GetJsonValue<int32_t>(json, kSourceId));
   ICEBERG_ASSIGN_OR_RAISE(
       auto transform,
@@ -125,8 +124,7 @@ expected<std::unique_ptr<SortField>, Error> SortFieldFromJson(
                                      null_order);
 }
 
-expected<std::unique_ptr<SortOrder>, Error> SortOrderFromJson(
-    const nlohmann::json& json) {
+Result<std::unique_ptr<SortOrder>> SortOrderFromJson(const nlohmann::json& json) {
   ICEBERG_ASSIGN_OR_RAISE(auto order_id, GetJsonValue<int32_t>(json, kOrderId));
   ICEBERG_ASSIGN_OR_RAISE(auto fields, GetJsonValue<nlohmann::json>(json, kFields));
 
@@ -232,7 +230,7 @@ nlohmann::json SchemaToJson(const Schema& schema) {
 
 namespace {
 
-expected<std::unique_ptr<Type>, Error> StructTypeFromJson(const nlohmann::json& json) {
+Result<std::unique_ptr<Type>> StructTypeFromJson(const nlohmann::json& json) {
   ICEBERG_ASSIGN_OR_RAISE(auto json_fields, GetJsonValue<nlohmann::json>(json, kFields));
 
   std::vector<SchemaField> fields;
@@ -244,7 +242,7 @@ expected<std::unique_ptr<Type>, Error> StructTypeFromJson(const nlohmann::json&
   return std::make_unique<StructType>(std::move(fields));
 }
 
-expected<std::unique_ptr<Type>, Error> ListTypeFromJson(const nlohmann::json& json) {
+Result<std::unique_ptr<Type>> ListTypeFromJson(const nlohmann::json& json) {
   ICEBERG_ASSIGN_OR_RAISE(auto element_type, TypeFromJson(json[kElement]));
   ICEBERG_ASSIGN_OR_RAISE(auto element_id, GetJsonValue<int32_t>(json, kElementId));
   ICEBERG_ASSIGN_OR_RAISE(auto element_required,
@@ -255,7 +253,7 @@ expected<std::unique_ptr<Type>, Error> ListTypeFromJson(const nlohmann::json& js
                   std::move(element_type), !element_required));
 }
 
-expected<std::unique_ptr<Type>, Error> MapTypeFromJson(const nlohmann::json& json) {
+Result<std::unique_ptr<Type>> MapTypeFromJson(const nlohmann::json& json) {
   ICEBERG_ASSIGN_OR_RAISE(
       auto key_type, GetJsonValue<nlohmann::json>(json, kKey).and_then(TypeFromJson));
   ICEBERG_ASSIGN_OR_RAISE(
@@ -274,7 +272,7 @@ expected<std::unique_ptr<Type>, Error> MapTypeFromJson(const nlohmann::json& jso
 
 }  // namespace
 
-expected<std::unique_ptr<Type>, Error> TypeFromJson(const nlohmann::json& json) {
+Result<std::unique_ptr<Type>> TypeFromJson(const nlohmann::json& json) {
   if (json.is_string()) {
     std::string type_str = json.get<std::string>();
     if (type_str == "boolean") {
@@ -346,7 +344,7 @@ expected<std::unique_ptr<Type>, Error> TypeFromJson(const nlohmann::json& json)
   }
 }
 
-expected<std::unique_ptr<SchemaField>, Error> FieldFromJson(const nlohmann::json& json) {
+Result<std::unique_ptr<SchemaField>> FieldFromJson(const nlohmann::json& json) {
   ICEBERG_ASSIGN_OR_RAISE(
       auto type, GetJsonValue<nlohmann::json>(json, kType).and_then(TypeFromJson));
   ICEBERG_ASSIGN_OR_RAISE(auto field_id, GetJsonValue<int32_t>(json, kId));
@@ -357,7 +355,7 @@ expected<std::unique_ptr<SchemaField>, Error> FieldFromJson(const nlohmann::json
                                        !required);
 }
 
-expected<std::unique_ptr<Schema>, Error> SchemaFromJson(const nlohmann::json& json) {
+Result<std::unique_ptr<Schema>> SchemaFromJson(const nlohmann::json& json) {
   ICEBERG_ASSIGN_OR_RAISE(auto schema_id, GetJsonValue<int32_t>(json, kSchemaId));
   ICEBERG_ASSIGN_OR_RAISE(auto type, TypeFromJson(json));
 

src/iceberg/json_internal.h

@@ -24,8 +24,8 @@
 
 #include <nlohmann/json_fwd.hpp>
 
-#include "iceberg/error.h"
 #include "iceberg/expected.h"
+#include "iceberg/result.h"
 #include "iceberg/type_fwd.h"
 
 namespace iceberg {
@@ -59,7 +59,7 @@ nlohmann::json ToJson(const SortOrder& sort_order);
 /// \param json The JSON object representing a `SortField`.
 /// \return An `expected` value containing either a `SortField` object or an error. If the
 /// JSON is malformed or missing expected fields, an error will be returned.
-expected<std::unique_ptr<SortField>, Error> SortFieldFromJson(const nlohmann::json& json);
+Result<std::unique_ptr<SortField>> SortFieldFromJson(const nlohmann::json& json);
 
 /// \brief Deserializes a JSON object into a `SortOrder` object.
 ///
@@ -70,7 +70,7 @@ expected<std::unique_ptr<SortField>, Error> SortFieldFromJson(const nlohmann::js
 /// \param json The JSON object representing a `SortOrder`.
 /// \return An `expected` value containing either a `SortOrder` object or an error. If the
 /// JSON is malformed or missing expected fields, an error will be returned.
-expected<std::unique_ptr<SortOrder>, Error> SortOrderFromJson(const nlohmann::json& json);
+Result<std::unique_ptr<SortOrder>> SortOrderFromJson(const nlohmann::json& json);
 
 /// \brief Convert an Iceberg Schema to JSON.
 ///
@@ -94,18 +94,18 @@ nlohmann::json FieldToJson(const SchemaField& field);
 ///
 /// \param[in] json The JSON representation of the schema.
 /// \return The Iceberg schema or an error if the conversion fails.
-expected<std::unique_ptr<Schema>, Error> SchemaFromJson(const nlohmann::json& json);
+Result<std::unique_ptr<Schema>> SchemaFromJson(const nlohmann::json& json);
 
 /// \brief Convert JSON to an Iceberg Type.
 ///
 /// \param[in] json The JSON representation of the type.
 /// \return The Iceberg type or an error if the conversion fails.
-expected<std::unique_ptr<Type>, Error> TypeFromJson(const nlohmann::json& json);
+Result<std::unique_ptr<Type>> TypeFromJson(const nlohmann::json& json);
 
 /// \brief Convert JSON to an Iceberg SchemaField.
 ///
 /// \param[in] json The JSON representation of the field.
 /// \return The Iceberg field or an error if the conversion fails.
-expected<std::unique_ptr<SchemaField>, Error> FieldFromJson(const nlohmann::json& json);
+Result<std::unique_ptr<SchemaField>> FieldFromJson(const nlohmann::json& json);
 
 }  // namespace iceberg

src/iceberg/error.h → src/iceberg/result.h

@@ -21,6 +21,7 @@
 
 #include <string>
 
+#include "iceberg/expected.h"
 #include "iceberg/iceberg_export.h"
 
 namespace iceberg {
@@ -47,4 +48,16 @@ struct ICEBERG_EXPORT [[nodiscard]] Error {
   std::string message;
 };
 
+/// /brief Default error trait
+template <typename T>
+struct DefaultError {
+  using type = Error;
+};
+
+/// \brief Result alias
+template <typename T, typename E = typename DefaultError<T>::type>
+using Result = expected<T, E>;
+
+using Status = Result<void>;
+
 }  // namespace iceberg