feat: add support for scalar key types in memoization methods (#3)

- Accept string|int|float|null keys in memo(), forget(), and has() methods
- Automatically convert numeric keys to string internally for consistency

Author: tomloprod

README.md

@@ -90,7 +90,7 @@ You can also not use namespaces and just memoize keys.
 // Expensive API call cached by key
 $weather = memoize()->memo(
     'weather_london', 
-    fn() => Http::get('api.weather.com/london'->json()
+    fn() => Http::get('api.weather.com/london')->json()
 );
 
 // Database query with dynamic key
@@ -286,7 +286,7 @@ $salesReport = memoize()->memo(
 <tr><td width="30%"><strong>Method</strong></td><td><strong>Description</strong></td></tr>
 <tr><td>
 
-**memo(?string $key, callable $callback)**
+**memo(string|int|float|null $key, callable $callback)**
 
 </td><td>
 
@@ -319,12 +319,12 @@ $salesReport = memoize()->memo(
 <tr><td width="30%"><strong>Method</strong></td><td><strong>Description</strong></td></tr>
 <tr><td>
 
-**has(string $key): bool**
+**has(string|int|float $key): bool**
 
 </td><td>Check if a key exists in cache</td></tr>
 <tr><td>
 
-**forget(string $key): bool**
+**forget(string|int|float $key): bool**
 
 </td><td>Remove specific key from cache</td></tr>
 <tr><td>

src/Services/MemoizeManager.php

@@ -66,23 +66,26 @@ public function for(string $class): self
      * This prevents repeated cache hits within the same execution, significantly
      * improving performance.
      *
-     * @param  string|null  $key  Cache key (null returns null when namespace is set)
+     * @param  string|int|float|null  $key  Cache key (null returns null when namespace is set)
      * @param  callable  $callback  Function to execute if value is not memoized
      */
-    public function memo(?string $key, callable $callback): mixed
+    public function memo(string|int|float|null $key, callable $callback): mixed
     {
         // Handle null key with namespace: return null without executing callback
-        if ($key === null && $this->namespace !== null) {
+        if (($key === null || $key === '') && $this->namespace !== null) {
             $this->namespace = null;
 
             return null;
         }
 
         // Handle null key without namespace: throw exception (backward compatibility)
-        if ($key === null) {
+        if ($key === null || $key === '') {
             throw new InvalidArgumentException('Key cannot be null when no namespace is set');
         }
 
+        // Convert key to string for consistent handling
+        $key = (string) $key;
+
         // Build namespaced key if namespace is set
         $namespacedKey = $this->buildNamespacedKey($this->namespace, $key);
 
@@ -120,12 +123,12 @@ public function memo(?string $key, callable $callback): mixed
     /**
      * Remove a specific memoized value by key.
      *
-     * @param  string  $key  Cache key to remove
+     * @param  string|int|float  $key  Cache key to remove
      * @return bool True if the key existed and was removed, false otherwise
      */
-    public function forget(string $key): bool
+    public function forget(string|int|float $key): bool
     {
-        $namespacedKey = $this->buildNamespacedKey($this->namespace, $key);
+        $namespacedKey = $this->buildNamespacedKey($this->namespace, (string) $key);
 
         if (array_key_exists($namespacedKey, $this->memoizedValues)) {
 
@@ -159,12 +162,12 @@ public function flush(): void
     /**
      * Check if a key exists in the memoized cache.
      *
-     * @param  string  $key  Cache key to check
+     * @param  string|int|float  $key  Cache key to check
      * @return bool True if the key exists, false otherwise
      */
-    public function has(string $key): bool
+    public function has(string|int|float $key): bool
     {
-        $namespacedKey = $this->buildNamespacedKey($this->namespace, $key);
+        $namespacedKey = $this->buildNamespacedKey($this->namespace, (string) $key);
 
         $result = array_key_exists($namespacedKey, $this->memoizedValues);
 

src/Support/Facades/Memoize.php

@@ -8,10 +8,10 @@
 use Tomloprod\Memoize\Services\MemoizeManager;
 
 /**
- * @method static mixed memo(?string $key, callable $callback)
- * @method static bool forget(string $key)
+ * @method static mixed memo(string|int|float|null $key, callable $callback)
+ * @method static bool forget(string|int|float $key)
  * @method static void flush()
- * @method static bool has(string $key)
+ * @method static bool has(string|int|float $key)
  * @method static array<string, MemoEntry> getMemoizedValues()
  * @method static callable once(callable $fn)
  * @method static void setMaxSize(?int $maxSize)

tests/Services/MemoizeManagerTest.php

@@ -775,3 +775,95 @@
     expect($entries)->toHaveKey('App\\Models\\User::key2');
     expect($entries)->toHaveKey('App\\Models\\User::key3');
 });
+
+test('memo works with integer keys', function (): void {
+    $manager = MemoizeManager::instance();
+    $manager->flush();
+
+    $callCount = 0;
+    $callback = function () use (&$callCount): string {
+        $callCount++;
+
+        return 'result_'.$callCount;
+    };
+
+    // Test with positive integer
+    $result1 = $manager->memo(123, $callback);
+    expect($result1)->toBe('result_1');
+    expect($callCount)->toBe(1);
+
+    // Should return memoized value
+    $result2 = $manager->memo(123, $callback);
+    expect($result2)->toBe('result_1');
+    expect($callCount)->toBe(1);
+
+    // Test with negative integer
+    $result3 = $manager->memo(-456, $callback);
+    expect($result3)->toBe('result_2');
+    expect($callCount)->toBe(2);
+
+    // Verify keys are stored as strings
+    $entries = $manager->getMemoizedValues();
+    expect($entries)->toHaveKey('123');
+    expect($entries)->toHaveKey('-456');
+});
+
+test('memo works with float keys', function (): void {
+    $manager = MemoizeManager::instance();
+    $manager->flush();
+
+    $callCount = 0;
+    $callback = function () use (&$callCount): string {
+        $callCount++;
+
+        return 'result_'.$callCount;
+    };
+
+    // Test with positive float
+    $result1 = $manager->memo(12.34, $callback);
+    expect($result1)->toBe('result_1');
+    expect($callCount)->toBe(1);
+
+    // Should return memoized value
+    $result2 = $manager->memo(12.34, $callback);
+    expect($result2)->toBe('result_1');
+    expect($callCount)->toBe(1);
+
+    // Verify keys are stored as strings
+    $entries = $manager->getMemoizedValues();
+    expect($entries)->toHaveKey('12.34');
+});
+
+test('different types with same string representation share same cache entry', function (): void {
+    $manager = MemoizeManager::instance();
+    $manager->flush();
+
+    // These should be the same entry since both convert to '123'
+    $manager->memo(123, fn (): string => 'integer_value');
+    $manager->memo('123', fn (): string => 'string_value');
+
+    // Should be only 1 entry since both convert to '123'
+    expect($manager->getMemoizedValues())->toHaveCount(1);
+    expect($manager->memo(123, fn (): string => 'should_not_execute'))->toBe('integer_value');
+    expect($manager->memo('123', fn (): string => 'should_not_execute'))->toBe('integer_value');
+});
+
+test('forget and has work with numeric keys', function (): void {
+    $manager = MemoizeManager::instance();
+    $manager->flush();
+
+    $manager->memo(123, fn (): string => 'int_value');
+    $manager->memo(45.67, fn (): string => 'float_value');
+
+    expect($manager->has(123))->toBe(true);
+    expect($manager->has(45.67))->toBe(true);
+    expect($manager->has('123'))->toBe(true); // Same as int 123
+    expect($manager->has('45.67'))->toBe(true); // Same as float 45.67
+
+    expect($manager->forget(123))->toBe(true);
+    expect($manager->has(123))->toBe(false);
+    expect($manager->has('123'))->toBe(false); // Also false since it's the same key
+
+    expect($manager->forget(45.67))->toBe(true);
+    expect($manager->has(45.67))->toBe(false);
+});