Updated style [skip ci]

Author: ankane

README.md

@@ -61,7 +61,7 @@ tx.exec("CREATE TABLE items (id bigserial PRIMARY KEY, embedding vector(3))");
 Insert a vector
 
 ```cpp
-auto embedding = pgvector::Vector({1, 2, 3});
+pgvector::Vector embedding({1, 2, 3});
 tx.exec("INSERT INTO items (embedding) VALUES ($1)", {embedding});
 ```
 
@@ -87,7 +87,7 @@ Use `std::optional<pgvector::Vector>` if the value could be `NULL`
 Create a vector from a `std::vector<float>`
 
 ```cpp
-auto vec = pgvector::Vector({1, 2, 3});
+pgvector::Vector vec(std::vector<float>{1, 2, 3});
 ```
 
 Convert to a `std::vector<float>`
@@ -101,7 +101,7 @@ auto float_vec = static_cast<std::vector<float>>(vec);
 Create a half vector from a `std::vector<float>`
 
 ```cpp
-auto vec = pgvector::HalfVector({1, 2, 3});
+pgvector::HalfVector vec(std::vector<float>{1, 2, 3});
 ```
 
 Convert to a `std::vector<float>`
@@ -115,14 +115,14 @@ auto float_vec = static_cast<std::vector<float>>(vec);
 Create a sparse vector from a `std::vector<float>`
 
 ```cpp
-auto vec = pgvector::SparseVector({1, 0, 2, 0, 3, 0});
+pgvector::SparseVector vec({1, 0, 2, 0, 3, 0});
 ```
 
 Or a map of non-zero elements
 
 ```cpp
-std::unordered_map<int, float> map = {{0, 1}, {2, 2}, {4, 3}};
-auto vec = pgvector::SparseVector(map, 6);
+std::unordered_map<int, float> map{{0, 1}, {2, 2}, {4, 3}};
+pgvector::SparseVector vec(map, 6);
 ```
 
 Note: Indices start at 0

test/halfvec_test.cpp

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

test/pqxx_test.cpp

@@ -32,8 +32,8 @@ void test_vector(pqxx::connection &conn) {
     before_each(conn);
 
     pqxx::nontransaction tx(conn);
-    auto embedding = pgvector::Vector({1, 2, 3});
-    auto embedding2 = pgvector::Vector({4, 5, 6});
+    pgvector::Vector embedding({1, 2, 3});
+    pgvector::Vector embedding2({4, 5, 6});
     tx.exec("INSERT INTO items (embedding) VALUES ($1), ($2), ($3)", {embedding, embedding2, std::nullopt});
 
     pqxx::result res = tx.exec("SELECT embedding FROM items ORDER BY embedding <-> $1", {embedding2});
@@ -47,8 +47,8 @@ void test_halfvec(pqxx::connection &conn) {
     before_each(conn);
 
     pqxx::nontransaction tx(conn);
-    auto embedding = pgvector::HalfVector({1, 2, 3});
-    auto embedding2 = pgvector::HalfVector({4, 5, 6});
+    pgvector::HalfVector embedding({1, 2, 3});
+    pgvector::HalfVector embedding2({4, 5, 6});
     tx.exec("INSERT INTO items (half_embedding) VALUES ($1), ($2), ($3)", {embedding, embedding2, std::nullopt});
 
     pqxx::result res = tx.exec("SELECT half_embedding FROM items ORDER BY half_embedding <-> $1", {embedding2});
@@ -62,8 +62,8 @@ void test_bit(pqxx::connection &conn) {
     before_each(conn);
 
     pqxx::nontransaction tx(conn);
-    std::string embedding = "101";
-    std::string embedding2 = "111";
+    std::string embedding{"101"};
+    std::string embedding2{"111"};
     tx.exec("INSERT INTO items (binary_embedding) VALUES ($1), ($2), ($3)", {embedding, embedding2, std::nullopt});
 
     pqxx::result res = tx.exec("SELECT binary_embedding FROM items ORDER BY binary_embedding <~> $1", pqxx::params{embedding2});
@@ -77,8 +77,8 @@ void test_sparsevec(pqxx::connection &conn) {
     before_each(conn);
 
     pqxx::nontransaction tx(conn);
-    auto embedding = pgvector::SparseVector({1, 2, 3});
-    auto embedding2 = pgvector::SparseVector({4, 5, 6});
+    pgvector::SparseVector embedding({1, 2, 3});
+    pgvector::SparseVector embedding2({4, 5, 6});
     tx.exec("INSERT INTO items (sparse_embedding) VALUES ($1), ($2), ($3)", {embedding, embedding2, std::nullopt});
 
     pqxx::result res = tx.exec("SELECT sparse_embedding FROM items ORDER BY sparse_embedding <-> $1", {embedding2});
@@ -93,7 +93,7 @@ void test_sparsevec_nnz(pqxx::connection &conn) {
 
     pqxx::nontransaction tx(conn);
     std::vector<float> vec(16001, 1);
-    auto embedding = pgvector::SparseVector(vec);
+    pgvector::SparseVector embedding(vec);
     assert_exception<pqxx::conversion_overrun>([&] {
         tx.exec("INSERT INTO items (sparse_embedding) VALUES ($1)", {embedding});
     }, "sparsevec cannot have more than 16000 dimensions");
@@ -103,7 +103,7 @@ void test_stream(pqxx::connection &conn) {
     before_each(conn);
 
     pqxx::nontransaction tx(conn);
-    auto embedding = pgvector::Vector({1, 2, 3});
+    pgvector::Vector embedding({1, 2, 3});
     tx.exec("INSERT INTO items (embedding) VALUES ($1)", {embedding});
     int count = 0;
     for (auto [id, embedding2] : tx.stream<int, pgvector::Vector>("SELECT id, embedding FROM items WHERE embedding IS NOT NULL")) {
@@ -117,7 +117,7 @@ void test_stream_to(pqxx::connection &conn) {
     before_each(conn);
 
     pqxx::nontransaction tx(conn);
-    auto stream = pqxx::stream_to::table(tx, {"items"}, {"embedding"});
+    pqxx::stream_to stream = pqxx::stream_to::table(tx, {"items"}, {"embedding"});
     stream.write_values(pgvector::Vector({1, 2, 3}));
     stream.write_values(pgvector::Vector({4, 5, 6}));
     stream.complete();
@@ -130,7 +130,7 @@ void test_precision(pqxx::connection &conn) {
     before_each(conn);
 
     pqxx::nontransaction tx(conn);
-    auto embedding = pgvector::Vector({1.23456789, 0, 0});
+    pgvector::Vector embedding({1.23456789, 0, 0});
     tx.exec("INSERT INTO items (embedding) VALUES ($1)", {embedding});
     tx.exec("SET extra_float_digits = 3");
     pqxx::result res = tx.exec("SELECT embedding FROM items ORDER BY id DESC LIMIT 1");

test/sparsevec_test.cpp

@@ -8,20 +8,20 @@
 using pgvector::SparseVector;
 
 static void test_constructor_vector() {
-    auto vec = SparseVector(std::vector<float>{1, 0, 2, 0, 3, 0});
+    SparseVector vec(std::vector<float>{1, 0, 2, 0, 3, 0});
     assert_equal(vec.dimensions(), 6);
     assert_equal(vec.indices() == std::vector<int>{0, 2, 4}, true);
     assert_equal(vec.values() == std::vector<float>{1, 2, 3}, true);
 }
 
 static void test_constructor_span() {
-    auto vec = SparseVector(std::span<const float>({1, 0, 2, 0, 3, 0}));
+    SparseVector vec(std::span<const float>{{1, 0, 2, 0, 3, 0}});
     assert_equal(vec.dimensions(), 6);
 }
 
 static void test_constructor_map() {
-    std::unordered_map<int, float> map = {{2, 2}, {4, 3}, {3, 0}, {0, 1}};
-    auto vec = SparseVector(map, 6);
+    std::unordered_map<int, float> map{{2, 2}, {4, 3}, {3, 0}, {0, 1}};
+    SparseVector vec(map, 6);
     assert_equal(vec.dimensions(), 6);
     assert_equal(vec.indices() == std::vector<int>{0, 2, 4}, true);
     assert_equal(vec.values() == std::vector<float>{1, 2, 3}, true);

test/vector_test.cpp

@@ -7,17 +7,17 @@
 using pgvector::Vector;
 
 static void test_constructor_vector() {
-    auto vec = Vector(std::vector<float>{1, 2, 3});
+    Vector vec(std::vector<float>{1, 2, 3});
     assert_equal(vec.dimensions(), 3u);
 }
 
 static void test_constructor_span() {
-    auto vec = Vector(std::span<const float>({1, 2, 3}));
+    Vector vec(std::span<const float>{{1, 2, 3}});
     assert_equal(vec.dimensions(), 3u);
 }
 
 static void test_as_vector() {
-    auto vec = Vector({1, 2, 3});
+    Vector vec({1, 2, 3});
     assert_equal(vec.as_vector() == std::vector<float>{1, 2, 3}, true);
 }