usearch 0.21.0 → 0.22.0

package/c/lib.cpp

@@ -2,6 +2,10 @@
 
 #include <usearch/index_punned_dense.hpp>
 
+#ifndef USEARCH_EXPORT
+#define USEARCH_EXPORT
+#endif
+
 extern "C" {
 #include "usearch.h"
 }
@@ -88,7 +92,7 @@ index_punned_dense_metric_t udf(metric_kind_t kind, usearch_metric_t raw_ptr) {
 
 extern "C" {
 
-usearch_index_t usearch_init(usearch_init_options_t* options, usearch_error_t* error) {
+USEARCH_EXPORT usearch_index_t usearch_init(usearch_init_options_t* options, usearch_error_t* error) {
 
     assert(options && error);
 
@@ -108,48 +112,48 @@ usearch_index_t usearch_init(usearch_init_options_t* options, usearch_error_t* e
     return result_ptr;
 }
 
-void usearch_free(usearch_index_t index, usearch_error_t*) { delete reinterpret_cast<index_t*>(index); }
+USEARCH_EXPORT void usearch_free(usearch_index_t index, usearch_error_t*) { delete reinterpret_cast<index_t*>(index); }
 
-void usearch_save(usearch_index_t index, char const* path, usearch_error_t* error) {
+USEARCH_EXPORT void usearch_save(usearch_index_t index, char const* path, usearch_error_t* error) {
     serialization_result_t result = reinterpret_cast<index_t*>(index)->save(path);
     if (!result)
         *error = result.error.what();
 }
 
-void usearch_load(usearch_index_t index, char const* path, usearch_error_t* error) {
+USEARCH_EXPORT void usearch_load(usearch_index_t index, char const* path, usearch_error_t* error) {
     serialization_result_t result = reinterpret_cast<index_t*>(index)->load(path);
     if (!result)
         *error = result.error.what();
 }
 
-void usearch_view(usearch_index_t index, char const* path, usearch_error_t* error) {
+USEARCH_EXPORT void usearch_view(usearch_index_t index, char const* path, usearch_error_t* error) {
     serialization_result_t result = reinterpret_cast<index_t*>(index)->view(path);
     if (!result)
         *error = result.error.what();
 }
 
-size_t usearch_size(usearch_index_t index, usearch_error_t*) { //
+USEARCH_EXPORT size_t usearch_size(usearch_index_t index, usearch_error_t*) { //
     return reinterpret_cast<index_t*>(index)->size();
 }
 
-size_t usearch_capacity(usearch_index_t index, usearch_error_t*) {
+USEARCH_EXPORT size_t usearch_capacity(usearch_index_t index, usearch_error_t*) {
     return reinterpret_cast<index_t*>(index)->capacity();
 }
 
-size_t usearch_dimensions(usearch_index_t index, usearch_error_t*) {
+USEARCH_EXPORT size_t usearch_dimensions(usearch_index_t index, usearch_error_t*) {
     return reinterpret_cast<index_t*>(index)->dimensions();
 }
 
-size_t usearch_connectivity(usearch_index_t index, usearch_error_t*) {
+USEARCH_EXPORT size_t usearch_connectivity(usearch_index_t index, usearch_error_t*) {
     return reinterpret_cast<index_t*>(index)->connectivity();
 }
 
-void usearch_reserve(usearch_index_t index, size_t capacity, usearch_error_t*) {
+USEARCH_EXPORT void usearch_reserve(usearch_index_t index, size_t capacity, usearch_error_t*) {
     // TODO: Consider returning the new capacity.
     reinterpret_cast<index_t*>(index)->reserve(capacity);
 }
 
-void usearch_add(                                                                                 //
+USEARCH_EXPORT void usearch_add(                                                                          //
     usearch_index_t index, usearch_label_t label, void const* vector, usearch_scalar_kind_t kind, //
     usearch_error_t* error) {
     add_result_t result = add_(reinterpret_cast<index_t*>(index), label, vector, to_native_scalar(kind));
@@ -157,11 +161,11 @@ void usearch_add(
         *error = result.error.what();
 }
 
-bool usearch_contains(usearch_index_t index, usearch_label_t label, usearch_error_t*) {
+USEARCH_EXPORT bool usearch_contains(usearch_index_t index, usearch_label_t label, usearch_error_t*) {
     return reinterpret_cast<index_t*>(index)->contains(label);
 }
 
-size_t usearch_search(                                                                           //
+USEARCH_EXPORT size_t usearch_search(                                                                    //
     usearch_index_t index, void const* vector, usearch_scalar_kind_t kind, size_t results_limit, //
     usearch_label_t* found_labels, usearch_distance_t* found_distances, usearch_error_t* error) {
     search_result_t result = search_(reinterpret_cast<index_t*>(index), vector, to_native_scalar(kind), results_limit);
@@ -173,13 +177,13 @@ size_t usearch_search(
     return result.dump_to(found_labels, found_distances);
 }
 
-bool usearch_get(                                 //
+USEARCH_EXPORT bool usearch_get(                          //
     usearch_index_t index, usearch_label_t label, //
     void* vector, usearch_scalar_kind_t kind, usearch_error_t*) {
     return get_(reinterpret_cast<index_t*>(index), label, vector, to_native_scalar(kind));
 }
 
-void usearch_remove(usearch_index_t, usearch_label_t, usearch_error_t* error) {
+USEARCH_EXPORT void usearch_remove(usearch_index_t, usearch_label_t, usearch_error_t* error) {
     if (error != nullptr)
         *error = "USearch does not support removal of elements yet.";
 }

package/c/usearch.h

@@ -4,17 +4,20 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
+#ifndef USEARCH_EXPORT
+#define USEARCH_EXPORT
+#endif
 #include <stdbool.h> // `bool`
 #include <stdint.h>  // `size_t`
 
-typedef void* usearch_index_t;
-typedef uint32_t usearch_label_t;
-typedef float usearch_distance_t;
-typedef char const* usearch_error_t;
+USEARCH_EXPORT typedef void* usearch_index_t;
+USEARCH_EXPORT typedef uint32_t usearch_label_t;
+USEARCH_EXPORT typedef float usearch_distance_t;
+USEARCH_EXPORT typedef char const* usearch_error_t;
 
-typedef usearch_distance_t (*usearch_metric_t)(void const*, void const*);
+USEARCH_EXPORT typedef usearch_distance_t (*usearch_metric_t)(void const*, void const*);
 
-typedef enum usearch_metric_kind_t {
+USEARCH_EXPORT typedef enum usearch_metric_kind_t {
     usearch_metric_ip_k = 0,
     usearch_metric_l2sq_k,
     usearch_metric_cos_k,
@@ -27,7 +30,7 @@ typedef enum usearch_metric_kind_t {
     usearch_metric_unknown_k,
 } usearch_metric_kind_t;
 
-typedef enum usearch_scalar_kind_t {
+USEARCH_EXPORT typedef enum usearch_scalar_kind_t {
     usearch_scalar_f32_k = 0,
     usearch_scalar_f64_k,
     usearch_scalar_f16_k,
@@ -36,7 +39,7 @@ typedef enum usearch_scalar_kind_t {
     usearch_scalar_unknown_k,
 } usearch_scalar_kind_t;
 
-typedef struct usearch_init_options_t {
+USEARCH_EXPORT typedef struct usearch_init_options_t {
 
     usearch_metric_kind_t metric_kind;
     usearch_metric_t metric;
@@ -48,39 +51,39 @@ typedef struct usearch_init_options_t {
     size_t expansion_search;
 } usearch_init_options_t;
 
-usearch_index_t usearch_init(usearch_init_options_t*, usearch_error_t*);
-void usearch_free(usearch_index_t, usearch_error_t*);
+USEARCH_EXPORT usearch_index_t usearch_init(usearch_init_options_t*, usearch_error_t*);
+USEARCH_EXPORT void usearch_free(usearch_index_t, usearch_error_t*);
 
-void usearch_save(usearch_index_t, char const* path, usearch_error_t*);
-void usearch_load(usearch_index_t, char const* path, usearch_error_t*);
-void usearch_view(usearch_index_t, char const* path, usearch_error_t*);
+USEARCH_EXPORT void usearch_save(usearch_index_t, char const* path, usearch_error_t*);
+USEARCH_EXPORT void usearch_load(usearch_index_t, char const* path, usearch_error_t*);
+USEARCH_EXPORT void usearch_view(usearch_index_t, char const* path, usearch_error_t*);
 
-size_t usearch_size(usearch_index_t, usearch_error_t*);
-size_t usearch_capacity(usearch_index_t, usearch_error_t*);
-size_t usearch_dimensions(usearch_index_t, usearch_error_t*);
-size_t usearch_connectivity(usearch_index_t, usearch_error_t*);
+USEARCH_EXPORT size_t usearch_size(usearch_index_t, usearch_error_t*);
+USEARCH_EXPORT size_t usearch_capacity(usearch_index_t, usearch_error_t*);
+USEARCH_EXPORT size_t usearch_dimensions(usearch_index_t, usearch_error_t*);
+USEARCH_EXPORT size_t usearch_connectivity(usearch_index_t, usearch_error_t*);
 
-void usearch_reserve(usearch_index_t, size_t capacity, usearch_error_t*);
+USEARCH_EXPORT void usearch_reserve(usearch_index_t, size_t capacity, usearch_error_t*);
 
-void usearch_add(                                                                            //
+USEARCH_EXPORT void usearch_add(                                                                     //
     usearch_index_t, usearch_label_t, void const* vector, usearch_scalar_kind_t vector_kind, //
     usearch_error_t*);
 
-bool usearch_contains(usearch_index_t, usearch_label_t, usearch_error_t*);
+USEARCH_EXPORT bool usearch_contains(usearch_index_t, usearch_label_t, usearch_error_t*);
 
 /**
  *  @brief      Performs k-Approximate Nearest Neighbors Search.
  *  @return     Number of found matches.
  */
-size_t usearch_search(                                                                                 //
+USEARCH_EXPORT size_t usearch_search(                                                                          //
     usearch_index_t, void const* query_vector, usearch_scalar_kind_t query_kind, size_t results_limit, //
     usearch_label_t* found_labels, usearch_distance_t* found_distances, usearch_error_t*);
 
-bool usearch_get(                     //
+USEARCH_EXPORT bool usearch_get(              //
     usearch_index_t, usearch_label_t, //
     void* vector, usearch_scalar_kind_t vector_kind, usearch_error_t*);
 
-void usearch_remove(usearch_index_t, usearch_label_t, usearch_error_t*);
+USEARCH_EXPORT void usearch_remove(usearch_index_t, usearch_label_t, usearch_error_t*);
 
 #ifdef __cplusplus
 }

package/cmake/emscripten.cmake

@@ -0,0 +1,8 @@
+include(FetchContent)
+FetchContent_Declare(
+    emscripten
+    GIT_REPOSITORY https://github.com/emscripten-core/emscripten
+    GIT_TAG main
+)
+FetchContent_MakeAvailable(emscripten)
+include_directories(${emscripten_SOURCE_DIR}/include)

package/conanfile.py

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

package/cpp/README.md

@@ -0,0 +1,88 @@
+# USearch C++ Inteface
+
+## Installation
+
+To use in a C++ project simply copy the `include/usearch/index.hpp` header into your project.
+Alternatively fetch it with CMake:
+
+```cmake
+FetchContent_Declare(usearch GIT_REPOSITORY https://github.com/unum-cloud/usearch.git)
+FetchContent_MakeAvailable(usearch)
+```
+
+## Quickstart
+
+Once included, the low-level C++11 interface is as simple as it gets: `reserve()`, `add()`, `search()`, `size()`, `capacity()`, `save()`, `load()`, `view()`.
+This covers 90% of use-cases.
+
+```c++
+using namespace unum::usearch;
+
+index_gt<cos_gt<float>> index;
+float vec[3] = {0.1, 0.3, 0.2};
+
+index.reserve(10);
+index.add(/* label: */ 42, /* vector: */ {&vec[0], 3});
+auto results = index.search(/* query: */ {&vec[0], 3}, 5 /* neighbors */);
+
+for (std::size_t i = 0; i != results.size(); ++i)
+    results[i].element.label, results[i].element.vector, results[i].distance;
+```
+
+The `add` is thread-safe for concurrent index construction.
+
+## Serialization
+
+```c++
+index.save("index.usearch");
+index.load("index.usearch"); // Copying from disk
+index.view("index.usearch"); // Memory-mapping from disk
+```
+
+## User-Defined Metrics in C++
+
+For advanced users, more compile-time abstractions are available.
+
+```cpp
+template <typename metric_at = ip_gt<float>,            //
+          typename label_at = std::size_t,              // `uint32_t`, `uuid_t`...
+          typename id_at = std::uint32_t,               // `uint40_t`, `uint64_t`...
+          typename scalar_at = float,                   // `double`, `half`, `char`...
+          typename allocator_at = std::allocator<char>> //
+class index_gt;
+```
+
+You may want to use a custom memory allocator or a rare scalar type, but most often, you would start by defining a custom similarity measure.
+The function object should have the following signature to support different-length vectors.
+
+```cpp
+struct custom_metric_t {
+    T operator()(T const* a, T const* b, std::size_t a_length, std::size_t b_length) const;
+};
+```
+
+The following distances are pre-packaged:
+
+- `cos_gt<scalar_t>` for "Cosine" or "Angular" distance.
+- `ip_gt<scalar_t>` for "Inner Product" or "Dot Product" distance.
+- `l2sq_gt<scalar_t>` for the squared "L2" or "Euclidean" distance.
+- `jaccard_gt<scalar_t>` for "Jaccard" distance between two ordered sets of unique elements.
+- `hamming_gt<scalar_t>` for "Hamming" distance, as the number of shared bits in hashes.
+- `tanimoto_gt<scalar_t>` for "Tanimoto" coefficient for bit-strings.
+- `sorensen_gt<scalar_t>` for "Dice-Sorensen" coefficient for bit-strings.
+- `pearson_correlation_gt<scalar_t>` for "Pearson" correlation between probability distributions.
+- `haversine_gt<scalar_t>` for "Haversine" or "Great Circle" distance between coordinates used in GIS applications.
+
+## Multi-Threading
+
+Most AI, HPC, or Big Data packages use some form of a thread pool.
+Instead of spawning additional threads within USearch, we focus on the thread safety of `add()` function, simplifying resource management.
+
+```cpp
+#pragma omp parallel for
+    for (std::size_t i = 0; i < n; ++i)
+        native.add(label, span_t{vector, dims}, add_config_t { .thread = omp_get_thread_num() });
+```
+
+During initialization, we allocate enough temporary memory for all the cores on the machine.
+On the call, the user can supply the identifier of the current thread, making this library easy to integrate with OpenMP and similar tools.

package/cpp/bench.cpp

@@ -15,7 +15,9 @@
 
 #define STDERR_FILENO HANDLE(2)
 #else
-#include <execinfo.h>
+#if defined(__linux__)
+#include <execinfo.h> // `backtrace`
+#endif
 #include <fcntl.h>    // `open`
 #include <stdlib.h>   // `getenv`
 #include <sys/mman.h> // `mmap`
@@ -36,7 +38,9 @@
 #include <vector>
 
 #include <clipp.h> // Command Line Interface
-#include <omp.h>   // `omp_set_num_threads()`
+#if USEARCH_USE_OPENMP
+#include <omp.h> // `omp_set_num_threads()`
+#endif
 
 #include <simsimd/simsimd.h>
 
@@ -45,6 +49,7 @@
 using namespace unum::usearch;
 using namespace unum;
 
+using label_t = std::int64_t;
 using vector_id_t = std::uint32_t;
 using vector_view_t = span_gt<float const>;
 
@@ -278,15 +283,19 @@ void index_many(index_at& native, std::size_t n, vector_id_at const* ids, real_a
 
     running_stats_printer_t printer{n, "Indexing"};
 
+#if USEARCH_USE_OPENMP
 #pragma omp parallel for schedule(static, 32)
+#endif
     for (std::size_t i = 0; i < n; ++i) {
         add_config_t config;
+#if USEARCH_USE_OPENMP
         config.thread = omp_get_thread_num();
+#endif
         config.store_vector = true;
         vector_view_t vector{vectors + dims * i, dims};
         native.add(ids[i], vector, config);
         printer.progress++;
-        if (omp_get_thread_num() == 0)
+        if (config.thread == 0)
             printer.refresh();
     }
 }
@@ -299,34 +308,18 @@ void search_many( //
     std::string name = "Search " + std::to_string(wanted);
     running_stats_printer_t printer{n, name.c_str()};
 
+#if USEARCH_USE_OPENMP
 #pragma omp parallel for schedule(static, 32)
+#endif
     for (std::size_t i = 0; i < n; ++i) {
         search_config_t config;
+#if USEARCH_USE_OPENMP
         config.thread = omp_get_thread_num();
+#endif
         vector_view_t vector{vectors + dims * i, dims};
         native.search(vector, wanted, config).dump_to(ids + wanted * i, distances + wanted * i);
         printer.progress++;
-        if (omp_get_thread_num() == 0)
-            printer.refresh();
-    }
-}
-
-template <typename index_at, typename vector_id_at, typename real_at>
-void paginate_many( //
-    index_at& native, std::size_t n, real_at const* vectors, std::size_t dims, std::size_t wanted,
-    vector_id_at const* hints) {
-
-    std::string name = "Paginate " + std::to_string(wanted);
-    running_stats_printer_t printer{n, name.c_str()};
-
-#pragma omp parallel for schedule(static, 32)
-    for (std::size_t i = 0; i < n; ++i) {
-        search_config_t config;
-        config.thread = omp_get_thread_num();
-        vector_view_t vector{vectors + dims * i, dims};
-        native.search_around(hints[i], vector, wanted, config);
-        printer.progress++;
-        if (omp_get_thread_num() == 0)
+        if (config.thread == 0)
             printer.refresh();
     }
 }
@@ -397,14 +390,6 @@ static void single_shot(dataset_at& dataset, index_at& index, bool construct = t
     std::printf("Unmatched %.2f %% (%zu items)\n", unmatched_count * 100.f / index.size(), unmatched_count);
     std::printf("Proposals %.2f / man (%zu total)\n", join_attempts * 1.f / index.size(), join_attempts);
 
-    // Paginate
-    std::vector<vector_id_t> hints(dataset.queries_count());
-    for (std::size_t i = 0; i != hints.size(); ++i)
-        hints[i] = dataset.neighborhood(i)[0];
-    paginate_many(index, dataset.queries_count(), dataset.query(0), dataset.dimensions(), 10, hints.data());
-    paginate_many(index, dataset.queries_count(), dataset.query(0), dataset.dimensions(), 100, hints.data());
-    paginate_many(index, dataset.queries_count(), dataset.query(0), dataset.dimensions(), 1000, hints.data());
-
     std::printf("------------\n");
     std::printf("\n");
 }
@@ -416,7 +401,7 @@ void handler(int sig) {
     // get void*'s for all entries on the stack
 #if defined(USEARCH_DEFINED_WINDOWS)
     size = CaptureStackBackTrace(0, 10, array, NULL);
-#else
+#elif defined(USEARCH_DEFINED_LINUX)
     size = backtrace(array, 10);
 #endif // WINDOWS
 
@@ -438,7 +423,7 @@ void handler(int sig) {
         WriteFile(STDERR_FILENO, "\n", 1, &bytes_written, NULL);
     }
     free(symbol);
-#else
+#elif defined(USEARCH_DEFINED_LINUX)
     backtrace_symbols_fd(array, size, STDERR_FILENO);
 #endif // WINDOWS
 
@@ -555,24 +540,24 @@ void run_big_or_small(dataset_at& dataset, args_t const& args, index_config_t co
     if (args.native) {
         if (args.metric_cos) {
             std::printf("-- Metric: Angular\n");
-            run_typed<index_gt<cos_gt<float>, std::size_t, neighbor_id_at>>(dataset, args, config, limits);
+            run_typed<index_gt<cos_gt<float>, label_t, neighbor_id_at>>(dataset, args, config, limits);
         } else if (args.metric_l2) {
             std::printf("-- Metric: Euclidean\n");
-            run_typed<index_gt<l2sq_gt<float>, std::size_t, neighbor_id_at>>(dataset, args, config, limits);
+            run_typed<index_gt<l2sq_gt<float>, label_t, neighbor_id_at>>(dataset, args, config, limits);
         } else if (args.metric_haversine) {
             std::printf("-- Metric: Haversine\n");
-            run_typed<index_gt<haversine_gt<float>, std::size_t, neighbor_id_at>>(dataset, args, config, limits);
+            run_typed<index_gt<haversine_gt<float>, label_t, neighbor_id_at>>(dataset, args, config, limits);
         } else {
             std::printf("-- Metric: Inner Product\n");
-            run_typed<index_gt<ip_gt<float>, std::size_t, neighbor_id_at>>(dataset, args, config, limits);
+            run_typed<index_gt<ip_gt<float>, label_t, neighbor_id_at>>(dataset, args, config, limits);
         }
     } else
-        run_punned<index_punned_dense_gt<std::size_t, neighbor_id_at>>(dataset, args, config, limits);
+        run_punned<index_punned_dense_gt<label_t, neighbor_id_at>>(dataset, args, config, limits);
 }
 
 void report_alternative_setups() {
     using set_member_t = std::uint32_t;
-    using sets_index_t = index_gt<jaccard_gt<set_member_t>, std::size_t, std::uint32_t>;
+    using sets_index_t = index_gt<jaccard_gt<set_member_t>, label_t, std::uint32_t>;
     set_member_t set_a[] = {10, 12, 15};
     set_member_t set_b[] = {11, 12, 15, 16};
     sets_index_t index;
@@ -662,12 +647,14 @@ int main(int argc, char** argv) {
         exit(0);
     }
 
+#if USEARCH_USE_OPENMP
     // Instead of relying on `multithreaded` from "index_punned_dense.hpp" we will use OpenMP
     // to better estimate statistics between tasks batches, without having to recreate
     // the threads.
     omp_set_dynamic(true);
     omp_set_num_threads(args.threads);
     std::printf("- OpenMP threads: %d\n", omp_get_max_threads());
+#endif
 
     std::printf("- Dataset: \n");
     std::printf("-- Base vectors path: %s\n", args.path_vectors.c_str());
@@ -695,7 +682,7 @@ int main(int argc, char** argv) {
     // config.expansion_search = args.expansion_search;
     index_limits_t limits;
     limits.threads_add = limits.threads_search = args.threads;
-    limits.elements = dataset.vectors_count();
+    limits.members = dataset.vectors_count();
 
     std::printf("- Index: \n");
     std::printf("-- Connectivity: %zu\n", config.connectivity);
@@ -703,7 +690,11 @@ int main(int argc, char** argv) {
     // std::printf("-- Expansion @ Search: %zu\n", config.expansion_search);
 
     if (args.big)
+#ifdef USEARCH_64BIT_ENV
         run_big_or_small<uint40_t>(dataset, args, config, limits);
+#else
+        std::printf("Error: Don't use 40 bit identifiers in 32bit environment\n");
+#endif
     else
         run_big_or_small<std::uint32_t>(dataset, args, config, limits);
 

package/cpp/test.cpp

@@ -84,17 +84,23 @@ template <typename scalar_at, typename index_at> void test3d_punned(index_at&& i
     using view_t = span_gt<scalar_t const>;
     using span_t = span_gt<scalar_at>;
 
-    scalar_t vec[3] = {10, 20, 15};
+    scalar_t vec42[3] = {10, 20, 15};
+    scalar_t vec43[3] = {19, 22, 11};
 
     index.reserve(10);
-    index.add(42, view_t{&vec[0], 3ul});
+    index.add(42, view_t{&vec42[0], 3ul});
 
     // Reconstruct
-    scalar_t vec_reconstructed[3] = {0, 0, 0};
-    index.get(42, span_t{&vec_reconstructed[0], 3ul});
-    expect(vec_reconstructed[0] == vec[0]);
-    expect(vec_reconstructed[1] == vec[1]);
-    expect(vec_reconstructed[2] == vec[2]);
+    scalar_t vec42_reconstructed[3] = {0, 0, 0};
+    index.get(42, span_t{&vec42_reconstructed[0], 3ul});
+    expect(vec42_reconstructed[0] == vec42[0]);
+    expect(vec42_reconstructed[1] == vec42[1]);
+    expect(vec42_reconstructed[2] == vec42[2]);
+
+    index.add(43, view_t{&vec43[0], 3ul});
+    expect(index.size() == 2);
+    index.remove(43);
+    expect(index.size() == 1);
 }
 
 template <typename index_at> void test_sets(index_at&& index) {

package/docs/golang/index.rst

@@ -0,0 +1,6 @@
+==============
+GoLang SDK
+==============
+
+
+.. mdinclude:: ../golang/README.md

package/docs/index.rst

@@ -14,11 +14,14 @@ Overview
    :hidden:
    :caption: �
 
-   c/index
    cpp/index
-   java/index
    python/index
+   java/index
    javascript/index
+   rust/index
+   swift/index
+   c/index
+   golang/index
 
 .. toctree:: 
    :hidden:

package/docs/python/reference.rst

@@ -17,6 +17,14 @@ IO
     :members:
     :undoc-members:
 
+==========
+Evaluation
+==========
+
+.. automodule:: usearch.eval
+    :members:
+    :undoc-members:
+
 ======
 Client
 ======
@@ -25,11 +33,10 @@ Client
     :members:
     :undoc-members:
 
-
 ======
 Server
 ======
 
 .. automodule:: usearch.server
     :members:
-    :undoc-members:
+    :undoc-members:

package/docs/rust/index.rst

@@ -0,0 +1,6 @@
+==============
+Rust SDK
+==============
+
+
+.. mdinclude:: ../rust/README.md

package/docs/swift/index.rst

@@ -0,0 +1,6 @@
+==============
+Swift SDK
+==============
+
+
+.. mdinclude:: ../swift/README.md

package/golang/README.md

@@ -0,0 +1,28 @@
+# USearch for GoLang
+
+## Installation
+
+```golang
+import (
+	"github.com/unum-cloud/usearch/golang"
+)
+```
+
+## Quickstart
+
+```golang
+package main
+
+import (
+	"fmt"
+	"github.com/unum-cloud/usearch/golang"
+)
+
+func main() {
+	conf := usearch.DefaultConfig(128)
+	index := usearch.NewIndex(conf)
+	v := make([]float32, 128)
+	index.Add(42, v)
+	results := index.Search(v, 1)
+}
+```