Allow the use of hashed arguments to be disabled

This allows marshaled objects to retain their memoized values when being unmarshaled
in a separate Ruby process where the object hashes may be different

benchmark.rb

@@ -39,6 +39,22 @@ def base_find(char)
   end
 end
 
+class FooNoHash
+  class << self
+    include Memery
+
+    self.memery_use_hashed_arguments = false
+
+    def base_find(char)
+      ("a".."k").find { |letter| letter == char }
+    end
+
+    memoize def find_new(char)
+      base_find(char)
+    end
+  end
+end
+
 def test_no_args
   Foo.find_z
 end
@@ -51,6 +67,10 @@ def test_empty_args
   Foo.find_optional
 end
 
+def test_with_args_no_hash
+  FooNoHash.find_new("d")
+end
+
 Benchmark.ips do |x|
   x.report("test_no_args") { test_no_args }
 end
@@ -75,4 +95,12 @@ def test_empty_args
   x.report("test_with_args") { 100.times { test_with_args } }
 end
 
+Benchmark.ips do |x|
+  x.report("test_with_args_no_hash") { test_with_args_no_hash }
+end
+
+Benchmark.memory do |x|
+  x.report("test_with_args_no_hash") { 100.times { test_with_args_no_hash } }
+end
+
 puts "```"

lib/memery.rb

@@ -13,6 +13,7 @@ def monotonic_clock
     extend(ClassMethods)
     include(InstanceMethods)
     extend ModuleMethods if instance_of?(Module)
+    @memery_use_hashed_arguments = true
   end
 
   private_constant :OUR_BLOCK
@@ -33,6 +34,8 @@ def included(base = nil, &block)
   extend ModuleMethods
 
   module ClassMethods
+    attr_accessor :memery_use_hashed_arguments
+
     def memoize(*method_names, condition: nil, ttl: nil)
       prepend_memery_module!
       method_names.each do |method_name|
@@ -53,6 +56,7 @@ def memoized?(method_name)
     def prepend_memery_module!
       return if defined?(@_memery_module)
       @_memery_module = Module.new { extend MemoizationModule }
+      @_memery_module.use_hashed_arguments = memery_use_hashed_arguments
       prepend(@_memery_module)
     end
 
@@ -68,9 +72,12 @@ def fresh?(ttl)
         end
       end
 
+      attr_accessor :use_hashed_arguments
+
       def define_memoized_method!(klass, method_name, condition: nil, ttl: nil)
         original_visibility = method_visibility(klass, method_name)
         original_arity = klass.instance_method(method_name).arity
+        use_hashed_arguments = self.use_hashed_arguments
 
         define_method(method_name) do |*args, &block|
           if block || (condition && !instance_exec(&condition))
@@ -81,8 +88,10 @@ def define_memoized_method!(klass, method_name, condition: nil, ttl: nil)
           cache_key =
             if original_arity.zero? || args.empty?
               method_name
-            else
+            elsif use_hashed_arguments
               [method_name, *args].hash
+            else
+              [method_name, *args]
             end
           cache = cache_store[cache_key]