memoize cache expiration policy: missing TTL implementation

Answer

There is no built-in TTL (Time-To-Live) support in clojure.core/memoize. The cache is stored in a private atom that is not exposed via the public API; attempting to access or mutate this internal state is unsupported and may lead to failures in future Clojure releases. To enforce an expiration policy, you must implement a custom wrapper that manages a cache map of args → [value timestamp] and handles eviction either during read access or via a background process.

Implementation Pattern

The following pattern replaces the standard memoize with a TTL-aware wrapper. It uses an atom to ensure thread-safe updates and a scheduled executor for periodic cleanup.

(defn memoize-with-ttl
  "Returns a memoized version of f with a TTL in milliseconds."
  [f ttl-ms]
  (let [cache (atom {})
        prune-fn (fn []
                   (let [now (System/currentTimeMillis)]
                     (swap! cache
                            (fn [m]
                              (into {} (filter (fn [[_ [v ts]]
                                                (<= (- now ts) ttl-ms)) m))))))]
    (let [scheduler (java.util.concurrent.Executors/newSingleThreadScheduledExecutor)
          _ (scheduler/scheduleAtFixedRate scheduler
                                           prune-fn
                                           ttl-ms ttl-ms
                                           java.util.concurrent.TimeUnit/MILLISECONDS)]
      (fn [& args]
        (let [now (System/currentTimeMillis)
              cached (get @cache args)]
          (if (and cached
                   (<= (- now (second cached)) ttl-ms))
            (first cached)
            (let [res (apply f args)]
              (swap! cache assoc args [res now])
              res)))))))

Technical Considerations

• Thread Safety: By using swap! for all mutations, the implementation remains thread-safe. Concurrent reads are non-blocking as they operate on the current state of the atom.
• Memory Management: Memory usage scales with the number of unique argument vectors. The background prune task prevents unbounded growth by removing stale entries.
• Scheduling: The ScheduledExecutorService should be configured as a daemon thread or explicitly shut down during application termination to avoid leaking JVM resources.
• Clock Drift: For high-precision requirements, consider using a monotonic clock instead of System/currentTimeMillis to avoid issues during system time adjustments.

Verification

To verify the implementation, memoize a function that returns a timestamp. Call it twice within the TTL to confirm the cached value is returned, then wait for the TTL to expire and verify that the subsequent call returns a fresh value.

Diagnostic Question

Do you require a global expiration for the entire cache, or must each unique set of arguments have its own independent TTL timer?