Add lsh_family, which returns the LSHFunction subtype and/or constructor used when calling LSHFunction. This makes it a little easier to find the documentation for a given similarity function.

Author: kernelmethod

src/LSH.jl

@@ -52,7 +52,7 @@ export SimHash, L1Hash, L2Hash, MIPSHash, SignALSH, MinHash,
        LSHFunction, MonteCarloHash, ChebHash
 
 # Helper / utility functions for LSHFunctions
-export index_hash, query_hash, n_hashes, hashtype, similarity,
+export index_hash, query_hash, n_hashes, hashtype, similarity, lsh_family,
        embedded_similarity
 
 # Hash tables and related functions

src/LSHBase.jl

@@ -38,6 +38,7 @@ LSHFunction API
 ========================#
 
 macro register_similarity! end
+function lsh_family end
 
 #=
 The following functions must be defined for all LSHFunction subtypes

src/hashes/lshfunction.jl

@@ -36,7 +36,8 @@ true
 ```
 """
 macro register_similarity!(similarity, hashfn)
-    fn = :(LSH.LSHFunction)
+    lshfn = :(LSH.LSHFunction)
+    lshfam = :(LSH.lsh_family)
 
     quote
         local similarity = $(esc(similarity))
@@ -57,17 +58,66 @@ macro register_similarity!(similarity, hashfn)
         union!(available_similarities, Set([similarity]))
 
         # Define LSHFunction(similarity, args...; kws...)
-        $(esc(fn))(::typeof($(esc(similarity))), args...; kws...) =
+        $(esc(lshfn))(::typeof($(esc(similarity))), args...; kws...) =
             $(esc(hashfn))(args...; kws...)
+
+        # Define lsh_family(similarity)
+        $(esc(lshfam))(::typeof($(esc(similarity)))) = $(esc(hashfn))
     end
 end
 
 #========================
 Associate similarity functions with LSHFunction subtypes
 ========================#
 
-@register_similarity!(cossim, SimHash)
-@register_similarity!(ℓ1, L1Hash)
-@register_similarity!(ℓ2, L2Hash)
-@register_similarity!(jaccard, MinHash)
-@register_similarity!(inner_prod, SignALSH)
+macro reset_similarities!()
+    quote
+        intersect!(available_similarities, Set())
+
+        methods(LSHFunction).ms .|> Base.delete_method
+        methods(lsh_family).ms  .|> Base.delete_method
+
+        @register_similarity!(cossim, SimHash)
+        @register_similarity!(ℓ1, L1Hash)
+        @register_similarity!(ℓ2, L2Hash)
+        @register_similarity!(jaccard, MinHash)
+        @register_similarity!(inner_prod, SignALSH)
+    end
+end
+
+@reset_similarities!()
+
+#========================
+Documentation
+========================#
+
+@doc """
+    lsh_family(similarity)
+
+Return the default constructor or `LSHFunction` subtype used to construct a hash function for the similarity function `similarity`.
+
+The main use of `lsh_family` is to make it easier to find the documentation for the hash function that's constructed when you call `LSHFunction`. For instance, if you want to know more about the arguments and keyword parameters that can be given to `LSHFunction(inner_prod)`, you can run
+
+```
+julia> lsh_family(inner_prod)
+SignALSH
+
+help?> SignALSH
+```
+
+# Examples
+
+```jldoctest; setup = :(using LSH)
+julia> lsh_family(cossim)
+SimHash
+
+julia> lsh_family(ℓ1)
+$(
+if L1Hash |> methods |> length == 1
+    "L1Hash (generic function with 1 method)"
+else
+    "L1Hash (generic function with $(L1Hash |> methods |> length) methods)"
+end
+)
+```
+""" lsh_family

test/hashes/test_lshfunction.jl

@@ -12,6 +12,44 @@ include(joinpath("..", "utils.jl"))
 Tests
 ==================#
 
+@testset "Test similarity function registration" begin
+    Random.seed!(RANDOM_SEED)
+
+    @testset "Register a custom similarity" begin
+        ### Test 1: register a function with @register_similarity!
+        mysim(x,y) = dot(x,y) / (norm(x) * norm(y))
+
+        @test_throws MethodError LSHFunction(mysim)
+        @test_throws MethodError lsh_family(mysim)
+
+        LSH.@register_similarity!(mysim, SimHash)
+
+        hashfn = LSHFunction(mysim)
+        @test isa(hashfn, SimHash)
+        @test lsh_family(mysim) == SimHash
+
+        ### Test 2: register a function-like object with @register_similarity!
+        struct mytype end
+
+        @test_throws MethodError LSHFunction(mytype())
+        @test_throws MethodError lsh_family(mytype())
+        @test_throws ErrorException LSH.@register_similarity!(mytype(), SimHash)
+
+        (::mytype)(x,y) = cossim(x,y)
+
+        LSH.@register_similarity!(mytype(), SimHash)
+        hashfn = LSH.LSHFunction(mytype())
+        @test isa(hashfn, SimHash)
+        @test lsh_family(mysim) == SimHash
+
+        ### Test 3: reset the available similarity functions
+        LSH.@reset_similarities!()
+
+        @test_throws MethodError LSHFunction(mysim)
+        @test_throws MethodError LSHFunction(mytype())
+    end
+end
+
 @testset "Test LSHFunction()" begin
     Random.seed!(RANDOM_SEED)
 

test/test_similarities.jl

@@ -7,34 +7,6 @@ include("utils.jl")
 Tests
 ==================#
 
-@testset "Test similarity function API" begin
-    Random.seed!(RANDOM_SEED)
-
-    @testset "Register a custom similarity" begin
-        # Test 1: register a function with @register_similarity!
-        mysim(x,y) = dot(x,y) / (norm(x) * norm(y))
-
-        @test_throws(MethodError, LSH.LSHFunction(mysim))
-
-        LSH.@register_similarity!(mysim, SimHash)
-
-        hashfn = LSHFunction(mysim)
-        @test isa(hashfn, SimHash)
-
-        # Test 2: register a function-like object with @register_similarity!
-        struct mytype end
-
-        @test_throws(MethodError, LSH.LSHFunction(mytype()))
-        @test_throws(ErrorException, LSH.@register_similarity!(mytype(), SimHash))
-
-        (::mytype)(x,y) = cossim(x,y)
-
-        LSH.@register_similarity!(mytype(), SimHash)
-        hashfn = LSH.LSHFunction(mytype())
-        @test isa(hashfn, SimHash)
-    end
-end
-
 @testset "ℓ^p distance and norm tests" begin
     Random.seed!(RANDOM_SEED)