Complex loop in EEx

Hello, I’d try to simplify it by moving the function to the view module, using string interpolation, i.e. (disclaimer: untested code ahead..)

def eval_item(x, index) do
  case x do
    {k, v} -> 
      "#{k} #{v} : @index: #{index}"
    val ->
      "#{val} : @index: #{index}"
    end
end

or with two functions using pattern matching on arguments (that I prefer as I find it easier to read):

def eval_item({k, v} = x, index), do: "#{k} #{v} : @index: #{index}"

def eval_item(x, index), do: "#{x} : @index: #{index}"

then in the template you could just:

<%= Enum.with_index(list) |> Enum.map(&eval_item/2) %> 

hth.

I would even go further and put all logic in a helper function. Putting logic in the template is not something I would advise.

Somehing like

<%= do_something(list) %> 

yes, good advice!

[..edit..] Putting all together would look like:

in template.html.eex

<%= iterate_over(list) %> 

in template_view.ex

def iterate_over(list) do
 list
 |> Enum.with_index()
 |> Enum.map(&eval_item/2)
end

defp eval_item({k, v} = _x, index), do: "#{k} #{v} : @index: #{index}"

defp eval_item(x, index), do: "#{x} : @index: #{index}"

These are good suggestions, but I’m not sure how to implement these inside of a template where the user’s formatting string (i.e. the template itself) needs to be referenced in the function (rather than the hard-coded example strings like "#{k} #{v} : @index: #{index}"

I might have to go meditate a bit more at the altar of Enum…

I figured out a solution based on your suggestions… I just had to jiggle my EEx tags around. There was an important caveat I had to consider here that makes it a better solution to have this logic done in the template – it has to do with a Handlebars parser I’m writing: GitHub - fireproofsocks/zappa: Elixir implementation of the Handlebars template language · GitHub

In the below example, both the list or map input options work:

      input = ["apple", "boy", "cat"]
      input = %{x: "xray", y: "yellow"}
      eex = ~s"""
          <ul>
          <%= Enum.with_index(list) |> Enum.map(fn({x, index}) -> %>
              <%= if is_tuple(x) do %>
                <% {k, v} = x %>
                <li><%= k %>: <%= v %></li>
              <% else %>
                <% this = x %>
                <li><%= this %></li>
              <% end %>
            <%= end) %>
          </ul>
      """

      out = EEx.eval_string(eex, list: input)

Yes, that looks awful, but this structure will work in my weird use-case.

<% %> doesn’t work like that (been there tried that ), and you can simplify the map/case by pattern matching in the function signatures.

untested:

<%= Enum.with_index(list) |> Enum.map(fn
  {{k, v}, index} ->
    "#{k} #{v}: @index: #{index}"
  {x, index} ->
    "#{x}: @index: #{index}"
end) %>