Fix infinite recursion error in MonteCarloHash construction.

Author: kernelmethod

src/function_hashing/chebhash.jl

@@ -33,7 +33,14 @@ end
 ChebHash(similarity, args...; kws...) =
     ChebHash(SimilarityFunction(similarity), args...; kws...)
 
-for (discrete_sim, fn_sim) in zip([ℓ2, cossim], [L2, cossim])
+const _valid_ChebHash_similarities = (
+    # Function space similarities
+    (L2, cossim),
+    # Discrete-space similarities corresponding to function space similarities
+    (ℓ2, cossim),
+)
+
+for (fn_sim, discrete_sim) in zip(_valid_ChebHash_similarities...)
     quote
         # Add an implementation of ChebHash that dispatches on the similarity
         # function fn_sim
@@ -49,11 +56,18 @@ for (discrete_sim, fn_sim) in zip([ℓ2, cossim], [L2, cossim])
 end
 
 # Implementation of ChebHash for invalid similarity functions. Just throws
-# a TypeError. Necessary because otherwise the first external ChebHash
-# constructor will go into an infinite loop when it receives an invalid
-# similarity function.
-ChebHash(sim::SimilarityFunction, args...; kws...) =
-    ErrorException("similarity must be ℓ2 or cossim") |> throw
+# a error.
+# Necessary because otherwise the first external ChebHash constructor
+# will go into infinite recursion if it receives an invalid similarity
+# function.
+function ChebHash(sim::SimilarityFunction, args...; kws...)
+    valid_sims = _valid_MonteCarloHash_similarities[1] .|>
+                 string  |>
+                 collect |>
+                 sort!
+    valid_sims = join(valid_sims, ", ", " or ")
+    ErrorException("similarity must be $(valid_sims)") |> throw
+end
 
 #========================
 Helper functions for ChebHash

src/function_hashing/monte_carlo.jl

@@ -51,7 +51,16 @@ end
 MonteCarloHash(similarity, args...; kws...) =
     MonteCarloHash(SimilarityFunction(similarity), args...; kws...)
 
-for (simfn, fn_space_simfn, p) in zip([ℓ1,ℓ2,cossim], [L1,L2,cossim], [1,2,2])
+const _valid_MonteCarloHash_similarities = (
+    # Function space similarities
+    (L1, L2, cossim),  
+    # Discrete-space similarities corresponding to function space similarities
+    (ℓ1, ℓ2, cossim),  
+    # Order of L^p space that the similarity applies to
+    (1, 2, 2),
+)
+
+for (fn_space_simfn, simfn, p) in zip(_valid_MonteCarloHash_similarities...)
     quote
         # Add dispatch for case in which we specify the similarity function
         # to be $fn_space_simfn
@@ -65,6 +74,19 @@ for (simfn, fn_space_simfn, p) in zip([ℓ1,ℓ2,cossim], [L1,L2,cossim], [1,2,2
     end |> eval
 end
 
+# Implementation of MonteCarloHash for invalid similarity functions. Just throws
+# an error.
+# Necessary because otherwise the first MonteCarloHash constructor will go into
+# infinite recursion if it receives an invalid similarity function.
+function MonteCarloHash(sim::SimilarityFunction, args...; kws...)
+    valid_sims = _valid_MonteCarloHash_similarities[1] .|>
+                 string  |>
+                 collect |>
+                 sort!
+    valid_sims = join(valid_sims, ", ", " or ")
+    ErrorException("similarity must be $(valid_sims)") |> throw
+end
+
 #========================
 MonteCarloHash helper functions
 ========================#

test/function_hashing/test_chebhash.jl

@@ -35,7 +35,7 @@ Tests
         @test_throws(ErrorException, ChebHash(L1))
         @test_throws(ErrorException, ChebHash(ℓ2))
 
-        # Construct a hash function (with valid similarity_ in the same
+        # Construct a hash function (with valid similarity) in the same
         # manner as we did above in case the ChebHash API ever changes.
         # This ensures that we won't forget to update these tests.
         _ = ChebHash(L2)

test/function_hashing/test_monte_carlo.jl

@@ -28,6 +28,21 @@ Tests
         @test hashtype(hashfn) == hashtype(LSHFunction(ℓ1))
     end
 
+    @testset "Pass invalid similarity function" begin
+        # Attempt to construct a MonteCarloHash with an invalid
+        # similarity function.
+        μ() = rand()
+
+        @test_throws(ErrorException, MonteCarloHash(ℓ1, μ))
+        @test_throws(ErrorException, MonteCarloHash(ℓ2, μ))
+        @test_throws(ErrorException, MonteCarloHash(jaccard, μ))
+
+        # Construct a hash function (with valid similarity) in the same
+        # manner in case the MonteCarloHash API ever changes.
+        # This ensures that we won't forget to update these tests.
+        _ = MonteCarloHash(L2, μ)
+    end
+
     #==========
     Cosine similarity hashing
     ==========#