Well, this is question many people ask. :) It is a matter of tradeoffs:
- Too many arguments may be an aesthetic problem. It may also reflect a
design problem; you might be able to rethink a system to simplify it. (What
"too many" means is debatable.)
- With many arguments, you may choose to combine them as a map. Then you
can destructure the ones you need. Risks: you may (a) lose clarity as to
what arguments are used; (b) miss out on memoization opportunities.
- Having ~4 to ~6 arguments may not be as bad as you think. First, it
provides clarify into what the function needs. Second, memoization is
easier. In summary, it may be better than the alternatives!
On Wednesday, May 13, 2015 at 9:38:43 AM UTC-4, Herwig Hochleitner wrote:
>
> In functional programming you can do a similar thing as in OOP: Define
> your functions as closures that can access common arguments via lexical
> scope. So instead of creating a context object, you create functions:
>
> (defn make-context [some context parameters]
> {:op1 (fn [x] ...)
> :op2 (fn [y] ...)})
>
> The clojure-specific variant are protocols, e.g.:
>
> (defn make-context [some context parameters]
> (reify ContextProtocol
> (op1 [_ x] ...)
> (op2 [_ y] ...)))
>
> They have the advantage of better type checking + defrecords to retain
> visibility into those context parameters.
>
> Hope that helps
>
--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to [email protected]
Note that posts from new members are moderated - please be patient with your
first post.
To unsubscribe from this group, send email to
[email protected]
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
---
You received this message because you are subscribed to the Google Groups
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
For more options, visit https://groups.google.com/d/optout.
