Regression calling cfunction

[musm]

using BenchmarkTools

foo(x) = x + 1
f() = cfunction(foo, Int, (Int,))

@btime f();
  815.538 ns (3 allocations: 96 bytes)

# version
# Julia Version 0.7.0-DEV.1159
# Commit 8d752a07f4* (2017-07-29 02:32 UTC)
# OS: Windows (x86_64-w64-mingw32)

Julia 0.6

using BenchmarkTools

foo(x) = x + 1
f() = cfunction(foo, Int, (Int,))

julia> @btime f();
  1.578 ns (0 allocations: 0 bytes)

[yuyichao]

Use cfunction(foo, Int, Tuple{Int}) instead.

[tkelman]

should the (Int,) form be deprecated if it's a performance trap?

[yuyichao]

That's why I also added the deprecation label....

[musm]

@yuyichao Is there reference for the updated syntax ?

[yuyichao]

New tuple type syntax? #10380 ?

[musm]

Thanks. Does it not seem a little inconsistent that, e.g., ccall (and some other functions) takes a tuple of types but cfunction and invoke take a tuple type, or is that something else?

[tkelman]

It should probably eventually be deprecated in ccall too - we should make a decision on whether we're going to do that soon

[musm]

Of the top of my head code_llvm, code_typed, code_warntype, ccall all use a tuple of types instead of a tuple type.

[yuyichao]

ccall is special since it's a syntax and not a function.
Other functions also doesn't matter since they are only for reflection.

[quinnj]

I'm not a big fan of the inconsistency here, the fact that we now have
cfunction(foo, Cint, Tuple{Ptr{Void}})
vs.
ccall((:foo, lib), Void, (Ptr{Void},), ptr)
As a user/library author, how am I supposed to remember/guess whether you want a Tuple{...} or a (...). Let's pick one and use it everywhere, ccall, reflection, etc.

[yuyichao]

Tuple of types is only kept for convinience. If people don't like that, we can certainly just drop all of them.

[musm]

@quinnj I thought so too initially, but I'm pretty satisfied with @yuyichao comment above.

• invoke, cfunction operatore on julia function and thus the tuple type. (consistent)
• ccall is syntax
• reflection methods doesn't matter