Uppercase in name of a function in Julia

Question

I am fairly new to Julia and got confused with the following code. After a function LucasTree is defined, it is used again as lt. Does Julia have some kind of role where I can recall a function using the uppercase abbreviation? If so, where can I find a nice reference for this feature?

function LucasTree(;γ = 2.0,
                   β = 0.95,
                   α = 0.9,
                   σ = 0.1,
                   grid_size = 100)

   ϕ = LogNormal(0.0, σ)
   shocks = rand(ϕ, 500)

   # build a grid with mass around stationary distribution
   ssd = σ / sqrt(1 - α^2)
   grid_min, grid_max = exp(-4ssd), exp(4ssd)
   grid = range(grid_min, grid_max, length = grid_size)

   # set h(y) = β * int u'(G(y,z)) G(y,z) ϕ(dz)
   h = similar(grid)
   for (i, y) in enumerate(grid)
       h[i] = β * mean((y^α .* shocks).^(1 - γ))
   end

   return (γ = γ, β = β, α = α, σ = σ, ϕ = ϕ, grid = grid, shocks = shocks, h = h)
end

function lucas_operator(lt, f)

    # unpack input
    @unpack grid, α, β, h = lt
    z = lt.shocks

    Af = LinearInterpolation(grid, f, extrapolation_bc=Line())

    Tf = [ h[i] + β * mean(Af.(grid[i]^α .* z)) for i in 1:length(grid) ]
    return Tf
end

Answer 1

No, this does not exist. It would be too nonunique to be practical, and moreover function names in Julia by convention should be entirely lowercase (structs/types can be CamelCase, but not functions, with the possible exception of constructors*).

In any case, all that is happening here in the code you have posted is that the function lucas_operator takes two arguments, lt and f, which can then be used within that lucas_operator function. These could in principle be anything, and regardless of what they are named outside the scope of the function, they will be named lt and f within the scope of the function. So for example:

function example(foo, bar)
    return foo(2*bar)
end

if you then call

example(somereallylongfunctionname, somevariable)

then that will return the equivalent of

somereallylongfunctionname(2*somevariable)

or similarly

example(SomeImproperlyCapitalizedFunction, somevariable)
# equivalent to SomeImproperlyCapitalizedFunction(2*somevariable)

in either case, regardless of its name outside the scope of the example function, the first argument passed to the function will be known as foo within the function.

* Aside about constructors: that would be a function that is used to construct a custom type. This doesn't quite do that, but it does return an instance of a NamedTuple which then seems to be treated somewhat like a type/struct in the subsequent code, so perhaps it could be counted as a constructor.