Question: In functional programming, it's often important to optimize any "looping" code to be tail recursive. Tail recursive algorithms are usually split between two functions, however - one which sets up the base case, and another that implements the actual loop. A good (albeit academic) example would be the reverse function.

```
reverse :: [a] -> [a]
reverse = reverse_helper []

reverse_helper :: [a] -> [a] -> [a]
reverse_helper result [] = result
reverse_helper result (x:xs) = reverse_helper (x:result) xs

```

"reverse\_helper" isn't really a good, descriptive name. However, "reverse\_recursive\_part" is just awkward.

What naming convention would you use for helper functions like this?

Answer: 
I agree with ShreevatsaR, if you don't make the helper function top-level (or worse, put it in the export list), than it doesn't matter what its name is.
I tend to call helper functions `f` and `g`.

```
reverse :: [a] -> [a]
reverse = f []
  where
    f ys []     = xs
    f ys (x:xs) = f (x:ys) xs

```

I just use this naming scheme for small functions (otherwise I don't know what the `f` refers to). Then again, why would you ever write big functions?

However, if you do want to export your 'helper' function because it might be useful to others, I would call it:

```
reverseAccumulator

```

Like Haskell's `zip` and `zipWith`.
But I wouldn't call those 'helper' functions, `zipWith` is just a generic function and `zip` is the default implementation (probably the one thats used the most).
setup and execute

example:

```
function whateverSetup() { ... }
function whateverExecute() { ... }

```