What to do when function has too many arguments?

Question

I develop a system in Clojure. I try to write it as functional as possible. One of things is referential transparency (for same arguments function should always return the same result).

The problem is that some functions (especially my views and partially controllers) get too many args (like 5-6 and probably more in future).

How would you solve that problem?

I see couple of possible solutions each has pros and cons.

1) create ParameterMap - put parameters to Map and validate it with schema (https://github.com/prismatic/schema) - this is preferred solution but problem with this solution is that I get runtime errors instead of compile-time errors (now application refuse to compile because of bad arity when I forgot to refactor some part of application)

2) use closures - closure can capture named variables and wait for the rest. It checks on compile time. This solution is simple but makes me to create closures just to split amount of arguments to more functions which I see like functional-way to do anemic design. This solution is similar to use of monads where nobody seems to see adding arguments in steps as something unclean which I don't understand why.

3) turn parameters to named parameters - I will still have large amount of parameters but they stop being unclear because I can see what they mean on the first sight. I used this approach in other parts of application and it works. Unfortunately this is prone to NullPointerException in runtime and doesn't check in compile time.

Answer 1

Well, the answer is highly dependent on your codebase but is likely a combination of all of these things.

It's not a matter of choosing one or the other, it's choosing what works best for the various specific functions. For example, you should use closures where closures make sense, named params where those make sense, and maps when those make sense.

If you've got a bunch of arguments and you're passing these common arguments around to numerous functions, it likely does make sense to use a map to contain them and make it clearer what the arguments actually are.

Answer 2

An extended comment:

Paul Graham wrote the following about a DSL called Rtml (in which programs are called templates):

Rtml depended heavily on keyword parameters, which up to that time I had always considered one of the more dubious features of Common Lisp. ...

If I wanted to add another dimension to the behavior of one of the operators, I could just add a new keyword parameter, and everyone's existing templates would continue to work. A few of the Rtml operators didn't take keyword parameters, because I didn't think I'd ever need to change them, and almost every one I ended up kicking myself about later. If I could go back and start over from scratch, one of the things I'd change would be that I'd make every Rtml operator take keyword parameters.