I actually started off doing exactly what you suggested. The original
version of my program used a map for the arguments and then used
explicit arguments when the number of arguments fell to a reasonable
level.
For example, I started off with:
(defn months_in_business
"The total number of months we will be in the business of renting out
our home"
[Months_To_Find_Tenant Months_In_Lease Lease_Cycles Months_To_Sell]
(-> (+ Months_To_Find_Tenant Months_In_Lease) (* Lease_Cycles) (+
Months_To_Sell)))
Which got called as (months_in_business Months_To_Find_Tenant
Months_In_Lease Lease_Cycles Months_To_Sell)
But this was a lot of typing every time I wanted to call the function.
So I changed it to:
(defn months_in_business
"The total number of months we will be in the business of renting out
our home"
[:keys [Months_To_Find_Tenant Months_In_Lease Lease_Cycles
Months_To_Sell]]
(-> (+ Months_To_Find_Tenant Months_In_Lease) (* Lease_Cycles) (+
Months_To_Sell)))
Which got called as (months_in_business bag_o_args)
This at least meant less typing when calling the function but defining
the function still required a bunch of typing.
So eventually I just went to:
(defn months_in_business
"The total number of months we will be in the business of renting out
our home"
[]
(-> (+ *Months_To_Find_Tenant* *Months_In_Lease*) (* *Lease_Cycles*)
(+ *Months_To_Sell*)))
Which was called as: (months_in_business)
At least there wasn't much typing involved but now I had a bunch of
thunks running around. Which is what brought me to the group in the
first place.
It seems to me that there is a design principal here somewhere that
says something like "One shouldn't have to pass static values around
as arguments to functions". But because there is nothing like an
object context in Clojure this ended up meaning that derived values
like months_in_business have to be thunks. Which I though was
inelegant.
If, on the other hand, I was implementing this in an object oriented
language I would just say:
class foo
var A
var B
foo (bag_o_args)
{
A = (bag_o_args A)
B = A+1
}
And I would be done. No heaps of typing. No thunks. Just what looks to
me like a nice simple solution.
But I recognize that I'm just running home to mommy because my
background is OO. That's why I came to the group in the first place.
Since I know I'm blinded by my OO past I wanted to see if there was an
approach to the problem in Clojure that was as easy and straight
forward as what I would have done in an OO language.
That having been said, defining a bunch of thunks isn't the worst
thing in the world. But it is unfortunate from both a design and
performance perspective.
Yaron
On Feb 16, 11:07 pm, Richard Newman <holyg...@gmail.com> wrote:
> > It seems however that the consensus of the group based on what I've
> > said so far is to pass around state in a structmap.
>
> Not necessarily a struct-map. Just a map.
>
> > This is nice in
> > that it makes each function completely self contained (e.g. no
> > external references). It's unfortunate in that it now means that every
> > single function needs this extra argument and every variable access
> > either needs to use the :keys feature in the arguments or has to
> > directly refer to the keys in the map.
>
> Not necessarily. At some point your functions should be fine-grained
> enough that they only take a couple of arguments. As soon as you drop
> below 6 or 7, where they're all mandatory, switch to ordinary function
> argument style.
>
> Wherever you call those functions should do the unpacking.
>
> E.g.,
>
> (defn outer-1 [{:keys [foo bar baz noo]}]
> (let [interm (foo-bar foo bar)
> fiddle (frostrup baz noo)]
> (tweep interm fiddle)))
>
> After all, your house-sale-profit function should be expressed in
> terms of two arguments:
>
> (defn house-sale-profit [house-sale-price house-sale-expenses]
> ...)
>
> It doesn't care about the other 17.
>
> Another thing: that big entry point function is like a much tidier
> version of the Java constructor that you created with 19 arguments --
> tidier in that you can use named keys or a map to identify the
> arguments.
--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
