Memoize

Memoize is a lightweight PHP library designed to handle memoization with ease.

#🚀 About Memoize

Memoize is a lightweight PHP library designed to implement memoization and function caching techniques with ease.

It allows you to optimize your application's performance by caching the results of expensive functions, avoiding repeated calculations when called with the same arguments.

Additionally, it provides specialized functionalities such as:

• Key-based memoization - Cache function results using custom keys for efficient retrieval
• Single execution functions - Execute functions only once and reuse the result in subsequent calls
• Simple and intuitive API - Facade and helper function for easy integration
• Cache management - Methods to check, remove, and clear cached values

#✨ Getting Started

#Basic memoization with memo()

You can memoize any callable function using the memo() method with a custom key. This will execute the callback only once and return the cached result on subsequent calls with the same key.

// Using the helper function
$result1 = memoize()->memo('expensive_calc', function () {
    sleep(2); // Simulates expensive operation
    return 42 * 1.5 + rand(1, 100);
});
 
// Second call with same key: returns cached result (fast)
$result2 = memoize()->memo('expensive_calc', function () {
    sleep(2); // This won't execute
    return 99999; // This value is ignored, cached value is returned
});
 
// $result1 === $result2 (same cached value)
 
// Different key: executes the function again
$result3 = memoize()->memo('another_calc', function () {
    return 'different calculation';
});

#Single execution with once()

For functions that should only be executed once regardless of how many times they are called, use the once() method.

// Expensive initialization function
$initializeDatabase = function () {
    echo "Initializing database...\n";
    sleep(3);
    return "Connection established";
};
 
// Create function that executes only once
$memoizedInit = memoize()->once($initializeDatabase);
 
// First call: executes the function
$connection1 = $memoizedInit(); // "Initializing database..." + 3 seconds
 
// Subsequent calls: return cached result
$connection2 = $memoizedInit(); // Instant, no output
$connection3 = $memoizedInit(); // Instant, no output
 
// All variables contain the same value: "Connection established"

#Cache management

The library provides methods to manage the memoized values:

// Check if a key exists
if (memoize()->has('my_key')) {
    echo "Value is cached";
}
 
// Remove a specific cached value
$removed = memoize()->forget('my_key'); // Returns true if existed
 
// Get all cached keys
$keys = memoize()->keys(); // Returns array of keys
 
// Clear all cached values
memoize()->flush();

#Practical use cases

#User data caching

$getUserData = function ($userId) {
    // Expensive database query or API call
    return database()->query("SELECT * FROM users WHERE id = ?", [$userId]);
};
 
// Cache user data by ID
$user = memoize()->memo("user_$userId", $getUserData);
$sameUser = memoize()->memo("user_$userId", $getUserData); // From cache

#Configuration loading

$loadConfig = function () {
    $config = [];
    foreach (glob('config/*.php') as $file) {
        $config = array_merge($config, require $file);
    }
    return $config;
};
 
// Load configuration only once
$config = memoize()->memo('app_config', $loadConfig);
$configAgain = memoize()->memo('app_config', $loadConfig); // From cache

#Expensive calculations

// Complex calculation that takes time
$complexCalculation = function ($data) {
    sleep(5); // Simulate heavy processing
    return array_sum(array_map(fn($x) => $x ** 2, $data));
};
 
$data = range(1, 1000);
$result = memoize()->memo('calculation_' . md5(serialize($data)), function () use ($complexCalculation, $data) {
    return $complexCalculation($data);
});

#One-time initialization

// Initialize third-party services only once
$initializeServices = memoize()->once(function () {
    // Heavy initialization
    return [
        'logger' => new Logger(),
        'cache' => new CacheManager(),
        'mailer' => new MailService()
    ];
});
 
$services = $initializeServices(); // Initializes
$sameServices = $initializeServices(); // From cache

#Performance and optimization

Memoization is especially useful for:

• Expensive database queries - Cache results for repeated queries
• API calls - Reduce HTTP requests for the same data
• File processing - Cache parsing or transformation results
• Complex calculations - CPU-intensive operations
• Configuration loading - Load settings once per request

#Performance example

// Without memoization - executes every time
$start = microtime(true);
for ($i = 0; $i < 100; $i++) {
    $result = expensiveFunction(); // Takes 100ms each
}
$timeWithoutMemo = microtime(true) - $start; // ~10 seconds
 
// With memoization - executes only once
$start = microtime(true);
for ($i = 0; $i < 100; $i++) {
    $result = memoize()->memo('expensive_key', fn() => expensiveFunction());
}
$timeWithMemo = microtime(true) - $start; // ~100ms
 
echo "Improvement: " . round($timeWithoutMemo / $timeWithMemo) . "x faster";

#Ways of using Memoize

You can use Memoize either with the helper function memoize():

// Using the helper function
$result = memoize()->memo('key', $callback);
$onceFunction = memoize()->once($callback);
memoize()->flush();

or by directly invoking the static methods of the Memoize facade:

use Tomloprod\Memoize\Support\Facades\Memoize;
 
// Using the facade
$result = Memoize::memo('key', $callback);
$onceFunction = Memoize::once($callback);
Memoize::flush();

#Available Methods

#🚀 Installation & Requirements

Requires PHP 8.2+

You may use Composer to install Memoize into your PHP project:

composer require tomloprod/memoize

#🧑‍🤝‍🧑 Contributing

Contributions are welcome, and are accepted via pull requests. Please review these guidelines before submitting any pull requests.

Memoize was created by Tomás López and open-sourced under the MIT license.