memo_wise 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2fa12aeb35a6c4ca923eb23d70867b41600795143570f3d7c5b6444c76547980
-  data.tar.gz: bac4074e758731ac5d20925ab32ef3cd78d10a1c030228df76c1868e104e1a40
+  metadata.gz: 3a2fbbb2a403502d6a492068a9a0c8c103f717ea5b32e5029ba1a0aebab61db6
+  data.tar.gz: c2c8118caa1621670b6cd666f92147eb5c3f069c7b910062ed0f635568764dd7
 SHA512:
-  metadata.gz: 52e8b1543bca54371a2743fbc22b3cee32ba68a050ac414e373ca2027faba214956bca3aef61a05d25ca1d339b3e4ae01a417cdb5d1a4a407fba16b0a3cae56e
-  data.tar.gz: 1bc40ccaab12ed598cc86d62d51ca8081a386b208559ac49788ff87601c45809958c2e936692fbb2e78f3ff0f04b124636f795d941558239fc20edf04f7b979b
+  metadata.gz: 699415e3445e60bf6037fdb6887a064a4d082159be15c8c52a0711be5b3b233e3a7caa974f6d31df769d9bd0c3825d7a9f11b17b1e3b98ec9202ee8224801204
+  data.tar.gz: f6f377da39902d30310e7304e0caa7195e372c5fe0666e05ea30d2c2f936f3cc7d00c3588e453d5ab4ba7393a4f747f5c328acd4f4024cfa126ecb5f683fd24c

data/.github/PULL_REQUEST_TEMPLATE.md

@@ -1,4 +1,4 @@
 **Before merging:**
 
-- [ ] Copy the latest benchmark results into the `README.md` and update this PR
-- [ ] If this change merits an update to `CHANGELOG.md`, add an entry following Keep a Changelog [guidelines](https://keepachangelog.com/en/1.0.0/) with [semantic versioning](https://semver.org/)
+- [ ] Copy the table printed at the end of the latest benchmark results into the `README.md` and update this PR
+- [ ] If this change merits an update to `CHANGELOG.md`, add an entry following Keep a Changelog [guidelines](https://keepachangelog.com/en/1.0.0/) with [semantic versioning](https://semver.org/)

data/.rubocop.yml

@@ -1,5 +1,17 @@
 inherit_gem:
   panolint: rubocop.yml
 
+Layout/LineLength:
+  Max: 120
+
+Metrics/ModuleLength:
+  Enabled: false
+
+Metrics/PerceivedComplexity:
+  Enabled: false
+
 Style/DocumentDynamicEvalDefinition:
   Enabled: false
+
+Style/MultipleComparison:
+  Enabled: false

data/CHANGELOG.md

@@ -6,24 +6,36 @@ 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!
+
+## [1.2.0] - 2021-11-10
+
 ### Updated
-- (Nothing, yet)
+- Improved performance of all methods by using an outer Array instead of a Hash
+- Improved performance for multi-argument methods and simplify internal data
+  structures
+
 ### Fixed
-- (Nothing, yet)
+- Removed use of #hash due to potential of hash collisions
+- Updated internal local variable names to avoid name collisions with method
+  arguments
+
 ### Breaking Changes
 - None
 
 ## [1.1.0] - 2021-07-29
 ### Updated
-- Improve performance across the board by:
+- Improved 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
+- Fixed usage on module singleton classes
+- Fixed usage on module which would be extended by other classes
+
 ### Breaking Changes
 - None
 
@@ -31,6 +43,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 - Support for `.preset_memo_wise` on class methods
 - Support for `.reset_memo_wise` on class methods
+
 ### Updated
 - Improved performance for common cases by reducing array allocations
 

data/Gemfile.lock

@@ -14,7 +14,7 @@ GIT
 PATH
   remote: .
   specs:
-    memo_wise (1.1.0)
+    memo_wise (1.2.0)
 
 GEM
   remote: https://rubygems.org/
@@ -27,7 +27,7 @@ GEM
     ansi (1.5.0)
     ast (2.4.2)
     brakeman (5.1.1)
-    codecov (0.5.2)
+    codecov (0.6.0)
       simplecov (>= 0.15, < 0.22)
     concurrent-ruby (1.1.9)
     diff-lcs (1.4.4)
@@ -117,4 +117,4 @@ DEPENDENCIES
   yard-doctest (~> 0.1)
 
 BUNDLED WITH
-   2.2.3
+   2.2.28

data/README.md

@@ -56,6 +56,15 @@ class Example
     x
   end
   memo_wise :slow_value
+  
+  private
+  
+  # maintains privacy of the memoized method
+  def private_slow_method(x)
+    sleep x
+    x
+  end
+  memo_wise :private_slow_method
 end
 
 ex = Example.new
@@ -102,44 +111,38 @@ 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). 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 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|
+Benchmarks are run in GitHub Actions, and the tables below are updated with every code change. **Values >1.00x represent how much _slower_ each gem’s memoized value retrieval is than the latest commit of `MemoWise`**, according to [`benchmark-ips`](https://github.com/evanphx/benchmark-ips) (2.9.1).
+
+Results using Ruby 3.0.2:
+
+|Method arguments|`Dry::Core`\* (0.7.1)|`Memery` (1.4.0)|
+|--|--|--|
+|`()` (none)|1.51x|19.82x|
+|`(a)`|2.30x|11.38x|
+|`(a, b)`|0.45x|2.10x|
+|`(a:)`|2.20x|22.83x|
+|`(a:, b:)`|0.49x|4.53x|
+|`(a, b:)`|0.46x|4.35x|
+|`(a, *args)`|0.89x|2.03x|
+|`(a:, **kwargs)`|0.82x|3.18x|
+|`(a, *args, b:, **kwargs)`|0.60x|1.62x|
+
+\* `Dry::Core`
+[may cause incorrect behavior caused by hash collisions](https://github.com/dry-rb/dry-core/issues/63).
+
+Results using Ruby 2.7.4 (because these gems raise errors in Ruby 3.x):
+
+|Method arguments|`DDMemoize` (1.0.0)|`Memoist` (0.16.2)|`Memoized` (1.0.2)|`Memoizer` (1.0.3)|
+|--|--|--|--|--|
+|`()` (none)|35.29x|3.46x|1.67x|4.27x|
+|`(a)`|25.04x|16.96x|12.83x|14.68x|
+|`(a, b)`|3.20x|2.28x|1.84x|2.04x|
+|`(a:)`|34.17x|27.77x|24.07x|25.39x|
+|`(a:, b:)`|5.22x|4.29x|3.74x|4.00x|
+|`(a, b:)`|4.81x|3.99x|3.49x|3.66x|
+|`(a, *args)`|3.21x|2.30x|1.97x|2.00x|
+|`(a:, **kwargs)`|2.84x|2.39x|2.12x|2.19x|
+|`(a, *args, b:, **kwargs)`|2.10x|1.80x|1.67x|1.66x|
 
 You can run benchmarks yourself with:
 
@@ -207,6 +210,7 @@ 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)
+- [Esosteric Ruby in MemoWise](https://jemma.dev/blog/esoteric-ruby-in-memowise)
 
 ## Logo
 

data/benchmarks/benchmarks.rb

@@ -2,6 +2,7 @@
 
 require "benchmark/ips"
 
+require "tempfile"
 require "memo_wise"
 
 # Some gems do not yet work in Ruby 3 so we only require them if they're loaded
@@ -49,7 +50,6 @@ 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 MemoWise", :memo_wise),
   (BenchmarkGem.new(DDMemoize, "DDMemoize.activate(self)", :memoize) if defined?(DDMemoize)),
@@ -59,7 +59,6 @@ BENCHMARK_GEMS = [
   (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.
@@ -87,42 +86,42 @@ BENCHMARK_GEMS.each do |benchmark_gem|
       #{benchmark_gem.memoization_method} :no_args_falsey
 
       def one_positional_arg(a)
-        100 if a.even?
+        100 if a.positive?
       end
       #{benchmark_gem.memoization_method} :one_positional_arg
 
       def positional_args(a, b)
-        100 if a.even?
+        100 if a.positive?
       end
       #{benchmark_gem.memoization_method} :positional_args
 
       def one_keyword_arg(a:)
-        100 if a.even?
+        100 if a.positive?
       end
       #{benchmark_gem.memoization_method} :one_keyword_arg
 
       def keyword_args(a:, b:)
-        100 if a.even?
+        100 if a.positive?
       end
       #{benchmark_gem.memoization_method} :keyword_args
 
       def positional_and_keyword_args(a, b:)
-        100 if a.even?
+        100 if a.positive?
       end
       #{benchmark_gem.memoization_method} :positional_and_keyword_args
 
       def positional_and_splat_args(a, *args)
-        100 if a.even?
+        100 if a.positive?
       end
       #{benchmark_gem.memoization_method} :positional_and_splat_args
 
       def keyword_and_double_splat_args(a:, **kwargs)
-        100 if a.even?
+        100 if a.positive?
       end
       #{benchmark_gem.memoization_method} :keyword_and_double_splat_args
 
       def positional_splat_keyword_and_double_splat_args(a, *args, b:, **kwargs)
-        100 if a.even?
+        100 if a.positive?
       end
       #{benchmark_gem.memoization_method} :positional_splat_keyword_and_double_splat_args
     end
@@ -132,155 +131,93 @@ end
 
 # We pre-create argument lists for our memoized methods with arguments, so that
 # our benchmarks are running the exact same inputs for each case.
-N_UNIQUE_ARGUMENTS = 100
+#
+# NOTE: The proportion of falsey results is 1/N_UNIQUE_ARGUMENTS (because for
+# the methods with arguments we are truthy for all but the first unique argument
+# set, and for zero-arity methods we manually execute `no_args` N_TRUTHY_RESULTS
+# times per each execution of `no_args_falsey`). This number was selected as the
+# lowest number such that this logic:
+#
+#   output = hash[key]
+#   if output || hash.key?(key)
+#     output
+#   else
+#     hash[key] = _original_method(...)
+#   end
+#
+# is consistently faster for cached lookups than:
+#
+#   hash.fetch(key) do
+#     hash[key] = _original_method(...)
+#   end
+#
+# as a result of `Hash#[]` having less overhead than `Hash#fetch`.
+#
+# We believe this is a reasonable choice because we believe most memoized method
+# results will be truthy, and so that is the case we should most optimize for.
+# However, we do not want to completely remove falsey method results from these
+# benchmarks because we do want to catch performance regressions for that case,
+# since it has its own "hot path."
+N_UNIQUE_ARGUMENTS = 30
 ARGUMENTS = Array.new(N_UNIQUE_ARGUMENTS) { |i| [i, i + 1] }
+N_TRUTHY_RESULTS = N_UNIQUE_ARGUMENTS - 1
+N_RESULT_DECIMAL_DIGITS = 2
 
-# We benchmark different cases separately, to ensure that slow performance in
-# one method or code path isn't hidden by fast performance in another.
-
-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
-
-    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.
+# Each method within these benchmarks is initially run once to memoize the
+# result value, so our benchmark only tests memoized retrieval time.
+benchmark_lambdas = [
+  lambda do |x, instance, benchmark_gem|
     instance.no_args_falsey
+    instance.no_args
 
-    x.report("#{benchmark_gem.benchmark_name}: () => falsey") do
+    x.report("#{benchmark_gem.benchmark_name}: ()") do
       instance.no_args_falsey
+      N_TRUTHY_RESULTS.times { 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 with each set of arguments to memoize the result values, so our
-    # benchmark only tests memoized retrieval time.
+  end,
+  lambda do |x, instance, benchmark_gem|
     ARGUMENTS.each { |a, _| instance.one_positional_arg(a) }
 
     x.report("#{benchmark_gem.benchmark_name}: (a)") do
       ARGUMENTS.each { |a, _| instance.one_positional_arg(a) }
     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 with each set of arguments to memoize the result values, so our
-    # benchmark only tests memoized retrieval time.
+  end,
+  lambda do |x, instance, benchmark_gem|
     ARGUMENTS.each { |a, b| instance.positional_args(a, b) }
 
     x.report("#{benchmark_gem.benchmark_name}: (a, b)") do
       ARGUMENTS.each { |a, b| instance.positional_args(a, b) }
     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 with each set of arguments to memoize the result values, so our
-    # benchmark only tests memoized retrieval time.
+  end,
+  lambda do |x, instance, benchmark_gem|
     ARGUMENTS.each { |a, _| instance.one_keyword_arg(a: a) }
 
     x.report("#{benchmark_gem.benchmark_name}: (a:)") do
       ARGUMENTS.each { |a, _| instance.one_keyword_arg(a: a) }
     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 with each set of arguments to memoize the result values, so our
-    # benchmark only tests memoized retrieval time.
+  end,
+  lambda do |x, instance, benchmark_gem|
     ARGUMENTS.each { |a, b| instance.keyword_args(a: a, b: b) }
 
     x.report("#{benchmark_gem.benchmark_name}: (a:, b:)") do
       ARGUMENTS.each { |a, b| instance.keyword_args(a: a, b: b) }
     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 with each set of arguments to memoize the result values, so our
-    # benchmark only tests memoized retrieval time.
+  end,
+  lambda do |x, instance, benchmark_gem|
     ARGUMENTS.each { |a, b| instance.positional_and_keyword_args(a, b: b) }
 
     x.report("#{benchmark_gem.benchmark_name}: (a, b:)") do
       ARGUMENTS.each { |a, b| instance.positional_and_keyword_args(a, b: b) }
     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 with each set of arguments to memoize the result values, so our
-    # benchmark only tests memoized retrieval time.
+  end,
+  lambda do |x, instance, benchmark_gem|
     ARGUMENTS.each { |a, b| instance.positional_and_splat_args(a, b) }
 
     x.report("#{benchmark_gem.benchmark_name}: (a, *args)") do
       ARGUMENTS.each { |a, b| instance.positional_and_splat_args(a, b) }
     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 with each set of arguments to memoize the result values, so our
-    # benchmark only tests memoized retrieval time.
+  end,
+  lambda do |x, instance, benchmark_gem|
     ARGUMENTS.each { |a, b| instance.keyword_and_double_splat_args(a: a, b: b) }
 
     x.report(
@@ -290,18 +227,8 @@ Benchmark.ips do |x|
         instance.keyword_and_double_splat_args(a: a, b: b)
       end
     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 with each set of arguments to memoize the result values, so our
-    # benchmark only tests memoized retrieval time.
+  end,
+  lambda do |x, instance, benchmark_gem|
     ARGUMENTS.each do |a, b|
       instance.positional_splat_keyword_and_double_splat_args(a, b, b: b, a: a)
     end
@@ -315,6 +242,62 @@ Benchmark.ips do |x|
       end
     end
   end
+]
+
+# We benchmark different cases separately, to ensure that slow performance in
+# one method or code path isn't hidden by fast performance in another.
+benchmark_lambdas.map do |benchmark|
+  json_file = Tempfile.new
+
+  Benchmark.ips do |x|
+    x.config(suite: suite)
+    BENCHMARK_GEMS.each do |benchmark_gem|
+      instance = Object.const_get("#{benchmark_gem.klass}Example").new
+
+      benchmark.call(x, instance, benchmark_gem)
+    end
+
+    x.compare!
+    x.json! json_file.path
+  end
+
+  JSON.parse(json_file.read)
+end.each_with_index do |benchmark_json, i|
+  # We print a comparison table after we run each benchmark to copy into our
+  # README.md
+
+  # MemoWise will not appear in the comparison table, but we will use it to
+  # compare against other gems' benchmarks
+  memo_wise = benchmark_json.find { _1["name"].include?("MemoWise") }
+  benchmark_json.delete(memo_wise)
+
+  # Sort benchmarks by gem name to alphabetize our final output table.
+  benchmark_json.sort_by! { _1["name"] }
+
+  # Print headers based on the first benchmark_json
+  if i.zero?
+    benchmark_headers = benchmark_json.map do |benchmark_gem|
+      # Gem name is of the form:
+      # "MemoWise (1.1.0): ()"
+      # We use this mapping to get a header of the form
+      # "`MemoWise` (1.1.0)
+      gem_name_parts = benchmark_gem["name"].split
+      "`#{gem_name_parts[0]}` #{gem_name_parts[1][...-1]}"
+    end.join("|")
+    puts "|Method arguments|#{benchmark_headers}|"
+    puts "#{'|--' * (benchmark_json.size + 1)}|"
+  end
+
+  output_str = benchmark_json.map do |bgem|
+    # "%.2f" % 12.345 => "12.34" (instead of "12.35")
+    #   See: https://bugs.ruby-lang.org/issues/12548
+    # 1.00.round(2).to_s => "1.0" (instead of "1.00")
+    #
+    # So to round and format correctly, we first use Float#round and then %
+    "%.#{N_RESULT_DECIMAL_DIGITS}fx" %
+      (memo_wise["central_tendency"] / bgem["central_tendency"]).round(N_RESULT_DECIMAL_DIGITS)
+  end.join("|")
 
-  x.compare!
+  name = memo_wise["name"].partition(": ").last
+  puts "|`#{name}`#{' (none)' if name == '()'}|#{output_str}|"
 end

data/lib/memo_wise/internal_api.rb

@@ -10,138 +10,138 @@ 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:
+      # `@_memo_wise` stores memoized results of method calls. The structure is
+      # slightly different for different types of methods. It looks like:
+      #   [
+      #     :memoized_result, # For method 0 (which takes no arguments)
+      #     { arg1 => :memoized_result, ... }, # For method 1 (which takes an argument)
+      #     { [arg1, arg2] => :memoized_result, ... } # For method 2 (which takes multiple arguments)
+      #   ]
+      # This is a faster alternative to:
       #   {
-      #     no_args_method_name: :memoized_result,
+      #     zero_arg_method_name: :memoized_result,
       #     single_arg_method_name: { arg1 => :memoized_result, ... },
-      #     [:multi_arg_method_name, arg1, arg2].hash => :memoized_result
+      #
+      #     # Surprisingly, this is faster than a single top-level hash key of: [:multi_arg_method_name, arg1, arg2]
+      #     multi_arg_method_name: { [arg1, arg2] => :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,
-      #       ...
-      #     ],
+      # because we can give each method its own array index at load time and
+      # perform that array lookup more quickly than a hash lookup by method
+      # name.
+      obj.instance_variable_set(:@_memo_wise, []) unless obj.instance_variable_defined?(:@_memo_wise)
+
+      # For zero-arity methods, memoized values are stored in the `@_memo_wise`
+      # array. Arrays do not differentiate between "unset" and "set to nil" and
+      # so to handle this case we need another array to store sentinels and
+      # store `true` at indexes for which a zero-arity method has been memoized.
+      # `@_memo_wise_sentinels` looks like:
+      #   [
+      #     true, # A zero-arity method's result has been memoized
+      #     nil, # A zero-arity method's result has not been memoized
+      #     nil, # A one-arity method will always correspond to `nil` here
       #     ...
-      #   }
-      unless obj.instance_variables.include?(:@_memo_wise_hashes)
-        obj.instance_variable_set(:@_memo_wise_hashes, {})
+      #   ]
+      # NOTE: Because `@_memo_wise` stores memoized values for more than just
+      # zero-arity methods, the `@_memo_wise_sentinels` array can end up being
+      # sparse (see above), even when all methods' memoized values have been
+      # stored. If this becomes an issue we could store a separate index for
+      # zero-arity methods to make every element in `@_memo_wise_sentinels`
+      # correspond to a zero-arity method.
+      # NOTE: Surprisingly, lookups on an array of `true` and `nil` values
+      # appear to outperform even bitwise operators on integers (as of Ruby
+      # 3.0.2), allowing us to avoid more complex sentinel structures.
+      unless obj.instance_variable_defined?(:@_memo_wise_sentinels)
+        obj.instance_variable_set(:@_memo_wise_sentinels, [])
       end
 
       obj
     end
 
-    # Determine whether `method` takes any *positional* args.
-    #
-    # These are the types of positional args:
-    #
-    #   * *Required* -- ex: `def foo(a)`
-    #   * *Optional* -- ex: `def foo(b=1)`
-    #   * *Splatted* -- ex: `def foo(*c)`
-    #
-    # @param method [Method, UnboundMethod]
-    #   Arguments of this method will be checked
-    #
-    # @return [Boolean]
-    #   Return `true` if `method` accepts one or more positional arguments
-    #
-    # @example
-    #   class Example
-    #     def no_args
-    #     end
-    #
-    #     def position_arg(a)
-    #     end
-    #   end
-    #
-    #   MemoWise::InternalAPI.
-    #     has_arg?(Example.instance_method(:no_args)) #=> false
-    #
-    #   MemoWise::InternalAPI.
-    #     has_arg?(Example.instance_method(:position_arg)) #=> true
-    #
-    def self.has_arg?(method) # rubocop:disable Naming/PredicateName
-      method.parameters.any? do |param, _|
-        param == :req || param == :opt || param == :rest # rubocop:disable Style/MultipleComparison
+    NONE = :none
+    ONE_REQUIRED_POSITIONAL = :one_required_positional
+    ONE_REQUIRED_KEYWORD = :one_required_keyword
+    MULTIPLE_REQUIRED = :multiple_required
+    SPLAT = :splat
+    DOUBLE_SPLAT = :double_splat
+    SPLAT_AND_DOUBLE_SPLAT = :splat_and_double_splat
+
+    # @param method [UnboundMethod] a method to categorize based on the types of
+    #   arguments it has
+    # @return [Symbol] one of:
+    #   - :none (example: `def foo`)
+    #   - :one_required_positional (example: `def foo(a)`)
+    #   - :one_required_keyword (example: `def foo(a:)`)
+    #   - :multiple_required (examples: `def foo(a, b)`, `def foo(a:, b:)`, `def foo(a, b:)`)
+    #   - :splat (examples: `def foo(a=1)`, `def foo(a, *b)`)
+    #   - :double_splat (examples: `def foo(a: 1)`, `def foo(a:, **b)`)
+    #   - :splat_and_double_splat (examples: `def foo(a=1, b: 2)`, `def foo(a=1, **b)`, `def foo(*a, **b)`)
+    def self.method_arguments(method)
+      return NONE if method.arity.zero?
+
+      parameters = method.parameters.map(&:first)
+
+      if parameters == [:req]
+        ONE_REQUIRED_POSITIONAL
+      elsif parameters == [:keyreq]
+        ONE_REQUIRED_KEYWORD
+      elsif parameters.all? { |type| type == :req || type == :keyreq }
+        MULTIPLE_REQUIRED
+      elsif parameters & %i[req opt rest] == parameters.uniq
+        SPLAT
+      elsif parameters & %i[keyreq key keyrest] == parameters.uniq
+        DOUBLE_SPLAT
+      else
+        SPLAT_AND_DOUBLE_SPLAT
       end
     end
 
-    # Determine whether `method` takes any *keyword* args.
-    #
-    # These are the types of keyword args:
-    #
-    #   * *Keyword Required* -- ex: `def foo(a:)`
-    #   * *Keyword Optional* -- ex: `def foo(b: 1)`
-    #   * *Keyword Splatted* -- ex: `def foo(**c)`
-    #
-    # @param method [Method, UnboundMethod]
-    #   Arguments of this method will be checked
-    #
-    # @return [Boolean]
-    #   Return `true` if `method` accepts one or more keyword arguments
-    #
-    # @example
-    #   class Example
-    #     def position_args(a, b=1)
-    #     end
-    #
-    #     def keyword_args(a:, b: 1)
-    #     end
-    #   end
-    #
-    #   MemoWise::InternalAPI.
-    #     has_kwarg?(Example.instance_method(:position_args)) #=> false
-    #
-    #   MemoWise::InternalAPI.
-    #     has_kwarg?(Example.instance_method(:keyword_args)) #=> true
-    #
-    def self.has_kwarg?(method) # rubocop:disable Naming/PredicateName
-      method.parameters.any? do |param, _|
-        param == :keyreq || param == :key || param == :keyrest # rubocop:disable Style/MultipleComparison
+    # @param method [UnboundMethod] a method being memoized
+    # @return [String] the arguments string to use when defining our new
+    #   memoized version of the method
+    def self.args_str(method)
+      case method_arguments(method)
+      when SPLAT then "*args"
+      when DOUBLE_SPLAT then "**kwargs"
+      when SPLAT_AND_DOUBLE_SPLAT then "*args, **kwargs"
+      when ONE_REQUIRED_POSITIONAL, ONE_REQUIRED_KEYWORD, MULTIPLE_REQUIRED
+        method.parameters.map do |type, name|
+          "#{name}#{':' if type == :keyreq}"
+        end.join(", ")
+      else
+        raise ArgumentError, "Unexpected arguments for #{method.name}"
       end
     end
 
-    # Determine whether `method` takes only *required* args.
-    #
-    # These are the types of required args:
-    #
-    #   * *Required* -- ex: `def foo(a)`
-    #   * *Keyword Required* -- ex: `def foo(a:)`
-    #
-    # @param method [Method, UnboundMethod]
-    #   Arguments of this method will be checked
-    #
-    # @return [Boolean]
-    #   Return `true` if `method` accepts only required arguments
-    #
-    # @example
-    #   class Ex
-    #     def optional_args(a=1, b: 1)
-    #     end
-    #
-    #     def required_args(a, b:)
-    #     end
-    #   end
-    #
-    #   MemoWise::InternalAPI.
-    #     has_only_required_args?(Ex.instance_method(:optional_args))
-    #     #=> false
-    #
-    #   MemoWise::InternalAPI.
-    #     has_only_required_args?(Ex.instance_method(:required_args))
-    #     #=> true
-    def self.has_only_required_args?(method) # rubocop:disable Naming/PredicateName
-      method.parameters.all? { |type, _| type == :req || type == :keyreq } # rubocop:disable Style/MultipleComparison
+    # @param method [UnboundMethod] a method being memoized
+    # @return [String] the arguments string to use when calling the original
+    #   method in our new memoized version of the method, i.e. when setting a
+    #   memoized value
+    def self.call_str(method)
+      case method_arguments(method)
+      when SPLAT then "*args"
+      when DOUBLE_SPLAT then "**kwargs"
+      when SPLAT_AND_DOUBLE_SPLAT then "*args, **kwargs"
+      when ONE_REQUIRED_POSITIONAL, ONE_REQUIRED_KEYWORD, MULTIPLE_REQUIRED
+        method.parameters.map do |type, name|
+          type == :req ? name : "#{name}: #{name}"
+        end.join(", ")
+      else
+        raise ArgumentError, "Unexpected arguments for #{method.name}"
+      end
+    end
+
+    # @param method [UnboundMethod] a method being memoized
+    # @return [String] the string to use as a hash key when looking up a
+    #   memoized value, based on the method's arguments
+    def self.key_str(method)
+      case method_arguments(method)
+      when SPLAT then "args"
+      when DOUBLE_SPLAT then "kwargs"
+      when SPLAT_AND_DOUBLE_SPLAT then "[args, kwargs]"
+      when MULTIPLE_REQUIRED then "[#{method.parameters.map(&:last).join(', ')}]"
+      else
+        raise ArgumentError, "Unexpected arguments for #{method.name}"
+      end
     end
 
     # Find the original class for which the given class is the corresponding
@@ -159,9 +159,7 @@ module MemoWise
     #   Raises if `klass` is not a singleton class.
     #
     def self.original_class_from_singleton(klass)
-      unless klass.singleton_class?
-        raise ArgumentError, "Must be a singleton class: #{klass.inspect}"
-      end
+      raise ArgumentError, "Must be a singleton class: #{klass.inspect}" unless klass.singleton_class?
 
       # Search ObjectSpace
       #   * 1:1 relationship of singleton class to original class is documented
@@ -195,63 +193,11 @@ module MemoWise
     # @return [Class, Module]
     attr_reader :target
 
-    # Returns the "fetch key" for the given `method_name` and parameters, to be
-    # used to lookup the memoized results specifically for this method and these
-    # parameters.
-    #
-    # @param method_name [Symbol]
-    #   Name of method to derive the "fetch key" for, with given parameters.
-    # @param args [Array]
-    #   Zero or more positional parameters
-    # @param kwargs [Hash]
-    #   Zero or more keyword parameters
-    #
-    # @return [Array, Hash, Object]
-    #   Returns one of:
-    #     - An `Array` if only positional parameters.
-    #     - A nested `Array<Array, Hash>` if *both* positional and keyword.
-    #     - A `Hash` if only keyword parameters.
-    #     - A single object if there is only a single parameter.
-    def fetch_key(method_name, *args, **kwargs)
-      method = target_class.instance_method(method_name)
-
-      if MemoWise::InternalAPI.has_only_required_args?(method)
-        key = method.parameters.map.with_index do |(type, name), index|
-          type == :req ? args[index] : kwargs[name]
-        end
-        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)
-          [method_name, args, kwargs].hash
-        elsif has_arg
-          args.hash
-        else
-          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
+    # @param method_name [Symbol] the name of the memoized method
+    # @return [Integer] the array index in `@_memo_wise_indices` to use to find
+    #   the memoization data for the given method
+    def index(method_name)
+      target_class.instance_variable_get(:@_memo_wise_indices)[method_name]
     end
 
     # Returns visibility of an instance method defined on class `target`.
@@ -274,8 +220,7 @@ module MemoWise
       elsif target.public_method_defined?(method_name)
         :public
       else
-        raise ArgumentError,
-              "#{method_name.inspect} must be a method on #{target}"
+        raise ArgumentError, "#{method_name.inspect} must be a method on #{target}"
       end
     end
 

data/lib/memo_wise/version.rb

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

data/lib/memo_wise.rb

@@ -25,7 +25,7 @@ require "memo_wise/version"
 #   - {.memo_wise} for API and usage examples.
 #   - {file:README.md} for general project information.
 #
-module MemoWise # rubocop:disable Metrics/ModuleLength
+module MemoWise
   # Constructor to set up memoization state before
   # [calling the original](https://medium.com/@jeremy_96642/ruby-method-auditing-using-module-prepend-4f4e69aacd95)
   # constructor.
@@ -91,7 +91,7 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
   #     prepend MemoWise
   #   end
   #
-  def self.prepended(target) # rubocop:disable Metrics/PerceivedComplexity
+  def self.prepended(target)
     class << target
       # Allocator to set up memoization state before
       # [calling the original](https://medium.com/@jeremy_96642/ruby-method-auditing-using-module-prepend-4f4e69aacd95)
@@ -111,7 +111,7 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
       end
 
       # NOTE: See YARD docs for {.memo_wise} directly below this method!
-      def memo_wise(method_name_or_hash) # rubocop:disable Metrics/PerceivedComplexity
+      def memo_wise(method_name_or_hash)
         klass = self
         case method_name_or_hash
         when Symbol
@@ -156,100 +156,87 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
           klass = klass.singleton_class
         end
 
-        unless method_name.is_a?(Symbol)
-          raise ArgumentError, "#{method_name.inspect} must be a Symbol"
-        end
+        raise ArgumentError, "#{method_name.inspect} must be a Symbol" unless method_name.is_a?(Symbol)
 
         api = MemoWise::InternalAPI.new(klass)
         visibility = api.method_visibility(method_name)
-        original_memo_wised_name =
-          MemoWise::InternalAPI.original_memo_wised_name(method_name)
+        original_memo_wised_name = MemoWise::InternalAPI.original_memo_wised_name(method_name)
         method = klass.instance_method(method_name)
 
         klass.send(:alias_method, original_memo_wised_name, method_name)
         klass.send(:private, original_memo_wised_name)
 
-        # Zero-arg methods can use simpler/more performant logic because the
-        # hash key is just the method name.
-        if method.arity.zero?
+        method_arguments = MemoWise::InternalAPI.method_arguments(method)
+        # `@_memo_wise_indices` stores the `@_memo_wise` indices of different
+        # method names. We only use this data structure when resetting or
+        # presetting memoization. It looks like:
+        #   {
+        #     single_arg_method_name: 0,
+        #     other_single_arg_method_name: 1
+        #   }
+        memo_wise_indices = klass.instance_variable_get(:@_memo_wise_indices)
+        memo_wise_indices ||= klass.instance_variable_set(:@_memo_wise_indices, {})
+        index = klass.instance_variable_get(:@_memo_wise_index_counter) || 0
+
+        memo_wise_indices[method_name] = index
+        klass.instance_variable_set(:@_memo_wise_index_counter, index + 1)
+
+        case method_arguments
+        when MemoWise::InternalAPI::NONE
+          # Zero-arg methods can use simpler/more performant logic because the
+          # hash key is just the method name.
           klass.module_eval <<-END_OF_METHOD, __FILE__, __LINE__ + 1
             def #{method_name}
-              output = @_memo_wise[:#{method_name}]
-              if output || @_memo_wise.key?(:#{method_name})
-                output
+              _memo_wise_output = @_memo_wise[#{index}]
+              if _memo_wise_output || @_memo_wise_sentinels[#{index}]
+                _memo_wise_output
               else
-                @_memo_wise[:#{method_name}] = #{original_memo_wised_name}
+                @_memo_wise_sentinels[#{index}] = true
+                @_memo_wise[#{index}] = #{original_memo_wised_name}
               end
             end
           END_OF_METHOD
-        else
-          if MemoWise::InternalAPI.has_only_required_args?(method)
-            args_str = method.parameters.map do |type, name|
-              "#{name}#{':' if type == :keyreq}"
-            end.join(", ")
-            args_str = "(#{args_str})"
-            call_str = method.parameters.map do |type, name|
-              type == :req ? name : "#{name}: #{name}"
-            end.join(", ")
-            call_str = "(#{call_str})"
-            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.
-            # See: <link>
-            # By only including logic for *args, **kwargs when they are used in
-            # the method, we can avoid allocating unnecessary arrays and hashes.
-            has_arg = MemoWise::InternalAPI.has_arg?(method)
-
-            if has_arg && MemoWise::InternalAPI.has_kwarg?(method)
-              args_str = "(*args, **kwargs)"
-              fetch_key_init = "[:#{method_name}, args, kwargs].hash"
-              use_hashed_key = true
-            elsif has_arg
-              args_str = "(*args)"
-              fetch_key_init = "args.hash"
-            else
-              args_str = "(**kwargs)"
-              fetch_key_init = "kwargs.hash"
-            end
-          end
+        when MemoWise::InternalAPI::ONE_REQUIRED_POSITIONAL, MemoWise::InternalAPI::ONE_REQUIRED_KEYWORD
+          key = method.parameters.first.last
 
-          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
+          klass.module_eval <<-END_OF_METHOD, __FILE__, __LINE__ + 1
+            def #{method_name}(#{MemoWise::InternalAPI.args_str(method)})
+              _memo_wise_hash = (@_memo_wise[#{index}] ||= {})
+              _memo_wise_output = _memo_wise_hash[#{key}]
+              if _memo_wise_output || _memo_wise_hash.key?(#{key})
+                _memo_wise_output
+              else
+                _memo_wise_hash[#{key}] = #{original_memo_wised_name}(#{MemoWise::InternalAPI.call_str(method)})
               end
-            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_OF_METHOD
+        # MemoWise::InternalAPI::MULTIPLE_REQUIRED, MemoWise::InternalAPI::SPLAT,
+        # MemoWise::InternalAPI::DOUBLE_SPLAT, MemoWise::InternalAPI::SPLAT_AND_DOUBLE_SPLAT
+        else
+          # NOTE: When benchmarking this implementation against something like:
+          #
+          #   @_memo_wise.fetch(key) do
+          #     ...
+          #   end
+          #
+          # this implementation may sometimes perform worse than the above. This
+          # is because this case uses a more complex hash key (see
+          # `MemoWise::InternalAPI.key_str`), and hashing that key has less
+          # consistent performance. In general, this should still be faster for
+          # truthy results because `Hash#[]` generally performs hash lookups
+          # faster than `Hash#fetch`.
+          klass.module_eval <<-END_OF_METHOD, __FILE__, __LINE__ + 1
+            def #{method_name}(#{MemoWise::InternalAPI.args_str(method)})
+              _memo_wise_hash = (@_memo_wise[#{index}] ||= {})
+              _memo_wise_key = #{MemoWise::InternalAPI.key_str(method)}
+              _memo_wise_output = _memo_wise_hash[_memo_wise_key]
+              if _memo_wise_output || _memo_wise_hash.key?(_memo_wise_key)
+                _memo_wise_output
+              else
+                _memo_wise_hash[_memo_wise_key] = #{original_memo_wised_name}(#{MemoWise::InternalAPI.call_str(method)})
               end
-            END_OF_METHOD
-          end
+            end
+          END_OF_METHOD
         end
 
         klass.send(visibility, method_name)
@@ -275,8 +262,7 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
       # (`...` or `*args, **kwargs`), making reflection on method parameters
       # useless without this.
       def target.instance_method(symbol)
-        original_memo_wised_name =
-          MemoWise::InternalAPI.original_memo_wised_name(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`,
@@ -368,7 +354,6 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
   #     Example.method_called_times #=> nil
   ##
 
-  # rubocop:disable Layout/LineLength
   ##
   # @!method self.reset_memo_wise(method_name = nil, *args, **kwargs)
   #   Implementation of {#reset_memo_wise} for class methods.
@@ -402,7 +387,6 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
   #
   #     Example.reset_memo_wise # reset "all methods" mode
   ##
-  # rubocop:enable Layout/LineLength
 
   # Presets the memoized result for the given method to the result of the given
   # block.
@@ -455,26 +439,35 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
   #   ex.method_called_times #=> nil
   #
   def preset_memo_wise(method_name, *args, **kwargs)
-    unless block_given?
-      raise ArgumentError,
-            "Pass a block as the value to preset for #{method_name}, #{args}"
-    end
+    raise ArgumentError, "Pass a block as the value to preset for #{method_name}, #{args}" unless block_given?
 
     api = MemoWise::InternalAPI.new(self)
     api.validate_memo_wised!(method_name)
 
-    if method(method_name).arity.zero?
-      @_memo_wise[method_name] = yield
-    else
-      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
+    method = method(method_name)
+    method_arguments = MemoWise::InternalAPI.method_arguments(method)
+    index = api.index(method_name)
+
+    if method_arguments == MemoWise::InternalAPI::NONE
+      @_memo_wise_sentinels[index] = true
+      @_memo_wise[index] = yield
+      return
+    end
+
+    hash = (@_memo_wise[index] ||= {})
+
+    case method_arguments
+    when MemoWise::InternalAPI::ONE_REQUIRED_POSITIONAL then hash[args.first] = yield
+    when MemoWise::InternalAPI::ONE_REQUIRED_KEYWORD then hash[kwargs.first.last] = yield
+    when MemoWise::InternalAPI::SPLAT then hash[args] = yield
+    when MemoWise::InternalAPI::DOUBLE_SPLAT then hash[kwargs] = yield
+    when MemoWise::InternalAPI::MULTIPLE_REQUIRED
+      key = method.parameters.map.with_index do |(type, name), idx|
+        type == :req ? args[idx] : kwargs[name]
       end
+      hash[key] = yield
+    else # MemoWise::InternalAPI::SPLAT_AND_DOUBLE_SPLAT
+      hash[[args, kwargs]] = yield
     end
   end
 
@@ -543,45 +536,66 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
   #
   #   ex.reset_memo_wise # reset "all methods" mode
   #
-  def reset_memo_wise(method_name = nil, *args, **kwargs) # rubocop:disable Metrics/PerceivedComplexity
+  def reset_memo_wise(method_name = nil, *args, **kwargs)
     if method_name.nil?
-      unless args.empty?
-        raise ArgumentError, "Provided args when method_name = nil"
-      end
-
-      unless kwargs.empty?
-        raise ArgumentError, "Provided kwargs when method_name = nil"
-      end
+      raise ArgumentError, "Provided args when method_name = nil" unless args.empty?
+      raise ArgumentError, "Provided kwargs when method_name = nil" unless kwargs.empty?
 
       @_memo_wise.clear
-      @_memo_wise_hashes.clear
+      @_memo_wise_sentinels.clear
       return
     end
 
-    unless method_name.is_a?(Symbol)
-      raise ArgumentError, "#{method_name.inspect} must be a Symbol"
-    end
-
-    unless respond_to?(method_name, true)
-      raise ArgumentError, "#{method_name} is not a defined method"
-    end
+    raise ArgumentError, "#{method_name.inspect} must be a Symbol" unless method_name.is_a?(Symbol)
+    raise ArgumentError, "#{method_name} is not a defined method" unless respond_to?(method_name, true)
 
     api = MemoWise::InternalAPI.new(self)
     api.validate_memo_wised!(method_name)
 
-    if args.empty? && kwargs.empty?
-      @_memo_wise.delete(method_name)
-      @_memo_wise_hashes[method_name]&.each do |hash|
-        @_memo_wise.delete(hash)
+    method = method(method_name)
+    method_arguments = MemoWise::InternalAPI.method_arguments(method)
+    index = api.index(method_name)
+
+    case method_arguments
+    when MemoWise::InternalAPI::NONE
+      @_memo_wise_sentinels[index] = nil
+      @_memo_wise[index] = nil
+    when MemoWise::InternalAPI::ONE_REQUIRED_POSITIONAL
+      if args.empty?
+        @_memo_wise[index]&.clear
+      else
+        @_memo_wise[index]&.delete(args.first)
+      end
+    when MemoWise::InternalAPI::ONE_REQUIRED_KEYWORD
+      if kwargs.empty?
+        @_memo_wise[index]&.clear
+      else
+        @_memo_wise[index]&.delete(kwargs.first.last)
+      end
+    when MemoWise::InternalAPI::SPLAT
+      if args.empty?
+        @_memo_wise[index]&.clear
+      else
+        @_memo_wise[index]&.delete(args)
       end
-      @_memo_wise_hashes.delete(method_name)
-    else
-      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)
+    when MemoWise::InternalAPI::DOUBLE_SPLAT
+      if kwargs.empty?
+        @_memo_wise[index]&.clear
       else
-        @_memo_wise[method_name]&.delete(key)
+        @_memo_wise[index]&.delete(kwargs)
+      end
+    else # MemoWise::InternalAPI::MULTIPLE_REQUIRED, MemoWise::InternalAPI::SPLAT_AND_DOUBLE_SPLAT
+      if args.empty? && kwargs.empty?
+        @_memo_wise[index]&.clear
+      else
+        key = if method_arguments == MemoWise::InternalAPI::SPLAT_AND_DOUBLE_SPLAT
+                [args, kwargs]
+              else
+                method.parameters.map.with_index do |(type, name), i|
+                  type == :req ? args[i] : kwargs[name] # rubocop:disable Metrics/BlockNesting
+                end
+              end
+        @_memo_wise[index]&.delete(key)
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: memo_wise
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Panorama Education
@@ -11,7 +11,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-07-30 00:00:00.000000000 Z
+date: 2021-11-10 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -69,7 +69,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.2.22
 signing_key:
 specification_version: 4
 summary: The wise choice for Ruby memoization