Global module variables

[benstigsen]

So I have something like

main.b
foo.b
bar.b

main.b:

import .foo
import .bar

foo.init()
echo foo.data.keys() # [hello]

bar.init()

foo.b:

var data = {}

def init() {
  data["hello"] = nil
}

bar.b:

import .foo

def init() {
  echo foo.data.keys() # []
} 

What I would expect to see:

[hello] # from main.b
[hello] # from bar.b

What I see instead:

[hello] # from main.b
[]      # from bar.b

Is there any way to have foo.data be completely global to all of them, so that all modules share the same data? Or would I have to do something like:

foo.init()
bar.init()
bar.data = foo.data

[mcfriend99]

In Blade, imported module/packages are local to the file/module that imported them so every import of foo module will create a new instance of data. In this light, its not possible to do what you are trying to do this way.

However, the builtin reflect module defines the function set_global that allows you set a function or class as globally available throughout your application. So to answer the question "Is there any way to have foo.data be completely global to all of them?", I would suggest something like this.

base.b:

import reflect

var data = {}

def get_data() {
  return data
}

reflect.set_global(get_data)

foo.b:

def init() {
  get_data()["hello"] = nil
}

bar.b:

def init() {
  echo get_data().keys() # []
}

main.b:

import .base
import .foo
import .bar

foo.init()
echo get_data().keys() # [hello]

bar.init()

In this example, the base module defines the global value data and makes it available via the function get_data which was in turn made available to the entire application. Since it was imported before foo and bar ever get imported in the application, the function get_data will automatically be available to both and will consistently point to the same dictionary — data.

You can always retrieve an instance of data anywhere in your application using the get_data function.