Codegeneration tool

[cekisakurek]

Hello dear TCA community,
I am making a code generation tool for TCA. I modelled the structure as Modules(for reducers) which has states and actions as well as submodules(which is a reference to a module). And I use this and populate a template to generate the code.
And I have a couple of questions and need some feedback from the community to cover the edge cases and check this tool can be useful at large too.

My first question is my model treats the state as a struct. But as you know we can use enums to represent the state which can be powerful. But I think the enum states also can be representable in a struct(but we lose the mutually exclusiveness of enums states) Is my assumption correct? And can you think of a case where it must be represented as an enum.
Side note: I modelled the navigation structure in submodules and solved the problem that comes with NavigationStackStore.

My second question is related to how I want to create the code. Currently I want to make it as a standalone SPM package so I don't have to deal with "generated code" and "editable code" The trade off is I had to introduce a mechanism to forward the actions to a function or somewhere where we can edit the custom business logic related to every action. So currently I create a protocol with all the actions and forward the actions to a static reference in the Module. I hope the code explains it further.

public struct AppModule: Reducer {

public static var controller: AppModuleReceiver!

public struct State: Equatable {}

public enum Action: Equatable {
    case setupLaunch
}

public var body: some ReducerOf<Self> {

    case .setupLaunch:
        // Here I redirect every action to the static controller
        return AppModule.controller.setupLaunch(state: &state, action: action)
}

}
public protocol AppModuleReceiver {
func setupLaunch(state: inout AppModule.State, action: AppModule.Action) -> Effect<AppModule.Action>
}

This also prevents the use of the generated code partially which removes a lot of flexibility. My current model works for me but since I would like this tool to be open source I would love some feedback from other people if I am making the tool restrictive.
Lastly I would like to ask you is that have you ever used a code generation tool and what do you think about them in general.
Thank you in advance

[mbrandonw]

And can you think of a case where it must be represented as an enum.

Well, if you are willing to model your domain imprecisely then certainly enums are never required, and in fact the vast majority of languages do not have enums. You can always swap out:

enum State {
  case child1(Child1.State)
  case child2(Child2.State)
}

…with:

struct State {
  var child1: Child1.State?
  var child2: Child2.State?
}

However, there are a lot of problems with modeling domains in this way, and so we do not recommend it. And it would be strange to force this style onto people who use your tool.

My current model works for me but since I would like this tool to be open source I would love some feedback from other people if I am making the tool restrictive.

I'm not sure I 100% understand the motivation for this approach, but I can say that referring a global mutable variable like this:

public static var controller: AppModuleReceiver!

…may be problematic. It opens up the possibility of people outside the module completely replacing this value. And in Swift 6 it will be a compiler error for escaping closures to capture mutable variables, and so this code will not even compile someday in the future. You will see this if you turn on concurrency warnings to the max in your code.

Lastly I would like to ask you is that have you ever used a code generation tool and what do you think about them in general.

We personally have never felt the need for code generation in our projects. In general it's quite difficult to properly integrate these kinds of tools into projects, and we think the time spent making the tool work pales in comparison to just writing out the code for a new feature.

However, that is just our personal preference. We do know others maintain tools in the community, and so it's definitely helping out some people!

[cekisakurek]

I have a sample project now if you like to check out the structure https://github.com/cekisakurek/CodegenTest
I am sorry for the formatting, still couldn't figure out how to format properly with jinja. This will be the end product. It is an spm package.

So I want to be able to override the return effects in a reducers body. Since this is an spm package I can't be able to edit it and the Receiver protocol is how I try to do it.

I got your point on it is overridable which is not ideal. I think I can get rid of it by creating a local array with all the Receivers and pass it when I am creating the store for root reducer. But it will be more complicated since then I have to map the receivers to reducers etc.

But I couldn't really understand "compiler error for escaping closures to capture mutable variables" error. Can you please elaborate on this? (having a static variable in a struct seems very innocent)

[mbrandonw]

But I couldn't really understand "compiler error for escaping closures to capture mutable variables" error. Can you please elaborate on this? (having a static variable in a struct seems very innocent)

Unfortunately it is not innocent at all. If you run the following code in a project with concurrency warnings turned to their max, you will see the problem:

struct Feature {
  static var int: Int! = 0
  func body() {
    _ = Reduce {
      // ⚠️ Reference to static property 'int' is not concurrency-safe 
      //     because it involves shared mutable state
      Self.int += 1  
    }
  }
}
struct Reduce {
  let run: () -> Void
}

Because Reduce takes an escaping closure it is not safe to access mutable state from within it, and it will be an error in Swift 6.

[cekisakurek]

Thank you for your explanation. I will go back to drawing board and try to figure out a way out.