refactor: continue refactor project from C++17 to 23

src/yycc/rust/option.hpp

@@ -1,10 +1,12 @@
 #pragma once
 #include <optional>
 
-/// @brief The reproduction of Rust Option type.
-/// @details
-/// This namespace reproduce Rust Option type, and its members Some and None in C++.
-/// However Option is not important than Result, so its implementation is very casual.
+/**
+ * @brief The reproduction of Rust Option type.
+ * @details
+ * This namespace reproduce Rust Option type, and its members Some and None in C++.
+ * However Option is not important than Result, so its implementation is very casual.
+ */
 namespace yycc::rust::option {
 
     template<typename T>

src/yycc/rust/panic.cpp

@@ -1,12 +1,9 @@
 #include "panic.hpp"
-#include "../macro/feature_probe.hpp"
 
 #include <cstdlib>
 #include <iomanip>
 #include <iostream>
-#if defined(YYCC_CPPFEAT_STACKTRACE)
 #include <stacktrace>
-#endif
 
 namespace yycc::rust::panic {
 
@@ -24,12 +21,8 @@ namespace yycc::rust::panic {
         // User custom message
         dst << "note: " << msg << std::endl;
         // Stacktrace message if we support it.
-#if defined(YYCC_CPPFEAT_STACKTRACE)
         dst << "stacktrace: " << std::endl;
         dst << std::stacktrace::current() << std::endl;
-#else
-        dst << "there is no stacktrace because your C++ runtime do not support it." << std::endl;
-#endif
         // // Restore color
         // dst << RESET;
 

src/yycc/rust/panic.hpp

@@ -1,10 +1,6 @@
 #pragma once
-#include "../macro/feature_probe.hpp"
 #include <string_view>
-
-#if defined(YYCC_CPPFEAT_FORMAT)
 #include <format>
-#endif
 
 /**
  * @brief Provides Rust-style panic functionality for immediate program termination on unrecoverable errors.
@@ -38,13 +34,7 @@ namespace yycc::rust::panic {
      * The macro parameters are the message to format and its arguments, following \c std::format syntax.
      * This macro essentially calls \c std::format internally.
      */
-#if defined(YYCC_CPPFEAT_FORMAT)
-#if defined(YYCC_CPPFEAT_VA_OPT)
 #define RS_PANICF(msg, ...) RS_PANIC(std::format(msg __VA_OPT__(, ) __VA_ARGS__))
-#else
-#define RS_PANICF(msg, ...) RS_PANIC(std::format(msg, ##__VA_ARGS__))
-#endif
-#endif
 
     /**
      * @brief Immediately crashes the entire program like Rust's \c panic! macro.

src/yycc/rust/prelude.hpp

@@ -0,0 +1,49 @@
+#pragma once
+
+// Rust prelude section
+#include "primitive.hpp"
+#include "result.hpp"
+#include "option.hpp"
+#include "panic.hpp"
+#include <vector>
+
+namespace yycc::rust::prelude {
+    // Include primitive types
+
+#define NS_RUST_PRIMITIVE ::yycc::rust::primitive
+
+    using i8 = NS_RUST_PRIMITIVE::i8;
+    using i16 = NS_RUST_PRIMITIVE::i16;
+    using i32 = NS_RUST_PRIMITIVE::i32;
+    using i64 = NS_RUST_PRIMITIVE::i64;
+    using u8 = NS_RUST_PRIMITIVE::u8;
+    using u16 = NS_RUST_PRIMITIVE::u16;
+    using u32 = NS_RUST_PRIMITIVE::u32;
+    using u64 = NS_RUST_PRIMITIVE::u64;
+
+    using isize = NS_RUST_PRIMITIVE::isize;
+    using usize = NS_RUST_PRIMITIVE::usize;
+
+    using f32 = NS_RUST_PRIMITIVE::f32;
+    using f64 = NS_RUST_PRIMITIVE::f64;
+
+    using str = NS_RUST_PRIMITIVE::str;
+
+#undef NS_RUST_PRIMITIVE
+
+    // Other types
+    using String = std::u8string;
+    template<typename T>
+    using Vec = std::vector<T>;
+
+    // Expose Result and Option
+    using namespace ::yycc::rust::option;
+    using namespace ::yycc::rust::result;
+
+    // Panic are introduced by including header file
+    // so we do not need re-expose it.
+
+} // namespace yycc::prelude::rust
+
+// Expose all members
+using namespace ::yycc::rust::prelude;

src/yycc/rust/primitive.hpp

@@ -0,0 +1,28 @@
+#pragma once
+#include <cstdint>
+#include <cstddef>
+#include <string_view>
+
+namespace yycc::rust::primitive {
+
+	// `bool` is keyword so should not declare it anymore.
+	// `char` is keyword so should not declare it anymore.
+
+	using i8 = std::int8_t;
+	using i16 = std::int16_t;
+	using i32 = std::int32_t;
+	using i64 = std::int64_t;
+	using u8 = std::uint8_t;
+	using u16 = std::uint16_t;
+	using u32 = std::uint32_t;
+	using u64 = std::uint64_t;
+
+	using isize = std::ptrdiff_t;
+	using usize = std::size_t;
+
+	using f32 = float;
+	using f64 = double;
+
+	using str = std::u8string_view;
+}
+

src/yycc/rust/result.hpp

@@ -1,9 +1,5 @@
 #pragma once
-#include "../macro/feature_probe.hpp"
-
-#if defined(YYCC_CPPFEAT_EXPECTED)
 #include <expected>
-#endif
 
 /**
  * @brief The reproduction of Rust Option type.
@@ -42,8 +38,6 @@
  */
 namespace yycc::rust::result {
 
-#if defined(YYCC_CPPFEAT_EXPECTED)
-
     /**
      * @brief Equivalent Rust \c Result in C++
      * @tparam T The type of the expected value.
@@ -80,6 +74,4 @@ namespace yycc::rust::result {
         return ResultType(std::unexpect, std::forward<Args>(args)...);
     }
 
-#endif
-
 } // namespace yycc::rust::result