usearch 0.19.1 → 0.19.3

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "usearch"
-version = "0.19.1"
+version = "0.19.3"
 authors = ["Ashot Vardanian <1983160+ashvardanian@users.noreply.github.com>"]
 description = "Smaller & Faster Single-File Vector Search Engine from Unum"
 edition = "2021"

package/c/lib.cpp

@@ -15,8 +15,7 @@ using index_t = index_punned_dense_gt<label_t>;
 using add_result_t = index_t::add_result_t;
 using search_result_t = index_t::search_result_t;
 using serialization_result_t = index_t::serialization_result_t;
-
-using span_t = span_gt<float>;
+using vector_view_t = span_gt<float>;
 
 // helper functions that are not part of the C ABI
 metric_kind_t to_native_metric(usearch_metric_kind_t kind) {

package/conanfile.py

@@ -4,7 +4,7 @@ from conans import ConanFile
 class USearchConan(ConanFile):
 
     name = 'USearch'
-    version = '0.19.1'
+    version = '0.19.3'
     license = 'Apache 2.0'
     url = 'https://github.com/unum-cloud/usearch'
     description = 'Smaller & Faster Single-File Vector Search Engine from Unum'

package/cpp/bench.cpp

@@ -1,7 +1,7 @@
 /**
- * @brief A benchmark for the construction speed of the USearch index
- * and the resulting accuracy (recall) of the Approximate Nearest Neighbors
- * Search queries.
+ *  @brief A benchmark for the construction speed of the USearch index
+ *  and the resulting accuracy (recall) of the Approximate Nearest Neighbors
+ *  Search queries.
  */
 
 #if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)

package/include/usearch/index.hpp

@@ -48,8 +48,11 @@
 // OS-specific includes
 #if defined(USEARCH_DEFINED_WINDOWS)
 #define _USE_MATH_DEFINES
+#define NOMINMAX
 #include <Windows.h>
 #include <sys/stat.h> // `fstat` for file size
+#undef NOMINMAX
+#undef _USE_MATH_DEFINES
 #else
 #include <fcntl.h>    // `fallocate`
 #include <stdlib.h>   // `posix_memalign`
@@ -1305,6 +1308,7 @@ class index_gt {
     using id_t = id_at;
     using allocator_t = allocator_at;
     using point_allocator_t = point_allocator_at;
+    static_assert(sizeof(label_t) >= sizeof(id_t), "Having tiny labels doesn't make sense.");
 
     using scalar_t = typename metric_t::scalar_t;
     using vector_view_t = span_gt<scalar_t const>;

package/include/usearch/index_punned_dense.hpp

@@ -652,7 +652,7 @@ class index_punned_dense_gt {
     }
 };
 
-using punned_small_t = index_punned_dense_gt<std::int64_t, std::uint32_t>;
+using punned_small_t = index_punned_dense_gt<std::uint64_t, std::uint32_t>;
 using punned_big_t = index_punned_dense_gt<uuid_t, uint40_t>;
 
 } // namespace usearch

package/java/cloud/unum/usearch/cloud_unum_usearch_Index.cpp

@@ -9,14 +9,16 @@
 using namespace unum::usearch;
 using namespace unum;
 
-using label_t = jint;
-using span_t = span_gt<float>;
+using metric_t = index_punned_dense_metric_t;
 using distance_t = punned_distance_t;
-using punned_t = index_punned_dense_gt<label_t>;
+using index_t = punned_small_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 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 vector_view_t = unum::usearch::span_gt<float>;
 
 JNIEXPORT jlong JNICALL Java_cloud_unum_usearch_Index_c_1create( //
     JNIEnv* env, jclass,                                         //
@@ -41,14 +43,14 @@ JNIEXPORT jlong JNICALL Java_cloud_unum_usearch_Index_c_1create( //
 
         scalar_kind_t accuracy = scalar_kind_from_name(accuracy_cstr, accuracy_length);
         metric_kind_t metric_kind = metric_from_name(metric_cstr, metric_length);
-        punned_t index = punned_t::make(static_cast<std::size_t>(dimensions), metric_kind, config, accuracy,
-                                        expansion_add, expansion_search);
+        index_t index = index_t::make( //
+            static_cast<std::size_t>(dimensions), metric_kind, config, accuracy, expansion_add, expansion_search);
         if (!index.reserve(static_cast<std::size_t>(capacity))) {
             jclass jc = (*env).FindClass("java/lang/Error");
             if (jc)
                 (*env).ThrowNew(jc, "Failed to reserve desired capacity!");
         } else {
-            punned_t* result_ptr = new punned_t(std::move(index));
+            index_t* result_ptr = new index_t(std::move(index));
             std::memcpy(&result, &result_ptr, sizeof(jlong));
         }
 
@@ -65,7 +67,7 @@ JNIEXPORT jlong JNICALL Java_cloud_unum_usearch_Index_c_1create( //
 
 JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1save(JNIEnv* env, jclass, jlong c_ptr, jstring path) {
     char const* path_cstr = (*env).GetStringUTFChars(path, 0);
-    if (!reinterpret_cast<punned_t*>(c_ptr)->save(path_cstr)) {
+    if (!reinterpret_cast<index_t*>(c_ptr)->save(path_cstr)) {
         jclass jc = (*env).FindClass("java/lang/Error");
         if (jc)
             (*env).ThrowNew(jc, "Failed to dump vector index to path!");
@@ -75,7 +77,7 @@ JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1save(JNIEnv* env, jclass
 
 JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1load(JNIEnv* env, jclass, jlong c_ptr, jstring path) {
     char const* path_cstr = (*env).GetStringUTFChars(path, 0);
-    if (!reinterpret_cast<punned_t*>(c_ptr)->load(path_cstr)) {
+    if (!reinterpret_cast<index_t*>(c_ptr)->load(path_cstr)) {
         jclass jc = (*env).FindClass("java/lang/Error");
         if (jc)
             (*env).ThrowNew(jc, "Failed to load vector index from path!");
@@ -85,7 +87,7 @@ JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1load(JNIEnv* env, jclass
 
 JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1view(JNIEnv* env, jclass, jlong c_ptr, jstring path) {
     char const* path_cstr = (*env).GetStringUTFChars(path, 0);
-    if (!reinterpret_cast<punned_t*>(c_ptr)->view(path_cstr)) {
+    if (!reinterpret_cast<index_t*>(c_ptr)->view(path_cstr)) {
         jclass jc = (*env).FindClass("java/lang/Error");
         if (jc)
             (*env).ThrowNew(jc, "Failed to view vector index from path!");
@@ -94,27 +96,27 @@ JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1view(JNIEnv* env, jclass
 }
 
 JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1destroy(JNIEnv*, jclass, jlong c_ptr) {
-    delete reinterpret_cast<punned_t*>(c_ptr);
+    delete reinterpret_cast<index_t*>(c_ptr);
 }
 
 JNIEXPORT jlong JNICALL Java_cloud_unum_usearch_Index_c_1size(JNIEnv*, jclass, jlong c_ptr) {
-    return reinterpret_cast<punned_t*>(c_ptr)->size();
+    return reinterpret_cast<index_t*>(c_ptr)->size();
 }
 
 JNIEXPORT jlong JNICALL Java_cloud_unum_usearch_Index_c_1connectivity(JNIEnv*, jclass, jlong c_ptr) {
-    return reinterpret_cast<punned_t*>(c_ptr)->connectivity();
+    return reinterpret_cast<index_t*>(c_ptr)->connectivity();
 }
 
 JNIEXPORT jlong JNICALL Java_cloud_unum_usearch_Index_c_1dimensions(JNIEnv*, jclass, jlong c_ptr) {
-    return reinterpret_cast<punned_t*>(c_ptr)->dimensions();
+    return reinterpret_cast<index_t*>(c_ptr)->dimensions();
 }
 
 JNIEXPORT jlong JNICALL Java_cloud_unum_usearch_Index_c_1capacity(JNIEnv*, jclass, jlong c_ptr) {
-    return reinterpret_cast<punned_t*>(c_ptr)->capacity();
+    return reinterpret_cast<index_t*>(c_ptr)->capacity();
 }
 
 JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1reserve(JNIEnv* env, jclass, jlong c_ptr, jlong capacity) {
-    if (!reinterpret_cast<punned_t*>(c_ptr)->reserve(static_cast<std::size_t>(capacity))) {
+    if (!reinterpret_cast<index_t*>(c_ptr)->reserve(static_cast<std::size_t>(capacity))) {
         jclass jc = (*env).FindClass("java/lang/Error");
         if (jc)
             (*env).ThrowNew(jc, "Failed to grow vector index!");
@@ -126,9 +128,9 @@ JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1add( //
 
     jfloat* vector_data = (*env).GetFloatArrayElements(vector, 0);
     jsize vector_dims = (*env).GetArrayLength(vector);
-    span_t vector_span = span_t{vector_data, static_cast<std::size_t>(vector_dims)};
+    vector_view_t vector_span = vector_view_t{vector_data, static_cast<std::size_t>(vector_dims)};
 
-    if (!reinterpret_cast<punned_t*>(c_ptr)->add(label, vector_span)) {
+    if (!reinterpret_cast<index_t*>(c_ptr)->add(static_cast<label_t>(label), vector_span)) {
         jclass jc = (*env).FindClass("java/lang/Error");
         if (jc)
             (*env).ThrowNew(jc, "Failed to insert a new point in vector index!");
@@ -150,10 +152,10 @@ JNIEXPORT jintArray JNICALL Java_cloud_unum_usearch_Index_c_1search( //
 
     jfloat* vector_data = (*env).GetFloatArrayElements(vector, 0);
     jsize vector_dims = (*env).GetArrayLength(vector);
-    span_t vector_span = span_t{vector_data, static_cast<std::size_t>(vector_dims)};
-    search_result_t result = reinterpret_cast<punned_t*>(c_ptr)->search(vector_span, static_cast<std::size_t>(wanted));
+    vector_view_t vector_span = vector_view_t{vector_data, static_cast<std::size_t>(vector_dims)};
+    search_result_t result = reinterpret_cast<index_t*>(c_ptr)->search(vector_span, static_cast<std::size_t>(wanted));
     if (result) {
-        std::size_t found = result.dump_to(matches_data, NULL);
+        std::size_t found = result.dump_to(reinterpret_cast<label_t*>(matches_data), NULL);
         (*env).SetIntArrayRegion(matches, 0, found, matches_data);
     } else {
         jclass jc = (*env).FindClass("java/lang/Error");

package/javascript/lib.cpp

@@ -9,14 +9,9 @@
  *  @see NodeJS docs: https://nodejs.org/api/addons.html#hello-world
  *
  */
-
-#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)
-#define _USE_MATH_DEFINES
-#define NAPI_CPP_EXCEPTIONS
-#endif
-
 #include <new> // `std::bad_alloc`
 
+#define NAPI_CPP_EXCEPTIONS
 #include <napi.h>
 #include <node_api.h>
 
@@ -25,9 +20,13 @@
 using namespace unum::usearch;
 using namespace unum;
 
-using label_t = std::uint32_t;
+using metric_t = index_punned_dense_metric_t;
 using distance_t = punned_distance_t;
-using punned_t = index_punned_dense_gt<label_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 label_t = typename index_t::label_t;
+using id_t = typename index_t::id_t;
 
 class Index : public Napi::ObjectWrap<Index> {
   public:
@@ -47,7 +46,7 @@ class Index : public Napi::ObjectWrap<Index> {
     void Add(Napi::CallbackInfo const& ctx);
     Napi::Value Search(Napi::CallbackInfo const& ctx);
 
-    std::unique_ptr<punned_t> native_;
+    std::unique_ptr<index_t> native_;
 };
 
 Napi::Object Index::Init(Napi::Env env, Napi::Object exports) {
@@ -124,7 +123,7 @@ Index::Index(Napi::CallbackInfo const& ctx) : Napi::ObjectWrap<Index>(ctx) {
     }
 
     native_.reset(
-        new punned_t(punned_t::make(dimensions, metric_kind, config, accuracy, expansion_add, expansion_search)));
+        new index_t(index_t::make(dimensions, metric_kind, config, accuracy, expansion_add, expansion_search)));
     native_->reserve(limits);
 }
 
@@ -235,7 +234,7 @@ Napi::Value Index::Search(Napi::CallbackInfo const& ctx) {
         return {};
     }
 
-    Napi::Uint32Array matches_js = Napi::Uint32Array::New(env, wanted);
+    Napi::TypedArrayOf<label_t> matches_js = Napi::TypedArrayOf<label_t>::New(env, wanted);
     Napi::Float32Array distances_js = Napi::Float32Array::New(env, wanted);
     try {
         std::size_t count = native_->search(vector, wanted).dump_to(matches_js.Data(), distances_js.Data());

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.1",
+    "version": "0.19.3",
     "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/scripts/bench.py

@@ -1,14 +1,13 @@
-import os
-import logging
 import itertools
-from typing import List, Optional, Iterable
+from typing import List
 from dataclasses import asdict
 
 import numpy as np
 import pandas as pd
 
-from usearch.index import Index, Label
-from usearch.eval import Evaluation, Dataset, AddTask
+from usearch.index import Index, Label, MetricKind, ScalarKind
+from usearch.numba import jit as njit
+from usearch.eval import Evaluation, AddTask
 from usearch.index import (
     DEFAULT_CONNECTIVITY,
     DEFAULT_EXPANSION_ADD,
@@ -26,14 +25,15 @@ def bench_speed(
 ) -> pd.DataFrame:
     # Build various indexes:
     indexes = []
-    jit_options = [False]
-    if jit:
-        jit_options.append(jit)
-    dtype_options = ["f32", "f16", "f8"]
+    jit_options = [False, True] if jit else [False]
+    dtype_options = [ScalarKind.F32, ScalarKind.F16, ScalarKind.F8]
     for jit, dtype in itertools.product(jit_options, dtype_options):
+        metric = MetricKind.IP
+        if jit:
+            metric = njit(eval.ndim, metric, dtype)
         index = Index(
             ndim=eval.ndim,
-            jit=jit,
+            metric=metric,
             dtype=dtype,
             expansion_add=expansion_add,
             expansion_search=expansion_search,

package/python/scripts/test.py

@@ -1,9 +1,12 @@
 import os
+import importlib.util
+
 import pytest
 import numpy as np
 
 from usearch.io import load_matrix, save_matrix
-from usearch.eval import recall_members, random_vectors
+from usearch.eval import random_vectors
+from usearch.numba import jit as njit
 
 from usearch.index import (
     Index,
@@ -13,9 +16,7 @@ from usearch.index import (
     MetricSignature,
     CompiledMetric,
     Matches,
-    MetricKindBitwise,
 )
-from usearch.index import _normalize_dtype
 from usearch.index import (
     DEFAULT_CONNECTIVITY,
     DEFAULT_EXPANSION_ADD,
@@ -34,7 +35,7 @@ index_types = [
 numpy_types = [np.float32, np.float64, np.float16]
 
 connectivity_options = [3, 13, 50, DEFAULT_CONNECTIVITY]
-jit_options = [False]
+jit_options = [False, True] if importlib.util.find_spec("spam") is not None else [False]
 continuous_metrics = [
     MetricKind.Cos,
     MetricKind.L2sq,
@@ -80,6 +81,8 @@ def test_index(
     connectivity: int,
     jit: bool,
 ):
+    if jit:
+        metric = njit(ndim, metric, index_type)
     index = Index(
         metric=metric,
         ndim=ndim,
@@ -87,7 +90,6 @@ def test_index(
         connectivity=connectivity,
         expansion_add=DEFAULT_EXPANSION_ADD,
         expansion_search=DEFAULT_EXPANSION_SEARCH,
-        jit=jit,
     )
     assert index.ndim == ndim
     assert index.connectivity == connectivity
@@ -176,7 +178,10 @@ def test_index_batch(
 @pytest.mark.parametrize("index_type", index_types)
 @pytest.mark.parametrize("numpy_type", numpy_types)
 def test_exact_recall(
-    metric: MetricKind, batch_size: int, index_type: ScalarKind, numpy_type: str
+    metric: MetricKind,
+    batch_size: int,
+    index_type: ScalarKind,
+    numpy_type: str,
 ):
     ndim: int = batch_size
     index = Index(ndim=ndim, metric=metric, dtype=index_type)
@@ -436,7 +441,10 @@ def test_index_peachpy(ndim: int, batch_size: int):
 @pytest.mark.parametrize("connectivity", connectivity_options)
 @pytest.mark.parametrize("batch_size", batch_sizes)
 def test_bitwise_index(
-    bits: int, metric: MetricKind, connectivity: int, batch_size: int
+    bits: int,
+    metric: MetricKind,
+    connectivity: int,
+    batch_size: int,
 ):
     index = Index(ndim=bits, metric=metric, connectivity=connectivity)
 

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:
@@ -167,10 +167,9 @@ class Index:
 
     def __init__(
         self,
-        ndim: int,
+        ndim: int = 0,
         metric: Union[str, MetricKind, CompiledMetric] = MetricKind.IP,
-        dtype: Optional[str] = None,
-        jit: bool = False,
+        dtype: Optional[Union[str, ScalarKind]] = None,
         connectivity: int = DEFAULT_CONNECTIVITY,
         expansion_add: int = DEFAULT_EXPANSION_ADD,
         expansion_search: int = DEFAULT_EXPANSION_SEARCH,
@@ -182,6 +181,10 @@ class Index:
 
         :param ndim: Number of vector dimensions
         :type ndim: int
+            Required for some metrics, optional for others.
+            Haversine, for example, only applies to 2-dimensional latitude/longitude
+            coordinates. Angular (Cos) and Euclidean (L2sq), obviously, apply to
+            vectors with arbitrary number of dimensions.
 
         :param metric: Distance function, defaults to MetricKind.IP
         :type metric: Union[MetricKind, Callable, str], optional
@@ -191,18 +194,12 @@ class Index:
             Not every kind is JIT-able. For Jaccard distance, use `SparseIndex`.
 
         :param dtype: Scalar type for internal vector storage, defaults to None
-        :type dtype: str, optional
+        :type dtype: Optional[Union[str, ScalarKind]], optional
             For continuous metrics can be: f16, f32, f64, or f8.
             For bitwise metrics it's implementation-defined, and can't change.
             Example: you can use the `f16` index with `f32` vectors in Euclidean space,
             which will be automatically downcasted.
 
-        :param jit: Enable Numba to JIT compile the metric, defaults to False
-        :type jit: bool, optional
-            This can result in up-to 3x performance difference on very large vectors
-            and very recent hardware, as the Python module is compiled with high
-            compatibility in mind and avoids very fancy assembly instructions.
-
         :param connectivity: Connections per node in HNSW, defaults to None
         :type connectivity: Optional[int], optional
             Hyper-parameter for the number of Graph connections
@@ -231,21 +228,6 @@ class Index:
         """
 
         metric = _normalize_metric(metric)
-        if isinstance(metric, MetricKind) and jit:
-            try:
-                from usearch.numba import jit
-            except ImportError:
-                raise ModuleNotFoundError(
-                    "To use JIT install Numba with `pip install numba`."
-                    "Alternatively, reinstall with `pip install usearch[jit]`"
-                )
-
-            metric = jit(
-                ndim=ndim,
-                metric=metric,
-                dtype=_normalize_dtype(dtype, metric),
-            )
-
         if isinstance(metric, MetricKind):
             self._metric_kind = metric
             self._metric_jit = None

package/python/usearch/numba.py

@@ -4,31 +4,19 @@
 # into the primary `Index` class, connecting USearch with Numba.
 from math import sqrt
 
-from numba import cfunc, types, carray
-
 from usearch.index import MetricKind, ScalarKind, MetricSignature, CompiledMetric
 
 
-signature_i8args = types.float32(types.CPointer(types.int8), types.CPointer(types.int8))
-
-signature_f16args = types.float32(
-    types.CPointer(types.float16), types.CPointer(types.float16)
-)
-
-signature_f32args = types.float32(
-    types.CPointer(types.float32), types.CPointer(types.float32)
-)
-
-signature_f64args = types.float32(
-    types.CPointer(types.float64), types.CPointer(types.float64)
-)
-
-
 def jit(
-    ndim: int, metric: MetricKind = MetricKind.Cos, dtype: ScalarKind = ScalarKind.F32
+    ndim: int,
+    metric: MetricKind = MetricKind.Cos,
+    dtype: ScalarKind = ScalarKind.F32,
 ) -> CompiledMetric:
-    """JIT-compiles a distance metric specifically tuned for the target hardware
-    and number of dimensions.
+    """JIT-compiles the metric for target hardware and number of dimensions.
+
+    This can result in up-to 3x performance difference on very large vectors
+    and very recent hardware, as the Python module is compiled with high
+    compatibility in mind and avoids very fancy assembly instructions.
 
     Uses Numba `cfunc` functionality, annotating it with Numba `types` instead
     of `ctypes` to support half-precision.
@@ -37,6 +25,24 @@ def jit(
     assert isinstance(metric, MetricKind)
     assert isinstance(dtype, ScalarKind)
 
+    from numba import cfunc, types, carray
+
+    signature_i8args = types.float32(
+        types.CPointer(types.int8), types.CPointer(types.int8)
+    )
+
+    signature_f16args = types.float32(
+        types.CPointer(types.float16), types.CPointer(types.float16)
+    )
+
+    signature_f32args = types.float32(
+        types.CPointer(types.float32), types.CPointer(types.float32)
+    )
+
+    signature_f64args = types.float32(
+        types.CPointer(types.float64), types.CPointer(types.float64)
+    )
+
     numba_supported_types = (
         ScalarKind.F8,
         # Half-precision is still unsupported
@@ -46,7 +52,7 @@ def jit(
         ScalarKind.F64,
     )
     if dtype not in numba_supported_types:
-        return None
+        return metric
 
     scalar_kind_to_accumulator_type = {
         ScalarKind.F8: types.int32,
@@ -109,7 +115,7 @@ def jit(
 
     pointer = cfunc(scalar_kind_to_signature[dtype])(metric_kind_to_function[metric])
     return CompiledMetric(
-        pointer=pointer,
+        pointer=pointer.address,
         kind=metric,
         signature=MetricSignature.ArrayArray,
     )

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)

package/wolfram/lib.cpp

@@ -2,9 +2,16 @@
 #include <usearch/index_punned_dense.hpp>
 
 using namespace unum::usearch;
+
+using metric_t = index_punned_dense_metric_t;
 using distance_t = punned_distance_t;
-using punned_t = index_punned_dense_gt<int>;
-using span_t = span_gt<float>;
+using index_t = punned_small_t;
+using vector_view_t = span_gt<float>;
+
+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;
 
 EXTERN_C DLLEXPORT int WolframLibrary_initialize(WolframLibraryData libData) { return LIBRARY_NO_ERROR; }
 EXTERN_C DLLEXPORT void WolframLibrary_uninitialize(WolframLibraryData libData) { return; }
@@ -24,10 +31,10 @@ EXTERN_C DLLEXPORT int IndexCreate(WolframLibraryData libData, mint Argc, MArgum
 
         scalar_kind_t accuracy = scalar_kind_from_name(accuracy_cstr, std::strlen(accuracy_cstr));
         metric_kind_t metric_kind = metric_from_name(metric_cstr, std::strlen(metric_cstr));
-        punned_t index = make_punned<punned_t>(metric_kind, dimensions, accuracy, config);
+        index_t index = make_punned<index_t>(metric_kind, dimensions, accuracy, config);
         index.reserve(capacity);
 
-        punned_t* result_ptr = new punned_t(std::move(index));
+        index_t* result_ptr = new index_t(std::move(index));
         MArgument_setInteger(Res, (long)result_ptr);
 
     } catch (...) {
@@ -41,7 +48,7 @@ EXTERN_C DLLEXPORT int IndexCreate(WolframLibraryData libData, mint Argc, MArgum
 
 EXTERN_C DLLEXPORT int IndexSave(WolframLibraryData libData, mint Argc, MArgument* Args, MArgument Res) {
     char* path_cstr = nullptr;
-    punned_t* c_ptr = (punned_t*)MArgument_getUTF8String(Args[0]);
+    index_t* c_ptr = (index_t*)MArgument_getUTF8String(Args[0]);
     try {
         path_cstr = MArgument_getUTF8String(Args[1]);
         c_ptr->save(path_cstr);
@@ -54,7 +61,7 @@ EXTERN_C DLLEXPORT int IndexSave(WolframLibraryData libData, mint Argc, MArgumen
 
 EXTERN_C DLLEXPORT int IndexLoad(WolframLibraryData libData, mint Argc, MArgument* Args, MArgument Res) {
     char* path_cstr = nullptr;
-    punned_t* c_ptr = (punned_t*)MArgument_getUTF8String(Args[0]);
+    index_t* c_ptr = (index_t*)MArgument_getUTF8String(Args[0]);
     try {
         path_cstr = MArgument_getUTF8String(Args[1]);
         c_ptr->load(path_cstr);
@@ -67,7 +74,7 @@ EXTERN_C DLLEXPORT int IndexLoad(WolframLibraryData libData, mint Argc, MArgumen
 
 EXTERN_C DLLEXPORT int IndexView(WolframLibraryData libData, mint Argc, MArgument* Args, MArgument Res) {
     char* path_cstr = nullptr;
-    punned_t* c_ptr = (punned_t*)MArgument_getUTF8String(Args[0]);
+    index_t* c_ptr = (index_t*)MArgument_getUTF8String(Args[0]);
     try {
         path_cstr = MArgument_getUTF8String(Args[1]);
         c_ptr->view(path_cstr);
@@ -79,44 +86,44 @@ EXTERN_C DLLEXPORT int IndexView(WolframLibraryData libData, mint Argc, MArgumen
 }
 
 EXTERN_C DLLEXPORT int IndexDestroy(WolframLibraryData libData, mint Argc, MArgument* Args, MArgument Res) {
-    delete (punned_t*)MArgument_getUTF8String(Args[0]);
+    delete (index_t*)MArgument_getUTF8String(Args[0]);
     return LIBRARY_NO_ERROR;
 }
 
 EXTERN_C DLLEXPORT int IndexSize(WolframLibraryData libData, mint Argc, MArgument* Args, MArgument Res) {
-    size_t res = ((punned_t*)MArgument_getUTF8String(Args[0]))->size();
+    std::size_t res = ((index_t*)MArgument_getUTF8String(Args[0]))->size();
     MArgument_setInteger(Res, res);
     return LIBRARY_NO_ERROR;
 }
 
 EXTERN_C DLLEXPORT int IndexConnectivity(WolframLibraryData libData, mint Argc, MArgument* Args, MArgument Res) {
-    size_t res = ((punned_t*)MArgument_getUTF8String(Args[0]))->connectivity();
+    std::size_t res = ((index_t*)MArgument_getUTF8String(Args[0]))->connectivity();
     MArgument_setInteger(Res, res);
     return LIBRARY_NO_ERROR;
 }
 
 EXTERN_C DLLEXPORT int IndexDimensions(WolframLibraryData libData, mint Argc, MArgument* Args, MArgument Res) {
-    size_t res = ((punned_t*)MArgument_getUTF8String(Args[0]))->dimensions();
+    std::size_t res = ((index_t*)MArgument_getUTF8String(Args[0]))->dimensions();
     MArgument_setInteger(Res, res);
     return LIBRARY_NO_ERROR;
 }
 
 EXTERN_C DLLEXPORT int IndexCapacity(WolframLibraryData libData, mint Argc, MArgument* Args, MArgument Res) {
-    size_t res = ((punned_t*)MArgument_getUTF8String(Args[0]))->capacity();
+    std::size_t res = ((index_t*)MArgument_getUTF8String(Args[0]))->capacity();
     MArgument_setInteger(Res, res);
     return LIBRARY_NO_ERROR;
 }
 
 EXTERN_C DLLEXPORT int IndexAdd(WolframLibraryData libData, mint Argc, MArgument* Args, MArgument Res) {
     char* path_cstr = nullptr;
-    punned_t* c_ptr = (punned_t*)MArgument_getUTF8String(Args[0]);
+    index_t* c_ptr = (index_t*)MArgument_getUTF8String(Args[0]);
     float* vector_data = nullptr;
     try {
         int label = MArgument_getInteger(Args[1]);
         MTensor tens = MArgument_getMTensor(Args[2]);
-        size_t len = libData->MTensor_getFlattenedLength(tens);
+        std::size_t len = libData->MTensor_getFlattenedLength(tens);
         vector_data = (float*)libData->MTensor_getRealData(tens);
-        span_t vector_span = span_t{vector_data, len};
+        vector_view_t vector_span = vector_view_t{vector_data, len};
         c_ptr->add(label, vector_span);
     } catch (...) {
         return LIBRARY_FUNCTION_ERROR;
@@ -125,7 +132,7 @@ EXTERN_C DLLEXPORT int IndexAdd(WolframLibraryData libData, mint Argc, MArgument
 }
 
 EXTERN_C DLLEXPORT int IndexSearch(WolframLibraryData libData, mint Argc, MArgument* Args, MArgument Res) {
-    punned_t* c_ptr = (punned_t*)MArgument_getUTF8String(Args[0]);
+    index_t* c_ptr = (index_t*)MArgument_getUTF8String(Args[0]);
     MTensor matches;
     mint dims[] = {1};
     int wanted = MArgument_getInteger(Args[2]);
@@ -137,12 +144,12 @@ EXTERN_C DLLEXPORT int IndexSearch(WolframLibraryData libData, mint Argc, MArgum
         libData->MTensor_new(MType_Integer, 1, dims, &matches);
 
         MTensor tens = MArgument_getMTensor(Args[1]);
-        size_t len = libData->MTensor_getFlattenedLength(tens);
+        std::size_t len = libData->MTensor_getFlattenedLength(tens);
         vector_data = (float*)libData->MTensor_getRealData(tens);
-        span_t vector_span = span_t{vector_data, len};
+        vector_view_t vector_span = vector_view_t{vector_data, len};
 
         matches_data = (int*)std::malloc(sizeof(int) * wanted);
-        found = c_ptr->search(vector_span, (size_t)wanted, matches_data, nullptr);
+        found = c_ptr->search(vector_span, static_cast<std::size_t>(wanted), matches_data, nullptr);
         for (mint i = 0; i < found; i++)
             libData->MTensor_setInteger(matches, &i, matches_data[i]);