Proposal: Support "memory releasable" assigns

There are temporary_assigns which was used before streams. Not sure if it will be deprecated or not. I would think not as you can use it for this purpose.

It is not the same thing, temporary_assigns can only be set in a LV’s mount/3 call, you can’t use it inside a live_component or with more modern features like handle_async, etc.

Ohhhhh fair enough. Ya this would indeed be nice (although I clearly never run into it much).

This is not correct. In fact temporary_assigns is exactly what you are proposing here

I’m attaching a single file example that demonstrates temporary assigns both inside a LiveComponent and with handle_async:

Application.put_env(:sample, Example.Endpoint,
  http: [ip: {127, 0, 0, 1}, port: 5001],
  server: true,
  live_view: [signing_salt: "aaaaaaaa"],
  secret_key_base: String.duplicate("a", 64)
)

Mix.install([
  {:plug_cowboy, "~> 2.5"},
  {:jason, "~> 1.0"},
  {:phoenix, "~> 1.7"},
  # please test your issue using the latest version of LV from GitHub!
  {:phoenix_live_view,
   github: "phoenixframework/phoenix_live_view", branch: "main", override: true}
])

# build the LiveView JavaScript assets (this needs mix and npm available in your path!)
path = Phoenix.LiveView.__info__(:compile)[:source] |> Path.dirname() |> Path.join("../")
System.cmd("mix", ["deps.get"], cd: path, into: IO.binstream())
System.cmd("npm", ["install"], cd: Path.join(path, "./assets"), into: IO.binstream())
System.cmd("mix", ["assets.build"], cd: path, into: IO.binstream())

defmodule Example.ErrorView do
  def render(template, _), do: Phoenix.Controller.status_message_from_template(template)
end

defmodule Example.HomeLive do
  use Phoenix.LiveView, layout: {__MODULE__, :live}

  def mount(_params, _session, socket) do
    socket
    |> assign(:property, %{foo: 1, bar: 2, baz: 3})
    |> assign(:count, 0)
    |> start_async(:property, fn ->
      Process.sleep(1000)
      %{foo: 4, bar: 5, baz: 6}
    end)
    |> then(&{:ok, &1, temporary_assigns: [property: nil]})
  end

  def handle_async(:property, {:ok, result}, socket) do
    {:noreply, assign(socket, :property, result)}
  end

  def render("live.html", assigns) do
    ~H"""
    <script src="/assets/phoenix/phoenix.js"></script>
    <script src="/assets/phoenix_live_view/phoenix_live_view.js"></script>
    <%!-- uncomment to use enable tailwind --%>
    <%!-- <script src="https://cdn.tailwindcss.com"></script> --%>
    <script>
      let liveSocket = new window.LiveView.LiveSocket("/live", window.Phoenix.Socket)
      liveSocket.connect()
    </script>
    <style>
      * { font-size: 1.1em; }
    </style>
    <%= @inner_content %>
    """
  end

  def render(assigns) do
    ~H"""
    <%= @count %>
    <button phx-click="inc">+</button>
    <button phx-click="dec">-</button>

    <%= @property.foo %>
    <%= @property.bar %>
    <%= @property.baz %>

    <div style="border: 1px solid black">
      <.live_component id="lc" module={Example.LiveComponent} />
    </div>
    """
  end

  def handle_event("inc", _params, socket) do
    {:noreply, assign(socket, :count, socket.assigns.count + 1)}
  end

  def handle_event("dec", _params, socket) do
    {:noreply, assign(socket, :count, socket.assigns.count - 1)}
  end
end

defmodule Example.LiveComponent do
  use Phoenix.LiveComponent

  def mount(socket) do
    socket
    |> assign(:property, %{foo: 10, bar: 20, baz: 30})
    |> assign(:count, 0)
    |> start_async(:property, fn ->
      Process.sleep(1000)
      %{foo: 40, bar: 50, baz: 60}
    end)
    |> then(&{:ok, &1, temporary_assigns: [property: nil]})
  end

  def handle_async(:property, {:ok, result}, socket) do
    {:noreply, assign(socket, :property, result)}
  end

  def render(assigns) do
    ~H"""
    <div>
    <%= @count %>
    <button phx-click="inc" phx-target={@myself}>+</button>
    <button phx-click="dec" phx-target={@myself}>-</button>

    <%= @property.foo %>
    <%= @property.bar %>
    <%= @property.baz %>
    </div>
    """
  end

  def handle_event("inc", _params, socket) do
    {:noreply, assign(socket, :count, socket.assigns.count + 1)}
  end

  def handle_event("dec", _params, socket) do
    {:noreply, assign(socket, :count, socket.assigns.count - 1)}
  end
end

defmodule Example.Router do
  use Phoenix.Router
  import Phoenix.LiveView.Router

  pipeline :browser do
    plug(:accepts, ["html"])
  end

  scope "/", Example do
    pipe_through(:browser)

    live("/", HomeLive, :index)
  end
end

defmodule Example.Endpoint do
  use Phoenix.Endpoint, otp_app: :sample
  socket("/live", Phoenix.LiveView.Socket)

  plug(Plug.Static, from: {:phoenix, "priv/static"}, at: "/assets/phoenix")
  plug(Plug.Static, from: {:phoenix_live_view, "priv/static"}, at: "/assets/phoenix_live_view")

  plug(Example.Router)
end

{:ok, _} = Supervisor.start_link([Example.Endpoint], strategy: :one_for_one)
Process.sleep(:infinity)

Temporary assigns tell LV to reset the value of the assign to the value given in mount and only re-render the parts of the template using the assign when it is assigned again.

You are totally correct! I just tested it myself with your code and it worked great, now I feel dumb to not realizing that myself

Ha, I also am feeling dumb