My preferred approach would be:

[]
|> prepend_if_true(cond1, [1])
|> prepend_if_true(cond2, [2])
|> prepend_if_true(cond3, [3])
|> Enum.reverse()

defp prepend_if_true(list, cond, extra) do
  if cond, do: extra ++ list, else: list
end

Just a couple of weeks ago we had something similar come up which involved collecting key/values into a map based upon conditions in another data structure. I came up with this helper function:

  defp conditional_put(map, _key, nil), do: map
  defp conditional_put(map, key, val), do: Map.put(map, key, val)

and for decimals:

  defp conditional_put_decimal(map, _key, nil), do: map
  defp conditional_put_decimal(map, key, num_str) do
    case Decimal.parse(num_str) do
      {:ok, num} -> Map.put(map, key, num)
      :error   -> map
    end
  end

Those pipeline nicely.

Thank you @josevalim and @gregvaughn!

I took a bit of everyone’s suggestions and ended up with this helper function which I think strikes the best balance for me; I’m not manipulating large lists on this occasion, so I opted for appending rather than prepending for convenience:

  def cond_append(list, false, _), do: list
  def cond_append(list, true, fun) do
    list ++ [fun.()]
  end
  def cond_append(list, bool_fun, value_fun) do
    if bool_fun.(), do: list ++ [value_fun.()], else: list
  end

I do have complex bool logic sometimes, hence the extra version accepting list, fun, fun.

Thanks everyone