How about
pairs = [e for e in enumerate(sqr)]
filter(p -> +(p...)%4 != 0, pairs)
?
--Peter
On Wednesday, June 18, 2014 3:34:24 PM UTC-7, gentlebeldin wrote:
>
> When you come across Julia, and know (a bit of) Haskell, comparisons are
> inevitable. Haskell has only functions with one argument, but the function
> value may be another function. It takes some time to wrap your brain around
> that idea, but hey, it works.
> Another type of functions with just one argument, possibly a tuple, may
> work as well, I guess, and that seemed to be the choice for Julia:
> uncurried.
> So let's define a function taking a pair: f=(x,y)->x*y, and define a pair:
> p=(2,3), and feed it to our function: f(p)
> ERROR: wrong number of arguments
> Oops...
> Suppose we have an array, sqr=[i^2 for i=1:5], and want to filter it, but
> depending on the index, too. There's a function for that, enumerate. Let's
> assume we want only those values where the index plus value (square) isn't
> divisible by 4. Check enumerate: [e for e in enumerate(sqr)]:
> 5-element Array{(Int64,Any),1}:
> (1,1)
> (2,4)
> (3,9)
> (4,16)
> (5,25)
> Ok, those are pairs, so let's filter:
> filter((x,y)->(x+y)%4!=0,[e for e in enumerate(sqr)])
> You guessed it, same "oops" as above.
> Well, you can work around that mess, naturally, but looking at the
> candidates...
> filter(p->(p[1]+p[2])%4!=0,[e for e in enumerate(sqr)])
> filter(p->(first(p)+last(p))%4!=0,[e for e in enumerate(sqr)])
> filter(p->((x,y)->(x+y)%4!=0)(p...),[e for e in enumerate(sqr)])
> All of them work, but what would be your favorite obfuscation of a simple
> thought? The last example suggests that the whole mess may be collateral
> damage from supporting varargs, but... is it worth that?
> Don't get me wrong, I like Julia, there's a lot of nice and powerful
> concepts, like multipe dispatch, but why does she have to have those warts
> right on her nose? ;-)
>
>
