refactor: finish rust parse and add testbench for it.

src/CMakeLists.txt

@@ -51,6 +51,7 @@ FILES
     yycc/rust/option.hpp
     yycc/rust/result.hpp
     yycc/rust/parse.hpp
+    yycc/rust/stringify.hpp
     yycc/windows/unsafe_suppressor.hpp
     yycc/windows/import_guard_head.hpp
     yycc/windows/import_guard_tail.hpp

src/yycc/prelude/rust.hpp

@@ -5,6 +5,9 @@
 
 // Rust prelude section
 #include "../rust/primitive.hpp"
+#include "../rust/result.hpp"
+#include "../rust/option.hpp"
+#include "../rust/panic.hpp"
 #include <vector>
 
 namespace yycc::prelude::rust {
@@ -35,6 +38,14 @@ namespace yycc::prelude::rust {
     using String = ::yycc::string::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

src/yycc/rust/option.hpp

@@ -11,7 +11,7 @@ namespace yycc::rust::option {
     using Option = std::optional<T>;
 
     template<typename OptionType, typename... Args>
-    OptionType Some(Args &&... args) {
+    OptionType Some(Args &&...args) {
         return OptionType(std::in_place, std::forward<Args>(args)...);
     }
 
@@ -20,4 +20,4 @@ namespace yycc::rust::option {
         return OptionType(std::nullopt);
     }
 
-}
+} // namespace yycc::rust::option

src/yycc/rust/parse.hpp

@@ -4,21 +4,96 @@
 #include "panic.hpp"
 #include "result.hpp"
 
+#define NS_YYCC_STRING ::yycc::string
 #define NS_YYCC_STRING_PARSE ::yycc::string::parse
+#define NS_YYCC_RUST_RESULT ::yycc::rust::result
 
+/**
+ * @namespace yycc::rust::parse
+ * @brief Provides Rust-inspired parsing utilities for converting strings to various types.
+ * @details
+ * This namespace contains template functions for parsing strings into different types
+ * (floating-point, integral, boolean) with Rust-like Result error handling.
+ */
 namespace yycc::rust::parse {
 
 #if defined(YYCC_CPPFEAT_EXPECTED)
 
+    /// @brief The error type of parsing.
     using Error = NS_YYCC_STRING_PARSE::ParseError;
 
-    // template<typename T>
+    /// @brief The result type of parsing.
-    // using Result = std::expected<T, Error>;
+    /// @tparam T The expected value type in result.
+    template<typename T>
+    using Result = NS_YYCC_RUST_RESULT::Result<T, Error>;
 
+    /**
+     * @brief Parses a string into a floating-point value.
+     * @tparam T Floating-point type to parse into (float, double, etc.)
+     * @param strl String view to parse
+     * @param fmt Formatting flags for parsing (default: general)
+     * @return Result<T> containing either the parsed value or an error
+     */
+    template<typename T, std::enable_if_t<std::is_floating_point_v<T>, int> = 0>
+    Result<T> parse(const NS_YYCC_STRING::u8string_view& strl,
+            std::chars_format fmt = std::chars_format::general) {
+        auto rv = NS_YYCC_STRING_PARSE::priv_parse<T>(strl, fmt);
 
+        if (const auto* ptr = std::get_if<T>(&rv)) {
+            return NS_YYCC_RUST_RESULT::Ok<Result<T>>(*ptr);
+        } else if (const auto* ptr = std::get_if<Error>(&rv)) {
+            return NS_YYCC_RUST_RESULT::Err<Result<T>>(*ptr);
+        } else {
+            // Unreachable
+            RS_PANIC("unreachable code.");
+        }
+    }
+
+    /**
+     * @brief Parses a string into an integral value (excluding bool).
+     * @tparam T Integral type to parse into (int, long, etc.)
+     * @param strl String view to parse
+     * @param base Numeric base for parsing (default: 10)
+     * @return Result<T> containing either the parsed value or an error
+     */
+    template<typename T, std::enable_if_t<std::is_integral_v<T> && !std::is_same_v<T, bool>, int> = 0>
+    Result<T> parse(const NS_YYCC_STRING::u8string_view& strl, int base = 10) {
+        auto rv = NS_YYCC_STRING_PARSE::priv_parse<T>(strl, base);
+
+        if (const auto* ptr = std::get_if<T>(&rv)) {
+            return NS_YYCC_RUST_RESULT::Ok<Result<T>>(*ptr);
+        } else if (const auto* ptr = std::get_if<Error>(&rv)) {
+            return NS_YYCC_RUST_RESULT::Err<Result<T>>(*ptr);
+        } else {
+            // Unreachable
+            RS_PANIC("unreachable code.");
+        }
+    }
+
+    /**
+     * @brief Parses a string into a boolean value.
+     * @tparam T Must be bool type
+     * @param strl String view to parse
+     * @return Result<bool> containing either the parsed value or an error
+     */
+    template<typename T, std::enable_if_t<std::is_same_v<T, bool>, int> = 0>
+    Result<T> parse(const NS_YYCC_STRING::u8string_view& strl) {
+        auto rv = NS_YYCC_STRING_PARSE::priv_parse<T>(strl);
+
+        if (const auto* ptr = std::get_if<T>(&rv)) {
+            return NS_YYCC_RUST_RESULT::Ok<Result<T>>(*ptr);
+        } else if (const auto* ptr = std::get_if<Error>(&rv)) {
+            return NS_YYCC_RUST_RESULT::Err<Result<T>>(*ptr);
+        } else {
+            // Unreachable
+            RS_PANIC("unreachable code.");
+        }
+    }
 
 #endif
 
 }
 
+#undef NS_YYCC_RUST_RESULT
 #undef NS_YYCC_STRING_PARSE
+#undef NS_YYCC_STRING

src/yycc/rust/result.hpp

@@ -82,4 +82,4 @@ namespace yycc::rust::result {
 
 #endif
 
-}
+} // namespace yycc::rust::result

src/yycc/rust/stringify.hpp

@@ -0,0 +1,10 @@
+#pragma once
+#include "../string/stringify.hpp"
+
+namespace yycc::rust::stringify {
+
+    // There is no modification for legacy "stringify" functions like "parse".
+    // So we simply expose all functions into this namespace.
+    using namespace ::yycc::string::stringify;
+
+} // namespace yycc::rust::stringify

testbench/CMakeLists.txt

@@ -10,6 +10,8 @@ PRIVATE
     yycc/string/reinterpret.cpp
     yycc/string/parse.cpp
     yycc/string/stringify.cpp
+    yycc/rust/parse.cpp
+    yycc/rust/stringify.cpp
 )
 # Setup headers
 target_include_directories(YYCCTestbench

testbench/yycc/rust/parse.cpp

@@ -0,0 +1,87 @@
+#include <gtest/gtest.h>
+#include <yycc.hpp>
+#include <yycc/rust/parse.hpp>
+
+#include <yycc/prelude/rust.hpp>
+
+#define PARSE ::yycc::rust::parse
+
+namespace yycctest::rust::parse {
+
+    // We only want to test it if C++ support it.
+#if defined(YYCC_CPPFEAT_EXPECTED)
+
+    // This namespace is just a wrapper for legacy "parse" module.
+    // So the test is just a copy of original implementation.
+    // Please update this if original test was updated.
+
+#define TEST_SUCCESS(type_t, expected_value, string_value, ...) \
+    { \
+        u8string cache_string(YYCC_U8(string_value)); \
+        auto rv = PARSE::parse<type_t>(cache_string, ##__VA_ARGS__); \
+        ASSERT_TRUE(rv.has_value()); \
+        EXPECT_EQ(rv.value(), expected_value); \
+    }
+
+#define TEST_FAIL(type_t, string_value, ...) \
+    { \
+        u8string cache_string(YYCC_U8(string_value)); \
+        auto rv = PARSE::parse<type_t>(cache_string, ##__VA_ARGS__); \
+        EXPECT_FALSE(rv.has_value()); \
+    }
+
+    TEST(RustParse, Common) {
+        TEST_SUCCESS(i8, INT8_C(-61), "-61");
+        TEST_SUCCESS(u8, UINT8_C(200), "200");
+        TEST_SUCCESS(i16, INT16_C(6161), "6161");
+        TEST_SUCCESS(u16, UINT16_C(32800), "32800");
+        TEST_SUCCESS(i32, INT32_C(61616161), "61616161");
+        TEST_SUCCESS(u32, UINT32_C(4294967293), "4294967293");
+        TEST_SUCCESS(i64, INT64_C(616161616161), "616161616161");
+        TEST_SUCCESS(u64, UINT64_C(9223372036854775807), "9223372036854775807");
+
+        TEST_SUCCESS(float, 1.0f, "1.0");
+        TEST_SUCCESS(double, 1.0, "1.0");
+
+        TEST_SUCCESS(bool, true, "true");
+        TEST_SUCCESS(bool, false, "false");
+    }
+
+    TEST(RustParse, Radix) {
+        TEST_SUCCESS(u32, UINT32_C(0xffff), "ffff", 16);
+        TEST_SUCCESS(u32, UINT32_C(032), "032", 8);
+        TEST_SUCCESS(u32, UINT32_C(0B1011), "1011", 2);
+    }
+
+    TEST(RustParse, CaseInsensitive) {
+        TEST_SUCCESS(bool, true, "tRUE");
+    }
+
+    TEST(RustParse, Overflow) {
+        TEST_FAIL(i8, "6161");
+        TEST_FAIL(u8, "32800");
+        TEST_FAIL(i16, "61616161");
+        TEST_FAIL(u16, "4294967293");
+        TEST_FAIL(i32, "616161616161");
+        TEST_FAIL(u32, "9223372036854775807");
+        TEST_FAIL(i64, "616161616161616161616161");
+        TEST_FAIL(u64, "92233720368547758079223372036854775807");
+
+        TEST_FAIL(float, "1e40");
+        TEST_FAIL(double, "1e114514");
+    }
+
+    TEST(RustParse, BadRadix) {
+        TEST_FAIL(u32, "fghj", 16);
+        TEST_FAIL(u32, "099", 8);
+        TEST_FAIL(u32, "12345", 2);
+    }
+
+    TEST(RustParse, InvalidWords) {
+        TEST_FAIL(u32, "hello, world!");
+        TEST_FAIL(bool, "hello, world!");
+    }
+
+#endif
+
+} // namespace yycctest::rust::parse

testbench/yycc/rust/stringify.cpp

@@ -0,0 +1,14 @@
+#include <gtest/gtest.h>
+#include <yycc.hpp>
+#include <yycc/rust/stringify.hpp>
+
+#include <yycc/prelude/rust.hpp>
+
+#define STRINGIFY ::yycc::string::stringify
+
+namespace yycctest::rust::stringify {
+
+    // There is not testbench for this
+    // because it just a map to original implementation without any modification.
+
+}

testbench/yycc/string/parse.cpp

@@ -12,20 +12,22 @@ namespace yycctest::string::parse {
     // These 2 test macros build string container via given string.
     // Check `try_parse` first, and then check `parse`.
 
-#define TEST_SUCCESS(type_t, value, string_value, ...) { \
+#define TEST_SUCCESS(type_t, value, string_value, ...) \
-    u8string cache_string(YYCC_U8(string_value)); \
+    { \
-    type_t cache; \
+        u8string cache_string(YYCC_U8(string_value)); \
-    ASSERT_TRUE(PARSE::try_parse<type_t>(cache_string, cache, ##__VA_ARGS__)); \
+        type_t cache; \
-    EXPECT_EQ(cache, value); \
+        ASSERT_TRUE(PARSE::try_parse<type_t>(cache_string, cache, ##__VA_ARGS__)); \
-    EXPECT_EQ(PARSE::parse<type_t>(cache_string, ##__VA_ARGS__), value); \
+        EXPECT_EQ(cache, value); \
-}
+        EXPECT_EQ(PARSE::parse<type_t>(cache_string, ##__VA_ARGS__), value); \
+    }
 
-#define TEST_FAIL(type_t, string_value, ...) { \
+#define TEST_FAIL(type_t, string_value, ...) \
-    u8string cache_string(YYCC_U8(string_value)); \
+    { \
-    type_t cache; \
+        u8string cache_string(YYCC_U8(string_value)); \
-    EXPECT_FALSE(PARSE::try_parse<type_t>(cache_string, cache, ##__VA_ARGS__)); \
+        type_t cache; \
-    EXPECT_ANY_THROW(PARSE::parse<type_t>(cache_string, ##__VA_ARGS__)); \
+        EXPECT_FALSE(PARSE::try_parse<type_t>(cache_string, cache, ##__VA_ARGS__)); \
-}
+        EXPECT_ANY_THROW(PARSE::parse<type_t>(cache_string, ##__VA_ARGS__)); \
+    }
 
     TEST(StringParse, Common) {
         TEST_SUCCESS(i8, INT8_C(-61), "-61");
@@ -79,4 +81,4 @@ namespace yycctest::string::parse {
         TEST_FAIL(bool, "hello, world!");
     }
 
-}
+} // namespace yycctest::string::parse

testbench/yycc/string/stringify.cpp

@@ -1,7 +1,7 @@
 #include <gtest/gtest.h>
 #include <yycc.hpp>
-#include <yycc/string/stringify.hpp>
 #include <yycc/string/reinterpret.hpp>
+#include <yycc/string/stringify.hpp>
 
 #include <yycc/prelude/rust.hpp>
 
@@ -9,11 +9,12 @@
 
 namespace yycctest::string::stringify {
 
-#define TEST_SUCCESS(type_t, value, string_value, ...) { \
+#define TEST_SUCCESS(type_t, value, string_value, ...) \
-    type_t cache = value; \
+    { \
-    u8string ret = STRINGIFY::stringify<type_t>(cache, ##__VA_ARGS__); \
+        type_t cache = value; \
-    EXPECT_EQ(ret, YYCC_U8(string_value)); \
+        u8string ret = STRINGIFY::stringify<type_t>(cache, ##__VA_ARGS__); \
-}
+        EXPECT_EQ(ret, YYCC_U8(string_value)); \
+    }
 
     TEST(StringStringify, Common) {
         TEST_SUCCESS(i8, INT8_C(-61), "-61");
@@ -38,4 +39,4 @@ namespace yycctest::string::stringify {
         TEST_SUCCESS(u32, UINT32_C(0B1011), "1011", 2);
     }
 
-}
+} // namespace yycctest::string::stringify