Modeling array of enums with associated values

[tylerjames]

I'm modelling some state based on an array of objects that have some common properties and a field called args that contains properties unique to each type. I've modelled it using an enum like this:

enum Mode: Codable, Equatable {
  case alpha(isActive:Bool, args:AlphaArgs)
  case beta(isActive:Bool, args:BetaArgs)
  case gamma(isActive:Bool, args:GammaArgs)
  case delta(isActive:Bool, args:DeltaArgs)
  case epsilon(isActive:Bool)
}

// Example Args
struct AlphaArgs {
  var name:String
  var age: Int
}

struct BetaArgs {
  var isHungry:Bool
  var weight: Double
}

So I have a parent state with IdentifiedArrayOf<Mode> and a child feature that represents an individual mode.

struct ChildFeature: ReducerProtocol {
  struct State {
	 let mode:Mode
    
    var name::String {
       mode.name
    }
    //etc

    init(mode:Mode) {
    }
  }
} 

And I need to create a Form based on the properties of the mode and its args, the isActive and all of the custom args will map to toggles or text fields that can be edited.

Here's where I'm stuck
I'm not sure how to model the args state and the actions here since every different Mode type would need to have some different actions.
There's a small number of different modes and changeable properties so I wouldn't be averse to creating a custom View for each

Has anybody run into this sort of issue before? I feel like I'm missing something obvious or trying to shoehorn this solution when I should be taking a different approach.

[mbrandonw]

Does it help if you refactor your Model type to extract out the common isActive field?

struct Model {
  var args: Args
  var isActive: Bool
}
enum Args {
  case alpha(AlphaArgs)
  case beta(BetaArgs)
  case gamma(GammaArgs)
  case delta(DeltaArgs)
  case epsilon
}

This kind of data type may play more nicely with TCA.

[tylerjames]

Sorry, just getting back to this now. I think I've got something that works. Though I'm curious if a JSON that looks like:

{
   "modes": [
      "alpha": {
        "isActive": true,
        "args": {
          "name": "whatever",
          "age": 32
        }
      },
      "beta": {
        "isActive": false,
        "args": {
          "isHungry": true,
          "weight": 170.0
        }
     }
   ]

... is decodable where the "args" part is the enum and the rest is a struct. I think once I saw the array of different objects that an enum made sense. I suppose I could decode it that way and then map them to an object that's more suitable for my store.

[tgrapperon]

I feel that the easiest would be to have the isActive boolean as a property of AlphaState, BetaState, etc. In other words, bundle the two associated values from your enum's case into one type. I would initially have suggested the same approach as Brandon, but this json suggests that it will be maybe smoother with the isActive flag bundled with the args.