ggez | Rust library to create a Good Game Easily | Game Engine library

I managed to figure it out, by reiterating through the rust documentation. Although it feels a little fishy to answer my own question it might actually be helpful for others:

TLDR; We want the code inside the main function to have access to MyGame but any other module outside denied access.

Can it be done with factoring out the code to game.rs: No.

Can it be done at all: Yes.

Here is why and how:

From the rust documentation Visibility and Privacy:

With the notion of an item being either public or private, Rust allows item accesses in two cases:

1. If an item is public, then it can be accessed externally from some module m if you can access all the item's parent modules from m. You can also potentially be able to name the item through re-exports. See below.
2. If an item is private, it may be accessed by the current module and its descendants.

This means I cannot factor out horizontally and expect to limit horizontally at the same time. Since the main.rs is on the top level anything on the same level that is public is accessible to the whole crate as any other module since every module can access the parent of the top level. Therefore the answer for refactoring to the same level into a file (module) is: No.

On a side note, if I had factored out the code into a file called lib.rs then the only difference would have been the path, as lib.rs on the top level is implicitly just the crate path, while in a file called game.rs the path would be crate::game.

But the same behavior as the single file can be done by factoring out vertically. We create a directory called game and move game.rs inside this directory and add the pub keyword to MyGame: pub struct MyGame. Similar to the python __init__.py file rust needs a file mod.rs to make the directory a module. Inside the mod.rs you declare the files you have inside, mod game in our case. Now we could address MyGame by the path crate::game::game::MyGame, however since game.rs is declared private the access to MyGame is sealed, as all elements of the path have to be public. However, since MyGame is declared public, any module on the same level has access to it. We cannot move the main.rs into the game directory but we can factor the code inside it into another function. Let's call it init for lack of fantasy. We put the init function inside a file called init.rs inside the game directory and declare it public inside mod.rs like so: pub mod init. Now we can call game::init::init() because it is public, but not game::game::MyGame. Init however, has access to MyGame.

The final structure looks like this: