Multi assign/stream

MUSTDOS

Hello all!

assign(socket, :name, “Elixir”)

Why can’t we have assign/stream take a group of atoms and maps/structs as a default to reduce spamming assign/stream along with their parentheses?

I know this isn’t a perfect example of code but here’s what I cooked up but it returns a list of assigns/streams instead finalizing them

def socket_initializer(socket,initializer_list) do
  socket = Enum.map(initializer_list, fn {key,value} ->
    case key do
      :stream -> 
        Enum.map(value, fn {stream_name, stream_value} -> 
         IO.inspect stream(socket, stream_name, stream_value)
        end)

      :assign ->
        Enum.map(value, fn {assign_name, assign_value} ->
          IO.inspect assign(socket, assign_name, assign_value)
        end)

      _ ->
        IO.puts(to_string(key) <> " is not a valid initalizer")
    end
  end)
end

initializer_list = [
  { :assign , [ {:search, %Worker{}}, {:active_account_tuple , Operations.status_tuple_registration()} ] },
  { :stream , [ {:workers , %Worker{}} ] }
]

5 comments

/phoenix #liveview

0 940 5

2025-12-30 14:10:39 UTC

Showing Posts 1 to 5

Show Best Posts
Show All (oldest first)
Show All (newest first)

rhcarvalho

stream/4 works on a single stream, but assign/2 can assign multiple values at once.

The one you were referring to is assign/3 which works on a single item.

Post #1

al2o3cr

(NOTE: spruced up the formatting of your code example using triple-backticks ```)

I don’t personally see a huge difference between adding a stream by writing:

  {:stream, [{:whatever, %Whatever{}}]},

and

  |> stream(:whatever, %Whatever{})

Your post mentions “along with their parentheses”, but the former definitely seems to have more bracketry than the latter.

Post #2

MUSTDOS

initializer_list = [
 {:stream, [
            {:whatever1, %Whatever1{}},
            {:whatever2, %Whatever2{}},
            {:whatever3, %Whatever3{}}
           ]
 },
 
 {:assign, [
            {:whatever4, %Whatever4{}},
            {:whatever5, %Whatever5{}},
            {:whatever6, %Whatever6{}}
           ]
 }
]

socket
 |> stream(:whatever1, %Whatever1{})
 |> stream(:whatever2, %Whatever2{})
 |> stream(:whatever3, %Whatever3{})
 |> assigns(:whatever, %Whatever{})
 |> assigns(:whatever, %Whatever{})
 |> assigns(:whatever, %Whatever{})
(or)
|>assigns(fn %{struct_of_whatever: struct_of_whatever} -> %{whatever: struct_of_whatever} end)

I just felt easier for multiple copy and pastes for bigger pages.

Post #6