Vous pouvez utiliser @code_lowered pour voir où se trouve le #temp# les variables proviennent :
julia> @code_lowered L0_reg(x, y, k, quiet=true)
LambdaInfo template for (::IHT.#kw##L0_reg){T<:Union{Float32,Float64}}(::Array{Any,1}, ::IHT.#L0_reg, x::DenseArray{T,2}, y::DenseArray{T,1}, k::Int64)
:(begin
NewvarNode(:(temp))
NewvarNode(:(tol))
#temp#@_7 = true
#temp#@_8 = true
max_iter = 100
max_step = 50
quiet = true
SSAValue(0) = (IHT.colon)(1,(Base.length)(#temp#@_2) >> 1)
#temp#@_14 = (Base.start)(SSAValue(0))
10:
unless !((Base.done)(SSAValue(0),#temp#@_14)) goto 42
SSAValue(1) = (Base.next)(SSAValue(0),#temp#@_14)
#temp#@_15 = (Core.getfield)(SSAValue(1),1)
#temp#@_14 = (Core.getfield)(SSAValue(1),2)
#temp#@_16 = #temp#@_15 * 2 - 1
#temp#@_17 = (Core.arrayref)(#temp#@_2,#temp#@_16)
unless #temp#@_17 === :quiet goto 20
quiet = (Core.typeassert)((Core.arrayref)(#temp#@_2,#temp#@_16 + 1),IHT.Bool)
goto 40
20:
unless #temp#@_17 === :max_step goto 24
max_step = (Core.typeassert)((Core.arrayref)(#temp#@_2,#temp#@_16 + 1),IHT.Int)
goto 40
24:
unless #temp#@_17 === :max_iter goto 28
max_iter = (Core.typeassert)((Core.arrayref)(#temp#@_2,#temp#@_16 + 1),IHT.Int)
goto 40
28:
unless #temp#@_17 === :tol goto 33
tol = (Core.typeassert)((Core.arrayref)(#temp#@_2,#temp#@_16 + 1),IHT.Float)
#temp#@_8 = false
goto 40
33:
unless #temp#@_17 === :temp goto 38
temp = (Core.typeassert)((Core.arrayref)(#temp#@_2,#temp#@_16 + 1),(Core.apply_type)(IHT.IHTVariables,$(Expr(:static_parameter, 1))))
#temp#@_7 = false
goto 40
38:
(Base.kwerr)(#temp#@_2,,x,y,k)
40:
goto 10
42:
unless #temp#@_7 goto 45
temp = (IHT.IHTVariables)(x,y,k)
45:
unless #temp#@_8 goto 48
tol = (IHT.convert)($(Expr(:static_parameter, 1)),0.0001)
48:
return (IHT.#L0_reg#75)(temp,tol,max_iter,max_step,quiet,,x,y,k)
end)
Dans ce cas, les temps (en particulier #temp#@_2 ) proviennent des arguments des mots-clés. C'est tout à fait normal pour les arguments de type mot-clé.
julia> f(; x=1) = x
f (generic function with 1 method)
julia> @code_warntype f(x=1)
Variables:
#unused#::#kw##f
#temp#@_2::Array{Any,1}
::#f
x::Any
#temp#@_5::Int64
#temp#@_6::Int64
#temp#@_7::Int64
#temp#@_8::Any
Body:
begin
x::Any = 1
SSAValue(2) = (Base.arraylen)(#temp#@_2::Array{Any,1})::Int64
SSAValue(3) = (Base.select_value)((Base.sle_int)(0,1)::Bool,(Base.box)(Int64,(Base.ashr_int)(SSAValue(2),(Base.box)(UInt64,1))),(Base.box)(Int64,(Base.shl_int)(SSAValue(2),(Base.box)(UInt64,(Base.box)(Int64,(Base.neg_int)(1))))))::Int64
SSAValue(4) = (Base.select_value)((Base.sle_int)(1,SSAValue(3))::Bool,SSAValue(3),(Base.box)(Int64,(Base.sub_int)(1,1)))::Int64
#temp#@_5::Int64 = 1
6:
unless (Base.box)(Base.Bool,(Base.not_int)((#temp#@_5::Int64 === (Base.box)(Int64,(Base.add_int)(SSAValue(4),1)))::Bool)) goto 21
SSAValue(5) = #temp#@_5::Int64
SSAValue(6) = (Base.box)(Int64,(Base.add_int)(#temp#@_5::Int64,1))
#temp#@_6::Int64 = SSAValue(5)
#temp#@_5::Int64 = SSAValue(6)
#temp#@_7::Int64 = (Base.box)(Int64,(Base.sub_int)((Base.box)(Int64,(Base.mul_int)(#temp#@_6::Int64,2)),1))
#temp#@_8::Any = (Core.arrayref)(#temp#@_2::Array{Any,1},#temp#@_7::Int64)::Any
unless (#temp#@_8::Any === :x)::Bool goto 17
x::Any = (Core.arrayref)(#temp#@_2::Array{Any,1},(Base.box)(Int64,(Base.add_int)(#temp#@_7::Int64,1)))::Any
goto 19
17:
(Base.throw)($(Expr(:new, :(Base.MethodError), :((Core.getfield)((Core.getfield)((Core.getfield)(#f,:name)::TypeName,:mt),:kwsorter)), :((Core.tuple)(#temp#@_2,)::Tuple{Array{Any,1},#f}))))::Union{}
19:
goto 6
21:
return x::Any
end::Any
Les arguments des mots-clés sont connus pour avoir une surcharge d'appels qui peut être quelque peu contournée en déclarant des types . Notez que, à moins que votre fonction ne fasse très peu de choses, il est peu probable que le tri des arguments des mots-clés soit un goulot d'étranglement important (malgré le désagrément de l'option @code_warntype sortie).
Quand vous le faites @code_warntype sur un appel d'argument de mot-clé, vous visualisez en fait les instabilités de type du trieur d'argument de mot-clé, une enveloppe autogénérée autour de la vraie fonction. Comme vous pouvez le voir, le code finit par appeler (IHT.#L0_reg#75)(temp,tol,max_iter,max_step,quiet,,x,y,k) qui est une fonction simple qui prend des arguments positionnels. Ainsi, la sortie de @code_warntype est presque inutile dans ce cas.
