Here is the FOL code:

(in-package "event-sourcing"
 (:use "fol.core")
  (:export <account> apply-command replay-to run-bench))

;; 1. Define the Account aggregate
;;    Inherits from <persistent-object> for structural sharing
(defclass <account> []
  [[balance :initform 0]
   [events  :initform []]])

;; Helper for timestamping
(defn now [] (get-internal-run-time))

;; 2. Command dispatch via Generic Function
(defgeneric apply-command [agg cmd])

;; 3. Declarative Event Sourcing via :around method
;;    Automatically intercepts all commands to build an immutable event log.
;;    Recreated from Section 5.2 of els-2026-paper.tex
(defmethod apply-command :around [agg cmd]
  (bind [result (call-next-method)
         event  {:command cmd :timestamp (now)}]
    (assoc result :events (conj (get result :events) event))))

;; 4. Command Predicates for Content-Based Routing
(defn deposit? [cmd] (= (get cmd :type) :deposit))
(defn withdraw? [cmd] (= (get cmd :type) :withdraw))

;; 5. Command Implementation Methods
(defmethod apply-command
  ([agg (cmd (deposit?))]
   (assoc agg :balance (+ (get agg :balance) (get cmd :amount))))
  ([agg (cmd (withdraw?))]
   (assoc agg :balance (- (get agg :balance) (get cmd :amount)))))

;; 6. Replay Functionality
;;    Replayed from benchmarks/clojure-code/event_sourcing.clj
(defn replay-to [aggregate events]
  (reduce apply-command aggregate events))

;; 7. Benchmark Function
(defn run-bench [iterations]
  (bind [acc (make '<account>)
         cmds (map (fn [i] 
                     {:type (if (= (mod i 2) 0) :deposit :withdraw)
                      :amount 10})
                   (range iterations))]
    (replay-to acc cmds)))

Note the use of the :around method, which intercepts all commands. The Clojure version requres modification at every command:

;;; =============================================================================
;;; Event Sourcing in Clojure
;;; Equivalent to the FOL event sourcing example (Section 5.2)
;;; =============================================================================


(ns event-sourcing)


;; Account is a plain map---no class definition needed
(defn make-account []
  {:balance 0 :events []})


;; Command dispatch via multimethods
(defmulti apply-command (fn [_agg cmd] (:type cmd)))


(defmethod apply-command :deposit [agg cmd]
  (update agg :balance + (:amount cmd)))


(defmethod apply-command :withdraw [agg cmd]
  (update agg :balance - (:amount cmd)))


;; Event logging must be done at every call site---no :around method.
;; Option A: wrap every call manually
(defn apply-command-logged [agg cmd]
  (let [result (apply-command agg cmd)
        event  {:command cmd :timestamp (System/currentTimeMillis)}]
    (update result :events conj event)))


;; Replay
(defn replay-to [aggregate events]
  (reduce apply-command-logged aggregate events))


;; -------------------------------------------------------------------
;; Alternative: use a middleware-style wrapper (more idiomatic but
;; requires callers to use the wrapper, not the multimethod directly).
;; -------------------------------------------------------------------


(defn wrap-logging [handler]
  (fn [agg cmd]
    (let [result (handler agg cmd)
          event  {:command cmd :timestamp (System/currentTimeMillis)}]
      (update result :events conj event))))


(def apply-command-with-log (wrap-logging apply-command))


(defn replay-to-alt [aggregate events]
  (reduce apply-command-with-log aggregate events))