usearch 0.19.2 → 0.20.0

package/javascript/test.js

@@ -11,7 +11,7 @@ index.add(16, new Float32Array([10, 25]))
 assert.equal(index.size(), 2)
 
 var results = index.search(new Float32Array([13, 14]), 2)
-assert.deepEqual(results.labels, new Uint32Array([15, 16]))
+assert.deepEqual(results.labels, new BigUint64Array([15n, 16n]))
 assert.deepEqual(results.distances, new Float32Array([45, 130]))
 
 console.log('JavaScript tests passed!')

package/objc/USearchObjective.mm

@@ -8,12 +8,15 @@
 using namespace unum::usearch;
 using namespace unum;
 
+using metric_t = index_punned_dense_metric_t;
 using distance_t = punned_distance_t;
-using punned_t = index_punned_dense_gt<UInt32>;
-using add_result_t = punned_t::add_result_t;
-using search_result_t = punned_t::search_result_t;
-using serialization_result_t = punned_t::serialization_result_t;
-using shared_index_t = std::shared_ptr<punned_t>;
+using index_t = punned_small_t;
+using add_result_t = typename index_t::add_result_t;
+using search_result_t = typename index_t::search_result_t;
+using serialization_result_t = typename index_t::serialization_result_t;
+using label_t = typename index_t::label_t;
+using id_t = typename index_t::id_t;
+using shared_index_t = std::shared_ptr<index_t>;
 
 metric_kind_t to_native_metric(USearchMetric m) {
     switch (m) {
@@ -117,11 +120,11 @@ scalar_kind_t to_native_scalar(USearchScalar m) {
     index_config_t config;
 
     config.connectivity = static_cast<std::size_t>(connectivity);
-    shared_index_t ptr = std::make_shared<punned_t>(punned_t::make(dims, to_native_metric(metric), config, to_native_scalar(quantization)));
+    shared_index_t ptr = std::make_shared<index_t>(index_t::make(dims, to_native_metric(metric), config, to_native_scalar(quantization)));
     return [[USearchIndex alloc] initWithIndex:ptr];
 }
 
-- (void)addSingle:(UInt32)label
+- (void)addSingle:(USearchLabel)label
            vector:(Float32 const *_Nonnull)vector {
     add_result_t result = _native->add(label, vector);
 
@@ -134,7 +137,7 @@ scalar_kind_t to_native_scalar(USearchScalar m) {
 
 - (UInt32)searchSingle:(Float32 const *_Nonnull)vector
                  count:(UInt32)wanted
-                labels:(UInt32 *_Nullable)labels
+                labels:(USearchLabel *_Nullable)labels
              distances:(Float32 *_Nullable)distances {
     search_result_t result = _native->search(vector, static_cast<std::size_t>(wanted));
 
@@ -148,7 +151,7 @@ scalar_kind_t to_native_scalar(USearchScalar m) {
     return static_cast<UInt32>(found);
 }
 
-- (void)addDouble:(UInt32)label
+- (void)addDouble:(USearchLabel)label
            vector:(Float64 const *_Nonnull)vector {
     add_result_t result = _native->add(label, (f64_t const *)vector);
 
@@ -161,7 +164,7 @@ scalar_kind_t to_native_scalar(USearchScalar m) {
 
 - (UInt32)searchDouble:(Float64 const *_Nonnull)vector
                  count:(UInt32)wanted
-                labels:(UInt32 *_Nullable)labels
+                labels:(USearchLabel *_Nullable)labels
              distances:(Float32 *_Nullable)distances {
     search_result_t result = _native->search((f64_t const *)vector, static_cast<std::size_t>(wanted));
 
@@ -175,7 +178,7 @@ scalar_kind_t to_native_scalar(USearchScalar m) {
     return static_cast<UInt32>(found);
 }
 
-- (void)addHalf:(UInt32)label
+- (void)addHalf:(USearchLabel)label
          vector:(void const *_Nonnull)vector {
     add_result_t result = _native->add(label, (f16_t const *)vector);
 
@@ -188,7 +191,7 @@ scalar_kind_t to_native_scalar(USearchScalar m) {
 
 - (UInt32)searchHalf:(void const *_Nonnull)vector
                count:(UInt32)wanted
-              labels:(UInt32 *_Nullable)labels
+              labels:(USearchLabel *_Nullable)labels
            distances:(Float32 *_Nullable)distances {
     search_result_t result = _native->search((f16_t const *)vector, static_cast<std::size_t>(wanted));
 

package/objc/include/USearchObjective.h

@@ -25,7 +25,7 @@ typedef NS_ENUM(NSUInteger, USearchMetric) {
     USearchMetricSorensen
 };
 
-typedef UInt32 USearchLabel;
+typedef UInt64 USearchLabel;
 
 API_AVAILABLE(ios(13.0), macos(10.15), tvos(13.0), watchos(6.0))
 @interface USearchIndex : NSObject
@@ -80,7 +80,7 @@ API_AVAILABLE(ios(13.0), macos(10.15), tvos(13.0), watchos(6.0))
  * @brief Adds a labeled vector to the index.
  * @param vector Double-precision vector.
  */
-- (void)addDouble:(UInt32)label
+- (void)addDouble:(USearchLabel)label
            vector:(Float64 const *_Nonnull)vector NS_SWIFT_NAME(addDouble(label:vector:));
 
 /**
@@ -100,7 +100,7 @@ API_AVAILABLE(ios(13.0), macos(10.15), tvos(13.0), watchos(6.0))
  * @brief Adds a labeled vector to the index.
  * @param vector Half-precision vector.
  */
-- (void)addHalf:(UInt32)label
+- (void)addHalf:(USearchLabel)label
          vector:(void const *_Nonnull)vector NS_SWIFT_NAME(addHalf(label:vector:));
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "usearch",
-    "version": "0.19.2",
+    "version": "0.20.0",
     "description": "Smaller & Faster Single-File Vector Search Engine from Unum",
     "author": "Ashot Vardanian",
     "license": "Apache 2.0",
@@ -24,6 +24,6 @@
         "@semantic-release/exec": "^6.0.3",
         "@semantic-release/git": "^10.0.1",
         "conventional-changelog-eslint": "^3.0.9",
-        "semantic-release": "^21.0.6"
+        "semantic-release": "^21.0.7"
     }
 }

package/python/lib.cpp

@@ -12,11 +12,10 @@
  *
  *  @copyright Copyright (c) 2023
  */
-#define PY_SSIZE_T_CLEAN
-#define NOMINMAX  // Some of our dependencies call `std::max(x, y)`, which crashes Windows builds
 #include <limits> // `std::numeric_limits`
 #include <thread> // `std::thread`
 
+#define PY_SSIZE_T_CLEAN
 #include <pybind11/numpy.h>
 #include <pybind11/pybind11.h>
 
@@ -38,26 +37,23 @@ enum class metric_signature_t {
 
 namespace py = pybind11;
 using py_shape_t = py::array::ShapeContainer;
-
-using label_t = std::uint32_t;
-using distance_t = punned_distance_t;
+using label_t = typename punned_small_t::label_t;
+using id_t = typename punned_small_t::id_t;
 using metric_t = index_punned_dense_metric_t;
-using id_t = std::uint32_t;
-using big_id_t = std::uint64_t;
-
-using punned_index_t = index_punned_dense_gt<label_t, id_t>;
-using punned_add_result_t = typename punned_index_t::add_result_t;
-using punned_search_result_t = typename punned_index_t::search_result_t;
+using distance_t = punned_distance_t;
+using dense_index_t = punned_small_t;
+using dense_add_result_t = typename dense_index_t::add_result_t;
+using dense_search_result_t = typename dense_index_t::search_result_t;
 
-struct punned_index_py_t : public punned_index_t {
-    using native_t = punned_index_t;
+struct dense_index_py_t : public dense_index_t {
+    using native_t = dense_index_t;
     using native_t::add;
     using native_t::capacity;
     using native_t::reserve;
     using native_t::search;
     using native_t::size;
 
-    punned_index_py_t(native_t&& base) : native_t(std::move(base)) {}
+    dense_index_py_t(native_t&& base) : native_t(std::move(base)) {}
 };
 
 using set_member_t = std::uint32_t;
@@ -121,7 +117,7 @@ metric_t udf(metric_kind_t kind, metric_signature_t signature, std::uintptr_t me
     }
 }
 
-static punned_index_py_t make_index(     //
+static dense_index_py_t make_index(      //
     std::size_t dimensions,              //
     scalar_kind_t scalar_kind,           //
     metric_kind_t metric_kind,           //
@@ -136,14 +132,14 @@ static punned_index_py_t make_index(     //
     config.connectivity = connectivity;
 
     if (tune)
-        config = punned_index_t::optimize(config);
+        config = dense_index_t::optimize(config);
 
     if (metric_uintptr)
-        return punned_index_t::make( //
+        return dense_index_t::make( //
             dimensions, udf(metric_kind, metric_signature, metric_uintptr, scalar_kind), config, scalar_kind,
             expansion_add, expansion_search);
     else
-        return punned_index_t::make(dimensions, metric_kind, config, scalar_kind, expansion_add, expansion_search);
+        return dense_index_t::make(dimensions, metric_kind, config, scalar_kind, expansion_add, expansion_search);
 }
 
 static std::unique_ptr<sparse_index_py_t> make_sparse_index( //
@@ -173,7 +169,7 @@ scalar_kind_t numpy_string_to_kind(std::string const& name) {
         return scalar_kind_t::unknown_k;
 }
 
-static void add_one_to_index(punned_index_py_t& index, label_t label, py::buffer vector, bool copy, std::size_t) {
+static void add_one_to_index(dense_index_py_t& index, label_t label, py::buffer vector, bool copy, std::size_t) {
 
     py::buffer_info vector_info = vector.request();
     if (vector_info.ndim != 1)
@@ -203,7 +199,7 @@ static void add_one_to_index(punned_index_py_t& index, label_t label, py::buffer
 
 template <typename scalar_at>
 static void add_typed_to_index(                                              //
-    punned_index_py_t& index,                                                //
+    dense_index_py_t& index,                                                 //
     py::buffer_info const& labels_info, py::buffer_info const& vectors_info, //
     bool copy, std::size_t threads) {
 
@@ -223,8 +219,8 @@ static void add_typed_to_index(                                              //
     });
 }
 
-static void add_many_to_index(                                       //
-    punned_index_py_t& index, py::buffer labels, py::buffer vectors, //
+static void add_many_to_index(                                      //
+    dense_index_py_t& index, py::buffer labels, py::buffer vectors, //
     bool copy, std::size_t threads) {
 
     if (index.limits().threads_add < threads)
@@ -265,7 +261,7 @@ static void add_many_to_index(                                       //
     }
 }
 
-static py::tuple search_one_in_index(punned_index_py_t& index, py::buffer vector, std::size_t wanted, bool exact) {
+static py::tuple search_one_in_index(dense_index_py_t& index, py::buffer vector, std::size_t wanted, bool exact) {
 
     py::buffer_info vector_info = vector.request();
     Py_ssize_t vector_dimensions = vector_info.shape[0];
@@ -282,7 +278,7 @@ static py::tuple search_one_in_index(punned_index_py_t& index, py::buffer vector
     search_config_t config;
     config.exact = exact;
 
-    auto raise_and_dump = [&](punned_search_result_t result) {
+    auto raise_and_dump = [&](dense_search_result_t result) {
         result.error.raise();
         count = result.dump_to(&labels_py1d(0), &distances_py1d(0));
     };
@@ -308,9 +304,9 @@ static py::tuple search_one_in_index(punned_index_py_t& index, py::buffer vector
 }
 
 template <typename scalar_at>
-static void search_typed(                                    //
-    punned_index_py_t& index, py::buffer_info& vectors_info, //
-    std::size_t wanted, bool exact, std::size_t threads,     //
+static void search_typed(                                   //
+    dense_index_py_t& index, py::buffer_info& vectors_info, //
+    std::size_t wanted, bool exact, std::size_t threads,    //
     py::array_t<label_t>& labels_py, py::array_t<distance_t>& distances_py, py::array_t<Py_ssize_t>& counts_py) {
 
     auto labels_py2d = labels_py.template mutable_unchecked<2>();
@@ -325,7 +321,7 @@ static void search_typed(                                    //
         config.thread = thread_idx;
         config.exact = exact;
         scalar_at const* vector = (scalar_at const*)(vectors_data + task_idx * vectors_info.strides[0]);
-        punned_search_result_t result = index.search(vector, wanted, config);
+        dense_search_result_t result = index.search(vector, wanted, config);
         result.error.raise();
         counts_py1d(task_idx) =
             static_cast<Py_ssize_t>(result.dump_to(&labels_py2d(task_idx, 0), &distances_py2d(task_idx, 0)));
@@ -344,7 +340,7 @@ static void search_typed(                                    //
  *      3. array with match counts.
  */
 static py::tuple search_many_in_index( //
-    punned_index_py_t& index, py::buffer vectors, std::size_t wanted, bool exact, std::size_t threads) {
+    dense_index_py_t& index, py::buffer vectors, std::size_t wanted, bool exact, std::size_t threads) {
 
     if (wanted == 0)
         return py::tuple(3);
@@ -591,7 +587,7 @@ PYBIND11_MODULE(compiled, m) {
     h.def_readonly("bytes_for_vectors", &file_head_result_t::bytes_for_vectors);
     h.def_readonly("bytes_checksum", &file_head_result_t::bytes_checksum);
 
-    auto i = py::class_<punned_index_py_t>(m, "Index");
+    auto i = py::class_<dense_index_py_t>(m, "Index");
 
     i.def(py::init(&make_index),                                           //
           py::kw_only(),                                                   //
@@ -632,30 +628,29 @@ PYBIND11_MODULE(compiled, m) {
         py::arg("threads") = 0           //
     );
 
-    i.def("__len__", &punned_index_py_t::size);
-    i.def_property_readonly("size", &punned_index_py_t::size);
-    i.def_property_readonly("ndim", &punned_index_py_t::dimensions);
-    i.def_property_readonly("connectivity", &punned_index_py_t::connectivity);
-    i.def_property_readonly("capacity", &punned_index_py_t::capacity);
+    i.def("__len__", &dense_index_py_t::size);
+    i.def_property_readonly("size", &dense_index_py_t::size);
+    i.def_property_readonly("ndim", &dense_index_py_t::dimensions);
+    i.def_property_readonly("connectivity", &dense_index_py_t::connectivity);
+    i.def_property_readonly("capacity", &dense_index_py_t::capacity);
     i.def_property_readonly( //
-        "dtype", [](punned_index_py_t const& index) -> scalar_kind_t { return index.metric().scalar_kind_; });
+        "dtype", [](dense_index_py_t const& index) -> scalar_kind_t { return index.metric().scalar_kind_; });
     i.def_property_readonly( //
-        "memory_usage", [](punned_index_py_t const& index) -> std::size_t { return index.memory_usage(); },
+        "memory_usage", [](dense_index_py_t const& index) -> std::size_t { return index.memory_usage(); },
         py::call_guard<py::gil_scoped_release>());
 
-    i.def_property("expansion_add", &punned_index_py_t::expansion_add, &punned_index_py_t::change_expansion_add);
-    i.def_property("expansion_search", &punned_index_py_t::expansion_search,
-                   &punned_index_py_t::change_expansion_search);
+    i.def_property("expansion_add", &dense_index_py_t::expansion_add, &dense_index_py_t::change_expansion_add);
+    i.def_property("expansion_search", &dense_index_py_t::expansion_search, &dense_index_py_t::change_expansion_search);
 
-    i.def_property_readonly("labels", &get_all_labels<punned_index_py_t>);
-    i.def("get_labels", &get_labels<punned_index_py_t>, py::arg("limit") = std::numeric_limits<std::size_t>::max());
-    i.def("__contains__", &punned_index_py_t::contains);
-    i.def("__getitem__", &get_member<punned_index_py_t>, py::arg("label"), py::arg("dtype") = scalar_kind_t::f32_k);
+    i.def_property_readonly("labels", &get_all_labels<dense_index_py_t>);
+    i.def("get_labels", &get_labels<dense_index_py_t>, py::arg("limit") = std::numeric_limits<std::size_t>::max());
+    i.def("__contains__", &dense_index_py_t::contains);
+    i.def("__getitem__", &get_member<dense_index_py_t>, py::arg("label"), py::arg("dtype") = scalar_kind_t::f32_k);
 
-    i.def("save", &save_index<punned_index_py_t>, py::arg("path"), py::call_guard<py::gil_scoped_release>());
-    i.def("load", &load_index<punned_index_py_t>, py::arg("path"), py::call_guard<py::gil_scoped_release>());
-    i.def("view", &view_index<punned_index_py_t>, py::arg("path"), py::call_guard<py::gil_scoped_release>());
-    i.def("clear", &punned_index_py_t::clear, py::call_guard<py::gil_scoped_release>());
+    i.def("save", &save_index<dense_index_py_t>, py::arg("path"), py::call_guard<py::gil_scoped_release>());
+    i.def("load", &load_index<dense_index_py_t>, py::arg("path"), py::call_guard<py::gil_scoped_release>());
+    i.def("view", &view_index<dense_index_py_t>, py::arg("path"), py::call_guard<py::gil_scoped_release>());
+    i.def("clear", &dense_index_py_t::clear, py::call_guard<py::gil_scoped_release>());
 
     auto si = py::class_<sparse_index_py_t>(m, "SparseIndex");
 

package/python/usearch/index.py

@@ -31,7 +31,7 @@ MetricKindBitwise = (
 
 SparseIndex = _CompiledSetsIndex
 
-Label = np.uint32
+Label = np.uint64
 
 
 def _normalize_dtype(dtype, metric: MetricKind = MetricKind.IP) -> ScalarKind:

package/rust/lib.cpp

@@ -4,14 +4,14 @@
 using namespace unum::usearch;
 using namespace unum;
 
-using punned_t = typename Index::punned_t;
-using add_result_t = typename punned_t::add_result_t;
-using search_result_t = typename punned_t::search_result_t;
-using serialization_result_t = typename punned_t::serialization_result_t;
+using index_t = typename Index::index_t;
+using add_result_t = typename index_t::add_result_t;
+using search_result_t = typename index_t::search_result_t;
+using serialization_result_t = typename index_t::serialization_result_t;
 
-Index::Index(std::unique_ptr<punned_t> index) : index_(std::move(index)) {}
+Index::Index(std::unique_ptr<index_t> index) : index_(std::move(index)) {}
 
-void Index::add_in_thread(uint32_t label, rust::Slice<float const> vector, size_t thread) const {
+void Index::add_in_thread(label_t label, rust::Slice<float const> vector, size_t thread) const {
     add_config_t config;
     config.thread = thread;
     index_->add(label, vector.data(), config).error.raise();
@@ -33,7 +33,7 @@ Matches Index::search_in_thread(rust::Slice<float const> vector, size_t count, s
     return matches;
 }
 
-void Index::add(uint32_t label, rust::Slice<float const> vector) const {
+void Index::add(label_t label, rust::Slice<float const> vector) const {
     index_->add(label, vector.data()).error.raise();
 }
 
@@ -64,9 +64,9 @@ void Index::view(rust::Str path) const { index_->view(std::string(path).c_str())
 
 scalar_kind_t accuracy(rust::Str quant) { return scalar_kind_from_name(quant.data(), quant.size()); }
 
-std::unique_ptr<Index> wrap(punned_t&& index) {
-    std::unique_ptr<punned_t> punned_ptr;
-    punned_ptr.reset(new punned_t(std::move(index)));
+std::unique_ptr<Index> wrap(index_t&& index) {
+    std::unique_ptr<index_t> punned_ptr;
+    punned_ptr.reset(new index_t(std::move(index)));
     std::unique_ptr<Index> result;
     result.reset(new Index(std::move(punned_ptr)));
     return result;
@@ -104,7 +104,7 @@ scalar_kind_t rust_to_cpp_scalar(ScalarKind value) {
 }
 
 std::unique_ptr<Index> new_index(IndexOptions const& options) {
-    return wrap(punned_t::make(options.dimensions, rust_to_cpp_metric(options.metric), config(options.connectivity),
-                               rust_to_cpp_scalar(options.quantization), options.expansion_add,
-                               options.expansion_search));
+    return wrap(index_t::make(options.dimensions, rust_to_cpp_metric(options.metric), config(options.connectivity),
+                              rust_to_cpp_scalar(options.quantization), options.expansion_add,
+                              options.expansion_search));
 }

package/rust/lib.hpp

@@ -10,16 +10,20 @@ struct IndexOptions;
 
 class Index {
   public:
-    using label_t = std::uint32_t;
+    using metric_t = unum::usearch::index_punned_dense_metric_t;
     using distance_t = unum::usearch::punned_distance_t;
-    using punned_t = unum::usearch::index_punned_dense_gt<label_t>;
+    using index_t = unum::usearch::punned_small_t;
+    using add_result_t = typename index_t::add_result_t;
+    using search_result_t = typename index_t::search_result_t;
+    using label_t = typename index_t::label_t;
+    using id_t = typename index_t::id_t;
 
-    Index(std::unique_ptr<punned_t> index);
+    Index(std::unique_ptr<index_t> index);
 
     void reserve(size_t) const;
 
-    void add(uint32_t label, rust::Slice<float const> vector) const;
-    void add_in_thread(uint32_t label, rust::Slice<float const> vector, size_t thread) const;
+    void add(label_t label, rust::Slice<float const> vector) const;
+    void add_in_thread(label_t label, rust::Slice<float const> vector, size_t thread) const;
 
     Matches search(rust::Slice<float const> vector, size_t count) const;
     Matches search_in_thread(rust::Slice<float const> vector, size_t count, size_t thread) const;
@@ -34,7 +38,7 @@ class Index {
     void view(rust::Str path) const;
 
   private:
-    std::unique_ptr<punned_t> index_;
+    std::unique_ptr<index_t> index_;
 };
 
 std::unique_ptr<Index> new_index(IndexOptions const& options);

package/rust/lib.rs

@@ -4,7 +4,7 @@ pub mod ffi {
     // Shared structs with fields visible to both languages.
     struct Matches {
         count: usize,
-        labels: Vec<u32>,
+        labels: Vec<u64>,
         distances: Vec<f32>,
     }
 
@@ -51,7 +51,7 @@ pub mod ffi {
         pub fn size(self: &Index) -> usize;
         pub fn capacity(self: &Index) -> usize;
 
-        pub fn add(self: &Index, label: u32, vector: &[f32]) -> Result<()>;
+        pub fn add(self: &Index, label: u64, vector: &[f32]) -> Result<()>;
         pub fn search(self: &Index, query: &[f32], count: usize) -> Result<Matches>;
 
         pub fn save(self: &Index, path: &str) -> Result<()>;

package/swift/Index+Sugar.swift

@@ -7,11 +7,15 @@
 
 @available(iOS 13, macOS 10.15, tvOS 13.0, watchOS 6.0, *)
 extension USearchIndex {
+    public typealias Label = USearchLabel
+    public typealias Metric = USearchMetric
+    public typealias Scalar = USearchScalar
+    
     /// Adds a labeled vector to the index.
     /// - Parameter label: Unique identifer for that object.
     /// - Parameter vector: Single-precision vector.
     /// - Throws: If runs out of memory.
-    public func add(label: UInt32, vector: ArraySlice<Float32>) {
+    public func add(label: USearchLabel, vector: ArraySlice<Float32>) {
         vector.withContiguousStorageIfAvailable {
             addSingle(label: label, vector: $0.baseAddress!)
         }
@@ -23,8 +27,8 @@ extension USearchIndex {
     /// - Parameter count: Upper limit on the number of matches to retrieve.
     /// - Returns: Labels and distances to closest approximate matches in decreasing similarity order.
     /// - Throws: If runs out of memory.
-    public func search(vector: ArraySlice<Float32>, count: Int) -> ([UInt32], [Float]) {
-        var matches: [UInt32] = Array(repeating: 0, count: count)
+    public func search(vector: ArraySlice<Float32>, count: Int) -> ([Label], [Float]) {
+        var matches: [Label] = Array(repeating: 0, count: count)
         var distances: [Float] = Array(repeating: 0, count: count)
         let results = vector.withContiguousStorageIfAvailable {
             searchSingle(vector: $0.baseAddress!, count: CUnsignedInt(count), labels: &matches, distances: &distances)
@@ -38,7 +42,7 @@ extension USearchIndex {
     /// - Parameter label: Unique identifer for that object.
     /// - Parameter vector: Double-precision vector.
     /// - Throws: If runs out of memory.
-    public func add(label: UInt32, vector: ArraySlice<Float64>) {
+    public func add(label: Label, vector: ArraySlice<Float64>) {
         vector.withContiguousStorageIfAvailable {
             addDouble(label: label, vector: $0.baseAddress!)
         }
@@ -49,8 +53,8 @@ extension USearchIndex {
     /// - Parameter count: Upper limit on the number of matches to retrieve.
     /// - Returns: Labels and distances to closest approximate matches in decreasing similarity order.
     /// - Throws: If runs out of memory.
-    public func search(vector: ArraySlice<Float64>, count: Int) -> ([UInt32], [Float]) {
-        var matches: [UInt32] = Array(repeating: 0, count: count)
+    public func search(vector: ArraySlice<Float64>, count: Int) -> ([Label], [Float]) {
+        var matches: [Label] = Array(repeating: 0, count: count)
         var distances: [Float] = Array(repeating: 0, count: count)
         let results = vector.withContiguousStorageIfAvailable {
             searchDouble(vector: $0.baseAddress!, count: CUnsignedInt(count), labels: &matches, distances: &distances)
@@ -67,7 +71,7 @@ extension USearchIndex {
         /// - Parameter vector: Half-precision vector.
         /// - Throws: If runs out of memory.
         @available(macOS 11.0, iOS 14.0, watchOS 7.0, tvOS 14.0, *)
-        public func add(label: UInt32, vector: ArraySlice<Float16>) {
+        public func add(label: Label, vector: ArraySlice<Float16>) {
             vector.withContiguousStorageIfAvailable { buffer in
                 addHalf(label: label, vector: buffer.baseAddress!)
             }
@@ -79,8 +83,8 @@ extension USearchIndex {
         /// - Returns: Labels and distances to closest approximate matches in decreasing similarity order.
         /// - Throws: If runs out of memory.
         @available(macOS 11.0, iOS 14.0, watchOS 7.0, tvOS 14.0, *)
-        public func search(vector: ArraySlice<Float16>, count: Int) -> ([UInt32], [Float]) {
-            var matches: [UInt32] = Array(repeating: 0, count: count)
+        public func search(vector: ArraySlice<Float16>, count: Int) -> ([Label], [Float]) {
+            var matches: [Label] = Array(repeating: 0, count: count)
             var distances: [Float] = Array(repeating: 0, count: count)
             let results = vector.withContiguousStorageIfAvailable {
                 searchHalf(vector: $0.baseAddress!, count: CUnsignedInt(count), labels: &matches, distances: &distances)