suggestion: define at-invokelatest macro:

[aviatesk]

• offers easier syntax to call Baes.invokelatest
• @invokelatest f(args...; kwargs...) will simply be expanded into Base.invokelatst(f, args...; kwargs...)

[aviatesk]

I made this PR just as a suggestion; if @invokelatest seems better to live within a community package, I'm totally okay with it and will close this.

[jw3126]

I have seen the pattern @foo f(args...; kw...) as syntax for foo(f, args...; kw...) at a couple of places in the ecosystem. If it occurs multiple times in Base, this macro could share code with those other macros.

[StefanKarpinski]

Triage is in favor! It would be nice to factor out the code that transforms @m f(args...) into f(m, args) and similar so that it can be shared. But otherwise this would be convenient.

[aviatesk]

It would be nice to factor out the code that transforms @m f(args...) into f(m, args) and similar so that it can be shared.

Could you kindly provide an example of those transformations ?
I've looked at gen_call_with_extracted_types (, which is used within @code_typed, etc), but imo it's not such a simple function that can be factored out to share a common piece of code with @invokelatest.

[aviatesk]

fwiw, I have somewhat same kind of macro @invoke like below, and it has a similar structure as @invokelatest:

"""
    @invoke f(arg::T, ...; kwargs...)

Provides a convenient way to call [`invoke`](@ref);
`@invoke f(arg1::T1, arg2::T2; kwargs...)` will be expanded into `invoke(f, Tuple{T1,T2}, arg1, arg2; kwargs...)`.
When an argument's type annotation is omitted, it's specified as `Any` argument, e.g.
`@invoke f(arg1::T, arg2)` will be expanded into `invoke(f, Tuple{T,Any}, arg1, arg2)`.
"""
macro invoke(ex)
    f = first(ex.args)
    argtypes = []
    args = []
    kwargs = []
    for x in ex.args[2:end]
        if isexpr(x, :parameters)
            append!(kwargs, x.args)
        elseif isexpr(x, :kw)
            push!(kwargs, x)
        else
            arg, argtype = isexpr(x, :(::)) ? (x.args...,) : (x, Any)
            push!(args, arg)
            push!(argtypes, argtype)
        end
    end
    return if isempty(kwargs)
        :(invoke($(f), Tuple{$(argtypes...)}, $(args...))) # might not be necessary
    else
        :(invoke($(f), Tuple{$(argtypes...)}, $(args...); $(kwargs...)))
    end |> esc
end

I may try to make a PR to introduce @invoke into Base in a separate PR, and we can refactor the code then, I think.

[JeffBezanson]

I think the loop is not necessary --- wouldn't just splatting all of ex.args[2:end] into the expression work?

[aviatesk]

na, I think the current parser requires the loop to correctly handle keyword arguments, e.g.:

julia> macro invokelatest(ex)
           @assert is_expr(ex, :call) "call expression f(args...; kwargs...) should be given"
       
           f = first(ex.args)
           args = ex.args[2:end]
           return esc(:($(GlobalRef(Base, :invokelatest))($(f), $(args...))))
       end
@invokelatest (macro with 1 method)

julia> @macroexpand @invokelatest printstyled(stdout, "blue"; color = :blue)
:(Base.invokelatest(printstyled, $(Expr(:parameters, :($(Expr(:kw, :color, :(:blue)))))), stdout, "blue"))

julia> @invokelatest printstyled(stdout, "blue"; color = :blue)
ERROR: syntax: invalid syntax ; color = :blue
Stacktrace:
 [1] top-level scope
   @ none:1

[JeffBezanson]

This shouldn't be an assert; it should throw an ArgumentError.

[aviatesk]

done

[StefanKarpinski]

This would be nice to finish off. What's required to make forward progress here?

[aviatesk]

I think we can merge this as is ?