String conversion and parsing format spec.

4 files changed, 637 insertions, 99 deletions

diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 515ae16..788e4ba 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -69,6 +69,7 @@ fud_add_test(test_sqlite SOURCES test_sqlite.cpp)
 fud_add_test(test_string SOURCES test_string.cpp)
 fud_add_test(test_utf8 SOURCES test_utf8.cpp)
 fud_add_test(test_vector SOURCES test_vector.cpp)
+fud_add_test(test_string_convert SOURCES test_string_convert.cpp)
 
 # fud_add_test(test_deserialize_number SOURCES test_deserialize_number.cpp)
 # fud_add_test(test_ext_algorithm SOURCES test_algorithm.cpp)
diff --git a/test/test_format.cpp b/test/test_format.cpp
index 319ed22..68c94cd 100644
--- a/test/test_format.cpp
+++ b/test/test_format.cpp
@@ -15,17 +15,339 @@
  * limitations under the License.
  */
 
-// #include "fud_array.hpp"
-// #include "fud_format.hpp"
-// #include "fud_span.hpp"
+#include "fud_string_view.hpp"
+#include "fud_format.hpp"
 
 #include "gtest/gtest.h"
 
 namespace fud {
 
-TEST(FormatTest, FormatSpecTest)
+TEST(FormatTest, BasePositionalTest)
 {
+    size_t length = 0;
 
+    auto formatSpecResult = FormatSpec::make(StringView{" {1:}"}, length);
+    ASSERT_TRUE(formatSpecResult.isError());
+    EXPECT_EQ(formatSpecResult.takeError(), FudStatus::ArgumentInvalid);
+
+    formatSpecResult = FormatSpec::make(StringView{"{1}"}, length);
+    ASSERT_TRUE(formatSpecResult.isOkay());
+    auto formatSpec = formatSpecResult.takeOkay();
+    EXPECT_EQ(formatSpec.position, 1);
+    EXPECT_EQ(length, 3);
+
+    formatSpecResult = FormatSpec::make(StringView{"{1:}"}, length);
+    ASSERT_TRUE(formatSpecResult.isOkay());
+    formatSpec = formatSpecResult.takeOkay();
+    EXPECT_EQ(length, 4);
+    EXPECT_EQ(formatSpec.position, 1);
+    EXPECT_EQ(formatSpec.fill.align(), FormatAlign::Value::Default);
+    EXPECT_EQ(formatSpec.fill.fill, ' ');
+    EXPECT_EQ(formatSpec.formatSign, FormatSign::Default);
+    EXPECT_FALSE(formatSpec.takesWidth);
+    EXPECT_FALSE(formatSpec.takesPrecision);
+    EXPECT_FALSE(formatSpec.alternateForm);
+    EXPECT_FALSE(formatSpec.leadingZero);
+    EXPECT_FALSE(formatSpec.hasLocale);
+    EXPECT_TRUE(std::holds_alternative<std::monostate>(formatSpec.formatType));
+}
+
+TEST(FormatTest, AlignTest)
+{
+    size_t length = 0;
+
+    auto formatSpecResult = FormatSpec::make(StringView{"{1:<}"}, length);
+    ASSERT_TRUE(formatSpecResult.isOkay());
+    auto formatSpec = formatSpecResult.takeOkay();
+    EXPECT_EQ(formatSpec.position, 1);
+    EXPECT_EQ(length, 5);
+    EXPECT_EQ(formatSpec.fill.align(), FormatAlign::Value::Left);
+    EXPECT_EQ(formatSpec.fill.fill, ' ');
+    EXPECT_FALSE(formatSpec.takesWidth);
+    EXPECT_FALSE(formatSpec.takesPrecision);
+    EXPECT_FALSE(formatSpec.alternateForm);
+    EXPECT_FALSE(formatSpec.leadingZero);
+    EXPECT_FALSE(formatSpec.hasLocale);
+    EXPECT_TRUE(std::holds_alternative<std::monostate>(formatSpec.formatType));
+
+    formatSpecResult = FormatSpec::make(StringView{"{1:<<}"}, length);
+    ASSERT_TRUE(formatSpecResult.isOkay());
+    formatSpec = formatSpecResult.takeOkay();
+    EXPECT_EQ(formatSpec.position, 1);
+    EXPECT_EQ(formatSpec.fill.align(), FormatAlign::Value::Left);
+    EXPECT_EQ(formatSpec.fill.fill, '<');
+
+    formatSpecResult = FormatSpec::make(StringView{"{:<<}"}, length);
+    ASSERT_TRUE(formatSpecResult.isOkay());
+    formatSpec = formatSpecResult.takeOkay();
+    EXPECT_EQ(length, 5);
+    EXPECT_EQ(formatSpec.position, FormatSpec::positionUnspecified);
+    EXPECT_EQ(formatSpec.fill.align(), FormatAlign::Value::Left);
+    EXPECT_EQ(formatSpec.fill.fill, '<');
+
+    formatSpecResult = FormatSpec::make(StringView{"{1:_<}"}, length);
+    ASSERT_TRUE(formatSpecResult.isOkay());
+    formatSpec = formatSpecResult.takeOkay();
+    EXPECT_EQ(length, 6);
+    EXPECT_EQ(formatSpec.position, 1);
+    EXPECT_EQ(formatSpec.fill.align(), FormatAlign::Value::Left);
+    EXPECT_EQ(formatSpec.fill.fill, '_');
+}
+
+TEST(FormatTest, SpecialTest)
+{
+    size_t length = 0;
+
+    auto formatSpecResult = FormatSpec::make(StringView{"{1:_< }"}, length);
+    ASSERT_TRUE(formatSpecResult.isOkay());
+    auto formatSpec = formatSpecResult.takeOkay();
+    EXPECT_EQ(length, 7);
+    EXPECT_EQ(formatSpec.position, 1);
+    EXPECT_EQ(formatSpec.fill.align(), FormatAlign::Value::Left);
+    EXPECT_EQ(formatSpec.fill.fill, '_');
+    EXPECT_EQ(formatSpec.formatSign, FormatSign::Space);
+    EXPECT_FALSE(formatSpec.alternateForm);
+    EXPECT_FALSE(formatSpec.leadingZero);
+
+    formatSpecResult = FormatSpec::make(StringView{"{1:+}"}, length);
+    ASSERT_TRUE(formatSpecResult.isOkay());
+    EXPECT_EQ(length, 5);
+    formatSpec = formatSpecResult.takeOkay();
+    EXPECT_EQ(formatSpec.position, 1);
+    EXPECT_EQ(formatSpec.formatSign, FormatSign::Plus);
+    EXPECT_FALSE(formatSpec.alternateForm);
+    EXPECT_FALSE(formatSpec.leadingZero);
+
+    formatSpecResult = FormatSpec::make(StringView{"{1:-}"}, length);
+    ASSERT_TRUE(formatSpecResult.isOkay());
+    formatSpec = formatSpecResult.takeOkay();
+    EXPECT_EQ(length, 5);
+    EXPECT_EQ(formatSpec.position, 1);
+    EXPECT_EQ(formatSpec.formatSign, FormatSign::Minus);
+    EXPECT_FALSE(formatSpec.alternateForm);
+    EXPECT_FALSE(formatSpec.leadingZero);
+
+    formatSpecResult = FormatSpec::make(StringView{"{1:_<#}"}, length);
+    ASSERT_TRUE(formatSpecResult.isOkay());
+    formatSpec = formatSpecResult.takeOkay();
+    EXPECT_EQ(length, 7);
+    EXPECT_EQ(formatSpec.position, 1);
+    EXPECT_EQ(formatSpec.fill.align(), FormatAlign::Value::Left);
+    EXPECT_EQ(formatSpec.fill.fill, '_');
+    EXPECT_EQ(formatSpec.formatSign, FormatSign::Default);
+    EXPECT_TRUE(formatSpec.alternateForm);
+    EXPECT_FALSE(formatSpec.leadingZero);
+
+    formatSpecResult = FormatSpec::make(StringView{"{1:_<0}"}, length);
+    ASSERT_TRUE(formatSpecResult.isOkay());
+    formatSpec = formatSpecResult.takeOkay();
+    EXPECT_EQ(length, 7);
+    EXPECT_EQ(formatSpec.position, 1);
+    EXPECT_EQ(formatSpec.fill.align(), FormatAlign::Value::Left);
+    EXPECT_EQ(formatSpec.fill.fill, '_');
+    EXPECT_EQ(formatSpec.formatSign, FormatSign::Default);
+    EXPECT_FALSE(formatSpec.alternateForm);
+    EXPECT_TRUE(formatSpec.leadingZero);
+
+    formatSpecResult = FormatSpec::make(StringView{"{1: #}"}, length);
+    ASSERT_TRUE(formatSpecResult.isOkay());
+    formatSpec = formatSpecResult.takeOkay();
+    EXPECT_EQ(length, 6);
+    EXPECT_EQ(formatSpec.position, 1);
+    EXPECT_EQ(formatSpec.fill.align(), FormatAlign::Value::Default);
+    EXPECT_EQ(formatSpec.fill.fill, ' ');
+    EXPECT_EQ(formatSpec.formatSign, FormatSign::Space);
+    EXPECT_TRUE(formatSpec.alternateForm);
+    EXPECT_FALSE(formatSpec.leadingZero);
+
+    formatSpecResult = FormatSpec::make(StringView{"{1:# }"}, length);
+    ASSERT_TRUE(formatSpecResult.isError());
+    EXPECT_EQ(formatSpecResult.takeError(), FudStatus::FormatInvalid);
+
+    formatSpecResult = FormatSpec::make(StringView{"{1:##}"}, length);
+    ASSERT_TRUE(formatSpecResult.isError());
+    EXPECT_EQ(formatSpecResult.takeError(), FudStatus::FormatInvalid);
+
+    formatSpecResult = FormatSpec::make(StringView{"{1: 0}"}, length);
+    ASSERT_TRUE(formatSpecResult.isOkay());
+    formatSpec = formatSpecResult.takeOkay();
+    EXPECT_EQ(length, 6);
+    EXPECT_EQ(formatSpec.position, 1);
+    EXPECT_EQ(formatSpec.fill.align(), FormatAlign::Value::Default);
+    EXPECT_EQ(formatSpec.fill.fill, ' ');
+    EXPECT_EQ(formatSpec.formatSign, FormatSign::Space);
+    EXPECT_FALSE(formatSpec.alternateForm);
+    EXPECT_TRUE(formatSpec.leadingZero);
+
+    formatSpecResult = FormatSpec::make(StringView{"{1:0 }"}, length);
+    ASSERT_TRUE(formatSpecResult.isError());
+    EXPECT_EQ(formatSpecResult.takeError(), FudStatus::FormatInvalid);
+
+    formatSpecResult = FormatSpec::make(StringView{"{1:0#}"}, length);
+    ASSERT_TRUE(formatSpecResult.isError());
+    EXPECT_EQ(formatSpecResult.takeError(), FudStatus::FormatInvalid);
+
+    formatSpecResult = FormatSpec::make(StringView{"{1:#00}"}, length);
+    ASSERT_TRUE(formatSpecResult.isError());
+    EXPECT_EQ(formatSpecResult.takeError(), FudStatus::FormatInvalid);
+
+    formatSpecResult = FormatSpec::make(StringView{"{1: #0}"}, length);
+    ASSERT_TRUE(formatSpecResult.isOkay());
+    formatSpec = formatSpecResult.takeOkay();
+    EXPECT_EQ(length, 7);
+    EXPECT_EQ(formatSpec.position, 1);
+    EXPECT_EQ(formatSpec.fill.align(), FormatAlign::Value::Default);
+    EXPECT_EQ(formatSpec.fill.fill, ' ');
+    EXPECT_EQ(formatSpec.formatSign, FormatSign::Space);
+    EXPECT_TRUE(formatSpec.alternateForm);
+    EXPECT_TRUE(formatSpec.leadingZero);
+}
+
+TEST(FormatTest, WidthTest)
+{
+    size_t length = 0;
+
+    auto formatSpecResult = FormatSpec::make(StringView{"{1:1}"}, length);
+    ASSERT_TRUE(formatSpecResult.isOkay());
+    auto formatSpec = formatSpecResult.takeOkay();
+    EXPECT_EQ(length, 5);
+    EXPECT_EQ(formatSpec.position, 1);
+    EXPECT_FALSE(formatSpec.takesWidth);
+    EXPECT_EQ(formatSpec.width, 1);
+
+    formatSpecResult = FormatSpec::make(StringView{"{1:543}"}, length);
+    ASSERT_TRUE(formatSpecResult.isOkay());
+    formatSpec = formatSpecResult.takeOkay();
+    EXPECT_EQ(length, 7);
+    EXPECT_EQ(formatSpec.position, 1);
+    EXPECT_FALSE(formatSpec.takesWidth);
+    EXPECT_EQ(formatSpec.width, 543);
+
+    formatSpecResult = FormatSpec::make(StringView{"{:543}"}, length);
+    ASSERT_TRUE(formatSpecResult.isOkay());
+    formatSpec = formatSpecResult.takeOkay();
+    EXPECT_EQ(length, 6);
+    EXPECT_EQ(formatSpec.position, FormatSpec::positionUnspecified);
+    EXPECT_FALSE(formatSpec.takesWidth);
+    EXPECT_EQ(formatSpec.width, 543);
+
+    // leading zero
+    formatSpecResult = FormatSpec::make(StringView{"{1:00}"}, length);
+    ASSERT_TRUE(formatSpecResult.isError());
+    EXPECT_EQ(formatSpecResult.getError(), FudStatus::FormatInvalid);
+
+    // #x100000000 4294967296
+    formatSpecResult = FormatSpec::make(StringView{"{1:4294967296}"}, length);
+    ASSERT_TRUE(formatSpecResult.isError());
+    EXPECT_EQ(formatSpecResult.getError(), FudStatus::RangeError);
+
+    formatSpecResult = FormatSpec::make(StringView{"{1:{1}}"}, length);
+    ASSERT_TRUE(formatSpecResult.isOkay());
+    formatSpec = formatSpecResult.takeOkay();
+    EXPECT_EQ(length, 7);
+    EXPECT_EQ(formatSpec.position, 1);
+    EXPECT_TRUE(formatSpec.takesWidth);
+    EXPECT_EQ(formatSpec.width, 1);
+
+    // #x10000 65536
+    formatSpecResult = FormatSpec::make(StringView{"{1:{65536}}"}, length);
+    ASSERT_TRUE(formatSpecResult.isError());
+    EXPECT_EQ(formatSpecResult.getError(), FudStatus::RangeError);
+
+    formatSpecResult = FormatSpec::make(StringView{"{:{1}}"}, length);
+    ASSERT_TRUE(formatSpecResult.isError());
+    EXPECT_EQ(formatSpecResult.getError(), FudStatus::FormatInvalid);
+
+    formatSpecResult = FormatSpec::make(StringView{"{:{}}"}, length);
+    ASSERT_TRUE(formatSpecResult.isOkay());
+    formatSpec = formatSpecResult.takeOkay();
+    EXPECT_EQ(length, 5);
+    EXPECT_EQ(formatSpec.position, FormatSpec::positionUnspecified);
+    EXPECT_TRUE(formatSpec.takesWidth);
+    EXPECT_EQ(formatSpec.width, FormatSpec::widthUnspecified);
+}
+
+TEST(FormatTest, PrecisionTest)
+{
+    size_t length = 0;
+
+    auto formatSpecResult = FormatSpec::make(StringView{"{1:.1}"}, length);
+    ASSERT_TRUE(formatSpecResult.isOkay());
+    auto formatSpec = formatSpecResult.takeOkay();
+    EXPECT_EQ(length, 6);
+    EXPECT_EQ(formatSpec.position, 1);
+    EXPECT_FALSE(formatSpec.takesPrecision);
+    EXPECT_EQ(formatSpec.precision, 1);
+
+    formatSpecResult = FormatSpec::make(StringView{"{1:.543}"}, length);
+    ASSERT_TRUE(formatSpecResult.isOkay());
+    formatSpec = formatSpecResult.takeOkay();
+    EXPECT_EQ(length, 8);
+    EXPECT_EQ(formatSpec.position, 1);
+    EXPECT_FALSE(formatSpec.takesPrecision);
+    EXPECT_EQ(formatSpec.precision, 543);
+
+    formatSpecResult = FormatSpec::make(StringView{"{:.543}"}, length);
+    ASSERT_TRUE(formatSpecResult.isOkay());
+    formatSpec = formatSpecResult.takeOkay();
+    EXPECT_EQ(length, 7);
+    EXPECT_EQ(formatSpec.position, FormatSpec::positionUnspecified);
+    EXPECT_FALSE(formatSpec.takesPrecision);
+    EXPECT_EQ(formatSpec.precision, 543);
+
+    // leading zero
+    formatSpecResult = FormatSpec::make(StringView{"{1:00}"}, length);
+    ASSERT_TRUE(formatSpecResult.isError());
+    EXPECT_EQ(formatSpecResult.getError(), FudStatus::FormatInvalid);
+
+    // #x100000000 4294967296
+    formatSpecResult = FormatSpec::make(StringView{"{1:.4294967296}"}, length);
+    ASSERT_TRUE(formatSpecResult.isError());
+    EXPECT_EQ(formatSpecResult.getError(), FudStatus::RangeError);
+
+    formatSpecResult = FormatSpec::make(StringView{"{1:.{1}}"}, length);
+    ASSERT_TRUE(formatSpecResult.isOkay());
+    formatSpec = formatSpecResult.takeOkay();
+    EXPECT_EQ(length, 8);
+    EXPECT_EQ(formatSpec.position, 1);
+    EXPECT_TRUE(formatSpec.takesPrecision);
+    EXPECT_EQ(formatSpec.precision, 1);
+
+    // #x10000 65536
+    formatSpecResult = FormatSpec::make(StringView{"{1:.{65536}}"}, length);
+    ASSERT_TRUE(formatSpecResult.isError());
+    EXPECT_EQ(formatSpecResult.getError(), FudStatus::RangeError);
+
+    formatSpecResult = FormatSpec::make(StringView{"{:.{1}}"}, length);
+    ASSERT_TRUE(formatSpecResult.isError());
+    EXPECT_EQ(formatSpecResult.getError(), FudStatus::FormatInvalid);
+
+    formatSpecResult = FormatSpec::make(StringView{"{:.{}}"}, length);
+    ASSERT_TRUE(formatSpecResult.isOkay());
+    formatSpec = formatSpecResult.takeOkay();
+    EXPECT_EQ(length, 6);
+    EXPECT_EQ(formatSpec.position, FormatSpec::positionUnspecified);
+    EXPECT_TRUE(formatSpec.takesPrecision);
+    EXPECT_EQ(formatSpec.precision, FormatSpec::widthUnspecified);
+}
+
+TEST(FormatTest, LocaleTest)
+{
+    size_t length = 0;
+
+    auto formatSpecResult = FormatSpec::make(StringView{"{1:L}"}, length);
+    ASSERT_TRUE(formatSpecResult.isOkay());
+    auto formatSpec = formatSpecResult.takeOkay();
+    EXPECT_EQ(length, 5);
+    EXPECT_EQ(formatSpec.position, 1);
+    EXPECT_TRUE(formatSpec.hasLocale);
+
+    formatSpecResult = FormatSpec::make(StringView{"{:L}"}, length);
+    ASSERT_TRUE(formatSpecResult.isOkay());
+    formatSpec = formatSpecResult.takeOkay();
+    EXPECT_EQ(length, 4);
+    EXPECT_EQ(formatSpec.position, FormatSpec::positionUnspecified);
+    EXPECT_TRUE(formatSpec.hasLocale);
 }
 
 } // namespace fud
diff --git a/test/test_string_convert.cpp b/test/test_string_convert.cpp
new file mode 100644
index 0000000..38f5123
--- /dev/null
+++ b/test/test_string_convert.cpp
@@ -0,0 +1,186 @@
+/*
+ * libfud
+ * Copyright 2024 Dominick Allen
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#include "fud_string_convert.hpp"
+
+#include "gtest/gtest.h"
+
+namespace fud {
+
+TEST(FudStringConvert, ConvertInt)
+{
+    auto intResult = fromString<int>(StringView{"0"});
+    ASSERT_TRUE(intResult.isOkay());
+    auto convertState = intResult.getOkay();
+    ASSERT_EQ(convertState.value, 0);
+    ASSERT_EQ(convertState.nextIndex, 1);
+
+    intResult = fromString<int>(StringView{"1"});
+    ASSERT_TRUE(intResult.isOkay());
+    convertState = intResult.getOkay();
+    ASSERT_EQ(convertState.value, 1);
+    ASSERT_EQ(convertState.nextIndex, 1);
+
+    intResult = fromString<int>(StringView{"-1"});
+    ASSERT_TRUE(intResult.isOkay());
+    convertState = intResult.getOkay();
+    ASSERT_EQ(convertState.value, -1);
+    ASSERT_EQ(convertState.nextIndex, 2);
+
+    intResult = fromString<int>(StringView{"+1"});
+    ASSERT_TRUE(intResult.isOkay());
+    convertState = intResult.getOkay();
+    ASSERT_EQ(convertState.value, 1);
+    ASSERT_EQ(convertState.nextIndex, 2);
+
+    intResult = fromString<int>(StringView{" +42"});
+    ASSERT_TRUE(intResult.isOkay());
+    convertState = intResult.getOkay();
+    ASSERT_EQ(convertState.value, 42);
+    ASSERT_EQ(convertState.nextIndex, 4);
+
+    intResult = fromString<int>(StringView{" +42Q"});
+    ASSERT_TRUE(intResult.isOkay());
+    convertState = intResult.getOkay();
+    ASSERT_EQ(convertState.value, 42);
+    ASSERT_EQ(convertState.nextIndex, 4);
+}
+
+TEST(FudStringConvert, ConvertUnsigned)
+{
+    auto unsignedResult = fromString<uint16_t>(StringView{"0"});
+    ASSERT_TRUE(unsignedResult.isOkay());
+    auto convertState = unsignedResult.getOkay();
+    ASSERT_EQ(convertState.value, 0);
+    ASSERT_EQ(convertState.nextIndex, 1);
+
+    unsignedResult = fromString<uint16_t>(StringView{"1"});
+    ASSERT_TRUE(unsignedResult.isOkay());
+    convertState = unsignedResult.getOkay();
+    ASSERT_EQ(convertState.value, 1);
+    ASSERT_EQ(convertState.nextIndex, 1);
+
+    unsignedResult = fromString<uint16_t>(StringView{"-1"});
+    ASSERT_TRUE(unsignedResult.isError());
+    ASSERT_EQ(unsignedResult.getError(), FudStatus::ArgumentInvalid);
+
+    unsignedResult = fromString<uint16_t>(StringView{"0xFFFF"});
+    ASSERT_TRUE(unsignedResult.isOkay());
+    convertState = unsignedResult.getOkay();
+    ASSERT_EQ(convertState.value, 0xFFFF);
+    ASSERT_EQ(convertState.nextIndex, 6);
+
+    unsignedResult = fromString<uint16_t>(StringView{"0x10000"});
+    ASSERT_TRUE(unsignedResult.isError());
+    ASSERT_EQ(unsignedResult.getError(), FudStatus::RangeError);
+
+    unsignedResult = fromString<uint16_t>(StringView{"+1"});
+    ASSERT_TRUE(unsignedResult.isOkay());
+    convertState = unsignedResult.getOkay();
+    ASSERT_EQ(convertState.value, 1);
+    ASSERT_EQ(convertState.nextIndex, 2);
+
+    unsignedResult = fromString<uint16_t>(StringView{" +42"});
+    ASSERT_TRUE(unsignedResult.isOkay());
+    convertState = unsignedResult.getOkay();
+    ASSERT_EQ(convertState.value, 42);
+    ASSERT_EQ(convertState.nextIndex, 4);
+
+    unsignedResult = fromString<uint16_t>(StringView{" +42Q"});
+    ASSERT_TRUE(unsignedResult.isOkay());
+    convertState = unsignedResult.getOkay();
+    ASSERT_EQ(convertState.value, 42);
+    ASSERT_EQ(convertState.nextIndex, 4);
+}
+
+TEST(FudStringConvert, ConvertFloat)
+{
+    auto floatResult = fromString<float>(StringView{"0"});
+    ASSERT_TRUE(floatResult.isOkay());
+    auto convertState = floatResult.getOkay();
+    ASSERT_EQ(convertState.value, 0.0);
+    ASSERT_EQ(convertState.nextIndex, 1);
+
+    floatResult = fromString<float>(StringView{"1.0"});
+    ASSERT_TRUE(floatResult.isOkay());
+    convertState = floatResult.getOkay();
+    ASSERT_EQ(convertState.value, 1.0);
+    ASSERT_EQ(convertState.nextIndex, 3);
+
+    floatResult = fromString<float>(StringView{"1.5"});
+    ASSERT_TRUE(floatResult.isOkay());
+    convertState = floatResult.getOkay();
+    ASSERT_EQ(convertState.value, 1.5);
+    ASSERT_EQ(convertState.nextIndex, 3);
+
+    floatResult = fromString<float>(StringView{"1.5 next"});
+    ASSERT_TRUE(floatResult.isOkay());
+    convertState = floatResult.getOkay();
+    ASSERT_EQ(convertState.value, 1.5);
+    ASSERT_EQ(convertState.nextIndex, 3);
+
+    floatResult = fromString<float>(StringView{"-1.0"});
+    ASSERT_TRUE(floatResult.isOkay());
+    convertState = floatResult.getOkay();
+    ASSERT_EQ(convertState.value, -1.0);
+    ASSERT_EQ(convertState.nextIndex, 4);
+
+    floatResult = fromString<float>(StringView{"-1.5 next"});
+    ASSERT_TRUE(floatResult.isOkay());
+    convertState = floatResult.getOkay();
+    ASSERT_EQ(convertState.value, -1.5);
+    ASSERT_EQ(convertState.nextIndex, 4);
+
+    floatResult = fromString<float>(StringView{" -1.5 next"});
+    ASSERT_TRUE(floatResult.isOkay());
+    convertState = floatResult.getOkay();
+    ASSERT_EQ(convertState.value, -1.5);
+    ASSERT_EQ(convertState.nextIndex, 5);
+
+    floatResult = fromString<float>(StringView{" -1.5E+3 next"});
+    ASSERT_TRUE(floatResult.isOkay());
+    convertState = floatResult.getOkay();
+    ASSERT_EQ(convertState.value, -1.5E+3);
+    ASSERT_EQ(convertState.nextIndex, sizeof(" -1.5E+3") - 1);
+
+    floatResult = fromString<float>(StringView{" -15E+2 next"});
+    ASSERT_TRUE(floatResult.isOkay());
+    convertState = floatResult.getOkay();
+    ASSERT_EQ(convertState.value, -1.5E+3);
+    ASSERT_EQ(convertState.nextIndex, sizeof(" -15E+2") - 1);
+
+    floatResult = fromString<float>(StringView{" -1EA next"});
+    ASSERT_TRUE(floatResult.isError());
+    ASSERT_EQ(floatResult.getError(), FudStatus::ArgumentInvalid);
+
+    floatResult = fromString<float>(StringView{" -1.5EA next"});
+    ASSERT_TRUE(floatResult.isError());
+    ASSERT_EQ(floatResult.getError(), FudStatus::ArgumentInvalid);
+
+    floatResult = fromString<float>(StringView{" -1.5EQ next"});
+    ASSERT_TRUE(floatResult.isError());
+    ASSERT_EQ(floatResult.getError(), FudStatus::ArgumentInvalid);
+
+    floatResult = fromString<float>(StringView{" -1.5E3Q next"});
+    ASSERT_TRUE(floatResult.isOkay());
+    convertState = floatResult.getOkay();
+    ASSERT_EQ(convertState.value, -1.5E3);
+    ASSERT_EQ(convertState.nextIndex, sizeof(" -1.5E3") - 1);
+}
+
+} // namespace fud
diff --git a/test/test_utf8.cpp b/test/test_utf8.cpp
index d1737f7..4b57b64 100644
--- a/test/test_utf8.cpp
+++ b/test/test_utf8.cpp
@@ -30,6 +30,35 @@
 
 namespace fud {
 
+using classify::CharPredicate;
+using classify::FudUtf8Predicate;
+using classify::isAscii;
+using classify::isAscii;
+using classify:: isAlphanumeric;
+using classify:: isAlphanumeric;
+using classify:: isAlpha;
+using classify:: isAlpha;
+using classify:: isLowercase;
+using classify:: isLowercase;
+using classify:: isUppercase;
+using classify:: isUppercase;
+using classify:: isDigit;
+using classify:: isDigit;
+using classify:: isHexDigit;
+using classify:: isHexDigit;
+using classify:: isControl;
+using classify:: isControl;
+using classify:: isGraphical;
+using classify:: isGraphical;
+using classify:: isSpace;
+using classify:: isSpace;
+using classify:: isBlank;
+using classify:: isBlank;
+using classify:: isPrintable;
+using classify:: isPrintable;
+using classify:: isPunctuation;
+using classify:: isPunctuation;
+
 constexpr size_t validAsciiSize = INT8_MAX + 1;
 constexpr size_t invalidAsciiSize = UINT8_MAX + 1 - validAsciiSize;
 
@@ -194,24 +223,24 @@ TEST(Utf8Test, Utf8MultiByte)
 
 TEST(Utf8Test, Utf8IsAscii)
 {
-    ASSERT_FALSE(charIsAscii(invalidAscii));
+    ASSERT_FALSE(isAscii(invalidAscii));
 
     Iota<int16_t> charIota{0, 1, validAsciiSize};
 
-    ASSERT_TRUE(allOf([&]() -> Option<char> { return charIota().map(toLetter<int16_t>); }, charIsAscii));
+    ASSERT_TRUE(allOf([&]() -> Option<char> { return charIota().map(toLetter<int16_t>); }, static_cast<CharPredicate>(isAscii)));
 
     Iota<int16_t> invalidCharIota{validAsciiSize, 1, invalidAsciiSize};
 
-    ASSERT_FALSE(anyOf([&]() -> Option<char> { return invalidCharIota().map(toLetter<int16_t>); }, charIsAscii));
+    ASSERT_FALSE(anyOf([&]() -> Option<char> { return invalidCharIota().map(toLetter<int16_t>); }, static_cast<CharPredicate>(isAscii)));
 
     FudUtf8 unicode{FudUtf8::invalidAscii()};
-    ASSERT_FALSE(utf8IsAscii(unicode));
+    ASSERT_FALSE(isAscii(unicode));
 
     charIota.set(0);
-    ASSERT_TRUE(allOf([&]() -> Option<FudUtf8> { return charIota().map(toUtf8<int16_t>); }, utf8IsAscii));
+    ASSERT_TRUE(allOf([&]() -> Option<FudUtf8> { return charIota().map(toUtf8<int16_t>); }, static_cast<FudUtf8Predicate>(isAscii)));
 
     invalidCharIota.set(invalidAsciiSize);
-    ASSERT_FALSE(anyOf([&]() -> Option<FudUtf8> { return invalidCharIota().map(toUtf8<int16_t>); }, utf8IsAscii));
+    ASSERT_FALSE(anyOf([&]() -> Option<FudUtf8> { return invalidCharIota().map(toUtf8<int16_t>); }, static_cast<FudUtf8Predicate>(isAscii)));
 }
 
 template <typename T, size_t Size = SIZE_MAX>
@@ -241,22 +270,22 @@ TEST(Utf8Test, Utf8IsAlphanumeric)
     Array<char, numAlphanumericChars> alphanumericChars{};
     copyMem<numAlphanumericChars>(alphanumericChars, alphanumericCharLiteral);
 
-    ASSERT_TRUE(allOf(alphanumericChars.span(), charIsAlphanumeric));
+    ASSERT_TRUE(allOf(alphanumericChars.span(), static_cast<CharPredicate>(isAlphanumeric)));
 
     constexpr size_t numNonAlphanumericChars = validAsciiSize - numAlphanumericChars;
     Vector<char> nonAlphanumericChars{};
     for (char idx = 0; idx < INT8_MAX; ++idx) {
-        if (!charIsAlphanumeric(idx)) {
+        if (!isAlphanumeric(idx)) {
             ASSERT_EQ(nonAlphanumericChars.pushBack(idx), FudStatus::Success);
         }
     }
     auto nonAlphanumericSpan{nonAlphanumericChars.span().takeOkay()};
-    ASSERT_FALSE(anyOf(nonAlphanumericSpan, charIsAlphanumeric));
+    ASSERT_FALSE(anyOf(nonAlphanumericSpan, static_cast<CharPredicate>(isAlphanumeric)));
 
     auto invalidAsciiChars = invalidAsciiGenerator();
-    ASSERT_FALSE(anyOf(invalidAsciiChars, charIsAlphanumeric));
+    ASSERT_FALSE(anyOf(invalidAsciiChars, static_cast<CharPredicate>(isAlphanumeric)));
 
-    ASSERT_FALSE(utf8IsAlphanumeric(FudUtf8{Ascii{invalidAscii}}));
+    ASSERT_FALSE(isAlphanumeric(FudUtf8{Ascii{invalidAscii}}));
 
     auto iotaGenerator = invalidAsciiGenerator();
     auto generator = generate(
@@ -265,11 +294,11 @@ TEST(Utf8Test, Utf8IsAlphanumeric)
 
     SpanGenerator<char, alphanumericChars.size()> alphanumericGenerator{alphanumericChars.span()};
     auto utf8AlphanumericGenerator = [&]() { return alphanumericGenerator().map(toUtf8<uint16_t>); };
-    ASSERT_TRUE(allOf(utf8AlphanumericGenerator, utf8IsAlphanumeric));
+    ASSERT_TRUE(allOf(utf8AlphanumericGenerator, static_cast<FudUtf8Predicate>(isAlphanumeric)));
 
     SpanGenerator<char> nonAlphanumericGenerator{nonAlphanumericChars.span().takeOkay()};
     auto utf8NonAlphanumericGenerator = [&]() { return nonAlphanumericGenerator().map(toUtf8<uint16_t>); };
-    ASSERT_FALSE(anyOf(utf8NonAlphanumericGenerator, utf8IsAlphanumeric));
+    ASSERT_FALSE(anyOf(utf8NonAlphanumericGenerator, static_cast<FudUtf8Predicate>(isAlphanumeric)));
 }
 
 TEST(Utf8Test, Utf8IsAlpha)
@@ -279,29 +308,29 @@ TEST(Utf8Test, Utf8IsAlpha)
     Array<char, numAlphaChars> alphaChars{};
     copyMem<numAlphaChars>(alphaChars, alphaCharLiteral);
 
-    ASSERT_TRUE(allOf(alphaChars.span(), charIsAlpha));
+    ASSERT_TRUE(allOf(alphaChars.span(), static_cast<CharPredicate>(isAlpha)));
 
     constexpr size_t numNonAlphanumericChars = validAsciiSize - numAlphaChars;
     Vector<char> nonAlphaChars{};
     for (char idx = 0; idx < INT8_MAX; ++idx) {
-        if (!charIsAlphanumeric(idx)) {
+        if (!isAlphanumeric(idx)) {
             ASSERT_EQ(nonAlphaChars.pushBack(idx), FudStatus::Success);
         }
     }
-    ASSERT_FALSE(anyOf(nonAlphaChars.span().takeOkay(), charIsAlpha));
+    ASSERT_FALSE(anyOf(nonAlphaChars.span().takeOkay(), static_cast<CharPredicate>(isAlpha)));
 
     auto invalidAsciiChars = invalidAsciiGenerator();
-    ASSERT_FALSE(anyOf(invalidAsciiChars, charIsAlpha));
+    ASSERT_FALSE(anyOf(invalidAsciiChars, static_cast<CharPredicate>(isAlpha)));
 
-    ASSERT_FALSE(utf8IsAlpha(FudUtf8{Ascii{invalidAscii}}));
+    ASSERT_FALSE(isAlpha(FudUtf8{Ascii{invalidAscii}}));
 
     SpanGenerator<char, alphaChars.size()> alphaGenerator{alphaChars.span()};
     auto utf8AlphaGenerator = [&]() { return alphaGenerator().map(toUtf8<uint16_t>); };
-    ASSERT_TRUE(allOf(utf8AlphaGenerator, utf8IsAlpha));
+    ASSERT_TRUE(allOf(utf8AlphaGenerator, static_cast<FudUtf8Predicate>(isAlpha)));
 
     SpanGenerator<char> nonAlphaGenerator{nonAlphaChars.span().takeOkay()};
     auto utf8NonAlphaGenerator = [&]() { return nonAlphaGenerator().map(toUtf8<uint16_t>); };
-    ASSERT_FALSE(anyOf(utf8NonAlphaGenerator, utf8IsAlpha));
+    ASSERT_FALSE(anyOf(utf8NonAlphaGenerator, static_cast<FudUtf8Predicate>(isAlpha)));
 }
 
 TEST(Utf8Test, Utf8IsLower)
@@ -311,29 +340,29 @@ TEST(Utf8Test, Utf8IsLower)
     Array<char, numLowerChars> lowerChars{};
     copyMem<numLowerChars>(lowerChars, lowerCharLiteral);
 
-    ASSERT_TRUE(allOf(lowerChars.span(), charIsLowercase));
+    ASSERT_TRUE(allOf(lowerChars.span(), static_cast<CharPredicate>(isLowercase)));
 
     constexpr size_t numNonLowerChars = validAsciiSize - numLowerChars;
     Vector<char> nonLowerChars{};
     for (char idx = 0; idx < INT8_MAX; ++idx) {
-        if (!charIsLowercase(idx)) {
+        if (!isLowercase(idx)) {
             ASSERT_EQ(nonLowerChars.pushBack(idx), FudStatus::Success);
         }
     }
-    ASSERT_FALSE(anyOf(nonLowerChars.span().takeOkay(), charIsLowercase));
+    ASSERT_FALSE(anyOf(nonLowerChars.span().takeOkay(), static_cast<CharPredicate>(isLowercase)));
 
     auto invalidAsciiChars = invalidAsciiGenerator();
-    ASSERT_FALSE(anyOf(invalidAsciiChars, charIsLowercase));
+    ASSERT_FALSE(anyOf(invalidAsciiChars, static_cast<CharPredicate>(isLowercase)));
 
-    ASSERT_FALSE(utf8IsLowercase(FudUtf8{Ascii{invalidAscii}}));
+    ASSERT_FALSE(isLowercase(FudUtf8{Ascii{invalidAscii}}));
 
     SpanGenerator<char, lowerChars.size()> lowerGenerator{lowerChars.span()};
     auto utf8LowerGenerator = [&]() { return lowerGenerator().map(toUtf8<uint16_t>); };
-    ASSERT_TRUE(allOf(utf8LowerGenerator, utf8IsLowercase));
+    ASSERT_TRUE(allOf(utf8LowerGenerator, static_cast<FudUtf8Predicate>(isLowercase)));
 
     SpanGenerator<char> nonLowerGenerator{nonLowerChars.span().takeOkay()};
     auto utf8NonLowerGenerator = [&]() { return nonLowerGenerator().map(toUtf8<uint16_t>); };
-    ASSERT_FALSE(anyOf(utf8NonLowerGenerator, utf8IsLowercase));
+    ASSERT_FALSE(anyOf(utf8NonLowerGenerator, static_cast<FudUtf8Predicate>(isLowercase)));
 }
 
 TEST(Utf8Test, Utf8IsUpper)
@@ -343,29 +372,29 @@ TEST(Utf8Test, Utf8IsUpper)
     Array<char, numUpperChars> upperChars{};
     copyMem<numUpperChars>(upperChars, upperCharLiteral);
 
-    ASSERT_TRUE(allOf(upperChars.span(), charIsUppercase));
+    ASSERT_TRUE(allOf(upperChars.span(), static_cast<CharPredicate>(isUppercase)));
 
     constexpr size_t numNonUpperChars = validAsciiSize - numUpperChars;
     Vector<char> nonUpperChars{};
     for (char idx = 0; idx < INT8_MAX; ++idx) {
-        if (!charIsUppercase(idx)) {
+        if (!isUppercase(idx)) {
             ASSERT_EQ(nonUpperChars.pushBack(idx), FudStatus::Success);
         }
     }
-    ASSERT_FALSE(anyOf(nonUpperChars.span().takeOkay(), charIsUppercase));
+    ASSERT_FALSE(anyOf(nonUpperChars.span().takeOkay(), static_cast<CharPredicate>(isUppercase)));
 
     auto invalidAsciiChars = invalidAsciiGenerator();
-    ASSERT_FALSE(anyOf(invalidAsciiChars, charIsUppercase));
+    ASSERT_FALSE(anyOf(invalidAsciiChars, static_cast<CharPredicate>(isUppercase)));
 
-    ASSERT_FALSE(utf8IsUppercase(FudUtf8{Ascii{invalidAscii}}));
+    ASSERT_FALSE(isUppercase(FudUtf8{Ascii{invalidAscii}}));
 
     SpanGenerator<char, upperChars.size()> upperGenerator{upperChars.span()};
     auto utf8UpperGenerator = [&]() { return upperGenerator().map(toUtf8<uint16_t>); };
-    ASSERT_TRUE(allOf(utf8UpperGenerator, utf8IsUppercase));
+    ASSERT_TRUE(allOf(utf8UpperGenerator, static_cast<FudUtf8Predicate>(isUppercase)));
 
     SpanGenerator<char> nonUpperGenerator{nonUpperChars.span().takeOkay()};
     auto utf8NonUpperGenerator = [&]() { return nonUpperGenerator().map(toUtf8<uint16_t>); };
-    ASSERT_FALSE(anyOf(utf8NonUpperGenerator, utf8IsUppercase));
+    ASSERT_FALSE(anyOf(utf8NonUpperGenerator, static_cast<FudUtf8Predicate>(isUppercase)));
 }
 
 TEST(Utf8Test, Utf8IsDigit)
@@ -375,29 +404,29 @@ TEST(Utf8Test, Utf8IsDigit)
     Array<char, numDigitChars> digitChars{};
     copyMem<numDigitChars>(digitChars, digitCharLiteral);
 
-    ASSERT_TRUE(allOf(digitChars.span(), charIsDigit));
+    ASSERT_TRUE(allOf(digitChars.span(), static_cast<CharPredicate>(isDigit)));
 
     constexpr size_t numNonDigitChars = validAsciiSize - numDigitChars;
     Vector<char> nonDigitChars{};
     for (char idx = 0; idx < INT8_MAX; ++idx) {
-        if (!charIsDigit(idx)) {
+        if (!isDigit(idx)) {
             ASSERT_EQ(nonDigitChars.pushBack(idx), FudStatus::Success);
         }
     }
-    ASSERT_FALSE(anyOf(nonDigitChars.span().takeOkay(), charIsDigit));
+    ASSERT_FALSE(anyOf(nonDigitChars.span().takeOkay(), static_cast<CharPredicate>(isDigit)));
 
     auto invalidAsciiChars = invalidAsciiGenerator();
-    ASSERT_FALSE(anyOf(invalidAsciiChars, charIsDigit));
+    ASSERT_FALSE(anyOf(invalidAsciiChars, static_cast<CharPredicate>(isDigit)));
 
-    ASSERT_FALSE(utf8IsDigit(FudUtf8{Ascii{invalidAscii}}));
+    ASSERT_FALSE(isDigit(FudUtf8{Ascii{invalidAscii}}));
 
     SpanGenerator<char, digitChars.size()> digitGenerator{digitChars.span()};
     auto utf8DigitGenerator = [&]() { return digitGenerator().map(toUtf8<uint16_t>); };
-    ASSERT_TRUE(allOf(utf8DigitGenerator, utf8IsDigit));
+    ASSERT_TRUE(allOf(utf8DigitGenerator, static_cast<FudUtf8Predicate>(isDigit)));
 
     SpanGenerator<char> nonDigitGenerator{nonDigitChars.span().takeOkay()};
     auto utf8NonDigitGenerator = [&]() { return nonDigitGenerator().map(toUtf8<uint16_t>); };
-    ASSERT_FALSE(anyOf(utf8NonDigitGenerator, utf8IsDigit));
+    ASSERT_FALSE(anyOf(utf8NonDigitGenerator, static_cast<FudUtf8Predicate>(isDigit)));
 }
 
 TEST(Utf8Test, Utf8IsHexDigit)
@@ -407,29 +436,29 @@ TEST(Utf8Test, Utf8IsHexDigit)
     Array<char, numHexDigitChars> hexDigitChars{};
     copyMem<numHexDigitChars>(hexDigitChars, hexDigitCharLiteral);
 
-    ASSERT_TRUE(allOf(hexDigitChars.span(), charIsHexDigit));
+    ASSERT_TRUE(allOf(hexDigitChars.span(), static_cast<CharPredicate>(isHexDigit)));
 
     constexpr size_t numNonHexDigitChars = validAsciiSize - numHexDigitChars;
     Vector<char> nonHexDigitChars{};
     for (char idx = 0; idx < INT8_MAX; ++idx) {
-        if (!charIsHexDigit(idx)) {
+        if (!isHexDigit(idx)) {
             ASSERT_EQ(nonHexDigitChars.pushBack(idx), FudStatus::Success);
         }
     }
-    ASSERT_FALSE(anyOf(nonHexDigitChars.span().takeOkay(), charIsHexDigit));
+    ASSERT_FALSE(anyOf(nonHexDigitChars.span().takeOkay(), static_cast<CharPredicate>(isHexDigit)));
 
     auto invalidAsciiChars = invalidAsciiGenerator();
-    ASSERT_FALSE(anyOf(invalidAsciiChars, charIsHexDigit));
+    ASSERT_FALSE(anyOf(invalidAsciiChars, static_cast<CharPredicate>(isHexDigit)));
 
-    ASSERT_FALSE(utf8IsHexDigit(FudUtf8{Ascii{invalidAscii}}));
+    ASSERT_FALSE(isHexDigit(FudUtf8{Ascii{invalidAscii}}));
 
     SpanGenerator<char, hexDigitChars.size()> hexDigitGenerator{hexDigitChars.span()};
     auto utf8HexDigitGenerator = [&]() { return hexDigitGenerator().map(toUtf8<uint16_t>); };
-    ASSERT_TRUE(allOf(utf8HexDigitGenerator, utf8IsHexDigit));
+    ASSERT_TRUE(allOf(utf8HexDigitGenerator, static_cast<FudUtf8Predicate>(isHexDigit)));
 
     SpanGenerator<char> nonHexDigitGenerator{nonHexDigitChars.span().takeOkay()};
     auto utf8NonHexDigitGenerator = [&]() { return nonHexDigitGenerator().map(toUtf8<uint16_t>); };
-    ASSERT_FALSE(anyOf(utf8NonHexDigitGenerator, utf8IsHexDigit));
+    ASSERT_FALSE(anyOf(utf8NonHexDigitGenerator, static_cast<FudUtf8Predicate>(isHexDigit)));
 }
 
 TEST(Utf8Test, Utf8IsControl)
@@ -439,7 +468,7 @@ TEST(Utf8Test, Utf8IsControl)
     constexpr const char deleteChar = 0x7F;
     controlChars.back() = deleteChar;
 
-    ASSERT_TRUE(allOf(controlChars.span(), charIsControl));
+    ASSERT_TRUE(allOf(controlChars.span(), static_cast<CharPredicate>(isControl)));
 
     constexpr size_t numNonControlChars = INT8_MAX + 1 - numControlChars;
     Vector<char> nonControlChars{};
@@ -447,21 +476,21 @@ TEST(Utf8Test, Utf8IsControl)
     for (auto idx = numControlChars - 1; idx < deleteChar; ++idx) {
         ASSERT_EQ(nonControlChars.pushBack(idx), FudStatus::Success);
     }
-    ASSERT_FALSE(anyOf(nonControlChars.span().takeOkay(), charIsControl));
-    ASSERT_TRUE(allOf(nonControlChars.span().takeOkay(), charIsAscii));
+    ASSERT_FALSE(anyOf(nonControlChars.span().takeOkay(), static_cast<CharPredicate>(isControl)));
+    ASSERT_TRUE(allOf(nonControlChars.span().takeOkay(), static_cast<CharPredicate>(isAscii)));
 
     auto invalidAsciiChars = invalidAsciiGenerator();
-    ASSERT_FALSE(anyOf(invalidAsciiChars, charIsControl));
+    ASSERT_FALSE(anyOf(invalidAsciiChars, static_cast<CharPredicate>(isControl)));
 
-    ASSERT_FALSE(utf8IsControl(FudUtf8{Ascii{invalidAscii}}));
+    ASSERT_FALSE(isControl(FudUtf8{Ascii{invalidAscii}}));
 
     SpanGenerator<char, controlChars.size()> controlGenerator{controlChars.span()};
     auto utf8ControlGenerator = [&]() { return controlGenerator().map(toUtf8<uint16_t>); };
-    ASSERT_TRUE(allOf(utf8ControlGenerator, utf8IsControl));
+    ASSERT_TRUE(allOf(utf8ControlGenerator, static_cast<FudUtf8Predicate>(isControl)));
 
     SpanGenerator<char> nonControlGenerator{nonControlChars.span().takeOkay()};
     auto utf8NonControlGenerator = [&]() { return nonControlGenerator().map(toUtf8<uint16_t>); };
-    ASSERT_FALSE(anyOf(utf8NonControlGenerator, utf8IsControl));
+    ASSERT_FALSE(anyOf(utf8NonControlGenerator, static_cast<FudUtf8Predicate>(isControl)));
 }
 
 TEST(Utf8Test, Utf8IsGraphical)
@@ -471,32 +500,32 @@ TEST(Utf8Test, Utf8IsGraphical)
     Array<char, numGraphicalChars> graphicalChars{};
     copyMem<numGraphicalChars>(graphicalChars, graphicalCharLiteral);
 
-    ASSERT_TRUE(allOf(graphicalChars.span(), charIsGraphical));
+    ASSERT_TRUE(allOf(graphicalChars.span(), static_cast<CharPredicate>(isGraphical)));
 
     constexpr size_t numNonGraphicalChars = validAsciiSize - numGraphicalChars;
     Vector<char> nonGraphicalChars{};
     ASSERT_EQ(nonGraphicalChars.reserve(numNonGraphicalChars), FudStatus::Success);
     for (uint8_t idx = 0; idx < INT8_MAX + 1; ++idx) {
-        if (!charIsGraphical(static_cast<char>(idx))) {
+        if (!isGraphical(static_cast<char>(idx))) {
             ASSERT_EQ(nonGraphicalChars.pushBack(static_cast<char>(idx)), FudStatus::Success);
         }
     }
-    ASSERT_FALSE(anyOf(nonGraphicalChars.span().takeOkay(), charIsGraphical));
-    ASSERT_TRUE(allOf(nonGraphicalChars.span().takeOkay(), charIsAscii));
+    ASSERT_FALSE(anyOf(nonGraphicalChars.span().takeOkay(), static_cast<CharPredicate>(isGraphical)));
+    ASSERT_TRUE(allOf(nonGraphicalChars.span().takeOkay(), static_cast<CharPredicate>(isAscii)));
     ASSERT_EQ(nonGraphicalChars.size() + graphicalChars.size(), INT8_MAX + 1);
 
     auto invalidAsciiChars = invalidAsciiGenerator();
-    ASSERT_FALSE(anyOf(invalidAsciiChars, charIsGraphical));
+    ASSERT_FALSE(anyOf(invalidAsciiChars, static_cast<CharPredicate>(isGraphical)));
 
-    ASSERT_FALSE(utf8IsGraphical(FudUtf8{Ascii{invalidAscii}}));
+    ASSERT_FALSE(isGraphical(FudUtf8{Ascii{invalidAscii}}));
 
     SpanGenerator<char, graphicalChars.size()> graphicalGenerator{graphicalChars.span()};
     auto utf8GraphicalGenerator = [&]() { return graphicalGenerator().map(toUtf8<uint16_t>); };
-    ASSERT_TRUE(allOf(utf8GraphicalGenerator, utf8IsGraphical));
+    ASSERT_TRUE(allOf(utf8GraphicalGenerator, static_cast<FudUtf8Predicate>(isGraphical)));
 
     SpanGenerator<char> nonGraphicalGenerator{nonGraphicalChars.span().takeOkay()};
     auto utf8NonGraphicalGenerator = [&]() { return nonGraphicalGenerator().map(toUtf8<uint16_t>); };
-    ASSERT_FALSE(anyOf(utf8NonGraphicalGenerator, utf8IsGraphical));
+    ASSERT_FALSE(anyOf(utf8NonGraphicalGenerator, static_cast<FudUtf8Predicate>(isGraphical)));
 }
 
 TEST(Utf8Test, Utf8IsSpace)
@@ -506,32 +535,32 @@ TEST(Utf8Test, Utf8IsSpace)
     Array<char, numSpaceChars> spaceChars{};
     copyMem<numSpaceChars>(spaceChars, spaceCharLiteral);
 
-    ASSERT_TRUE(allOf(spaceChars.span(), charIsSpace));
+    ASSERT_TRUE(allOf(spaceChars.span(), static_cast<CharPredicate>(isSpace)));
 
     constexpr size_t numNonSpaceChars = validAsciiSize - numSpaceChars;
     Vector<char> nonSpaceChars{};
     ASSERT_EQ(nonSpaceChars.reserve(numNonSpaceChars), FudStatus::Success);
     for (uint8_t idx = 0; idx < INT8_MAX + 1; ++idx) {
-        if (!charIsSpace(static_cast<char>(idx))) {
+        if (!isSpace(static_cast<char>(idx))) {
             ASSERT_EQ(nonSpaceChars.pushBack(static_cast<char>(idx)), FudStatus::Success);
         }
     }
-    ASSERT_FALSE(anyOf(nonSpaceChars.span().takeOkay(), charIsSpace));
-    ASSERT_TRUE(allOf(nonSpaceChars.span().takeOkay(), charIsAscii));
+    ASSERT_FALSE(anyOf(nonSpaceChars.span().takeOkay(), static_cast<CharPredicate>(isSpace)));
+    ASSERT_TRUE(allOf(nonSpaceChars.span().takeOkay(), static_cast<CharPredicate>(isAscii)));
     ASSERT_EQ(nonSpaceChars.size() + spaceChars.size(), INT8_MAX + 1);
 
     auto invalidAsciiChars = invalidAsciiGenerator();
-    ASSERT_FALSE(anyOf(invalidAsciiChars, charIsSpace));
+    ASSERT_FALSE(anyOf(invalidAsciiChars, static_cast<CharPredicate>(isSpace)));
 
-    ASSERT_FALSE(utf8IsSpace(FudUtf8{Ascii{invalidAscii}}));
+    ASSERT_FALSE(isSpace(FudUtf8{Ascii{invalidAscii}}));
 
     SpanGenerator<char, spaceChars.size()> spaceGenerator{spaceChars.span()};
     auto utf8SpaceGenerator = [&]() { return spaceGenerator().map(toUtf8<uint16_t>); };
-    ASSERT_TRUE(allOf(utf8SpaceGenerator, utf8IsSpace));
+    ASSERT_TRUE(allOf(utf8SpaceGenerator, static_cast<FudUtf8Predicate>(isSpace)));
 
     SpanGenerator<char> nonSpaceGenerator{nonSpaceChars.span().takeOkay()};
     auto utf8NonSpaceGenerator = [&]() { return nonSpaceGenerator().map(toUtf8<uint16_t>); };
-    ASSERT_FALSE(anyOf(utf8NonSpaceGenerator, utf8IsSpace));
+    ASSERT_FALSE(anyOf(utf8NonSpaceGenerator, static_cast<FudUtf8Predicate>(isSpace)));
 }
 
 TEST(Utf8Test, Utf8IsBlank)
@@ -541,32 +570,32 @@ TEST(Utf8Test, Utf8IsBlank)
     Array<char, numBlankChars> blankChars{};
     copyMem<numBlankChars>(blankChars, blankCharLiteral);
 
-    ASSERT_TRUE(allOf(blankChars.span(), charIsBlank));
+    ASSERT_TRUE(allOf(blankChars.span(), static_cast<CharPredicate>(isBlank)));
 
     constexpr size_t numNonBlankChars = validAsciiSize - numBlankChars;
     Vector<char> nonBlankChars{};
     ASSERT_EQ(nonBlankChars.reserve(numNonBlankChars), FudStatus::Success);
     for (uint8_t idx = 0; idx < INT8_MAX + 1; ++idx) {
-        if (!charIsBlank(static_cast<char>(idx))) {
+        if (!isBlank(static_cast<char>(idx))) {
             ASSERT_EQ(nonBlankChars.pushBack(static_cast<char>(idx)), FudStatus::Success);
         }
     }
-    ASSERT_FALSE(anyOf(nonBlankChars.span().takeOkay(), charIsBlank));
-    ASSERT_TRUE(allOf(nonBlankChars.span().takeOkay(), charIsAscii));
+    ASSERT_FALSE(anyOf(nonBlankChars.span().takeOkay(), static_cast<CharPredicate>(isBlank)));
+    ASSERT_TRUE(allOf(nonBlankChars.span().takeOkay(), static_cast<CharPredicate>(isAscii)));
     ASSERT_EQ(nonBlankChars.size() + blankChars.size(), INT8_MAX + 1);
 
     auto invalidAsciiChars = invalidAsciiGenerator();
-    ASSERT_FALSE(anyOf(invalidAsciiChars, charIsBlank));
+    ASSERT_FALSE(anyOf(invalidAsciiChars, static_cast<CharPredicate>(isBlank)));
 
-    ASSERT_FALSE(utf8IsBlank(FudUtf8{Ascii{invalidAscii}}));
+    ASSERT_FALSE(isBlank(FudUtf8{Ascii{invalidAscii}}));
 
     SpanGenerator<char, blankChars.size()> blankGenerator{blankChars.span()};
     auto utf8BlankGenerator = [&]() { return blankGenerator().map(toUtf8<uint16_t>); };
-    ASSERT_TRUE(allOf(utf8BlankGenerator, utf8IsBlank));
+    ASSERT_TRUE(allOf(utf8BlankGenerator, static_cast<FudUtf8Predicate>(isBlank)));
 
     SpanGenerator<char> nonBlankGenerator{nonBlankChars.span().takeOkay()};
     auto utf8NonBlankGenerator = [&]() { return nonBlankGenerator().map(toUtf8<uint16_t>); };
-    ASSERT_FALSE(anyOf(utf8NonBlankGenerator, utf8IsBlank));
+    ASSERT_FALSE(anyOf(utf8NonBlankGenerator, static_cast<FudUtf8Predicate>(isBlank)));
 }
 
 TEST(Utf8Test, Utf8IsPrintable)
@@ -576,32 +605,32 @@ TEST(Utf8Test, Utf8IsPrintable)
     Array<char, numPrintableChars> printableChars{};
     copyMem<numPrintableChars>(printableChars, printableCharLiteral);
 
-    ASSERT_TRUE(allOf(printableChars.span(), charIsPrintable));
+    ASSERT_TRUE(allOf(printableChars.span(), static_cast<CharPredicate>(isPrintable)));
 
     constexpr size_t numNonPrintableChars = validAsciiSize - numPrintableChars;
     Vector<char> nonPrintableChars{};
     ASSERT_EQ(nonPrintableChars.reserve(numNonPrintableChars), FudStatus::Success);
     for (uint8_t idx = 0; idx < INT8_MAX + 1; ++idx) {
-        if (!charIsPrintable(static_cast<char>(idx))) {
+        if (!isPrintable(static_cast<char>(idx))) {
             ASSERT_EQ(nonPrintableChars.pushBack(static_cast<char>(idx)), FudStatus::Success);
         }
     }
-    ASSERT_FALSE(anyOf(nonPrintableChars.span().takeOkay(), charIsPrintable));
-    ASSERT_TRUE(allOf(nonPrintableChars.span().takeOkay(), charIsAscii));
+    ASSERT_FALSE(anyOf(nonPrintableChars.span().takeOkay(), static_cast<CharPredicate>(isPrintable)));
+    ASSERT_TRUE(allOf(nonPrintableChars.span().takeOkay(), static_cast<CharPredicate>(isAscii)));
     ASSERT_EQ(nonPrintableChars.size() + printableChars.size(), INT8_MAX + 1);
 
     auto invalidAsciiChars = invalidAsciiGenerator();
-    ASSERT_FALSE(anyOf(invalidAsciiChars, charIsPrintable));
+    ASSERT_FALSE(anyOf(invalidAsciiChars, static_cast<CharPredicate>(isPrintable)));
 
-    ASSERT_FALSE(utf8IsPrintable(FudUtf8{Ascii{invalidAscii}}));
+    ASSERT_FALSE(isPrintable(FudUtf8{Ascii{invalidAscii}}));
 
     SpanGenerator<char, printableChars.size()> printableGenerator{printableChars.span()};
     auto utf8PrintableGenerator = [&]() { return printableGenerator().map(toUtf8<uint16_t>); };
-    ASSERT_TRUE(allOf(utf8PrintableGenerator, utf8IsPrintable));
+    ASSERT_TRUE(allOf(utf8PrintableGenerator, static_cast<FudUtf8Predicate>(isPrintable)));
 
     SpanGenerator<char> nonPrintableGenerator{nonPrintableChars.span().takeOkay()};
     auto utf8NonPrintableGenerator = [&]() { return nonPrintableGenerator().map(toUtf8<uint16_t>); };
-    ASSERT_FALSE(anyOf(utf8NonPrintableGenerator, utf8IsPrintable));
+    ASSERT_FALSE(anyOf(utf8NonPrintableGenerator, static_cast<FudUtf8Predicate>(isPrintable)));
 }
 
 TEST(Utf8Test, Utf8IsPunctuation)
@@ -611,32 +640,32 @@ TEST(Utf8Test, Utf8IsPunctuation)
     Array<char, numPunctuationChars> punctuationChars{};
     copyMem<numPunctuationChars>(punctuationChars, punctuationCharLiteral);
 
-    ASSERT_TRUE(allOf(punctuationChars.span(), charIsPunctuation));
+    ASSERT_TRUE(allOf(punctuationChars.span(), static_cast<CharPredicate>(isPunctuation)));
 
     constexpr size_t numNonPunctuationChars = validAsciiSize - numPunctuationChars;
     Vector<char> nonPunctuationChars{};
     ASSERT_EQ(nonPunctuationChars.reserve(numNonPunctuationChars), FudStatus::Success);
     for (uint8_t idx = 0; idx < INT8_MAX + 1; ++idx) {
-        if (!charIsPunctuation(static_cast<char>(idx))) {
+        if (!isPunctuation(static_cast<char>(idx))) {
             ASSERT_EQ(nonPunctuationChars.pushBack(static_cast<char>(idx)), FudStatus::Success);
         }
     }
-    ASSERT_FALSE(anyOf(nonPunctuationChars.span().takeOkay(), charIsPunctuation));
-    ASSERT_TRUE(allOf(nonPunctuationChars.span().takeOkay(), charIsAscii));
+    ASSERT_FALSE(anyOf(nonPunctuationChars.span().takeOkay(), static_cast<CharPredicate>(isPunctuation)));
+    ASSERT_TRUE(allOf(nonPunctuationChars.span().takeOkay(), static_cast<CharPredicate>(isAscii)));
     ASSERT_EQ(nonPunctuationChars.size() + punctuationChars.size(), INT8_MAX + 1);
 
     auto invalidAsciiChars = invalidAsciiGenerator();
-    ASSERT_FALSE(anyOf(invalidAsciiChars, charIsPunctuation));
+    ASSERT_FALSE(anyOf(invalidAsciiChars, static_cast<CharPredicate>(isPunctuation)));
 
-    ASSERT_FALSE(utf8IsPunctuation(FudUtf8{Ascii{invalidAscii}}));
+    ASSERT_FALSE(isPunctuation(FudUtf8{Ascii{invalidAscii}}));
 
     SpanGenerator<char, punctuationChars.size()> punctuationGenerator{punctuationChars.span()};
     auto utf8PunctuationGenerator = [&]() { return punctuationGenerator().map(toUtf8<uint16_t>); };
-    ASSERT_TRUE(allOf(utf8PunctuationGenerator, utf8IsPunctuation));
+    ASSERT_TRUE(allOf(utf8PunctuationGenerator, static_cast<FudUtf8Predicate>(isPunctuation)));
 
     SpanGenerator<char> nonPunctuationGenerator{nonPunctuationChars.span().takeOkay()};
     auto utf8NonPunctuationGenerator = [&]() { return nonPunctuationGenerator().map(toUtf8<uint16_t>); };
-    ASSERT_FALSE(anyOf(utf8NonPunctuationGenerator, utf8IsPunctuation));
+    ASSERT_FALSE(anyOf(utf8NonPunctuationGenerator, static_cast<FudUtf8Predicate>(isPunctuation)));
 }
 
 } // namespace fud