`replace` unable to determine type with broadcast, but can with a for-loop

[numbermaniac]

I had a 2D array of integers and used replace to replace some of them using a list of pairs.

function replace_listcomp(r :: Vector{Vector{Int}}, p :: Vector{Pair{Int, Int}})
    result = [replace(rr, p...) for rr in r]
    return result
end

With this list comprehension, Julia correctly determines the output type:

julia> @code_warntype replace_listcomp([[1,2,3]], [1 => 10])
# output cropped to relevant part
Locals
  #1::var"#1#2"{Vector{Pair{Int64, Int64}}}
  result::Vector{Vector{Int64}}
Body::Vector{Vector{Int64}}

I then changed the function to use broadcast syntax instead, but surprisingly, it was no longer able to determine the output type.

function replace_broadcast(r :: Vector{Vector{Int}}, p :: Vector{Pair{Int, Int}})
    result = replace.(r, p...)
    return result
end

julia> @code_warntype replace_broadcast([[1,2,3]], [1 => 10])
# [...]
Arguments
  #self#::Core.Const(replace_broadcast)
  r::Vector{Vector{Int64}}
  p::Vector{Pair{Int64, Int64}}
Locals
  result::Any
Body::Any
1 ─ %1 = Core.tuple(Main.replace, r)::Tuple{typeof(replace), Vector{Vector{Int64}}}
│   %2 = Core._apply_iterate(Base.iterate, Base.broadcasted, %1, p)::Any
│        (result = Base.materialize(%2))
└──      return result

It now says the output type is just Any. I expected that it would say Vector{Vector{Int64}} instead, just like the previous example.

---

Interestingly though, it does figure out the output type if I change the p argument from a vector to a tuple.

function replace_broadcast_tuple(r :: Vector{Vector{Int}}, p :: Tuple{Vararg{Pair{Int, Int}}})
    result = replace.(r, p...)
    return result
end

julia> @code_warntype replace_broadcast_tuple([[1,2,3]], (1 => 10, 2 => 15))
# [...]
Arguments
  #self#::Core.Const(replace_broadcast_tuple)
  r::Vector{Vector{Int64}}
  p::Tuple{Pair{Int64, Int64}, Pair{Int64, Int64}}
Locals
  result::Vector{Vector{Int64}}
Body::Vector{Vector{Int64}}
1 ─ %1 = Core.tuple(Main.replace, r)::Tuple{typeof(replace), Vector{Vector{Int64}}}
│   %2 = Core._apply_iterate(Base.iterate, Base.broadcasted, %1, p)::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(replace), Tuple{Vector{Vector{Int64}}, Base.RefValue{Pair{Int64, Int64}}, Base.RefValue{Pair{Int64, Int64}}}}
│        (result = Base.materialize(%2))
└──      return result

While I've already found a workaround that doesn't use replace at all, I figured I'd post this anyway since it surprised me when I encountered it.

julia> versioninfo()
Julia Version 1.7.2
Commit bf53498635 (2022-02-06 15:21 UTC)

[mikmoore]

Vaguely similar to #43333, but I can't judge whether it might be the same problem or not.

[Moelf]

julia> function replace_broadcast(r :: Vector{Vector{Int}}, p :: Vector{Pair{Int, Int}})
           result = replace.(r, Ref(p...))
           return result
       end

is type stable.

problem is your original broadcasting is not equivalent to the comprehension, the comprehension has a fixed set of p..., so here Ref() replicates that condition

[numbermaniac]

Shouldn't p... expand before the broadcast, so that the results are equivalent? I can't seem to find a case where the listcomp and broadcast versions return different results. Plus, I mentioned how it became type stable if I changed the type of p from a Vector to a Tuple.

When I try your function with an example input, it returns an error:

function replace_listcomp(r :: Vector{Vector{Int}}, p :: Vector{Pair{Int, Int}})
    result = [replace(rr, p...) for rr in r]
    return result
end

function replace_broadcast(r :: Vector{Vector{Int}}, p :: Vector{Pair{Int, Int}})
    result = replace.(r, p...)
    return result
end

function replace_broadcast_moelf(r :: Vector{Vector{Int}}, p :: Vector{Pair{Int, Int}})
	result = replace.(r, Ref(p...))
	return result
end

function main()
	r = [[1,2,3], [4,5,6]]
	p = [1 => 10, 2 => 20, 5 => 55, 7 => 75]
	println("replace_listcomp ", replace_listcomp(r, p))
	println("replace_broadcast ", replace_broadcast(r, p))
	println("replace_broadcast_moelf ", replace_broadcast_moelf(r, p))
end

main()

Output:

replace_listcomp [[10, 20, 3], [4, 55, 6]]
replace_broadcast [[10, 20, 3], [4, 55, 6]]
ERROR: LoadError: MethodError: no method matching Ref(::Pair{Int64, Int64}, ::Pair{Int64, Int64}, ::Pair{Int64, Int64}, ::Pair{Int64, Int64})
Closest candidates are:
  Ref(::Any) at /Applications/Julia-1.7.app/Contents/Resources/julia/share/julia/base/refpointer.jl:134