memo_wise 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e4c330faa7d0718ac3b4873dae8fb1933949481747f639fd6fe050724a2ce8dd
-  data.tar.gz: 52777a008d6b5b41a37cec36f1b9fe0198b85df97fb11329d73bac71ad22b600
+  metadata.gz: 2fa12aeb35a6c4ca923eb23d70867b41600795143570f3d7c5b6444c76547980
+  data.tar.gz: bac4074e758731ac5d20925ab32ef3cd78d10a1c030228df76c1868e104e1a40
 SHA512:
-  metadata.gz: 17a0e939940e73826fbca1876317bcd772e1cd07f16383a9d3e9c973c2545b4b8539c42110de98d8a8c8c4c4a4aa6a666b29cc40c6351001b2b9a7c6964918a3
-  data.tar.gz: fd4a09fe2dab6dbae43fae753c15530982d1cc26c0ef7b47cdff40f0bff603d7c7c9d0c7d0509b7eb98c0e15b2bd2ca7c005900a00d97201e44a9fd49603d4b0
+  metadata.gz: 52e8b1543bca54371a2743fbc22b3cee32ba68a050ac414e373ca2027faba214956bca3aef61a05d25ca1d339b3e4ae01a417cdb5d1a4a407fba16b0a3cae56e
+  data.tar.gz: 1bc40ccaab12ed598cc86d62d51ca8081a386b208559ac49788ff87601c45809958c2e936692fbb2e78f3ff0f04b124636f795d941558239fc20edf04f7b979b

data/.gitignore

@@ -1,5 +1,6 @@
 /.bundle/
 /benchmarks/.bundle/
+/benchmarks/Gemfile.lock
 /.yardoc
 /_yardoc/
 /coverage/

data/.rubocop.yml

@@ -1,2 +1,5 @@
 inherit_gem:
   panolint: rubocop.yml
+
+Style/DocumentDynamicEvalDefinition:
+  Enabled: false

data/CHANGELOG.md

@@ -5,8 +5,27 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
-(nothing yet!)
+## Unreleased
+### Updated
+- (Nothing, yet)
+### Fixed
+- (Nothing, yet)
+### Breaking Changes
+- None
+
+## [1.1.0] - 2021-07-29
+### Updated
+- Improve performance across the board by:
+  - removing `Hash#fetch`
+  - using `Array#hash`
+  - avoiding multi-layer hash lookups for multi-argument methods
+  - optimizing for truthy results
+- Add `dry-core` to benchmarks in README
+### Fixed
+- Fix usage on module singleton classes
+- Fix usage on module which would be extended by other classes
+### Breaking Changes
+- None
 
 ## [1.0.0] - 2021-06-24
 ### Added
@@ -61,7 +80,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Panolint
 - Dependabot setup
 
-[Unreleased]: https://github.com/panorama-ed/memo_wise/compare/v1.0.0...HEAD
+[Unreleased]: https://github.com/panorama-ed/memo_wise/compare/v1.1.0...HEAD
+[1.1.0]: https://github.com/panorama-ed/memo_wise/compare/v1.0.0...v1.1.0
 [1.0.0]: https://github.com/panorama-ed/memo_wise/compare/v0.4.0...v1.0.0
 [0.4.0]: https://github.com/panorama-ed/memo_wise/compare/v0.3.0...v0.4.0
 [0.3.0]: https://github.com/panorama-ed/memo_wise/compare/v0.2.0...v0.3.0

data/Gemfile.lock

@@ -1,6 +1,6 @@
 GIT
   remote: https://github.com/panorama-ed/panolint.git
-  revision: 6f38f73dafdc25370ecc367dc87d7e6340ae664d
+  revision: c709ebcc5fd9593db959df4a92c12cae1d1fb9af
   branch: main
   specs:
     panolint (0.1.3)
@@ -14,7 +14,7 @@ GIT
 PATH
   remote: .
   specs:
-    memo_wise (1.0.0)
+    memo_wise (1.1.0)
 
 GEM
   remote: https://rubygems.org/
@@ -26,7 +26,7 @@ GEM
       tzinfo (~> 1.1)
     ansi (1.5.0)
     ast (2.4.2)
-    brakeman (5.0.4)
+    brakeman (5.1.1)
     codecov (0.5.2)
       simplecov (>= 0.15, < 0.22)
     concurrent-ruby (1.1.9)
@@ -40,11 +40,11 @@ GEM
       concurrent-ruby (~> 1.0)
     minitest (5.14.4)
     parallel (1.20.1)
-    parser (3.0.1.1)
+    parser (3.0.2.0)
       ast (~> 2.4.1)
     rack (2.2.3)
     rainbow (3.0.0)
-    rake (13.0.3)
+    rake (13.0.6)
     redcarpet (3.5.1)
     regexp_parser (2.1.1)
     rexml (3.2.5)

data/README.md

@@ -103,27 +103,43 @@ For more usage details, see our detailed [documentation](#documentation).
 ## Benchmarks
 
 Benchmarks measure memoized value retrieval time using
-[`benchmark-ips`](https://github.com/evanphx/benchmark-ips). All benchmarks are
-run on Ruby 3.0.1, except as indicated below for specific gems. Benchmarks are
+[`benchmark-ips`](https://github.com/evanphx/benchmark-ips). Benchmarks are
 run in GitHub Actions and updated in every PR that changes code.
 
 **Values >1.00x represent how much _slower_ each gem’s memoized value retrieval
-is than the latest commit of `memo_wise`.**
-
-|Method arguments|`memery` (1.4.0)|`memoist`\* (0.16.2)|`memoized`\* (1.0.2)|`memoizer`\* (1.0.3)|
-|--|--|--|--|--|
-|`()` (none)|13.17x|2.64x|1.46x|3.10x|
-|`(a)`|9.76x|15.44x|11.98x|13.12x|
-|`(a, b)`|1.98x|2.25x|1.82x|1.98x|
-|`(a:)`|17.65x|23.64x|20.69x|21.61x|
-|`(a:, b:)`|4.16x|3.94x|3.53x|3.67x|
-|`(a, b:)`|3.96x|3.72x|3.27x|3.42x|
-|`(a, *args)`|1.93x|2.25x|1.93x|1.95x|
-|`(a:, **kwargs)`|3.06x|2.38x|2.10x|2.20x|
-|`(a, *args, b:, **kwargs)`|1.52x|1.79x|1.65x|1.65x|
-
-_\*Indicates a benchmark run on Ruby 2.7.3 because the gem raises errors in Ruby
-3.0.1 due to its incorrect handling of keyword arguments._
+is than the baseline.**
+
+Benchmarks using Ruby 3.0.2:
+
+|Method arguments|`memo_wise` (latest)|`dry-core` (0.7.1)|`memery` (1.4.0)|
+|--|--|--|--|
+|`()` (none)|baseline|0.98-1.44x|10.40-14.95x|
+|`(a)`|baseline|2.10x|8.39x|
+|`(a, b)`|baseline|baseline\*|4.45x|
+|`(a:)`|baseline|1.89x|17.37x|
+|`(a:, b:)`|baseline|baseline\*|9.66x|
+|`(a, b:)`|baseline|baseline\*|8.78x|
+|`(a, *args)`|baseline|1.88x|4.07x|
+|`(a:, **kwargs)`|baseline|1.41x|4.98x|
+|`(a, *args, b:, **kwargs)`|baseline|baseline\*|2.50x|
+
+\*Indicates a run that was slower than the baseline but the difference was not
+significant.
+
+The following benchmarks are run on Ruby 2.7.4 because these gems raise errors
+in Ruby 3.0.2 due to their incorrect handling of keyword arguments:
+
+|Method arguments|`memo_wise` (latest)|`ddmemoize` (1.0.0)|`memoist` (0.16.2)|`memoized` (1.0.2)|`memoizer` (1.0.3)|
+|--|--|--|--|--|--|
+|`()` (none)|baseline|20.96-25.44x|2.49-3.31x|1.06-1.48x|2.96-3.83x|
+|`(a)`|baseline|19.37x|13.28x|9.31x|10.78x|
+|`(a, b)`|baseline|3.65x|2.64x|2.00x|2.28x|
+|`(a:)`|baseline|25.88x|21.74x|17.68x|19.17x|
+|`(a:, b:)`|baseline|5.72x|4.57x|3.90x|4.42x|
+|`(a, b:)`|baseline|5.63x|5.06x|4.20x|4.18x|
+|`(a, *args)`|baseline|5.13x|3.89x|3.25x|3.31x|
+|`(a:, **kwargs)`|baseline|3.23x|2.55x|2.33x|2.47x|
+|`(a, *args, b:, **kwargs)`|baseline|2.51x|2.00x|1.84x|1.88x|
 
 You can run benchmarks yourself with:
 
@@ -185,6 +201,13 @@ memoization between your tests with something like:
 after(:each) { helper.reset_memo_wise }
 ```
 
+## Further Reading
+
+We've written more about MemoWise in a series of blog posts:
+
+- [Introducing: MemoWise](https://medium.com/building-panorama-education/introducing-memowise-51a5f0523489)
+- [Optimizing MemoWise Performance](https://ja.cob.land/optimizing-memowise-performance)
+
 ## Logo
 
 `MemoWise`'s logo was created by [Luci Cooke](https://www.lucicooke.com/). The

data/benchmarks/Gemfile

@@ -2,13 +2,15 @@
 
 source "https://rubygems.org"
 
-ruby ">= 2.7.2"
+ruby ">= 2.7.4"
 
 gem "benchmark-ips", "2.9.1"
 
 if RUBY_VERSION > "3"
+  gem "dry-core", "0.7.1"
   gem "memery", "1.4.0"
 else
+  gem "ddmemoize", "1.0.0"
   gem "memoist", "0.16.2"
   gem "memoized", "1.0.2"
   gem "memoizer", "1.0.3"

data/benchmarks/benchmarks.rb

@@ -6,13 +6,16 @@ require "memo_wise"
 
 # Some gems do not yet work in Ruby 3 so we only require them if they're loaded
 # in the Gemfile.
-%w[memery memoist memoized memoizer].
+%w[memery memoist memoized memoizer ddmemoize dry-core].
   each { |gem| require gem if Gem.loaded_specs.key?(gem) }
 
 # The VERSION constant does not get loaded above for these gems.
 %w[memoized memoizer].
   each { |gem| require "#{gem}/version" if Gem.loaded_specs.key?(gem) }
 
+# The Memoizable module from dry-core needs to be required manually
+require "dry/core/memoizable" if Gem.loaded_specs.key?("dry-core")
+
 class BenchmarkSuiteWithoutGC
   def warming(*)
     run_gc
@@ -36,7 +39,7 @@ class BenchmarkSuiteWithoutGC
 end
 suite = BenchmarkSuiteWithoutGC.new
 
-BenchmarkGem = Struct.new(:klass, :inheritance_method, :memoization_method) do
+BenchmarkGem = Struct.new(:klass, :activation_code, :memoization_method) do
   def benchmark_name
     "#{klass} (#{klass::VERSION})"
   end
@@ -46,70 +49,84 @@ end
 # using it to minimize the chance that our benchmarks are affected by ordering.
 # NOTE: Some gems do not yet work in Ruby 3 so we only test with them if they've
 # been `require`d.
+# rubocop:disable Layout/LineLength
 BENCHMARK_GEMS = [
-  BenchmarkGem.new(MemoWise, :prepend, :memo_wise),
-  (BenchmarkGem.new(Memery, :include, :memoize) if defined?(Memery)),
-  (BenchmarkGem.new(Memoist, :extend, :memoize) if defined?(Memoist)),
-  (BenchmarkGem.new(Memoized, :include, :memoize) if defined?(Memoized)),
-  (BenchmarkGem.new(Memoizer, :include, :memoize) if defined?(Memoizer))
+  BenchmarkGem.new(MemoWise, "prepend MemoWise", :memo_wise),
+  (BenchmarkGem.new(DDMemoize, "DDMemoize.activate(self)", :memoize) if defined?(DDMemoize)),
+  (BenchmarkGem.new(Dry::Core, "include Dry::Core::Memoizable", :memoize) if defined?(Dry::Core)),
+  (BenchmarkGem.new(Memery, "include Memery", :memoize) if defined?(Memery)),
+  (BenchmarkGem.new(Memoist, "extend Memoist", :memoize) if defined?(Memoist)),
+  (BenchmarkGem.new(Memoized, "include Memoized", :memoize) if defined?(Memoized)),
+  (BenchmarkGem.new(Memoizer, "include Memoizer", :memoize) if defined?(Memoizer))
 ].compact.shuffle
+# rubocop:enable Layout/LineLength
 
 # Use metaprogramming to ensure that each class is created in exactly the
 # the same way.
 BENCHMARK_GEMS.each do |benchmark_gem|
   # rubocop:disable Security/Eval
-  # rubocop:disable Style/DocumentDynamicEvalDefinition
   eval <<-CLASS, binding, __FILE__, __LINE__ + 1
+    # For these methods, we alternately return truthy and falsey values in
+    # order to benchmark memoization when the result of a method is falsey.
+    #
+    # We do this by checking if the first argument to a method is even.
     class #{benchmark_gem.klass}Example
-      #{benchmark_gem.inheritance_method} #{benchmark_gem.klass}
+      #{benchmark_gem.activation_code}
 
       def no_args
         100
       end
       #{benchmark_gem.memoization_method} :no_args
 
+      # For the no_args case, we can't depend on arguments to alternate between
+      # returning truthy and falsey values, so instead make two separate
+      # no_args methods
+      def no_args_falsey
+        nil
+      end
+      #{benchmark_gem.memoization_method} :no_args_falsey
+
       def one_positional_arg(a)
-        100
+        100 if a.even?
       end
       #{benchmark_gem.memoization_method} :one_positional_arg
 
       def positional_args(a, b)
-        100
+        100 if a.even?
       end
       #{benchmark_gem.memoization_method} :positional_args
 
       def one_keyword_arg(a:)
-        100
+        100 if a.even?
       end
       #{benchmark_gem.memoization_method} :one_keyword_arg
 
       def keyword_args(a:, b:)
-        100
+        100 if a.even?
       end
       #{benchmark_gem.memoization_method} :keyword_args
 
       def positional_and_keyword_args(a, b:)
-        100
+        100 if a.even?
       end
       #{benchmark_gem.memoization_method} :positional_and_keyword_args
 
       def positional_and_splat_args(a, *args)
-        100
+        100 if a.even?
       end
       #{benchmark_gem.memoization_method} :positional_and_splat_args
 
       def keyword_and_double_splat_args(a:, **kwargs)
-        100
+        100 if a.even?
       end
       #{benchmark_gem.memoization_method} :keyword_and_double_splat_args
 
       def positional_splat_keyword_and_double_splat_args(a, *args, b:, **kwargs)
-        100
+        100 if a.even?
       end
       #{benchmark_gem.memoization_method} :positional_splat_keyword_and_double_splat_args
     end
   CLASS
-  # rubocop:enable Style/DocumentDynamicEvalDefinition
   # rubocop:enable Security/Eval
 end
 
@@ -130,7 +147,26 @@ Benchmark.ips do |x|
     # retrieval time.
     instance.no_args
 
-    x.report("#{benchmark_gem.benchmark_name}: ()") { instance.no_args }
+    x.report("#{benchmark_gem.benchmark_name}: () => truthy") do
+      instance.no_args
+    end
+  end
+
+  x.compare!
+end
+
+Benchmark.ips do |x|
+  x.config(suite: suite)
+  BENCHMARK_GEMS.each do |benchmark_gem|
+    instance = Object.const_get("#{benchmark_gem.klass}Example").new
+
+    # Run once to memoize the result value, so our benchmark only tests memoized
+    # retrieval time.
+    instance.no_args_falsey
+
+    x.report("#{benchmark_gem.benchmark_name}: () => falsey") do
+      instance.no_args_falsey
+    end
   end
 
   x.compare!

data/lib/memo_wise.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "set"
+
 require "memo_wise/internal_api"
 require "memo_wise/version"
 
@@ -120,6 +122,23 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
               MemoWise::InternalAPI.original_class_from_singleton(klass)
             )
           end
+
+          # Ensures a module extended by another class/module still works
+          # e.g. rails `ClassMethods` module
+          if klass.is_a?(Module) && !klass.is_a?(Class)
+            # Using `extended` without `included` & `prepended`
+            # As a call to `create_memo_wise_state!` is already included in
+            # `.allocate`/`#initialize`
+            #
+            # But a module/class extending another module with memo_wise
+            # would not call `.allocate`/`#initialize` before calling methods
+            #
+            # On method call `@_memo_wise` would still be `nil`
+            # causing error when fetching cache from `@_memo_wise`
+            def klass.extended(base)
+              MemoWise::InternalAPI.create_memo_wise_state!(base)
+            end
+          end
         when Hash
           unless method_name_or_hash.keys == [:self]
             raise ArgumentError,
@@ -154,14 +173,11 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
         # hash key is just the method name.
         if method.arity.zero?
           klass.module_eval <<-END_OF_METHOD, __FILE__, __LINE__ + 1
-            # def foo
-            #   @_memo_wise.fetch(:foo) do
-            #     @_memo_wise[:foo] = _memo_wise_original_foo
-            #   end
-            # end
-
             def #{method_name}
-              @_memo_wise.fetch(:#{method_name}) do
+              output = @_memo_wise[:#{method_name}]
+              if output || @_memo_wise.key?(:#{method_name})
+                output
+              else
                 @_memo_wise[:#{method_name}] = #{original_memo_wised_name}
               end
             end
@@ -176,12 +192,14 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
               type == :req ? name : "#{name}: #{name}"
             end.join(", ")
             call_str = "(#{call_str})"
-            fetch_key = method.parameters.map(&:last)
-            fetch_key = if fetch_key.size > 1
-                          "[#{fetch_key.join(', ')}].freeze"
-                        else
-                          fetch_key.first.to_s
-                        end
+            fetch_key_params = method.parameters.map(&:last)
+            if fetch_key_params.size > 1
+              fetch_key_init =
+                "[:#{method_name}, #{fetch_key_params.join(', ')}].hash"
+              use_hashed_key = true
+            else
+              fetch_key = fetch_key_params.first.to_s
+            end
           else
             # If our method has arguments, we need to separate out our handling
             # of normal args vs. keyword args due to the changes in Ruby 3.
@@ -192,37 +210,46 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
 
             if has_arg && MemoWise::InternalAPI.has_kwarg?(method)
               args_str = "(*args, **kwargs)"
-              fetch_key = "[args, kwargs].freeze"
+              fetch_key_init = "[:#{method_name}, args, kwargs].hash"
+              use_hashed_key = true
             elsif has_arg
               args_str = "(*args)"
-              fetch_key = "args"
+              fetch_key_init = "args.hash"
             else
               args_str = "(**kwargs)"
-              fetch_key = "kwargs"
+              fetch_key_init = "kwargs.hash"
             end
           end
 
-          # Note that we don't need to freeze args before using it as a hash key
-          # because Ruby always copies argument arrays when splatted.
-          klass.module_eval <<-END_OF_METHOD, __FILE__, __LINE__ + 1
-            # def foo(*args, **kwargs)
-            #   hash = @_memo_wise.fetch(:foo) do
-            #     @_memo_wise[:foo] = {}
-            #   end
-            #   hash.fetch([args, kwargs].freeze) do
-            #     hash[[args, kwargs].freeze] = _memo_wise_original_foo(*args, **kwargs)
-            #   end
-            # end
-
-            def #{method_name}#{args_str}
-              hash = @_memo_wise.fetch(:#{method_name}) do
-                @_memo_wise[:#{method_name}] = {}
+          if use_hashed_key
+            klass.module_eval <<-END_OF_METHOD, __FILE__, __LINE__ + 1
+              def #{method_name}#{args_str}
+                key = #{fetch_key_init}
+                output = @_memo_wise[key]
+                if output || @_memo_wise.key?(key)
+                  output
+                else
+                  hashes = (@_memo_wise_hashes[:#{method_name}] ||= Set.new)
+                  hashes << key
+                  @_memo_wise[key] = #{original_memo_wised_name}#{call_str || args_str}
+                end
               end
-              hash.fetch(#{fetch_key}) do
-                hash[#{fetch_key}] = #{original_memo_wised_name}#{call_str || args_str}
+            END_OF_METHOD
+          else
+            fetch_key ||= "key"
+            klass.module_eval <<-END_OF_METHOD, __FILE__, __LINE__ + 1
+              def #{method_name}#{args_str}
+                hash = (@_memo_wise[:#{method_name}] ||= {})
+                #{"key = #{fetch_key_init}" if fetch_key_init}
+                output = hash[#{fetch_key}]
+                if output || hash.key?(#{fetch_key})
+                  output
+                else
+                  hash[#{fetch_key}] = #{original_memo_wised_name}#{call_str || args_str}
+                end
               end
-            end
-          END_OF_METHOD
+            END_OF_METHOD
+          end
         end
 
         klass.send(visibility, method_name)
@@ -248,8 +275,8 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
       # (`...` or `*args, **kwargs`), making reflection on method parameters
       # useless without this.
       def target.instance_method(symbol)
-        # TODO: Extract this method naming pattern
-        original_memo_wised_name = :"_memo_wise_original_#{symbol}"
+        original_memo_wised_name =
+          MemoWise::InternalAPI.original_memo_wised_name(symbol)
 
         super.tap do |curr_method|
           # Start with calling the original `instance_method` on `symbol`,
@@ -439,10 +466,15 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
     if method(method_name).arity.zero?
       @_memo_wise[method_name] = yield
     else
-      hash = @_memo_wise.fetch(method_name) do
-        @_memo_wise[method_name] = {}
+      key = api.fetch_key(method_name, *args, **kwargs)
+      if api.use_hashed_key?(method_name)
+        hashes = @_memo_wise_hashes[method_name] ||= []
+        hashes << key
+        @_memo_wise[key] = yield
+      else
+        hash = @_memo_wise[method_name] ||= {}
+        hash[key] = yield
       end
-      hash[api.fetch_key(method_name, *args, **kwargs)] = yield
     end
   end
 
@@ -511,7 +543,7 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
   #
   #   ex.reset_memo_wise # reset "all methods" mode
   #
-  def reset_memo_wise(method_name = nil, *args, **kwargs)
+  def reset_memo_wise(method_name = nil, *args, **kwargs) # rubocop:disable Metrics/PerceivedComplexity
     if method_name.nil?
       unless args.empty?
         raise ArgumentError, "Provided args when method_name = nil"
@@ -521,7 +553,9 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
         raise ArgumentError, "Provided kwargs when method_name = nil"
       end
 
-      return @_memo_wise.clear
+      @_memo_wise.clear
+      @_memo_wise_hashes.clear
+      return
     end
 
     unless method_name.is_a?(Symbol)
@@ -537,9 +571,18 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
 
     if args.empty? && kwargs.empty?
       @_memo_wise.delete(method_name)
+      @_memo_wise_hashes[method_name]&.each do |hash|
+        @_memo_wise.delete(hash)
+      end
+      @_memo_wise_hashes.delete(method_name)
     else
-      @_memo_wise[method_name]&.
-        delete(api.fetch_key(method_name, *args, **kwargs))
+      key = api.fetch_key(method_name, *args, **kwargs)
+      if api.use_hashed_key?(method_name)
+        @_memo_wise_hashes[method_name]&.delete(key)
+        @_memo_wise.delete(key)
+      else
+        @_memo_wise[method_name]&.delete(key)
+      end
     end
   end
 end

data/lib/memo_wise/internal_api.rb

@@ -10,10 +10,34 @@ module MemoWise
     #
     # @return [Object] the passed-in obj
     def self.create_memo_wise_state!(obj)
+      # `@_memo_wise` stores memoized results of method calls. For performance
+      # reasons, the structure differs for different types of methods. It looks
+      # like:
+      #   {
+      #     no_args_method_name: :memoized_result,
+      #     single_arg_method_name: { arg1 => :memoized_result, ... },
+      #     [:multi_arg_method_name, arg1, arg2].hash => :memoized_result
+      #   }
       unless obj.instance_variables.include?(:@_memo_wise)
         obj.instance_variable_set(:@_memo_wise, {})
       end
 
+      # `@_memo_wise_hashes` stores the `Array#hash` values for each key in
+      # `@_memo_wise` that represents a multi-argument method call. We only use
+      # this data structure when resetting memoization for an entire method. It
+      # looks like:
+      #   {
+      #     multi_arg_method_name: Set[
+      #       [:multi_arg_method_name, arg1, arg2].hash,
+      #       [:multi_arg_method_name, arg1, arg3].hash,
+      #       ...
+      #     ],
+      #     ...
+      #   }
+      unless obj.instance_variables.include?(:@_memo_wise_hashes)
+        obj.instance_variable_set(:@_memo_wise_hashes, {})
+      end
+
       obj
     end
 
@@ -143,7 +167,9 @@ module MemoWise
       #   * 1:1 relationship of singleton class to original class is documented
       #   * Performance concern: searches all Class objects
       #     But, only runs at load time
-      ObjectSpace.each_object(Class).find { |cls| cls.singleton_class == klass }
+      ObjectSpace.each_object(Module).find do |cls|
+        cls.singleton_class == klass
+      end
     end
 
     # Convention we use for renaming the original method when we replace with
@@ -193,20 +219,41 @@ module MemoWise
         key = method.parameters.map.with_index do |(type, name), index|
           type == :req ? args[index] : kwargs[name]
         end
-        key.size == 1 ? key.first : key
+        key.size == 1 ? key.first : [method_name, *key].hash
       else
         has_arg = MemoWise::InternalAPI.has_arg?(method)
 
         if has_arg && MemoWise::InternalAPI.has_kwarg?(method)
-          [args, kwargs].freeze
+          [method_name, args, kwargs].hash
         elsif has_arg
-          args
+          args.hash
         else
-          kwargs
+          kwargs.hash
         end
       end
     end
 
+    # Returns whether the given method should use an array's hash value as the
+    # cache lookup key. See the comments in `.create_memo_wise_state!` for an
+    # example.
+    #
+    # @param method_name [Symbol]
+    #   Name of memoized method we're checking the implementation of
+    #
+    # @return [Boolean] true iff the method uses a hashed cache key; false
+    #   otherwise
+    def use_hashed_key?(method_name)
+      method = target_class.instance_method(method_name)
+
+      if MemoWise::InternalAPI.has_arg?(method) &&
+         MemoWise::InternalAPI.has_kwarg?(method)
+        return true
+      end
+
+      MemoWise::InternalAPI.has_only_required_args?(method) &&
+        method.parameters.size > 1
+    end
+
     # Returns visibility of an instance method defined on class `target`.
     #
     # @param method_name [Symbol]
@@ -244,6 +291,8 @@ module MemoWise
       end
     end
 
+    private
+
     # @return [Class] where we look for method definitions
     def target_class
       if target.instance_of?(Class)

data/lib/memo_wise/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MemoWise
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: memo_wise
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Panorama Education
@@ -11,7 +11,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-06-24 00:00:00.000000000 Z
+date: 2021-07-30 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -39,9 +39,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- benchmarks/.ruby-version
 - benchmarks/Gemfile
-- benchmarks/Gemfile.lock
 - benchmarks/benchmarks.rb
 - bin/console
 - bin/setup

data/benchmarks/.ruby-version

@@ -1 +0,0 @@
-3.0.0

data/benchmarks/Gemfile.lock

@@ -1,29 +0,0 @@
-PATH
-  remote: ..
-  specs:
-    memo_wise (0.4.0)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    benchmark-ips (2.9.1)
-    memoist (0.16.2)
-    memoized (1.0.2)
-    memoizer (1.0.3)
-
-PLATFORMS
-  x86_64-darwin-19
-  x86_64-linux
-
-DEPENDENCIES
-  benchmark-ips (= 2.9.1)
-  memo_wise!
-  memoist (= 0.16.2)
-  memoized (= 1.0.2)
-  memoizer (= 1.0.3)
-
-RUBY VERSION
-   ruby 3.0.0p0
-
-BUNDLED WITH
-   2.2.3