K1::Core.Box
f1::#f1#15
Body:
begin
K1::Core.Box = $(Expr(:new, :(Core.Box)))
NewvarNode(:(f1::#f1#15))
unless (Base.sle_int)(n::Int64, 0)::Bool goto 6 # lin
e 139:
(Main.throw)($(Expr(:new, :(Base.ArgumentError), "The
angular velocity must be greater than 0.")))::Union{}
6: # line 143:
(Core.setfield!)(K1::Core.Box, :contents, 3.0)::Float
64 # line 146:
f1::#f1#15 = $(Expr(:new, :(Main.#f1#15), :(K1)))
return f1::#f1#15
end::#f1#15
```
`Core.Box` doesn鈥檛 mean that there鈥檚 a type instability. It just means the variable gets boxed, here because it might not be needed depending on if there鈥檚 an exception or not. But its result is not type-unstable. In fact,
```julia
(Core.setfield!)(K1::Core.Box, :contents, 3.0)::Float64 # line 146:
```
this line says that it knows that the contents will be `Float64`, so all of the types in the AST are inferred and everything is fine.
---
### Author:  [@Ronis\_BR](https://discourse.julialang.org/u/Ronis_BR)
#### Post date: [April 8, 2018, 10:49pm UTC](https://discourse.julialang.org/t/correct-way-to-declare-global-constant-in-modules/10234/10 "2018-04-08T22:49:45Z")
Hi @ChrisRackauckas
Sorry, it is a part of a bigger code and I maybe misunderstood the real problem. See this other code:
```julia
VERSION >= v"0.4.0-dev+6521" && __precompile__ ()
module TestConst
export test
# Earth Equatorial radius [m].
const R0 = 6378137.0
# Standard gravitational parameter for Earth [m^3/s^2].
const m0 = 3.986004418e14
# Perturbation terms based on EGM-08 standard gravitational model [1, pp. 1039].
const J2 = 1.08262617385222e-3
# Earth's orbit mean motion [rad/s]
const ne = (360.0/365.2421897)*pi/180/86400
function test(n::Number, e::Number)
# Check if the arguments are valid.
if (n <= 0)
throw(ArgumentError("The angular velocity must be greater than 0."))
end
if !( 0. <= e < 1. )
throw(ArgumentError("The eccentricity must be within the interval 0 <= e < 1."))
end
# Auxiliary variables.
sqrt_m0 = sqrt(m0)
sqrt_e2 = sqrt(1-e^2)
# Auxiliary constant to compute the functions.
K1 = 3.0*R0^2*J2*sqrt_m0/(4.0*(1-e^2)^2)
# Declare the functions that must solved for 0.
f1(a, i) = ne + 2.0*K1*a^(-3.5)*cos(i)
a_k::Float64 = (m0/n^2)^(1/3)
i_k::Float64 = acos( -ne*a_k^(3.5)/(2*K1) )
f1(a_k, i_k)
end
end
```
In this case, it is not correcting guessing the return value:
```julia
return $(Expr(:invoke, MethodInstance for (::TestConst.#f1#1)(::Float64, ::Float64), :(f1), SSAValue(1), :(i_k)))
end::Any
```
On the other hand, if I remove `K1` from the function `f(a,i)`, then it works:
```julia
return $(Expr(:invoke, MethodInstance for (::TestConst.#f1#1)(::Float64, ::Float64), :(f1), SSAValue(0), SSAValue(1)))
end::Float64
```
**NOTE** : I know that I can always do `K1::Float64`, but I want to avoid that.
---
### Author:  [@tkoolen](https://discourse.julialang.org/u/tkoolen)
#### Post date: [April 9, 2018, 12:07am UTC](https://discourse.julialang.org/t/correct-way-to-declare-global-constant-in-modules/10234/11 "2018-04-09T00:07:57Z")
The code is type-stable in the sense that the output type is inferred correctly, but there鈥檚 still a performance issue here: the code in [this post](https://discourse.julialang.org/t/correct-way-to-declare-global-constant-in-modules/10234/6) allocates with the `if` statement in place, while it doesn鈥檛 without that `if` statement. ~~I think that @NickNack鈥檚 assessment ([performance of captured variables in closures 路 Issue #15276 路 JuliaLang/julia 路 GitHub](https://github.com/JuliaLang/julia/issues/15276)) is correct, especially given that the [`let` block workaround](https://github.com/JuliaLang/julia/issues/15276#issuecomment-297596373) fixes the performance problem:~~
Edit: I鈥檓 no longer convinced that it鈥檚 [performance of captured variables in closures 路 Issue #15276 路 JuliaLang/julia 路 GitHub](https://github.com/JuliaLang/julia/issues/15276), as the `let` block trick doesn鈥檛 work.
---
### Author:  [@Ronis\_BR](https://discourse.julialang.org/u/Ronis_BR)
#### Post date: [April 9, 2018, 1:10am UTC](https://discourse.julialang.org/t/correct-way-to-declare-global-constant-in-modules/10234/12 "2018-04-09T01:10:33Z")
Should I do something? Comment on this bug perhaps?
---
### Author:  [@tkoolen](https://discourse.julialang.org/u/tkoolen)
#### Post date: [April 9, 2018, 1:43am UTC](https://discourse.julialang.org/t/correct-way-to-declare-global-constant-in-modules/10234/13 "2018-04-09T01:43:44Z")
I鈥檇 give it a minute, maybe someone who knows more about the internals of Julia will stop by this post.
---
### Author:  [@tkoolen](https://discourse.julialang.org/u/tkoolen)
#### Post date: [April 9, 2018, 1:58am UTC](https://discourse.julialang.org/t/correct-way-to-declare-global-constant-in-modules/10234/14 "2018-04-09T01:58:38Z")
Actually, I didn鈥檛 apply the `let` block trick correctly previously. The following doesn鈥檛 exhibit the performance problem:
```julia
module TestConst
export test
function test(n::Number, e::Number)
# Check if the arguments are valid.
if (n <= 0)
throw(ArgumentError("The angular velocity must be greater than 0."))
end
# Auxiliary constant to compute the functions.
K1 = 3.0
# Declare the functions that must solved for 0.
f1 = let K1 = K1
(a, i) -> K1
end
end
end
```
---
### Author:  [@StefanKarpinski](https://discourse.julialang.org/u/StefanKarpinski)
#### Post date: [April 9, 2018, 3:22am UTC](https://discourse.julialang.org/t/correct-way-to-declare-global-constant-in-modules/10234/15 "2018-04-09T03:22:27Z")
This isn鈥檛 the basic 15276 because a much fancier optimization is required. Naively, the inner function `f` is visible and could be called throughout the outer test function鈥攂efore or after `K0` is defined. In order to correctly implement that, `K0` must be boxed so that it鈥檚 state can be either unassigned or assigned. The compiler would have to prove that `f` cannot be called before `K0` defined in order to know that it doesn鈥檛 need to do any boxing here. It鈥檚 possible but quite tricky. You could try moving the definition of `K0` before the error checks or putting the main computation into a separate function body that is called after the checks are done. It鈥檚 also worth filing an issue about this situation since we would ideally like to handle it efficiently.
---
### Author:  [@Ronis\_BR](https://discourse.julialang.org/u/Ronis_BR)
#### Post date: [April 9, 2018, 2:17pm UTC](https://discourse.julialang.org/t/correct-way-to-declare-global-constant-in-modules/10234/16 "2018-04-09T14:17:42Z")
Hi guys,
First of all, thanks for the help. As per @StefanKarpinski advice, I opened a issue in gitbhub: [Variable type is not inferred correctly if an `if` statement is added 路 Issue #26752 路 JuliaLang/julia 路 GitHub](https://github.com/JuliaLang/julia/issues/26752)
Sorry about the technical description and title of the issue, I really do not have the necessary technical background to do any better 馃檪
> [@StefanKarpinski](#):
>
> You could try moving the definition of K0 before the error checks or putting the main computation into a separate function body that is called after the checks are done.
You are right! If I put `K1` before the `if`, then the problem is gone!