(v2) Remove Model.Init() in favor of a tea.InitMsg

[myaaaaaaaaa]

As of the below PR, Model.Init() and Model.Update() now have nearly identical signatures:

• feat!: make Init return the model #1112

At this point, we might as well just turn it into a tea.InitMsg like so:

diff --git a/tea.go b/tea.go
index cc0406c..e39727b 100644
--- a/tea.go
+++ b/tea.go
@@ -795,11 +795,11 @@ func (p *Program) Run() (Model, error) {
 	// Start the renderer.
 	p.startRenderer()
 
 	// Initialize the program.
 	var initCmd Cmd
-	model, initCmd = model.Init()
+	model, initCmd = model.Update(InitMsg{})
 	if initCmd != nil {
 		ch := make(chan struct{})
 		p.handlers.add(ch)
 
 		go func() {

Thoughts?

[bashbunni]

Hey thanks for mentioning this! I'm going to convert this to a discussion as it's not something directly actionable at the moment.

[meowgorithm]

Hi! So this is interesting. We're unlikely to stray too far from Elm's conventions, but how would this work in practice?

[myaaaaaaaaa]

Models that don't need initialization can now save some boilerplate:

-func (m model) Init() (tea.Model, tea.Cmd) {
-	return m, nil
-}
 func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	switch msg := msg.(type) {
+		// no case for tea.InitMsg
 	}
 	return m, nil
 }

---

Models that do need initialization now have more options. As an example, given this ticker:

type model int
type tickMsg struct{}

func tick() tea.Msg {
	time.Sleep(time.Second)
	return tickMsg{}
}
func (m model) Init() tea.Cmd {
	return tick
}
func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
	switch msg.(type) {
	case tickMsg:
		return m + 1, tick
	}
	return m, nil
}

Users now have the option of fully inlining everything into one function, which can sometimes be the most convenient solution (though not always pretty):

type model int
type tickMsg struct{}

func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
	switch msg.(type) {
	case tea.InitMsg, tickMsg:
		return m + 1, func() tea.Msg {
			time.Sleep(time.Second)
			return tickMsg{}
		}
	}
	return m, nil
}

Or they can keep them as separate cases, but still having the benefit of sharing setup/teardown code due to being in a single function:

type model int
type tickMsg struct{}

func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
	tick := func() tea.Msg {
		time.Sleep(time.Second)
		return tickMsg{}
	}
	if !enableTick {
		tick = nil
	}

	switch msg.(type) {
	case tea.InitMsg:
		return m, tick
	case tickMsg:
		return m + 1, tick
	}
	return m, nil
}