Compare and contrast unclebob/functor ur example and different implementation tradeoffs

ex.clj

;; Baseline

(defn encrypt-if-direct-message [content tags]
  (if (re-find #"^D \#\[\d+\]" content)
    (let [reference-digits (re-find #"\d+" content)
          reference-index (Integer/parseInt reference-digits)
          p-tag (get tags reference-index)]
      (if (nil? p-tag)
        [content 1]
        (let [recipient-key (hex-string->num (second p-tag))
              private-key (get-mem [:keys :private-key])
              sender-key (hex-string->num private-key)
              shared-secret (SECP256K1/calculateKeyAgreement sender-key recipient-key)
              encrypted-content (SECP256K1/encrypt shared-secret content)]
          [encrypted-content 4])))
    [content 1]))

;; Functor

(def encrypt-if-direct-message
  (functor
    ([content tags]
     (if (is-direct?)
       (encrypt-if-properly-referenced)
       (leave-unencrypted)))

    (is-direct? [] (re-find #"^D \#\[\d+\]" content))

    (get-p-tag-from-content
      []
      (let [reference-digits (re-find #"\d+" content)
            reference-index (Integer/parseInt reference-digits)]
        (get tags reference-index)))

    (encrypt-content
      []
      (let [recipient-key (hex-string->num (second p-tag))
            private-key (get-mem [:keys :private-key])
            sender-key (hex-string->num private-key)
            shared-secret (SECP256K1/calculateKeyAgreement sender-key recipient-key)]
        (SECP256K1/encrypt shared-secret content)))

    (encrypt-if-properly-referenced
      []
      (<- p-tag (get-p-tag-from-content))
      (if (nil? p-tag)
        [content 1]
        [(encrypt-content) 4]))

    (leave-unencrypted [] [content 1])))

;; Factor to functions

(defn- direct? [content]
  (re-find #"^D \#\[\d+\]" content))

(defn- get-p-tag-from-content
  [content tags]
  (let [reference-digits (re-find #"\d+" content)
        reference-index (Integer/parseInt reference-digits)]
    (get tags reference-index)))

(defn- encrypt-content
  [content p-tag]
  (let [recipient-key (hex-string->num (second p-tag))
        private-key (get-mem [:keys :private-key])
        sender-key (hex-string->num private-key)
        shared-secret (SECP256K1/calculateKeyAgreement sender-key recipient-key)]
    (SECP256K1/encrypt shared-secret content)))

(defn- encrypt-if-properly-referenced [content tags]
  (let [p-tag (get-p-tag-from-content content tags)]
    (if (nil? p-tag)
      [content 1]
      [(encrypt-content content p-tag) 4])))

(defn- leave-unencrypted [content] [content 1])

(defn encrypt-if-direct-message
  [content tags]
  (if (direct? content)
    (encrypt-if-properly-referenced content tags)
    (leave-unencrypted content)))

I'm not too concerned about the mental overhead for small functors. Large functors should be avoided, period.
The testability issue is more concerning. However, so long as functors are small tests should be conducted through the main functor rather than the individual subfunctions. This is similar to the argument that tests should only go through public functions not through private functions.

My inner pessimist just knows those functors won't remain small.
I also adopted a weird approach where I tend to avoid private functions. I prefer moving them to an impl namespace. This makes testing more convenient, and also shows some more trust in the user.

On another subject, for performance, you could replace the lazily initialized vars backing refs with an array of size 1. That would allow you to pass primitive args, too.

If you want to avoid the allocated functions in lets, you can use them as templates and inline them. But inlining is both risky and hard

Another point brought up on Slack by @alexander-yakushev: less REPL friendly, which is somewhat associated with it being less test friendly. I can imagine wanting to tinker with the regex and having a lot of unnecessary concerns mixed in while I figure out the right regex and edge cases.