Package memo provides a simple memoization utility to cache function results.

The package offers a Memoizer type that can cache function results based on keys, with optional validation of cached values. This is useful for expensive computations that need to be cached and potentially invalidated based on custom conditions.

It is the B+ tree successor to gno.land/p/moul/memo/v0 (which is backed by an AVL tree): a bump to v3 because the backing data structure — and thus the on-chain storage layout — changed. The exported API is identical to v2 (New/Memoize/MemoizeWithValidator/Invalidate/Clear/Size). A B+ tree packs many entries per persisted node, so it costs materially less storage and gas per cached entry — prefer v3 when the cache is part of persisted realm state.

Because the B+ tree backing mutates in place (the AVL backing was copy-on-write), do NOT invalidate or add entries to the same Memoizer from inside a callback that is iterating it, and do NOT copy a non-zero Memoizer by value.

/!\ Important Warning for Gno Usage: In Gno, storage updates only persist during transactions. This means:

• Cache entries created during queries will NOT persist
• Creating cache entries during queries will actually decrease performance as it wastes resources trying to save data that won't be saved

Best Practices: - Use this pattern in transaction-driven contexts rather than query/render scenarios - Consider controlled cache updates, e.g., by specific accounts (like oracles) - Ideal for cases where cache updates happen every N blocks or on specific events - Carefully evaluate if caching will actually improve performance in your use case

Basic usage example:

 1m := memo.New()
 2
 3// Cache expensive computation
 4result := m.Memoize("key", func() any {
 5    // expensive operation
 6    return "computed-value"
 7})
 8
 9// Subsequent calls with same key return cached result
10result = m.Memoize("key", func() any {
11    // function won't be called, cached value is returned
12    return "computed-value"
13})

Example with validation:

 1type TimestampedValue struct {
 2    Value     string
 3    Timestamp time.Time
 4}
 5
 6m := memo.New()
 7
 8// Cache value with timestamp
 9result := m.MemoizeWithValidator(
10    "key",
11    func() any {
12        return TimestampedValue{
13            Value:     "data",
14            Timestamp: time.Now(),
15        }
16    },
17    func(cached any) bool {
18        // Validate that the cached value is not older than 1 hour
19        if tv, ok := cached.(TimestampedValue); ok {
20            return time.Since(tv.Timestamp) < time.Hour
21        }
22        return false
23    },
24)