kstd: extract result helper alias

13 files changed, 127 insertions, 96 deletions

diff --git a/kernel/kernel/filesystem/devfs/filesystem.cpp b/kernel/kernel/filesystem/devfs/filesystem.cpp
index d91ee1e4..7ffcb3c4 100644
--- a/kernel/kernel/filesystem/devfs/filesystem.cpp
+++ b/kernel/kernel/filesystem/devfs/filesystem.cpp
@@ -11,10 +11,10 @@
 #include <kapi/devices/device.hpp>
 
 #include <kstd/memory.hpp>
+#include <kstd/result.hpp>
 #include <kstd/system_error.hpp>
 
 #include <algorithm>
-#include <expected>
 #include <string_view>
 
 namespace kernel::filesystem::devfs
@@ -40,30 +40,30 @@ namespace kernel::filesystem::devfs
   [[gnu::used]]
   constexpr auto registration = type_registration<type>{};
 
-  auto filesystem::mount(kstd::shared_ptr<kernel::filesystem::inode> const &) -> std::expected<void, kstd::error_code>
+  auto filesystem::mount(kstd::shared_ptr<kernel::filesystem::inode> const &) -> kstd::result<void>
   {
     m_root_inode = kstd::make_shared<inode>();
     build_device_inode_table();
 
-    return {};
+    return kstd::success();
   }
 
   auto filesystem::lookup(kstd::shared_ptr<kernel::filesystem::inode> const & parent, std::string_view name) const
-      -> std::expected<kstd::shared_ptr<kernel::filesystem::inode>, kstd::error_code>
+      -> kstd::result<kstd::shared_ptr<kernel::filesystem::inode>>
   {
     if (!parent)
     {
-      return std::unexpected{vfs_errc::invalid_inode};
+      return kstd::failure(vfs_errc::invalid_inode);
     }
 
     if (!parent->is_directory())
     {
-      return std::unexpected{vfs_errc::not_a_directory};
+      return kstd::failure(vfs_errc::not_a_directory);
     }
 
     if (parent.get() != m_root_inode.get())
     {
-      return std::unexpected{vfs_errc::invalid_inode};
+      return kstd::failure(vfs_errc::invalid_inode);
     }
 
     auto it = std::ranges::find_if(m_inodes, [&](auto const & dev_node) {
@@ -79,7 +79,7 @@ namespace kernel::filesystem::devfs
       return *it;
     }
 
-    return std::unexpected{vfs_errc::no_such_file_or_directory};
+    return kstd::failure(vfs_errc::no_such_file_or_directory);
   }
 
   auto filesystem::build_device_inode_table() -> void
diff --git a/kernel/kernel/filesystem/devfs/filesystem.hpp b/kernel/kernel/filesystem/devfs/filesystem.hpp
index e96790b8..dadeaf7d 100644
--- a/kernel/kernel/filesystem/devfs/filesystem.hpp
+++ b/kernel/kernel/filesystem/devfs/filesystem.hpp
@@ -6,10 +6,10 @@
 #include <kernel/filesystem/inode.hpp>
 
 #include <kstd/memory.hpp>
+#include <kstd/result.hpp>
 #include <kstd/system_error.hpp>
 #include <kstd/vector.hpp>
 
-#include <expected>
 #include <string_view>
 
 namespace kernel::filesystem::devfs
@@ -27,8 +27,7 @@ namespace kernel::filesystem::devfs
     @param backing_inode Backing inode passed by the vfs (not required by devfs).
     @return The result of the mount operation.
     */
-    auto mount(kstd::shared_ptr<kernel::filesystem::inode> const & backing_inode)
-        -> std::expected<void, kstd::error_code> override;
+    auto mount(kstd::shared_ptr<kernel::filesystem::inode> const & backing_inode) -> kstd::result<void> override;
 
     /**
     @brief Looks up an inode by @p name within a @p parent directory.
@@ -37,7 +36,7 @@ namespace kernel::filesystem::devfs
     @return A pointer to the found inode, or a null pointer if not found.
     */
     [[nodiscard]] auto lookup(kstd::shared_ptr<kernel::filesystem::inode> const & parent, std::string_view name) const
-        -> std::expected<kstd::shared_ptr<kernel::filesystem::inode>, kstd::error_code> override;
+        -> kstd::result<kstd::shared_ptr<kernel::filesystem::inode>> override;
 
   private:
     auto build_device_inode_table() -> void;
diff --git a/kernel/kernel/filesystem/ext2/filesystem.cpp b/kernel/kernel/filesystem/ext2/filesystem.cpp
index 5b0e0907..4195ad05 100644
--- a/kernel/kernel/filesystem/ext2/filesystem.cpp
+++ b/kernel/kernel/filesystem/ext2/filesystem.cpp
@@ -11,6 +11,7 @@
 #include <kernel/filesystem/type.hpp>
 
 #include <kstd/memory.hpp>
+#include <kstd/result.hpp>
 #include <kstd/system_error.hpp>
 #include <kstd/vector.hpp>
 
@@ -45,8 +46,7 @@ namespace kernel::filesystem::ext2
   [[gnu::used]]
   constexpr auto registration = type_registration<type>{};
 
-  auto filesystem::mount(kstd::shared_ptr<kernel::filesystem::inode> const & backing_inode)
-      -> std::expected<void, kstd::error_code>
+  auto filesystem::mount(kstd::shared_ptr<kernel::filesystem::inode> const & backing_inode) -> kstd::result<void>
   {
     std::ignore = kernel::filesystem::filesystem::mount(backing_inode);
 
@@ -54,7 +54,7 @@ namespace kernel::filesystem::ext2
 
     if (m_superblock.magic != constants::magic_number)
     {
-      return std::unexpected{ext2_errc::invalid_magic_number};
+      return kstd::failure(ext2_errc::invalid_magic_number);
     }
 
     auto const blocks_per_group = m_superblock.blocks_per_group;
@@ -72,23 +72,23 @@ namespace kernel::filesystem::ext2
 
     if (!m_root_inode || !m_root_inode->is_directory())
     {
-      return std::unexpected{ext2_errc::invalid_root_inode};
+      return kstd::failure(ext2_errc::invalid_root_inode);
     }
 
     return {};
   }
 
   auto filesystem::lookup(kstd::shared_ptr<kernel::filesystem::inode> const & parent, std::string_view name) const
-      -> std::expected<kstd::shared_ptr<kernel::filesystem::inode>, kstd::error_code>
+      -> kstd::result<kstd::shared_ptr<kernel::filesystem::inode>>
   {
     if (!parent)
     {
-      return std::unexpected{vfs_errc::invalid_inode};
+      return kstd::failure(vfs_errc::invalid_inode);
     }
 
     if (!parent->is_directory())
     {
-      return std::unexpected{vfs_errc::not_a_directory};
+      return kstd::failure(vfs_errc::not_a_directory);
     }
 
     auto * ext2_parent = static_cast<inode *>(parent.get());
@@ -101,7 +101,7 @@ namespace kernel::filesystem::ext2
 
       if (!global_block_number)
       {
-        return std::unexpected{global_block_number.error()};
+        return kstd::failure(global_block_number.error());
       }
 
       auto const block_offset = global_block_number.value() * block_size();
@@ -123,10 +123,10 @@ namespace kernel::filesystem::ext2
       }
     }
 
-    return std::unexpected{vfs_errc::no_such_file_or_directory};
+    return kstd::failure(vfs_errc::no_such_file_or_directory);
   }
 
-  auto filesystem::read_inode(uint32_t inode_number) const -> std::expected<kstd::shared_ptr<inode>, kstd::error_code>
+  auto filesystem::read_inode(uint32_t inode_number) const -> kstd::result<kstd::shared_ptr<inode>>
   {
     auto const inodes_per_group = m_superblock.inodes_per_group;
     auto const block_group_index = (inode_number - 1) / inodes_per_group;
@@ -134,7 +134,7 @@ namespace kernel::filesystem::ext2
 
     if (block_group_index >= m_block_group_descriptors.size())
     {
-      return std::unexpected{ext2_errc::invalid_block_group_index};
+      return kstd::failure(ext2_errc::invalid_block_group_index);
     }
 
     auto const & block_group_descriptor = m_block_group_descriptors.at(block_group_index);
@@ -201,7 +201,7 @@ namespace kernel::filesystem::ext2
       return block_number;
     }
 
-    return std::unexpected{ext2_errc::invalid_block_index};
+    return kstd::failure(ext2_errc::invalid_block_index);
   }
 
   auto filesystem::read_block_number_at_index(uint32_t block_number, size_t index) const -> uint32_t
diff --git a/kernel/kernel/filesystem/ext2/filesystem.hpp b/kernel/kernel/filesystem/ext2/filesystem.hpp
index da7ae64e..58620596 100644
--- a/kernel/kernel/filesystem/ext2/filesystem.hpp
+++ b/kernel/kernel/filesystem/ext2/filesystem.hpp
@@ -8,13 +8,13 @@
 #include <kernel/filesystem/inode.hpp>
 
 #include <kstd/memory.hpp>
+#include <kstd/result.hpp>
 #include <kstd/system_error.hpp>
 #include <kstd/vector.hpp>
 
 #include <array>
 #include <cstddef>
 #include <cstdint>
-#include <expected>
 #include <string_view>
 
 namespace kernel::filesystem::ext2
@@ -55,8 +55,7 @@ namespace kernel::filesystem::ext2
     @param backing_inode The backing inode to mount.
     @return The result of the mount operation.
     */
-    auto mount(kstd::shared_ptr<kernel::filesystem::inode> const & backing_inode)
-        -> std::expected<void, kstd::error_code> override;
+    auto mount(kstd::shared_ptr<kernel::filesystem::inode> const & backing_inode) -> kstd::result<void> override;
 
     /**
     @brief Looks up an inode by @p name within a @p parent directory.
@@ -65,7 +64,7 @@ namespace kernel::filesystem::ext2
     @return A pointer to the found inode, or a null pointer if not found.
     */
     [[nodiscard]] auto lookup(kstd::shared_ptr<kernel::filesystem::inode> const & parent, std::string_view name) const
-        -> std::expected<kstd::shared_ptr<kernel::filesystem::inode>, kstd::error_code> override;
+        -> kstd::result<kstd::shared_ptr<kernel::filesystem::inode>> override;
 
     /**
     @brief Gets the size of a block in the filesystem.
@@ -86,7 +85,7 @@ namespace kernel::filesystem::ext2
     @return The global block number on success, an error otherwise.
     */
     [[nodiscard]] auto map_inode_block_index_to_global_block_number(size_t inode_block_index, inode_data data) const
-        -> std::expected<std::size_t, kstd::error_code>;
+        -> kstd::result<std::size_t>;
 
   private:
     struct indirect_level
@@ -97,8 +96,7 @@ namespace kernel::filesystem::ext2
 
     [[nodiscard]] auto indirect_levels() const -> std::array<indirect_level, 3>;
 
-    [[nodiscard]] auto read_inode(uint32_t inode_number) const
-        -> std::expected<kstd::shared_ptr<inode>, kstd::error_code>;
+    [[nodiscard]] auto read_inode(uint32_t inode_number) const -> kstd::result<kstd::shared_ptr<inode>>;
     [[nodiscard]] auto read_block_number_at_index(uint32_t block_number, size_t index) const -> uint32_t;
 
     [[nodiscard]] auto inode_size() const -> uint16_t;
diff --git a/kernel/kernel/filesystem/filesystem.cpp b/kernel/kernel/filesystem/filesystem.cpp
index 1d15d410..ac0d0ebc 100644
--- a/kernel/kernel/filesystem/filesystem.cpp
+++ b/kernel/kernel/filesystem/filesystem.cpp
@@ -7,10 +7,10 @@
 #include <kapi/system.hpp>
 
 #include <kstd/memory.hpp>
+#include <kstd/result.hpp>
 #include <kstd/system_error.hpp>
 
 #include <array>
-#include <expected>
 
 namespace kernel::filesystem
 {
@@ -22,7 +22,7 @@ namespace kernel::filesystem
   }  // namespace
 
   auto filesystem::probe_and_mount(kstd::shared_ptr<inode> const & backing_inode)
-      -> std::expected<kstd::shared_ptr<filesystem>, kstd::error_code>
+      -> kstd::result<kstd::shared_ptr<filesystem>>
   {
     if (!backing_inode)
     {
@@ -38,10 +38,10 @@ namespace kernel::filesystem
       }
     }
 
-    return std::unexpected{vfs_errc::unsupported_filesystem};
+    return kstd::failure(vfs_errc::unsupported_filesystem);
   }
 
-  auto filesystem::mount(kstd::shared_ptr<inode> const & backing_inode) -> std::expected<void, kstd::error_code>
+  auto filesystem::mount(kstd::shared_ptr<inode> const & backing_inode) -> kstd::result<void>
   {
     if (!backing_inode)
     {
@@ -49,7 +49,7 @@ namespace kernel::filesystem
     }
 
     m_backing_inode = backing_inode;
-    return {};
+    return kstd::success();
   }
 
   auto filesystem::root_inode() const -> kstd::shared_ptr<inode> const &
diff --git a/kernel/kernel/filesystem/filesystem.hpp b/kernel/kernel/filesystem/filesystem.hpp
index f9521d1f..1264d00d 100644
--- a/kernel/kernel/filesystem/filesystem.hpp
+++ b/kernel/kernel/filesystem/filesystem.hpp
@@ -4,10 +4,10 @@
 #include <kernel/filesystem/inode.hpp>
 
 #include <kstd/memory.hpp>
+#include <kstd/result.hpp>
 #include <kstd/system_error.hpp>
 #include <kstd/vector.hpp>
 
-#include <expected>
 #include <string_view>
 
 namespace kernel::filesystem
@@ -32,7 +32,7 @@ namespace kernel::filesystem
     @warning Panics if @p backing_inode is null.
     */
     auto static probe_and_mount(kstd::shared_ptr<inode> const & backing_inode)
-        -> std::expected<kstd::shared_ptr<filesystem>, kstd::error_code>;
+        -> kstd::result<kstd::shared_ptr<filesystem>>;
 
     /**
     @brief Initializes the filesystem with the given @p backing_inode.
@@ -40,7 +40,7 @@ namespace kernel::filesystem
     representing the block device or another inode which contains the filesystem data.)
     @return Nothing on success, and error otherwise.
     */
-    virtual auto mount(kstd::shared_ptr<inode> const & backing_inode) -> std::expected<void, kstd::error_code>;
+    virtual auto mount(kstd::shared_ptr<inode> const & backing_inode) -> kstd::result<void>;
 
     /**
     @brief Looks up a child inode within the given @p parent inode with the specified @p name. This method must be
@@ -51,7 +51,7 @@ namespace kernel::filesystem
     @return A pointer to the requested child inode, an error otherwise.
     */
     [[nodiscard]] virtual auto lookup(kstd::shared_ptr<inode> const & parent, std::string_view name) const
-        -> std::expected<kstd::shared_ptr<inode>, kstd::error_code> = 0;
+        -> kstd::result<kstd::shared_ptr<inode>> = 0;
 
     /**
     @brief Returns a reference to the root inode of the filesystem.
diff --git a/kernel/kernel/filesystem/open_file_table.cpp b/kernel/kernel/filesystem/open_file_table.cpp
index 1109249a..f33fed2e 100644
--- a/kernel/kernel/filesystem/open_file_table.cpp
+++ b/kernel/kernel/filesystem/open_file_table.cpp
@@ -6,11 +6,11 @@
 #include <kapi/system.hpp>
 
 #include <kstd/memory.hpp>
+#include <kstd/result.hpp>
 #include <kstd/system_error.hpp>
 
 #include <algorithm>
 #include <cstddef>
-#include <expected>
 #include <optional>
 
 namespace
@@ -41,11 +41,11 @@ namespace kernel::filesystem
   }
 
   auto open_file_table::add_file(kstd::shared_ptr<open_file_descriptor> const & file_descriptor)
-      -> std::expected<std::size_t, kstd::error_code>
+      -> kstd::result<std::size_t>
   {
     if (!file_descriptor)
     {
-      return std::unexpected{vfs_errc::invalid_file_descriptor};
+      return kstd::failure(vfs_errc::invalid_file_descriptor);
     }
 
     auto it = std::ranges::find_if(m_open_files, [](auto const & open_file) { return open_file == nullptr; });
@@ -59,25 +59,25 @@ namespace kernel::filesystem
     return m_open_files.size() - 1;
   }
 
-  auto open_file_table::file(size_t fd) const -> std::expected<kstd::shared_ptr<open_file_descriptor>, kstd::error_code>
+  auto open_file_table::file(size_t fd) const -> kstd::result<kstd::shared_ptr<open_file_descriptor>>
   {
     if (fd >= m_open_files.size() || m_open_files.at(fd) == nullptr)
     {
-      return std::unexpected{vfs_errc::invalid_file_descriptor};
+      return kstd::failure(vfs_errc::invalid_file_descriptor);
     }
 
-    return m_open_files.at(fd);
+    return kstd::success(m_open_files.at(fd));
   }
 
-  auto open_file_table::remove_file(size_t fd) -> std::expected<std::size_t, kstd::error_code>
+  auto open_file_table::remove_file(size_t fd) -> kstd::result<std::size_t>
   {
     if (fd >= m_open_files.size() || m_open_files.at(fd) == nullptr)
     {
-      return std::unexpected{vfs_errc::invalid_file_descriptor};
+      return kstd::failure(vfs_errc::invalid_file_descriptor);
     }
 
     m_open_files.at(fd) = nullptr;
-    return 0;
+    return kstd::success(0);
   }
 }  // namespace kernel::filesystem
 
diff --git a/kernel/kernel/filesystem/open_file_table.hpp b/kernel/kernel/filesystem/open_file_table.hpp
index efdaf578..a2c0e028 100644
--- a/kernel/kernel/filesystem/open_file_table.hpp
+++ b/kernel/kernel/filesystem/open_file_table.hpp
@@ -4,11 +4,11 @@
 #include <kernel/filesystem/open_file_descriptor.hpp>
 
 #include <kstd/memory.hpp>
+#include <kstd/result.hpp>
 #include <kstd/system_error.hpp>
 #include <kstd/vector.hpp>
 
 #include <cstddef>
-#include <expected>
 
 namespace kernel::filesystem
 {
@@ -41,21 +41,21 @@ namespace kernel::filesystem
     @param fd The file descriptor to add.
     @return The file descriptor index assigned to the file, or -1 on failure.
     */
-    auto add_file(kstd::shared_ptr<open_file_descriptor> const & fd) -> std::expected<std::size_t, kstd::error_code>;
+    auto add_file(kstd::shared_ptr<open_file_descriptor> const & fd) -> kstd::result<std::size_t>;
 
     /**
     @brief Get a file from the open file table.
     @param fd The file descriptor index to retrieve.
     @return A pointer to the requested file descriptor, or a null pointer if not found.
     */
-    [[nodiscard]] auto file(size_t fd) const -> std::expected<kstd::shared_ptr<open_file_descriptor>, kstd::error_code>;
+    [[nodiscard]] auto file(size_t fd) const -> kstd::result<kstd::shared_ptr<open_file_descriptor>>;
 
     /**
     @brief Remove a file from the open file table.
     @param fd The file descriptor index to remove.
     @return 0 on success, or -1 on failure.
     */
-    auto remove_file(size_t fd) -> std::expected<std::size_t, kstd::error_code>;
+    auto remove_file(size_t fd) -> kstd::result<std::size_t>;
 
   private:
     open_file_table() = default;
diff --git a/kernel/kernel/filesystem/rootfs/filesystem.cpp b/kernel/kernel/filesystem/rootfs/filesystem.cpp
index ea2ceedf..fef43e28 100644
--- a/kernel/kernel/filesystem/rootfs/filesystem.cpp
+++ b/kernel/kernel/filesystem/rootfs/filesystem.cpp
@@ -7,9 +7,9 @@
 #include <kernel/filesystem/type.hpp>
 
 #include <kstd/memory.hpp>
+#include <kstd/result.hpp>
 #include <kstd/system_error.hpp>
 
-#include <expected>
 #include <string_view>
 
 namespace kernel::filesystem::rootfs
@@ -36,15 +36,15 @@ namespace kernel::filesystem::rootfs
   [[gnu::used]]
   constexpr auto registration = type_registration<type>{};
 
-  auto filesystem::mount(kstd::shared_ptr<kernel::filesystem::inode> const &) -> std::expected<void, kstd::error_code>
+  auto filesystem::mount(kstd::shared_ptr<kernel::filesystem::inode> const &) -> kstd::result<void>
   {
     m_root_inode = kstd::make_shared<inode>();
-    return {};
+    return kstd::success();
   }
 
   auto filesystem::lookup(kstd::shared_ptr<kernel::filesystem::inode> const &, std::string_view) const
-      -> std::expected<kstd::shared_ptr<kernel::filesystem::inode>, kstd::error_code>
+      -> kstd::result<kstd::shared_ptr<kernel::filesystem::inode>>
   {
-    return std::unexpected{vfs_errc::no_such_file_or_directory};
+    return kstd::failure(vfs_errc::no_such_file_or_directory);
   }
 }  // namespace kernel::filesystem::rootfs
diff --git a/kernel/kernel/filesystem/rootfs/filesystem.hpp b/kernel/kernel/filesystem/rootfs/filesystem.hpp
index e05cc808..8507d8b8 100644
--- a/kernel/kernel/filesystem/rootfs/filesystem.hpp
+++ b/kernel/kernel/filesystem/rootfs/filesystem.hpp
@@ -5,11 +5,11 @@
 #include <kernel/filesystem/inode.hpp>
 
 #include <kstd/memory.hpp>
+#include <kstd/result.hpp>
 #include <kstd/string.hpp>
 #include <kstd/system_error.hpp>
 #include <kstd/vector.hpp>
 
-#include <expected>
 #include <string_view>
 
 namespace kernel::filesystem::rootfs
@@ -27,8 +27,7 @@ namespace kernel::filesystem::rootfs
     @param backing_inode The backing inode to mount (not required by rootfs).
     @return The result of the mount operation.
     */
-    auto mount(kstd::shared_ptr<kernel::filesystem::inode> const & backing_inode)
-        -> std::expected<void, kstd::error_code> override;
+    auto mount(kstd::shared_ptr<kernel::filesystem::inode> const & backing_inode) -> kstd::result<void> override;
 
     /**
     @brief Looks up an inode by @p name within a @p parent directory.
@@ -37,7 +36,7 @@ namespace kernel::filesystem::rootfs
     @return Always returns nullptr.
     */
     [[nodiscard]] auto lookup(kstd::shared_ptr<kernel::filesystem::inode> const & parent, std::string_view name) const
-        -> std::expected<kstd::shared_ptr<kernel::filesystem::inode>, kstd::error_code> override;
+        -> kstd::result<kstd::shared_ptr<kernel::filesystem::inode>> override;
   };
 }  // namespace kernel::filesystem::rootfs
 
diff --git a/kernel/kernel/filesystem/vfs.cpp b/kernel/kernel/filesystem/vfs.cpp
index 40f2c3aa..9aa8b2df 100644
--- a/kernel/kernel/filesystem/vfs.cpp
+++ b/kernel/kernel/filesystem/vfs.cpp
@@ -13,6 +13,7 @@
 #include <kapi/system.hpp>
 
 #include <kstd/memory.hpp>
+#include <kstd/result.hpp>
 #include <kstd/system_error.hpp>
 #include <kstd/vector.hpp>
 
@@ -88,12 +89,12 @@ namespace kernel::filesystem
     return *active_vfs;
   }
 
-  auto vfs::open(std::string_view path) -> std::expected<dentry_ptr, kstd::error_code>
+  auto vfs::open(std::string_view path) -> kstd::result<dentry_ptr>
   {
     auto resolved_path = resolve_path_internal(path);
     if (!resolved_path)
     {
-      return std::unexpected{resolved_path.error()};
+      return kstd::failure(resolved_path.error());
     }
 
     auto [dentry, mount] = resolved_path.value();
@@ -101,73 +102,73 @@ namespace kernel::filesystem
     return dentry;
   }
 
-  auto vfs::close(std::string_view path) -> std::expected<void, kstd::error_code>
+  auto vfs::close(std::string_view path) -> kstd::result<void>
   {
     if (auto mount = find_mount(path))
     {
       mount.value()->decrement_ref_count();
-      return {};
+      return kstd::success();
     }
-    return std::unexpected{vfs_errc::invalid_path};
+    return kstd::failure(vfs_errc::invalid_path);
   }
 
-  auto vfs::mount(std::string_view source, std::string_view target) -> std::expected<void, kstd::error_code>
+  auto vfs::mount(std::string_view source, std::string_view target) -> kstd::result<void>
   {
     if (!path::is_valid_path(source) || !path::is_valid_path(target))
     {
-      return std::unexpected{vfs_errc::invalid_path};
+      return kstd::failure(vfs_errc::invalid_path);
     }
 
     auto resolved_target = resolve_path_internal(target);
     if (!resolved_target)
     {
-      return std::unexpected{resolved_target.error()};
+      return kstd::failure(resolved_target.error());
     }
     auto [mount_point_dentry, mount_context] = *resolved_target;
 
     auto resolved_source = resolve_path_internal(source);
     if (!resolved_source)
     {
-      return std::unexpected{resolved_source.error()};
+      return kstd::failure(resolved_source.error());
     }
     auto [source_dentry, source_mount_context] = *resolved_source;
 
     auto fs = kernel::filesystem::filesystem::probe_and_mount(source_dentry->get_inode());
     if (!fs)
     {
-      return std::unexpected{fs.error()};
+      return kstd::failure(fs.error());
     }
 
     do_mount_internal(mount_point_dentry, mount_context, *fs, source_mount_context);
-    return {};
+    return kstd::success();
   }
 
-  auto vfs::unmount(std::string_view path) -> std::expected<void, kstd::error_code>
+  auto vfs::unmount(std::string_view path) -> kstd::result<void>
   {
     if (!path::is_valid_path(path))
     {
-      return std::unexpected{vfs_errc::invalid_path};
+      return kstd::failure(vfs_errc::invalid_path);
     }
 
     auto remove_result = m_mount_table.remove_mount(path);
     if (remove_result == mount_table::operation_result::removed)
     {
-      return {};
+      return kstd::success();
     }
     else if (remove_result == mount_table::operation_result::mount_not_found)
     {
-      return std::unexpected{vfs_errc::mount_point_not_found};
+      return kstd::failure(vfs_errc::mount_point_not_found);
     }
     else if (remove_result == mount_table::operation_result::cannot_be_unmounted)
     {
-      return std::unexpected{vfs_errc::mount_busy};
+      return kstd::failure(vfs_errc::mount_busy);
     }
     else if (remove_result == mount_table::operation_result::has_child_mounts)
     {
-      return std::unexpected{vfs_errc::has_child_mounts};
+      return kstd::failure(vfs_errc::has_child_mounts);
     }
 
-    return std::unexpected{vfs_errc::unmount_failed};
+    return kstd::failure(vfs_errc::unmount_failed);
   }
 
   auto vfs::do_mount_internal(dentry_ptr const & mount_point_dentry, mount_ptr const & parent_mount, fs_ptr const & fs,
@@ -195,12 +196,11 @@ namespace kernel::filesystem
     }
   }
 
-  auto vfs::resolve_path_internal(std::string_view path) const
-      -> std::expected<std::pair<dentry_ptr, mount_ptr>, kstd::error_code>
+  auto vfs::resolve_path_internal(std::string_view path) const -> kstd::result<std::pair<dentry_ptr, mount_ptr>>
   {
     if (!path::is_valid_absolute_path(path))
     {
-      return std::unexpected{vfs_errc::invalid_path};
+      return kstd::failure(vfs_errc::invalid_path);
     }
 
     auto current_mount = m_mount_table.find_mount("/");
@@ -224,7 +224,7 @@ namespace kernel::filesystem
 
       if (!current_dentry->get_inode()->is_directory())
       {
-        return std::unexpected{vfs_errc::not_a_directory};
+        return kstd::failure(vfs_errc::not_a_directory);
       }
 
       if (part == ".")
@@ -261,7 +261,7 @@ namespace kernel::filesystem
         auto found_inode = current_fs->lookup(current_dentry->get_inode(), part);
         if (!found_inode)
         {
-          return std::unexpected{found_inode.error()};
+          return kstd::failure(found_inode.error());
         }
 
         next_dentry = kstd::make_shared<dentry>(current_dentry, *found_inode, part);
@@ -282,7 +282,7 @@ namespace kernel::filesystem
       {
         if (symlink_counter++ > constants::symloop_max)
         {
-          return std::unexpected{vfs_errc::too_many_symbolic_link_levels};
+          return kstd::failure(vfs_errc::too_many_symbolic_link_levels);
         }
 
         kstd::vector<uint8_t> buffer(constants::symlink_max_path_length);
@@ -308,12 +308,12 @@ namespace kernel::filesystem
     return std::pair{current_dentry, current_mount};
   }
 
-  auto vfs::resolve_path(std::string_view path) const -> std::expected<dentry_ptr, kstd::error_code>
+  auto vfs::resolve_path(std::string_view path) const -> kstd::result<dentry_ptr>
   {
     return resolve_path_internal(path).transform([](auto result) { return result.first; });
   }
 
-  auto vfs::find_mount(std::string_view path) const -> std::expected<mount_ptr, kstd::error_code>
+  auto vfs::find_mount(std::string_view path) const -> kstd::result<mount_ptr>
   {
     return resolve_path_internal(path).transform([](auto result) { return result.second; });
   }
diff --git a/kernel/kernel/filesystem/vfs.hpp b/kernel/kernel/filesystem/vfs.hpp
index 2645fe14..9dfd3637 100644
--- a/kernel/kernel/filesystem/vfs.hpp
+++ b/kernel/kernel/filesystem/vfs.hpp
@@ -8,9 +8,9 @@
 #include <kernel/filesystem/mount_table.hpp>
 
 #include <kstd/memory.hpp>
+#include <kstd/result.hpp>
 #include <kstd/system_error.hpp>
 
-#include <expected>
 #include <string_view>
 #include <utility>
 
@@ -53,14 +53,14 @@ namespace kernel::filesystem
     @param path The path to the file to open.
     @return A shared pointer to the dentry on success or an error code on failure.
     */
-    auto open(std::string_view path) -> std::expected<dentry_ptr, kstd::error_code>;
+    auto open(std::string_view path) -> kstd::result<dentry_ptr>;
 
     /**
     @brief Close a file by its associated @p path.
     @param path The path to the file to close.
     @return Nothing on success or an error code on failure.
     */
-    auto close(std::string_view path) -> std::expected<void, kstd::error_code>;
+    auto close(std::string_view path) -> kstd::result<void>;
 
     /**
     @brief Mount a @p source path to a specific @p target path.
@@ -68,14 +68,14 @@ namespace kernel::filesystem
     @param target The path where the filesystem should be mounted.
     @return Nothing on success or an error code on failure.
     */
-    auto mount(std::string_view source, std::string_view target) -> std::expected<void, kstd::error_code>;
+    auto mount(std::string_view source, std::string_view target) -> kstd::result<void>;
 
     /**
     @brief Unmount the filesystem mounted at the specified @p path.
     @param path The path where the filesystem is mounted.
     @return Nothing on success or an error code on failure.
     */
-    auto unmount(std::string_view path) -> std::expected<void, kstd::error_code>;
+    auto unmount(std::string_view path) -> kstd::result<void>;
 
   private:
     /**
@@ -89,11 +89,11 @@ namespace kernel::filesystem
      * - find_mount() for the mount context only.
      */
     [[nodiscard]] auto resolve_path_internal(std::string_view path) const
-        -> std::expected<std::pair<dentry_ptr, mount_ptr>, kstd::error_code>;
+        -> kstd::result<std::pair<dentry_ptr, mount_ptr>>;
 
-    [[nodiscard]] auto resolve_path(std::string_view path) const -> std::expected<dentry_ptr, kstd::error_code>;
+    [[nodiscard]] auto resolve_path(std::string_view path) const -> kstd::result<dentry_ptr>;
 
-    [[nodiscard]] auto find_mount(std::string_view path) const -> std::expected<mount_ptr, kstd::error_code>;
+    [[nodiscard]] auto find_mount(std::string_view path) const -> kstd::result<mount_ptr>;
 
     auto do_mount_internal(dentry_ptr const & mount_point_dentry, mount_ptr const & parent_mount, fs_ptr const & fs,
                            mount_ptr const & source_mount = nullptr) -> void;
diff --git a/libs/kstd/kstd/result.hpp b/libs/kstd/kstd/result.hpp
new file mode 100644
index 00000000..7b027a8d
--- /dev/null
+++ b/libs/kstd/kstd/result.hpp
@@ -0,0 +1,35 @@
+#ifndef KSTD_RESULT_HPP
+#define KSTD_RESULT_HPP
+
+#include <kstd/system_error.hpp>
+
+#include <expected>
+#include <type_traits>
+#include <utility>
+
+namespace kstd
+{
+
+  template<typename SuccessType>
+  using result = std::expected<SuccessType, error_code>;
+
+  template<typename SuccessType>
+    requires(!std::is_void_v<SuccessType>)
+  constexpr auto inline success(SuccessType && value) -> result<std::remove_cvref_t<SuccessType>>
+  {
+    return result<std::remove_cvref_t<SuccessType>>{std::in_place, std::forward<SuccessType>(value)};
+  }
+
+  constexpr auto inline success() -> result<void>
+  {
+    return result<void>{std::in_place};
+  }
+
+  constexpr auto inline failure(error_code error) -> std::unexpected<error_code>
+  {
+    return std::unexpected(error);
+  }
+
+}  // namespace kstd
+
+#endif
\ No newline at end of file