Trying to subtype a function does not throw an error

[dpsanders]

The following came up in a discussion with @davidagold, trying to subtype a function. MyFuncs is completely ignored, even when it hasn't yet been defined:

11:36 $ julia-dev
               [banner here]

julia> function f() <: MyFuncs
             end
f (generic function with 1 method)

[dpsanders]

Is there a "correct" way to make a subclass of Functions on 0.5?

[dpsanders]

But of course running the function gives an error:

julia> f()
ERROR: UndefVarError: MyFuncs not defined
 in f() at ./REPL[4]:1
 in eval(::Module, ::Any) at ./boot.jl:234
 in macro expansion at ./REPL.jl:92 [inlined]
 in (::Base.REPL.##1#2{Base.REPL.REPLBackend})() at ./event.jl:46

[yuyichao]

This is simply because <: MyFuncs is a valid expression and it's part of the function body. I don't think we have a special syntax for subtyping Function. You can always do type A <: Function of course.

[dpsanders]

How do you then declare a particular function to be a subtype of A?

[yuyichao]

You can't, other than just use call overload on your own type.

It is unclear what does declare a particular function to be a subtype of A mean. (the function ... end syntax defines a method, not a function)

[dpsanders]

Good point. The underlying question was about traits for functions...

[JeffBezanson]

It would be nice to allow this syntax. If f is a new function, you can in fact pick a supertype for it, which does not have to be Function. Of course, as @yuyichao said, if it's not a new function then you can't do this so there would be an error.

[JaredCrean2]

I have done something like this with functors in 0.4 and would definitely like to see capability preserved now that functions are types that can be specialized on.

Of course, as @yuyichao said, if it's not a new function then you can't do this so there would be an error.

Does that mean it would be an error to declare a second method for the function at all, or that the second method can't specify its supertype?

[yuyichao]

There should be an error at least when you specify a parent type on a function that already has a different type. Adding methods to such a function should still be allowed.

[TotalVerb]

Would this syntax be effectively equivalent with

immutable _f <: MyFunction end
const f = _f.instance

followed by the method definition?

[yuyichao]

Roughtly, probably with slightly different printing.

[JaredCrean2]

@yuyichao Cool, thanks for the clarification.

[TotalVerb]

If MyFunct is a subtype of Function, then the printing should already be there. Otherwise, arguably, this syntax should not force any different printing.

Edit: Apparently I am mistaken about how show for functions works. It prints (::_f) which is not good. Right, then the printing needs to be handled differently.