Renamed HalfType to Half

Author: ankane

include/pgvector/halfvec.hpp

@@ -19,35 +19,35 @@
 namespace pgvector {
 
 #if __STDCPP_FLOAT16_T__
-using HalfType = std::float16_t;
+using Half = std::float16_t;
 #else
-using HalfType = float;
+using Half = float;
 #endif
 
 /// A half vector.
 class HalfVector {
   public:
-    /// Creates a half vector from a `std::vector<pgvector::HalfType>`.
-    explicit HalfVector(const std::vector<HalfType>& value) : value_{value} {}
+    /// Creates a half vector from a `std::vector<pgvector::Half>`.
+    explicit HalfVector(const std::vector<Half>& value) : value_{value} {}
 
-    /// Creates a half vector from a `std::vector<pgvector::HalfType>`.
-    explicit HalfVector(std::vector<HalfType>&& value) : value_{std::move(value)} {}
+    /// Creates a half vector from a `std::vector<pgvector::Half>`.
+    explicit HalfVector(std::vector<Half>&& value) : value_{std::move(value)} {}
 
     /// Creates a half vector from a span.
-    explicit HalfVector(std::span<const HalfType> value) : value_{std::vector<HalfType>(value.begin(), value.end())} {}
+    explicit HalfVector(std::span<const Half> value) : value_{std::vector<Half>(value.begin(), value.end())} {}
 
     /// Returns the number of dimensions.
     size_t dimensions() const {
         return value_.size();
     }
 
-    /// Returns the half vector as a `std::vector<pgvector::HalfType>`.
-    operator const std::vector<HalfType>() const {
+    /// Returns the half vector as a `std::vector<pgvector::Half>`.
+    operator const std::vector<Half>() const {
         return value_;
     }
 
-    /// Returns the half vector as a `std::span<const pgvector::HalfType>`.
-    operator const std::span<const HalfType>() const {
+    /// Returns the half vector as a `std::span<const pgvector::Half>`.
+    operator const std::span<const Half>() const {
         return value_;
     }
 
@@ -68,6 +68,6 @@ class HalfVector {
     }
 
   private:
-    std::vector<HalfType> value_;
+    std::vector<Half> value_;
 };
 } // namespace pgvector

include/pgvector/pqxx.hpp

@@ -93,23 +93,23 @@ template <> struct string_traits<pgvector::HalfVector> {
             throw conversion_error("Malformed halfvec literal");
         }
 
-        std::vector<pgvector::HalfType> values;
+        std::vector<pgvector::Half> values;
         if (text.size() > 2) {
             std::string_view inner = text.substr(1, text.size() - 2);
             size_t start = 0;
             for (size_t i = 0; i < inner.size(); i++) {
                 if (inner[i] == ',') {
-                    values.push_back(static_cast<pgvector::HalfType>(string_traits<float>::from_string(inner.substr(start, i - start), c)));
+                    values.push_back(static_cast<pgvector::Half>(string_traits<float>::from_string(inner.substr(start, i - start), c)));
                     start = i + 1;
                 }
             }
-            values.push_back(static_cast<pgvector::HalfType>(string_traits<float>::from_string(inner.substr(start), c)));
+            values.push_back(static_cast<pgvector::Half>(string_traits<float>::from_string(inner.substr(start), c)));
         }
         return pgvector::HalfVector(std::move(values));
     }
 
     static std::string_view to_buf(std::span<char> buf, const pgvector::HalfVector& value, ctx c = {}) {
-        std::span<const pgvector::HalfType> values{value};
+        std::span<const pgvector::Half> values{value};
 
         // important! size_buffer cannot throw an exception on overflow
         // so perform this check before writing any data
@@ -133,7 +133,7 @@ template <> struct string_traits<pgvector::HalfVector> {
     }
 
     static size_t size_buffer(const pgvector::HalfVector& value) noexcept {
-        std::span<const pgvector::HalfType> values{value};
+        std::span<const pgvector::Half> values{value};
 
         // cannot throw an exception here on overflow
         // so throw in into_buf

test/halfvec_test.cpp

@@ -12,7 +12,7 @@ static void test_constructor_vector() {
 }
 
 static void test_constructor_span() {
-    auto vec = HalfVector(std::span<const pgvector::HalfType>({1, 2, 3}));
+    auto vec = HalfVector(std::span<const pgvector::Half>({1, 2, 3}));
     assert_equal(vec.dimensions(), 3u);
 }
 

test/pqxx_test.cpp

@@ -49,7 +49,7 @@ void test_halfvec(pqxx::connection &conn) {
 
     pqxx::nontransaction tx(conn);
     auto embedding = pgvector::HalfVector({1, 2, 3});
-    pgvector::HalfType arr[] = {4, 5, 6};
+    pgvector::Half arr[] = {4, 5, 6};
     auto embedding2 = pgvector::HalfVector(std::span{arr, 3});
     tx.exec("INSERT INTO items (half_embedding) VALUES ($1), ($2), ($3)", {embedding, embedding2, std::nullopt});
 
@@ -186,13 +186,13 @@ void test_halfvec_to_string() {
 #endif
 
     assert_exception<pqxx::conversion_overrun>([] {
-        pqxx::to_string(pgvector::HalfVector(std::vector<pgvector::HalfType>(16001)));
+        pqxx::to_string(pgvector::HalfVector(std::vector<pgvector::Half>(16001)));
     }, "halfvec cannot have more than 16000 dimensions");
 }
 
 void test_halfvec_from_string() {
     assert_equal(pqxx::from_string<pgvector::HalfVector>("[1,2,3]"), pgvector::HalfVector({1, 2, 3}));
-    assert_equal(pqxx::from_string<pgvector::HalfVector>("[]"), pgvector::HalfVector(std::vector<pgvector::HalfType>{}));
+    assert_equal(pqxx::from_string<pgvector::HalfVector>("[]"), pgvector::HalfVector(std::vector<pgvector::Half>{}));
 
     assert_exception<pqxx::conversion_error>([] {
         auto _ = pqxx::from_string<pgvector::HalfVector>("");