Trying to understand how lazy computation works

General Usage
1

Trying to understand the following argument

A zero-argument anonymous function is written as ()->3. The idea of a function with no arguments may seem strange, but is useful for “delaying” a computation. In this usage, a block of code is wrapped in a zero-argument function, which is later invoked by calling it as f.

get(()->time(), dict, key)

from here

I used the following expressions using two different methods of the get!() function:

julia> d = Dict()
Dict{Any, Any}()

julia> get!(()->"d(b)", d,'b')
"d(b)"

julia> d
Dict{Any, Any} with 1 entry:
  'b' => "d(b)"

julia> get!(d,'a',()->"d(a)")
#65 (generic function with 1 method)

julia> d
Dict{Any, Any} with 2 entries:
  'a' => #65
  'b' => "d(b)"

why in the second case the anonymous function is not evaluated?
Another question: what does the symbol "#65 " stand for?
I understand it’s referring to the anonymous function somehow, but…
Is it possible (although perhaps not recommended) to use it in any way?

i tried giving it as an argument to typeof() and methods() but my REPL stops as waiting to complete the expression (!?)

2
  1. If you look at the function semantics in the manual, you’ll see that this behavior is what’s intended – in one case, you store the anonymous function in the dictionary and in another you store the result of evaluating the anonymous function in the dictionary.
  2. #65 is a kind of internal name for the anonymous function. I am not aware of it being possible to use and would think it’s not wise to use given that the point of anonymous functions is that they don’t have canonical names.
2 Likes
3

This is because the name is a comment, no?

4

yes :smiley:.

also like this methods(var"#15()") and typeof(var"#15()") doesn’t give any result

julia> get!(d,'d',()->"z-arg")()
"z-arg"

julia> d
Dict{Any, Any} with 4 entries:
  'a' => sqrt
  'd' => #9
  'b' => "d(b)"

julia> d['a'](9)
3.0

julia> d['d']()
"z-arg"

# does this mean that `#nnn` is not just a comment but a variable referring to the anonymous function?
5

Note that #15 is the function name, in the same sense that #sin is the function name of sin:

julia> typeof(sin).name.name

Symbol("#sin")

The difference is that the function named #sin is bound to a const global named sin which we can use to call the function. The anonymous function #15 however is not bound to a global variable so (as far as I can see) it cannot be called by its name.

In particular, #15 is not bound to a variable of that name! That’s why var"#15" returns an error. But you can actually make the binding yourself:

var"#15" = d['a']   # assuming that d['a'] is the anonymous function #15

But we could also bind an unrelated value to var"#15", or bind #15 to var"#19" or whatever…

There’s also a name for the type of the anonymous function, and this one is actually bound to a variable, you can access it with var"#15#16. You can use that in a method declaration to dispatch on the type of the anonymous function, or with var"#15#16".name.mt you can get the method table, but I don’t know how to use it to call the function itself.

2 Likes
6

perhaps

var"#15#16".instance()

julia> get!(d,'g',()->"g-arg") 
#23 (generic function with 1 method)

julia> d
Dict{Any, Any} with 4 entries:
  'g' => #23
  'd' => #21
  'a' => sqrt
  'e' => "eheheh"

julia> var"#23#24".instance()
"g-arg"
1 Like
7

Indeed that works! However I think this field is only defined for singleton types, so it won’t work if the anonymous function is a closure:

c = let a=1
    ()->a
end

julia> typeof(c)
var"#15#16"{Int64}

julia> var"#15#16"{Int64}.instance
ERROR: UndefRefError: access to undefined reference