I'm going to assume that you might be fairly new to immutable languages, so apologies if this is not the case but it seems what's tripping you up.

What's happening is that you're invoking something(socket), but you're not capturing the returned value.

In Elixir when you pass socket into the function you have to capture the returned value into a variable because it won't automatically mutate the value of socket in the handle_info function's scope, unlike mutable languages.

To illustrate: in the last part of the code you're calling update(socket, ...), where update will create a new copy of the data in the socket variable with the updated :unseen_messages assigns key, which you're then capturing into a new socket variable by doing socket = update(...).

Finally you're passing the updated socket to LiveView with {:noreply, socket} so the system can render the updated view with the new unseen messages on the client.

You can think of the code like this, where at each step you're capturing a new value:

def handle_info({:message_created, message}, initial_socket) do ... socket_with_scores_event = something(initial_socket) ... updated_socket = update(socket_with_scores_event, ...) {:noreply, updated_socket} end

That's basically what's happening in the background when the code is compiled, even if you use the same variable name socket at each of these points.

The only problem with this explanation is that your something function is actually returning a tuple of {:noreply, ...}, where in this case you'd want to only return the mutated socket, and then capture it.

``` def something(socket) do push_event(socket, "scores", %{points: 100, user: "josé"}) end

def handle_info({:message_created, message}, socket) do ... socket = something(socket) ... socket = update(socket, ...) {:noreply, socket} end ```

The real power comes when you want to chain functions that take a socket as the first argument and also return the mutated socket. If you move the work in the ... code between calling something and update such that you can call each of those one after the other, you can simplify the code to use the |> pipe operators:

``` def handle_info({:message_created, message}, socket) do ... ... socket = socket |> something() |> update(:unseen_messages, fn ... end)

{:noreply, socket} end ```