That said, its a bit of a trip to translate a definition like that into Clojure. The language provides (just about) everything you need to do so efficiently, but, well, see for yourself if you like where this ends up.

Here’s the closest expression of the initial definition as I could make it as a simple recursive fn

(defn Freqs [[x & ys :as coll] c]
  (cond
   (empty? coll) 0
   (= x c) (inc (Freqs ys c))
   :else (Freqs ys c)))

That definition will compute the entirety of Freqs every time you ask for c. It can avoid the repeated work by memoizing an anonymous function.

(defn fix [f]
  ((fn [makef]
     (fn [& args]
       (apply f (makef makef) args)))
   (fn [makef]
     (fn [& args]
       (apply f (makef makef) args)))))

(def Freqs
  (memoize (fix (fn [recurse [x & ys :as coll] c]
                  (cond
                   (empty? coll) 0
                   (= x c) (inc (recurse ys c))
                   :else (recurse ys c))))))

Thankfully, Clojure lets you name anonymous functions so that you don’t have to resort to a fixed-point combinator.

(def Freqs
  (memoize (fn thisfn [[x & ys :as coll] c]
             (cond
              (empty? coll) 0
              (= x c) (inc (thisfn ys c))
              :else (thisfn ys c)))))

This solution still consumes stack every time we recurse and will be unable to compute Freqs on very large seqs.

(Freqs (take 10000 (repeatedly #(rand-int 10))) 7)
=> StackOverflowError

To get around that, we can use Clojure’s `trampoline` to the mix to solve it in this style.

(defn sequentially [thunk f]
  (if (fn? thunk)
    (fn [] (sequentially (thunk) f))
    (f thunk)))

(def Freqs
  (memoize (fn [coll c]
             (trampoline
              (fn thisfn [[x & ys :as coll] c]
                (cond
                 (empty? coll) 0
                 (= x c) (sequentially (fn [] (thisfn ys c)) inc)
                 :else (fn [] (thisfn ys c))))
              coll c))))

However, we’re still left computing the whole of Freqs for every unique c that we pass to the function. I believe that’s still true even if we write this solution in Haskell, which will result in code that looks virtually identical to your mathematical notation and doesn’t have to manually perform the memoization and trampolining backflips above But, if you only use the function once then maybe the increased readability is worth the performance hit

If you’re interested in a solution that clearly communicates the idea behind the solution, use the mathematical notation, but if you want to run this code, take the advice of commenters above and use clojure.core/frequencies.

Freqs(())[c] = 0

Freqs(x.ys)[c] = Freqs(ys)[c] + (1 if x = c else 0).

Don’t underestimate the power of recursion.

Even when you’re not using it explicitly, you are probably using some built-in function which does (e.g. reduce).

you should properly format the code under rule #1. The “(let” line needs to have the same indentation as the last line that starts with “counts”, otherwise it’s hard to recognize as the 2 branches of the if-not.

The threading ops make this kind of error impossible, while maintaining code clarity. Not using them is a big mistake. They exist to reduce errors, reduce excess typing, and signal to code readers that a transformation is taking place. Not using them due to dogma is a mistake.