Avoiding type assertions for sub-models

[yrashk]

I noticed the following pattern in my models:

If a model has multiple models, my parent's model would have to call Update on them. However,Update returns tea.Model and if this is not what I store in my parent model, I would have to assert type, something like:

m1, cmd := m.m1.Update(msg)
m.m1 = m1.(M1)
cmds = append(cmds, cmd)

However, this is far from being ergonomic, so I devised this helper method:

func Update[M tea.Model](model M, msg tea.Msg) (M, tea.Cmd) {
	new_model, cmd := model.Update(msg)
	return new_model.(M), cmd
}

and my original code becomes this:

m.1m1, cmd := Update(m.m1, msg)
cmds = append(cmds, cmd)

Also, noticing how it is still a two-liner, I improved the above helper to return an appended list of commands (to be later combined with Batch or Sequence):

func Update[M tea.Model](model M, msg tea.Msg, cmds []tea.Cmd) (M, []tea.Cmd) {
	new_model, cmd := model.Update(msg)
	return new_model.(M), append(cmds, cmd)
}

Now my code looks like this:

m.1m1, cmds = Update(m.m1, msg, cmds)

Any thoughts?

[meowgorithm]

That's very nice. We've discussed changing Model and Program.Run to use generics internally, however because it's a breaking change we don't expect to apply it until the next major version.

For what it's worth, it's perfectly fine to not implement tea.Model on children:

// On the child. We return the concrete type rather than an abstract tea.Model.
func (m ChildModel) Update(msg tea.Msg) (ChildModel, tea.Cmd) { /* ... */ }

// In the parent. No assertion necessary.
m.child, cmd = m.child.Update(msg)

[yrashk]

Oh, I know you don't have to, but I prefer them to be composable. For example, to be able to run them in a program at a top level, so prefer them to satisfy the interface.