Access to global variable in fn

[gryznar]

Last update added support for global variables declaration. So I wrote some code to test that:

let x: UInt8 = 1


fn test_global():
    print(x)

test_global()

This gives me an error about unknown declaration "x". Is this not implemented yet or am I doing sth wrong?

[lattner]

@Mogball ?

[gryznar]

@Mogball So maybe it is worth to point it out in documentation and language description that Mojo can behave also like a interpreted one and replicate Python behavior? It looks like a real game changer! Hiding this feature may confuse and misleads people.

One more thing to add is also mentioning that (as of my knowledge) Mojo will have optional GIL to handle C extensions for example (another great advantage). It may be another game changer, because all current extensions could work out-of-the-box without any changes required and hopefully with the same speed.

Currently it may seem that use cases are somehow restricted, because of not clarifying that details

[Mogball]

The feature is accessible in the sense that compile-time expressions are evaluated using an interpreter. Like

fn sum(lb: Int, ub: Int, step: Int):
  var total = 0
  for i in range(lb, ub, step):
    total += i
  return total

fn main():
  alias x = sum(10, 20, 2) # `x` is evaluated at compile time: the interpreter invokes `sum`
  print(x) # should compile to `print(70)`

By "it is not directly accessible", I mean that it is not possible to run normal Mojo code using the interpreter. It is only invoked during compilation.

[gryznar]

Are there plans to make it accessible? Or interpreter is tend to stay "implementation detail"?

[Mogball]

Are there plans to make it accessible?

Not at the moment. The interpreter is a low-level affair so some amount of "compilation" would still have to occur before it can be invoked.

[gryznar]

Make sense! Thanks for clarification :)