Share variable with all functions in a module

Simply put, you don’t do that in an FP language (though there are escape hatches like ETS indeed).

You’ll get better responses if you specify your original problem – and not how you want to solve it.

Are you looking how you can handle state? If yes you can use Agents for storing something simple (a string)

As mentioned, you cant do what you are trying because modules are not classes, they don’t contain state.

For that you need a GenServer (which agent is just more simplified)

A GenServer would be perfect for that. You can even make it so that the GenServer automatically refreshes the token every interval.

e.g.

defmodule TokenManager do
  use GenServer
  
  # Stick `TokenManager` in your Application's children
  def start_link(init_arg) do
    GenServer.start_link(__MODULE__, init_arg, name: __MODULE__)
  end
  
  def token do
    GenServer.call(__MODULE__, :token)
  end
  
  def init(init_arg) do
    token = 1
    Process.send_after(self(), :refresh_token, :timer.seconds(2))
    {:ok, token}
  end
  
  def handle_call(:token, _from, token) do
    {:reply, token, token}
  end
  
  def handle_info(:refresh_token, old_token) do
    new_token = old_token + 1
    Process.send_after(self(), :refresh_token, :timer.seconds(2))
    {:noreply, new_token}
  end
end

Edit: untested code FYI

For a similar case, when I need to use and update something, I use the following kinda programming pattern. But as @hlx mentioned, Genserver might serve best for your case without further knowing the context of your original problem.

defmodule SomeModule do
@state %{token: nil}

def some_function(params, state) do
 state
end

def another_function(params, params2, state) do
state
end

def update_token(state) do
# update the token
%{token: updated_token}
end

end

So, I try to pass around states, between functions, so any update that happens in any function should be available to the next one. Not sure it serves your purpose, maybe you can add further context to it.