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

@@ -33,6 +33,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 +55,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.nil? ? true : memery_use_hashed_arguments
       prepend(@_memery_module)
     end
 
@@ -68,9 +71,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))
@@ -80,8 +86,10 @@ def define_memoized_method!(klass, method_name, condition: nil, ttl: nil)
           cache_store = (@_memery_memoized_values ||= {})
           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]