Can I read from channels and Update the model?

[rew1nter]

I went through the tutorials, bubbles, and a few examples but couldn't figure this out. Is this possible to listen to a channel and update the model?

[deicon]

Sure. You might want to look at how glow uses a channel to load files.

https://github.com/charmbracelet/glow/blob/4dd3ba1d3c2b47a68b3ee4a7f30f97b0e5b18c78/ui/ui.go

func findNextLocalFile(m model) tea.Cmd {
	return func() tea.Msg {
		res, ok := <-m.localFileFinder

		if ok {
			// Okay now find the next one
			return foundLocalFileMsg(res)
		}
		// We're done
		if debug {
			log.Println("local file search finished")
		}
		return localFileSearchFinished{}
	}
}

[rew1nter]

Can't wrap my head around it, unfortunately. Could you please show how this piece of code would work in the realtime example to transfer strings over channel?

[deicon]

Not sure what the exact problem is here. The sample does exactly what you where asking for. I didn't know this one but the more complex one in glow. But still they both do the same thing.

In Init(), we send out two commands. One for each side of the channel.

listenForActivity(m.sub), // generate activity
waitForActivity(m.sub),   // wait for activity

Those two methods return a cmd each. Each command basically is an action, which once it finishes delivers a message. Message can transport data.
Once a Message is received, it is passed into the Update Method of the model, where the Model can react on the message and literally update its state aka model.

So in this example, the listenForActivity(...) function is actually simulating any asynch call by simply waiting before sending a message onto the channel. It does this in an endless loop. So once the message is pushed into the channel its going to sleep again before another message is sent. This command is kind of misusing the ELM Architecture, as the command never actually returns a message. All it does is, that it constantly pushes out messages onto a channel.

func listenForActivity(sub chan struct{}) tea.Cmd {
	return func() tea.Msg {
		for {
			time.Sleep(time.Millisecond * time.Duration(rand.Int63n(900)+100))
			sub <- struct{}{}
		}
	}
}

That covers the sending part of the channel.

The other side of the channel simply receives data from the channel and returns it as a message which will end up in one of the next calls to the models Update method.

// A command that waits for the activity on a channel.
func waitForActivity(sub chan struct{}) tea.Cmd {
	return func() tea.Msg {
		return responseMsg(<-sub)
	}
}

All thats missing is the action on the message within the Update method. Whenever a message of the responseMsg type is received, all it does is to count the message and return the same command again by call waitForActivity again

case responseMsg:
		m.responses++                    // record external activity
		return m, waitForActivity(m.sub) // wait for next event

I am not sure if this is of any help.

[meowgorithm]

Editor's note: there's more detail to the answer in the surrounding questions as well. We're choosing this one as "the answer" mostly to mark this discussion as answered in general.

[rew1nter]

Great explanation! That definitely helped me understand it better.

Heres what I'm trying to do. Lets say the channel is of type string and listenForActivity() func looks like this:

func listenForActivity(sub chan string) tea.Cmd {
	return func() tea.Msg {
		for {
			time.Sleep(time.Millisecond * time.Duration(rand.Int63n(900)+100))
			sub <- "this is str"
		}
	}
}

where the waitForActivity() func is listening to the channel for string. Now in that case how'd I access and print the data that waitForActivity() function receives?

[rew1nter]

case responseMsg:
		m.responses++                    // record external activity
		return m, waitForActivity(m.sub) // wait for next event

Here its just incrementing an int in the model upon a message. Whereas Im trying to read what actually came out of waitForActivity function. Hope I've been able to explain what I'm trying to do.

[deicon]

Almost there.
instead of sending a string, you send a Message containing the string (data). Thats how Messages work here actually.

type MessageStruct struct {
     data string
}

func listenForActivity(sub chan string) tea.Cmd {
	return func() tea.Msg {
		for {
			time.Sleep(time.Millisecond * time.Duration(rand.Int63n(900)+100))
			sub <- MessageStruct{
                                         data: "thestring"
                                     }
		}
	}
}

So the Cmd is returning a message using a typed struct containing your data.
All the channel reading cmd does is to take the received message and pass it on as a bubbletea message. All what happens here is that the Message received from the channel is passed on to Update() message.

// A command that waits for the activity on a channel.
func waitForActivity(sub chan struct{}) tea.Cmd {
	return func() tea.Msg {
		return responseMsg(<-sub)
	}
}

With the Update Message the message is received and we can easily get to the data

case MessageStruct:
                fmt.Printf("Message contains %s", msg.data)
                // restarting the reading by calling the waitForActivity again,
		return m, waitForActivity(m.sub) // wait for next event

Sos thats all there is to it. If this all does not make sense, please consider taking a step back and start with simple examples, not using channels. Just to get the basic concepts of Command, Messages and how the Update View Cycle actually works.

[rew1nter]

Perfect! This is exactly what I was trying to do. Thanks for the help.

[rew1nter]

Welp I ran into this situation. I want to execute one pair of listenForActivity and WaitForActivity, get the results, then start another pair of these two functions for a different job.

I can store the result data from the first pair of execution into a struct and use it for the next. But how do I do it at first? I'm not supposed to somehow stop the entire execution and restart it with different functions right? can I somehow reInit()?

[bashbunni]

Update on this one: we did a blog post on "Channels in Bubble Tea" specifically because it has been asked about quite a bit.
https://charm.sh/blog/commands-in-bubbletea/

[deicon]

Not sure here, but the question was regarding reading from channels and updating the model. The blog post seems not to cover this.
It seems more a question of how to update my UI (Update) when some data arrives from a different part of my app. For this scenario, channels are a nice way to decouple UI and logic.

[franalbani]

I've recently read this discussion and I agree with @deicon , whom I would like to thank for the explanations!

I'm building a tool to inspect various aspects of a running process [1], and I will use this to improve the way I'm reading stdout and stderr.

[1] https://github.com/franalbani/loupe

[meowgorithm]

Just to close the loop here—no, the blog post doesn't cover working with channels (per the question). That said, @deicon has done a great job explaining the nuances of the realtime example which is how we recommend working with channels from within Bubble Tea (thank you, @deicon!).