Should warn for method overwritten in local scope

[Ph0non]

What I want to do?
-> perform a LsqFit with different models to the same data

using LsqFit
xdata = [[0.1, 0.5, 2.0], [0.1, 0.5, 2.0], [0.1, 0.5, 2.0], [0.1, 0.5, 2.0], [0.1, 0.5, 2.0], [0.1, 0.5, 2.0], [0.1, 0.5, 2.0], [0.1, 0.5, 2.0]]
ydata = [[45.0, 25.48, 9.53], [22.52, 24.44, 15.46], [24.06, 20.26, 12.35], [14.1, 2.95, 1.83], [10.46, 4.65, 1.86], [3.54, 1.61, 1.4], [14.63, 10.21, 
7.44], [13.64, 11.45, 9.94]]

What works?
-> set of the variables outside a loop

m =  @. model(x, p) = p[1] + p[2] * exp(p[3] * x)
p = [0.5, 0.5, 0.5]
fit = curve_fit(m, xdata[1], ydata[1], p)
println("exp-os \n", fit)

m =  @. model(x, p) = p[1] * exp(p[2] * x)
p = [0.5, 0.5]
fit = curve_fit(m, xdata[1], ydata[1], p)
println("exp \n", fit)

exp-os
[8.58075, 44.1262, -1.91957]
exp
[47.8473, -1.01323]

What works not? -> declare und print(!) all in a loop

for i=1:2
    m1 = @. model(x, p) = p[1] + p[2] * exp(p[3] * x)
    p1 = [0.5, 0.5, 0.5]
    fit1 = curve_fit(m1, xdata[i], ydata[i], p1)
    println("exp-os, set", i, "\n", fit1.param)

    m2 = @. model(x, p) = p[1] * exp(p[2] * x)
    p2 = [0.5, 0.5]
    fit2 = curve_fit(m2, xdata[i], ydata[i], p2)
    println("exp, set", i, "\n", fit2.param)
end

exp-os, set1
[47.8473, -1.01323, 0.5]
exp, set1
[47.8473, -1.01323]
exp-os, set2
[24.6766, -0.21308, 0.5]
exp, set2
[24.6766, -0.21308]

The values for the first model are exactly the same as for the second.
What worsk instead? -> As suggested by @pkofod in #JuliaNLSolvers/LsqFit.jl#125 a direct function declaration instead of assigning a variable.

for i=1:2
    println()
    @. model1(x, p) = p[1] + p[2] * exp(p[3] * x)
    p1 = [0.5, 0.5, 0.5]
    fit1 = curve_fit(model1, xdata[i], ydata[i], p1)
    println("exp-os, set", i, "\n", fit1.param)

    @. model2(x, p) = p[1] * exp(p[2] * x)
    p2 = [0.5, 0.5]
    fit2 = curve_fit(model2, xdata[i], ydata[i], p2)
    println("exp, set", i, "\n", fit2.param)
end

exp-os, set1
[8.58075, 44.1262, -1.91957]
exp, set1
[47.8473, -1.01323]

What behaviour of the loop leads to wrong print inside the loop?

versioninfo()
Julia Version 1.1.0
Commit 80516ca202 (2019-01-21 21:24 UTC)
Platform Info:
  OS: Windows (x86_64-w64-mingw32)
  CPU: AMD Ryzen 5 2500U with Radeon Vega Mobile Gfx
  WORD_SIZE: 64
  LIBM: libopenlibm
  LLVM: libLLVM-6.0.1 (ORCJIT, znver1)
Environment:
  JULIA_EDITOR = "C:\Users\Martin\AppData\Local\Programs\Microsoft VS Code\Code.exe"

[stevengj]

Here is a simpler example:

for i = 1:2
    model() = i
    println("1st: i = $i, f() = ", model())
    model() = -i
    println("2nd: i = $i, f() = ", model())
end

which gives

1st: i = 1, f() = -1
2nd: i = 1, f() = -1
1st: i = 2, f() = -2
2nd: i = 2, f() = -2

The issue is that functions are constants in Julia: by defining model(x, p) = ... twice, your second method definition overwrites the first. Outside a loop, the compiler evaluates one expression at a time so the method is not overwritten until the second model is evaluated, but with the loop it compiles the whole loop body at once.

That's why it works if you give them separate names, since it defines separate functions. If you just want to pass a function as a parameter or assign it to a variable, it would be more common to use an anonymous function:

m2 = @. (x, p) -> p[1] * exp(p[2] * x)

[stevengj]

It would be nice for the compiler to give a warning if method definitions are overwritten in a local-scope block, since this is probably not the behavior that the user wanted.

[Ph0non]

A comprehensive compiler warning sound like a wonderful option to clarify things.