Long form anonymous functions don't support return type declarations

[mbauman]

It would be nice if the long form anonymous functions would support return type declarations akin to named functions. That is, it'd be nice if the following converted and asserted the return type is T:

julia> function(x, y)::T
           return x*y
       end
ERROR: syntax: expected "(" in function definition

Note that this appears to work with one argument, but it's bugged and actually applying the type declaration to the argument instead of the function's return:

julia> f = function(x)::Int
           x/2
       end
#11 (generic function with 1 method)

julia> f(2.0)
ERROR: MethodError: no method matching (::getfield(Main, Symbol("##11#12")))(::Float64)
Closest candidates are:
  #11(::Int64) at REPL[41]:2
Stacktrace:
 [1] top-level scope at none:0

julia> :(function(x)::Int
                  x/2
              end)
:(function (x::Int,)
      #= REPL[47]:2 =#
      x / 2
  end)

(from https://discourse.julialang.org/t/controlling-the-type-of-anonymous-functions/26264).

[nathanielvirgo]

Probably a related issue: if you try and put type assertions on both the argument and the return type, it gives a syntax error:

julia> f = function(x::Int)::Int
ERROR: syntax: expected "(" in function definition

[JeffBezanson]

Long form anonymous functions are one of my least favorite syntaxes :) In the example from discourse, there's a name anyway so it can be written as

function make_func()
	function f(x::Cint)::Cint
		return x*10
	end
end

The (x)::Int is unfortunately ambiguous; I'm not sure we can do anything about this.

[mbauman]

I get that this is a super-overloaded form, and I get that we're free to parenthesize the names of arguments like (x)::Int, but don't we need an outer set of parentheses for the argument list itself? I'm missing the ambiguity.

[rfourquet]

This is a dup of #23072.

[mbauman]

Duplicate of #23072