Application design around sum types.

[amano-kenji]

I have a code like this

data Mode = Normal | Error Text | Processing Text

data UIState = State1 Form | State2 Form | ...

data State = State {
  mode :: Mode
, uiState :: UIState
}

handleEvent :: BrickEvent n e -> EventM n State ()
handleEvent be = do
  State { mode, uiState } <- get
  case uiState of
    State1 form -> do
      form' <- nestEventM' form $ handleFormEvent be
      modify $ set #uiState $ State1 form'

nestEventM' results in two lines. I came up with zoomOut which compresses two lines into one line.

With zoomOut, the code looks like this. This actually works.

zoomOut :: (s -> t) -> s -> EventM n s () -> EventM n t ()
zoomOut constructor intState eventM = do
  intState' <- nestEventM' intState eventM
  put $ constructor intState'

handleEvent :: BrickEvent n e -> EventM n State ()
handleEvent be = do
  State { mode, uiState } <- get
  case uiState of
    State1 form -> do
      zoom #uiState $ zoomOut State1 form $ handleFormEvent be

Now, I can use zoom and zoomOut together, and there is one less line for sum types.

My problem was that nestEventM' involved a bit of boilerplate for sum types. I haven't really looked into converting State into a product type that contains all application modes simultaneously. I'm reasonably satisfied with zoomOut in my application.

What do you think is the right way or the best practice? What is the problem in this case? I think this codebase is small enough to understand the problem immediately. My whole codebase looks like this. mode is shared among all modes. UIState describes application modes. I'm open to a better way to do things if you can show me a broad picture.

[amano-kenji]

I'm going to elevate it to an issue.