>> This is a known limitation of Julia.  The trouble is that Julia cannot 
>> do its type interference with the passed in function.  I don't have time 
>> to search for the relevant issues but you should be able to find them. 
>> Similarly, lambdas also suffer from this.  Hopefully this will be 
>> resolved soon! 
>>
>
> Mauro: When you say "Hopefully this will be resolved soon! " does that mean 
> this is an issue with a planned future fix?

I've had a look through the issues and not one fitted exactly, there are
several related/encompassing ones:
https://github.com/JuliaLang/julia/issues/1864
https://github.com/JuliaLang/julia/issues/4428

Maybe worth its own issue?  Although once the anonymous function issue
is solved, then the issue of this thread (passing a generic function to
a function) should be mostly solved too.

> For those of us used to programming in a very functional style, this 
> limitation leads to less performant code in Julia.

I totally agree, for me this is Julia's biggest shortcoming.

>> On Wed, 2015-03-25 at 19:41, Phil Tomson <[email protected] <javascript:>> 
>> wrote: 
>> >  Maybe this is just obvious, but it's not making much sense to me. 
>> > 
>> > If I have a reference to a function (pardon if that's not the correct 
>> > Julia-ish terminology - basically just a variable that holds a Function 
>> > type) and call it, it runs much more slowly (persumably because it's 
>> > allocating a lot more memory) than it would if I make the same call with 
>>   
>> > the function directly. 
>> > 
>> > Maybe that's not so clear, so let me show an example using the abs 
>> function: 
>> > 
>> >     function test_time() 
>> >          sum = 1.0 
>> >          for i in 1:1000000 
>> >            sum += abs(sum) 
>> >          end 
>> >          sum 
>> >      end 
>> > 
>> > Run it a few times with @time: 
>> > 
>> >    julia> @time test_time() 
>> >     elapsed time: 0.007576883 seconds (96 bytes allocated) 
>> >     Inf 
>> > 
>> >    julia> @time test_time() 
>> >     elapsed time: 0.002058207 seconds (96 bytes allocated) 
>> >     Inf 
>> > 
>> >     julia> @time test_time() 
>> >     elapsed time: 0.005015882 seconds (96 bytes allocated) 
>> >     Inf 
>> > 
>> > Now let's try a modified version that takes a Function on the input: 
>> > 
>> >     function test_time(func::Function) 
>> >          sum = 1.0 
>> >          for i in 1:1000000 
>> >            sum += func(sum) 
>> >          end 
>> >          sum 
>> >      end 
>> > 
>> > So essentially the same function, but this time the function is passed 
>> in. 
>> > Running this version a few times: 
>> > 
>> >     julia> @time test_time(abs) 
>> >     elapsed time: 0.066612994 seconds (32000080 bytes allocated, 31.05% 
>> > gc     time) 
>> >     Inf 
>> >   
>> >     julia> @time test_time(abs) 
>> >     elapsed time: 0.064705561 seconds (32000080 bytes allocated, 31.16% 
>> gc 
>> > time) 
>> >     Inf 
>> > 
>> > So roughly 10X slower, probably because of the much larger amount of 
>> memory 
>> > allocated (32000080 bytes vs. 96 bytes) 
>> > 
>> > Why does the second version allocate so much more memory? (I'm running 
>> > Julia 0.3.6 for this testcase) 
>> > 
>> > Phil 
>>
>>

Reply via email to