Instantiating function from type?

[stevengj]

Given the type F of a function, is there a good/documented way to instantiate the underlying function if possible?

F() doesn’t work, but I feel like it should:

julia> F = typeof(sin)
typeof(sin) (singleton type of function sin, subtype of Function)

julia> F()
ERROR: MethodError: no method matching typeof(sin)()
Stacktrace:
 [1] top-level scope
   @ REPL[52]:1

You can use the undocumented internal field F.instance:

julia> F.instance
sin (generic function with 14 methods)

so the best I can come up with is:

(::Type{F})() where {F<:Function} = Base.issingletontype(F) ? F.instance : throw(MethodError(F, ()))

Is there something better than issingletontype to determine whether a Function type corresponds to a generic function, as opposed to some other user-defined datatype?

(Obviously, this is type piracy … in a package this would better be named functioninstance(F) or something like that. But I’m thinking that something like this should go into Base.)

PS. On a related note, it feels like there should be a GenericFunction <: Function supertype for all Function types that come from bona-fide Julia functions, as opposed to user-defined functor types.

[ffevotte]

Not sure whether there exist other solutions, but what you suggest here is more or less the same as the solution provided by @Mason in this older thread:

How to get a function instance from a function type?

No, because not all functions have a one-to-one relationship with their types. For instance, f = let x = 1 y -> x + y end captures runtime data and cannot be reconstructed from it’s type alone. That said, in the case of functions which are singleton instances, you could do if isdefined(tf, :instance) ft.instance else error("This type does not have a single instance") end

[nsajko]

You can use incomplete initialization to get a valid instance of any singleton type, instead of using the undocumented instance field. I have a tiny package for it here: Neven Sajko / InstanceOfSingletonType.jl · GitLab. Registering it.

[nsajko]

@stevengj

F() doesn’t work, but I feel like it should

Related thread:

Constructors for `<:Function` types when possible, like in C++

I was thinking about how C++20 added support for default constructors for stateless (with no captures) lambdas, meaning that nowadays all function object families may be default-constructible in C++. Then I realized that in Julia I can’t even do typeof(sqrt)(), or something like this: func(::F) where {F <: Function} = F()(5.0) func(sqrt) # Or this func(::Type{F}) where {F <: Function} = F()(5.0) func(typeof(sqrt)) Seems like passing “pure” functions as types, instead of as objects would make…

[mkitti]

There is Core.Compiler.singleton_type.

julia> const F = typeof(sin)
typeof(sin) (singleton type of function sin, subtype of Function)

julia> Core.Compiler.singleton_type(F)
sin (generic function with 14 methods)