Hello,
2010/2/17 Yaron <ygol...@gmail.com>:
> 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
> }
I would like to try to help, but I first need to understand your
(pseudo?) OO langage above.
Could you detail it a little bit more ?
>
> 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
--
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
