Re: Destructuring arguments to pure functions?
- To: mathgroup at smc.vnet.net
- Subject: [mg95756] Re: Destructuring arguments to pure functions?
- From: dreeves <dreeves at gmail.com>
- Date: Mon, 26 Jan 2009 05:03:07 -0500 (EST)
- References: <gjad0c$p4b$1@smc.vnet.net>
I'm curious what you all think of this idea:
Unprotect[Integer];
1[x_] := x[[1]]
2[x_] := x[[2]]
3[x_] := x[[3]]
4[x_] := x[[4]]
5[x_] := x[[5]]
6[x_] := x[[6]]
7[x_] := x[[7]]
8[x_] := x[[8]]
9[x_] := x[[9]]
Protect[Integer];
and then
1@# + 2@# & /@ testList
It seems to be very slow in the current version of Mathematica but it
seems like a concise/elegant way to avoid the clunky yet oft-typed #
[[n]] (ie, replacing it with n@# or n[#]).
Perhaps more generally, other sensible behavior could be defined for
expressions with non-symbols as the Head for which the meaning is
currently undefined.
On Dec 29 2008, 6:41 am, Stoney Ballard <ston... at gmail.com> wrote:
> I hate using #[[1]] etc. to access elements of list arguments to pure
> functions, so I've been looking for a way around that.
>
> One way is to simply stop using pure functions in those cases, and use
> locally bound function definitions, like
>
> testList = Flatten[Table[{x, y}, {x, 1, 100}, {y, 1, 100}], 1];
>
> (Example 1)
>
> Module[{fun},
> fun[{x_, y_}] := x + y;
> Map[fun, testList]]
>
> This turns out to be significantly faster than any other method I've
> tried, but it seems clunky and requires Module.
>
> Another way is to use RuleDelayed:
>
> (Example 2)
>
> Map[# /. {x_, y_} :> x + y &, testList]
>
> but this is about 5 times slower than example 1. Binding the rule with
> Module:
>
> (Example 3)
>
> Module[{fun = {x_, y_} :> x + y},
> Map[# /. fun &, testList]]
>
> Is only marginally slower than example 1, but still requires Module or
> With. Strangely (to me), I found that binding the rule as a pure
> function:
>
> (Example 4)
>
> Module[{fun = # /. {x_, y_} :> x + y &},
> Map[fun, testList]]
>
> is about the same speed as example 2, or 5 times slower than example
> 1. I don't understand why there should be so much of a difference
> there.
>
> Finally, doing this with Part:
>
> (Example 5)
>
> Map[#[[1]] + #[[2]] &, testList]
>
> is 2-3 times faster than using destructuring in example 1.
>
> Clearly, I need to give up some performance to get the clarity of
> destructuring, but is there a better way than example 1?