Describe how to use the custom saving functions in the README.

Author: LTLA

README.md

@@ -96,15 +96,15 @@ typedef knncolle_annoy::AnnoyBuilder<
 
 To save and reload Annoy indices from disk, we need to register a loading function into **knncolle**'s `load_prebuilt()` registry.
 This is a little complicated as we must decide on which combinations of types and distances we want to deal with.
-Here, we only consider the obvious distance metrics and the defaults for the internal Annoy types,
+In the example below, we only consider the obvious distance metrics and the defaults for the internal Annoy types,
 though more combinations could also be supported at the cost of larger binaries and longer compile times.
 
 ```cpp
 auto& reg = knncolle::load_prebuilt_registry<int, double, double>();
 reg[knncolle_annoy::save_name] = [](const std::string& prefix) -> Prebuilt<int, double, double>* {
-    auto config = knncolle_annoy::scan_prebuilt_save_config(prefix);
+    auto config = knncolle_annoy::load_annoy_prebuilt_types(prefix);
 
-    // Maybe add some checks that the types are as expected.
+    // Checks that the AnnoyIndex_ and AnnoyData_ types are the same as the defaults.
     if (config.index != knncolle_annoy::get_numeric_type<int>()) {
         throw std::runtime_error("unexpected type for the Annoy index");
     }
@@ -122,14 +122,56 @@ reg[knncolle_annoy::save_name] = [](const std::string& prefix) -> Prebuilt<int,
 ```
 
 Then we can save and reload the `Prebuilt` Annoy indices.
-Note the caveats on `knncolle::Prebuilt::save()` - specifically, the files are not guaranteed to be portable between machines or even different versions of **knncolle_annoy**.
+Note the caveats on `knncolle::Prebuilt::save()` -
+specifically, the files are not guaranteed to be portable between machines or even different versions of **knncolle_annoy**.
 
 ```cpp
-std::string path_prefix = "anno/location/here_";
+std::string path_prefix = "annoy/location/here_";
 an_index.save(path_prefix);
 auto reloaded = knncolle::load_prebuilt(path_prefix);
 ```
 
+For custom Annoy-related types and distances, users can define their own saving and loading methods.
+For example, if we had a custom distance:
+
+```cpp
+// Mock up a custom distance.
+class MyCustomDistance : public Annoy::Euclidean {};
+
+// Define a function to save information about this custom distance during .save() calls.
+knncolle_annoy::custom_save_for_annoy_data<MyCustomDistance>() = [](const std::string& prefix) -> void {
+    const auto custdistpath = prefix + "_custom";
+    // write something about MyCustomDistance at 'custdistpath'.
+};
+
+// Make a new loading function that uses the saved custom information. 
+reg[knncolle_annoy::save_name] = [](const std::string& prefix) -> Prebuilt<int, double, double>* {
+    auto config = knncolle_annoy::load_annoy_prebuilt_types(prefix);
+    if (config.index != knncolle_annoy::get_numeric_type<int>()) {
+        throw std::runtime_error("unexpected type for the Annoy index");
+    }
+    if (config.data != knncolle_annoy::get_numeric_type<float>()) {
+        throw std::runtime_error("unexpected type for the Annoy data");
+    }
+
+    if (config.distance == "euclidean") {
+        return knncolle_annoy::load_annoy_prebuilt<int, double, double, Annoy::Euclidean>();
+    } else if (config.distance == "manhattan") {
+        return knncolle_annoy::load_annoy_prebuilt<int, double, double, Annoy::Manhattan>();
+    } else {
+        const auto custdispath = prefix + "_custom";
+        // read something from 'custdistpath' to determine the custom distance to use.
+        return knncolle_annoy::load_annoy_prebuilt<int, double, double, MyCustomDistance>();
+    }
+};
+
+std::string custom_prefix = "annoy/location/custom_";
+knncolle_annoy::AnnoyBuilder<int, double, double, MyCustomDistance> custom_builder;
+auto custom_index = custom_builder.build_unique(mat);
+custom_index.save(custom_prefix);
+auto custom_reloaded = knncolle::load_prebuilt(custom_prefix);
+```
+
 ## Building projects 
 
 ### CMake with `FetchContent`