Tail recursive FizzBuzz in Common Lisp I solved FizzBuzz using tail recursion. Is it efficient enough?

(defun mod-3 (n)
   (zerop (mod n 3)))

(defun mod-5 (n)
  (zerop (mod n 5)))


(defun analyzer (n)
  (if (mod-3 n)
  (if (mod-5 n)
      'fizzbuzz
      'fizz)
  (if (mod-5 n)
      'buzz
      n)))


(defun fizzbuzz (limit)
  (fizzbuzz-helper limit nil))


(defun fizzbuzz-helper (limit result)
  (cond ((zerop limit) result)
    (t (fizzbuzz-helper (- limit 1)
            (cons (analyzer limit) result)))))
When a function does too little...
I personally find that your mod-3 and mod-5 functions do something so very specific that you may as well at least combine them into a generic function.
I would call them something different, because what your functions are really doing is not a modulus (there's already a mod function for that), it's verifying if a number is evenly divisible by another number. I would write something like this:
(defun evenly-divisible-by (n x)
  &quot;Given divisor n and dividend x, returns true if x ÷ n has no remainder.&quot;
  (zerop (mod x n)))


analyzer
This function's name really doesn't say much to the next person reading the code. What does it analyze? Why? What goal is it trying to achieve? I think a name like calc-fizzbuzz-for-n would honestly be much more clear about (1) the action &quot;calc&quot; and (2) the expected result from the action &quot;fizzbuzz&quot;.
In this function, the indentation you applied is a bit misleading. I added some comments below to illustrate:

(defun calc-fizzbuzz (n)
  (if (evenly-divisible-by 3 n)
  ;then...
  (if (evenly-divisible-by 5 n)
      ;then...
      'fizzbuzz
      ;else...
      'fizz)
  ;else...
  (if (evenly-divisible-by 5 n)
    ;then...
    'buzz
    ;else...
      n)))


This seems minor for just a small indentation (and Lisp can make it seem more trivial since you have all those parentheses anyways), but if you wrote something like this in a more &quot;typical&quot; language, I would certainly expect it would be pointed out during a code review...

if (condA) {
if (condB) {
    foo.actionB();
} else {
    foo.actionA();
}
if (condC) {
    foo.ActionC();
} else {
    foo.defaultAction();
}
}


Applying above changes as well, I think this would be better:
(defun calc-fizzbuzz-for-n (n)
  &quot;Given a number n, return whether it is evenly divisible by 3 (fizz), 5 (buzz), 
  or both (fizzbuzz). Returns n when neither condition is true.&quot;
  (if (evenly-divisible-by 3 n)
      (if (evenly-divisible-by 5 n)
          'fizzbuzz
          'fizz)
      (if (evenly-divisible-by 5 n)
          'buzz
          n)))


Optional &amp; default values
As far as I can tell, the only purpose of the fizzbuzz function is to take a limit argument, then call fizzbuzz-helper with the limit and added nil for its result argument. This can be simplified by making the result argument optional, like so:
(defun fizzbuzz (limit &amp;optional result)

Note: I changed its name to fizzbuzz since it is no longer a &quot;helper&quot; to your original fizzbuzz function.
According to a related article on nullprogram.com:

If second and third arguments are not provided, b and c will be bound to nil. To provide a default argument, put that parameter inside a list. Below, when a third argument is not provided, c will be bound to &quot;bar&quot;.
(defun foo (a &amp;optional b (c &quot;bar&quot;))


So in your case, result will be nil unless it is provided a different argument. Alternatively, and as it appears to be the intention, you can force result to be nil by default using the let special operator:
(defun fizzbuzz (limit)
  (let (result) ;; defaults to nil if not specified
                ;; you can also do this if you find it more clear: (let ((result nil))
    (cond ;...


Alternative solution using lambda expression
This type of approach is often more idiomatic to Lisp/functional programming. You can use an anonymous function (a.k.a. lambda expression) as an argument to a map function. Your last line would look something like this:
(t (map 'list
        #'fizzbuzz
        (loop for i from 1 to limit by 1 collect i)))

or simpler:
(t (loop for i from 1 to limit collect (fizzbuzz i)))

More modern Lisps have a built-in range function to make things simpler, which Common Lisp doesn't; thankfully though, you can just write your own (code below from Stack Overflow answer Python's range() analog in Common Lisp):

(defun range (max &amp;key (min 0) (step 1))
   (loop for n from min below max by step
      collect n))


And your last line can simply become:
(t (map 'integer #'(lambda (N) (fizzbuzz N)) (range limit 1)))
Thanks to @Renzo for the correction,  your last function could be written as:
(defun fizzbuzz (limit) 
  (mapcar #'calc-fizzbuzz-for-n (range (1+ limit) :min 1)))

or using LOOP:
(defun fizzbuzz (limit) 
  (loop for n from 1 upto limit
        collect (calc-fizzbuzz-for-n n)))