title: Is there a style convention for Common Lisp recursive helper functions?
body: <p>I would like to know if there is a style guideline, published by ANSI or implementation authors or another influential authority, for Lisp functions which are implemented using recursive helper functions which take additional parameters that the person calling the function doesn't need to think about. Here is the simplest example I can think of. Which of these three, if any, is preferred in a standardized style guide for common lisp (if there is one)?</p>
  
  <pre><code>(defun factorial (n)
     (defun tail-factorial (n m)
        (if (= n 1)
            m
            (tail-factorial (- n 1) (* n m))))
     (tail-factorial n 1))
  </code></pre>
  
  <p>This seems unpleasant because of the function declaration within the function declaration. I would use a lambda to avoid naming the helper function and convoluting things, but I am not clear how to recurse within a lambda expression by having it call itself. Even if there is a way to have an anonymous function call itself, it seems like it would get messy, especially if the helper needs a helper needs a helper ... </p>
  
  <p>Another alternative is to declare the tail guy first (or after, but that makes sbcl complain):</p>
  
  <pre><code>(defun tail-factorial (n m)
     (if (= n 1)
        n
        (tail-factorial (- n 1) (* n m))))
  (defun factorial (n)
     (tail-factorial n 1))
  </code></pre>
  
  <p>This seems unpleasant because somebody reading my code would see tail-factorial and might feel the need to understand it, even though it's just a helper function for factorial and won't be used elsewhere. In my own code, I keep writing functions analogous to this and I really struggle to come up with comments that will make me re-understand what I did months or years from now. Again, the situation gets really bad here when the helper needs a helper needs a ...</p>
  
  <p>Another alternative uses optionals:</p>
  
  <pre><code>(defun factorial (n &amp;optional (m 1))
     (if (= n 1)
        m
        (factorial (- n 1) (* n m))))
  </code></pre>
  
  <p>This seems unpleasant because we expect only one argument for a factorial. Nobody outside this function would have a reason to call this with that second argument. I find it annoying to try to understand code with optional arguments I will never use.</p>
  
  <p>Now, I'm clear that asking what you think is best is the kind of subjective conversation stackoverflow dislikes, so my objective question is whether or not there is some kind of standardized style guideline about which of these alternatives is preferred. I use SBCL and have not found a guideline for this sort of thing on their site, and I am not aware of such a guide published by ANSI or any other standardizing body, including other implementors.</p>
  
  <p>Perhaps there is another alternative altogether, and I welcome your suggestions. I keep running into this situation of needing a little helper function (who needs a helper function, etc) and I want to get used to writing in the way most people will find clear. Somebody asked a similar question at <a href="https://stackoverflow.com/questions/7607338/recursing-in-a-lambda-function">Recursing in a lambda function</a> , and several people recommended some favorite pet projects but nobody mentioned a style guideline.</p>
  
  <p>Thanks in advance!</p>