Map operation on recursive hierarchical structure (Composite pattern)

Are you looking for something like this?

iex(7)> posts                                                                                  
[
  %{"has_footnote" => false, "label" => "My Title Without Asterisk"},
  %{"has_footnote" => false, "label" => "My Title*"}
]
iex(8)> for %{"label" => title} = p <- posts do                                                
...(8)>   if String.ends_with?(title, "*") do                                         
...(8)>     %{p | "label" => String.trim_trailing(title, "*"), "has_footnote" => true}
...(8)>   else
...(8)>     p                                                                         
...(8)>   end
...(8)> end
[
  %{"has_footnote" => false, "label" => "My Title Without Asterisk"},
  %{"has_footnote" => true, "label" => "My Title"}
] 

Note that you don’t have to match the “label” key or even the fact that it’s a map. I just did it so that I could use title without writing p.title, but the risk here is that if you have a badly formed collection of posts and some of them don’t have the "label" key, this actually acts as a filter, which is likely not what you want.

The correct thing, of course, is to not be able to create a post struct like this without having these keys. You can do this using defstruct and the @enforce_keys module attribute (or using Vex, Ecto, etc. to have validation and required fields some other way):

defmodule MyApp.Post do
  @fields [:label, :has_footnote]
  defstruct @fields
  @enforce_keys @fields
end

Edit: Of course @kokolegorille has it: You need to simply call the transformation on the list of children you have as well, and as long as they have the needed keys you’ll be fine.

Maybe You want something more recursive, to process children as well?

defmodule Koko do
  def transform(%{"label" => label, "children" => children} = item) do
    if String.ends_with?(label, "*") do
      %{item | 
        "has_footnote" => true, 
        "label" => String.trim_trailing(label, "*"),
        "children" => Enum.map(children, &transform(&1))
      }
    else
      %{item | 
        "children" => Enum.map(children, &transform(&1))
      }
    end
  end
end

iex> koko = %{
  "label" => "My Title*",
  "has_footnote" => false,
  "children" => [
    %{
      "label" => "My Child with *",
      "has_footnote" => false,
      "children" => [
        %{
          "label" => "My SubChild with *",
          "has_footnote" => false,
          "children" => []
        },
        %{
          "label" => "My SubChild without",
          "has_footnote" => false,
          "children" => []
        }
      ]
    },
    %{
      "label" => "My Child without",
      "has_footnote" => false,
      "children" => []
    }
  ]
}

iex> Koko.transform koko
%{
  "children" => [ 
    %{
      "children" => [
        %{
          "children" => [],
          "has_footnote" => true,
          "label" => "My SubChild with "
        },
        %{
          "children" => [],
          "has_footnote" => false,
          "label" => "My SubChild without"
        }
      ],
      "has_footnote" => true,
      "label" => "My Child with "
    },
    %{"children" => [], "has_footnote" => false, "label" => "My Child without"}
  ],
  "has_footnote" => true,
  "label" => "My Title"
}

I find it more structured to separate the walking of the map (a “deep map”) from the transformation process. For example, I have a function called deep_map/2 that will recursively walk a map and invoke a function on each key-value pair. Its quite simple and documented at https://github.com/kipcole9/cldr/blob/master/lib/cldr/helpers/map.ex#L6-L44 I suspect many members of this forum have a similar function in their back pocket.

Using this approach you would do the following:

deep_map(your_map, fn 
  {"label", value} when is_binary(value) ->
    {key, String.trim_trailing(value, "*")}
  {key, value} -> 
    {key, value}
end)

(edited a bit to be clearer, not necessary exactly the required use case)

Here is a modification of @kokolegorille’s example, from an editor with some more structure:

defmodule Sandbox.Post do
  # `label` is the only key that needs explicit setting
  @keys [:label, has_footnote: false, children: []]
  @enforce_keys [:label]
  defstruct @keys

  @type t :: %__MODULE__{label: String.t(), has_footnote: boolean(), children: [t()]}

  @spec set_footnote(post :: t()) :: t()
  def set_footnote(%__MODULE__{label: title, children: children} = post) do
    if String.ends_with?(title, "*") do
      %{
        post
        | label: String.trim_trailing(title, "*"),
          has_footnote: true,
          children: Enum.map(children, &set_footnote/1)
      }
    else
      %{post | children: Enum.map(children, &set_footnote/1)}
    end
  end

  @spec new(label :: String.t(), children :: [t()]) :: t()
  def new(label, children \\ []) do
    if String.ends_with?(label, "*") do
      label_without_asterisk = String.trim_trailing(label, "*")

      %__MODULE__{
        label: label_without_asterisk,
        has_footnote: true,
        children: Enum.map(children, &set_footnote/1)
      }
    else
      %__MODULE__{label: label, children: children}
    end
  end
end

defmodule Sandbox.PostsRecursive do
  alias Sandbox.Post

  @posts [
    %Post{
      label: "Post with footnote*",
      children: [%Post{label: "Nested post with footnote*"}, %Post{label: "No footnote here"}]
    },
    %Post{label: "Top-level note without footnote", children: [%Post{label: "Footnote here*"}]}
  ]

  def example(), do: Enum.map(@posts, &Post.set_footnote/1)
end

I suggest studying @kip’s function in order to understand what is happening, as you’ll likely not have any issues with recursion as a concept if you fully understand it.

Edit: I’ve added an alternative approach using a new function that could move the application of this logic to the creation of posts instead, provided you create them by calling that function.

This, coupled with some discipline, is useful when you want to guarantee things about datatypes and is the preferred way in languages where the norm is to not expose raw data constructors and instead have limited interfaces generally only exposing constructor/modification/accessor functions.