Using Let block

General Usage
1

If I define a variable b in Main and then use the let block:

b = 5
let 
  b = b
  println(b)
end

I get the error saying: " UndefVarError: b not defined"

I can get this to work by doing:

b = 5
let 
  b = Main.b
  println(b)
end

Is there a way to do this which doesn’t use Main but instead whatever level this was called in? In other words if I did this within a function, then I wouldn’t want to use the word Main.

I tried using the escape function but wasn’t successful.

Thanks,

2

You can also do:

julia> b = 5
5

julia> let 
         global b
         println(b)
       end
1 Like
3

No that doesn’t do anything. If you want a new b inside the let block, put it on the first line of the let block

julia> let b = b
           println(b)
       end
5
8 Likes
4

Wow. Very interesting. I needed to do multiple variables, but I just created a block in first line and it works. Thanks!

5

When defining multiple variables in a let block, I tend to favor the following syntax (which I learned about here on Discourse, too). In the line of the let keyword, I only list the variables to be given a local scope, without their assigned values. And then, in the first fiew lines of the body of the let block, I assign their values. E.g.,

global_value = let x, y
    x = <expression-to-compute-x>
    y = <expression-to-compute-y>
    <expression-using-x-and-y>
end
2 Likes
6

Yes, but only in the first line of the let block do you have the ability to create a new binding for an existing variable, while still referring to that variable for the assigned value. (And this was precisely the use case mentioned in the OP).

Consider the following example:

julia> x = 1
1

# in the lhs, x refers to a new binding
# in the rhs, x refers to the global variable
julia> let x = x + 1
           x *= 2
       end
4

julia> x
1

but

julia> x = 1
1

julia> let x         # <- new binding introduced here, shadows the global variable everywhere in the let body
           x = x + 1 # x refers to the new variable in both lhs and rhs
           x *= 2    #   => ERROR
       end
ERROR: UndefVarError: `x` not defined
Stacktrace:
 [1] top-level scope
   @ REPL[4]:2
2 Likes
7

Fair point. If you need to use the values of some shadowed variables, you have no other option than to use them in the first line of the let block. I don’t like rebinding variables, though, so this is usually not an issue for me.

8

In this case, is it possible to omit the variables on the let line?

global_value = let
    x = <expression-to-compute-x>
    y = <expression-to-compute-y>
    <expression-using-x-and-y>
end
9

That will reassign existing variables. If you want new variables they have to go in the first line of the let.

Edit: it’s different if the existing variables are globals. See below.

2 Likes
10

No I don’t think so:

julia> x=5
5

julia> let
           x=10
       end
10

julia> x
5

Because let creates a local scope and assignments in local scopes create a new binding. If you only used x inside the let block then you’d get the global value. But in any case you cannot overwrite it globally without using global x somewhere.

11

I think your example does rely only on the global. Assignments in the body of a let otherwise reassign existing variables from enclosing scopes.

julia> function f()
           x = 5
           let
               x = 10
           end
           x
       end
f (generic function with 1 method)

julia> f()
10
1 Like
12

Your are right of course. Here x is already a local binding - just not local to the let-block (which I honestly find a bit confusing). Arguably that is the default mode of operation for let and what I posted a special case for true global variables.

I think, I just interpreted the @greg_plowman’s code to be in global scope due to the variable named global_value.

Good that you cleared this up :slight_smile:

1 Like