Hello everyone, I'm making a game engine in Go and I have a question about exposing the API.

This API is what allows developers to define the behaviors of their game and/or software. Despite being far into the development, I was never been able to figure out how to expose the API in a good way and I'm stuck on whether to expose an interface or struct.

I tried both approaches and they have their own pros and cons. So, I wanted to ask for your opinion on which approach is the most "Go" for these kinds of problems.

I have the following behaviors: - Load/OnSpawn : When the game is started. - Unload/OnDespawn : When the game engine swap contexs. - Destroy/OnDispose : When the game is terminated. - Draw : A call for each frame. - ProcessEvent : Whenever an event is received. - and many others.

I could follow the Go's best practices and create an interface for all behaviors, and then wrap all of them into a big interface:

``` type GameRunner interface { Unloader Drawer // ... }

type Loader interface { Load() error }

type Unloader interface { Loader Unload() error }

type Drawer interface { Draw() error }

// ... ```

Or I can create a struct that has all the callbacks:

type ControlBlock struct { OnSpawn func() error OnDespawn func() error OnDispose func() error // ... }

Which strategy is the best? Is there like an hybrid approach that suits best that I did not considered?

(Optional) If you know better names for the methods/callbacks and interfaces/structs, let me know. I'm bad at naming things.

NOTES: I need this API exposing since the developers can pass their modules to the game engine.

``` // main.go

func main(){ settings := // your settings. module := // your object compliant to the interface or struct.

err := engine.Execute(module, settings) // run the module // handle error. } ```