Consider subtyping `Function`

[andyferris]

Hi,

One thing that can help with compatibility elsewhere is to hint your lenses and so-on are functions, by directly subtyping Function.

For example the code at https://github.com/JuliaObjects/Accessors.jl/blob/master/src/optics.jl#L345 could become:

struct PropertyLens{fieldname} <: Function
end 

This came up in SplitApplyCombine, which (unfortunately) is currently using Base.Callable in a few cases (although I wish the API were factored so it were obvious which terms must be functions rather than collections), here.

CC @aplavin

[jw3126]

While I am not a friend of dispatching on Base.Callable I can see that it might be pragmatic to do so. I am open to such a PR. One hassle is that we don t want the default printing of functions. Is there more baggage we inherit from subtyping function?

[andyferris]

One hassle is that we don t want the default printing of functions. Is there more baggage we inherit from subtyping function?

Hmm, it's never really given me baggage before - but yeah good point about the printing.

[tkf]

FWIW I think the main downside of subtyping Function is that the compiler de-optimizes a higher-order function that does not call the argument. (Though I really wish it stops doing this...)

IMHO an API that dispatches on Callable or Function is an anti-pattern and, ideally, should be refactored, as in JuliaLang/julia#34296

[andyferris]

is that the compiler de-optimizes a higher-order function that does not call the argument

Really? That's weird.

IMHO an API that dispatches on Callable or Function is an anti-pattern and, ideally, should be refactored, as in JuliaLang/julia#34296

You're probably right on that one.

[tkf]

I was referring to this issue JuliaLang/julia#33978

[andyferris]

I see - I can think of it working like ::Type{T} then. At least now I know - thanks!

When I opened this issue I didn't see any possible downsides but it's more complex than I imagined, so I'll close this one.

[aplavin]

FWIW I think the main downside of subtyping Function is that the compiler de-optimizes a higher-order function that does not call the argument.

Does this behavior differ depending on whether the passed callable is a Function or not?

[jw3126]

Does this behavior differ depending on whether the passed callable is a Function or not?

Types also get deoptimized unless you do f(::Type{T},...)