UndefVarError shadowing function

[apaz-cli]

The bug:

function f(s, price)
    @show f
    f = s * price
end

f(2, 3)

ERROR: LoadError: UndefVarError: `f` not defined
Stacktrace:
 [1] macro expansion
   @ Main ./show.jl:1153 [inlined]
 [2] f(s::Int64, price::Int64)
   @ Main ~/git/julia/bug.jl:2
 [3] top-level scope
   @ ~/git/julia/bug.jl:5
in expression starting at /home/apaz/git/julia/bug.jl:5

User's versioninfo():

julia> versioninfo()
Julia Version 1.9.0
Commit 8e630552924 (2023-05-07 11:25 UTC)
Platform Info:
  OS: Linux (x86_64-linux-gnu)
  CPU: 24 × AMD Ryzen 9 7900X 12-Core Processor
  WORD_SIZE: 64
  LIBM: libopenlibm
  LLVM: libLLVM-14.0.6 (ORCJIT, znver3)
  Threads: 69 on 24 virtual cores

I also replicated this on my own machine on master.

julia> Meta.parse("function f(s, price)\n  @show f\n  f = s * price\nend")
:(function f(s, price)
      #= none:1 =#
      #= none:2 =#
      #= none:2 =# @show f
      #= none:3 =#
      f = s * price
  end)

julia> @code_lowered f(2, 3)
CodeInfo(
1 ─      value = f
│   %2 = f
│   %3 = Base.repr(%2)
│        Base.println("f = ", %3)
│        value
│   %6 = s * price
│        f = %6
└──      return %6
)

julia> @code_typed f(2, 3)
CodeInfo(
1 ─     $(Expr(:throw_undef_if_not, :f, false))::Any
└──     unreachable
) => Union{}

[apaz-cli]

Pinging @Ellipse0934

[martinholters]

Seems to work as intended? f is a local variable and you try to @show it before assigning a value. What did you expect to happen?

[apaz-cli]

The expectation is that shadowing works the same way it does in other languages, or that it provides an error message that helps you figure out what the problem is.

[elextr]

It doesn't work the same.

As the documentation says "The scope of a variable cannot be an arbitrary set of source lines; instead, it will always line up with one of these blocks.", which means its usable within its scope block before it is declared, but only after it has been given a value, so:

# no s here
for i = 1:5
    if i > 1
        @show s
    end
    s = i
end

is fine.

Aside, I thought that this used to be clearer in the docs, but it seems to have been de-emphasised.

[andrewjradcliffe]

function f(s, price)
    println(f + 1)
    f = s * price
end

Produces the same error, for reasons which are obvious.

(define (f s price)
    (newline)
    (display f)
    (newline)
    (define f (* s price))
    (newline) 
    (display f) 
    (newline))

;; produces (in MIT/GNU Scheme)
1 ]=> (f 2 3)

#[compound-procedure 12 f]

6
;Unspecified return value

But this makes sense given how bindings are resolved in Scheme -- f is found in the enclosing environment (the global environment, in this case).

function f(s, price)
    @show f
    s * price
end

Has the same behavior.

The semantics are little less obvious here since there is no set! (Scheme) equivalent in Julia, which employs = for both define and set! (excluding setfield!, setproperty!, which are not germane to the discussion at hand). I do not know the precise treatment Julia uses, but seemingly, Julia scans out internal definitions, then binds them according to the sequential order indicated by the lines in the source code -- that is, the environment is created with the variables set to '*unassigned* (or some equivalent), then values are bound sequentially; if an unbound variable is used, throw an error.

I suppose one could wish for a more clever name-shadowing.

Rust happily proceeds with the example.

Python returns what is arguably a more informative error message.

def f(s, price):
    print(f)
    f = s * price
    print(f)

# and we get
>>> f(2, 3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in f
UnboundLocalError: cannot access local variable 'f' where it is not associated with a value

@elextr
The usable-once-defined treatment is similar to one method of handling internal definitions. Consider the example:

Given that Julia's let is actually let*, it is preferable to use the following for clarity:

let u
    # u exists in environment, but is unassigned                    
    let v
        # v exists in environment, but is unassigned             
        let a = 2        
            let b = 3
                # now we assign values to u and v. If this were Scheme, we'd use `set!`  
                u = a + b
                v = a * b
            end          
        end              
    println(u + v) # prints 11               
    end
    # println(v) # this will error as v is now out of scope   
    println(u) # prints 5           
end