Pathex - a library for performing fast actions with nested data structures

Here you go

defmodule X do
  import Pathex
  import Pathex.Combinator
  import Pathex.Lenses

  def post_lens(post_id) do
    combine(fn recursive ->
      matching(%{id: ^post_id}) ||| path(:children) ~> some() ~> recursive
    end)
  end

  def set_show_reply_form_to_true(tree, post_id) do
    Pathex.set!(tree, post_lens(post_id) ~> path(:show_reply_form), true)
  end
end

And try it out with this

%{
  id: 1,
  show_reply_form: false,
  children: [
    %{
      id: 2,
      show_reply_form: false,
      children: [
        %{
          id: 4,
          show_reply_form: false,
          children: []
        }
      ]
    },
    %{
      id: 3,
      show_reply_form: false,
      children: [
        %{
          id: 5,
          show_reply_form: false,
          children: []
        }
      ]
    }
  ]
}
|> X.set_show_reply_form_to_true(4)
|> IO.inspect()

A few words about this cryptic thing

combine(fn recursive ->
  matching(%{id: ^post_id}) ||| path(:children) ~> some() ~> recursive
end)

I know that combine is hard to get correctly from the first try, especially when combined with logical operators (like |||), but my advise here is to always think of it as of a recursive tree traversal.

Once you get into the node, it might be the node you were looking for (hence the matching(%{id: ^post_id}), but if it is not (hence the |||), you need to check it’s children. First you need to find where the children are (under children key, hense the path(:children)), then you need to traverse all children or just some (here I assume we can encounter post with id=4 only once, so we need to find the single one, hence we do ~> some()), and then you need to treat them just like you did (hence the ~> recursive)

This section of the docs shows what I think I’m after, but I’m rather lost and have not managed to replace any nested value yet.

I have a nested structure of unknown levels, generated from Ecto results and Arbor. Simplified:

%Post{
  id: 1,
  show_reply_form: false,
  children: [
    %Post{
      id: 2,
      show_reply_form: false,
      children: [
        %Post{
          id: 4,
          show_reply_form: false,
          children: []
        }
      ]
    },
    %Post{
      id: 3,
      show_reply_form: false,
      children: []
    }
  ]
}

There’s always one root Post struct.

I need to update a couple of keys’ values (e.g., :show_reply_form to true) for the potentially nested struct/map that has a given id. The id is coming from a user-triggered LiveView event value.

As part of stumbling through, it seemed as if I needed to change this line from the documentation:

combine(fn recursive -> some() ~> (recursive() ||| matching()) end)

to the following in order to avoid errors:

combine(fn recursive -> some() ~> (recursive ||| matching(_)) end)

Here’s what I’m trying:

target_id = 4

path_to_post =
  combine(fn recursive -> some() ~> (recursive ||| matching(_)) end)
  ~> matching(%{id: _})
  ~> path(1 / :id) # ???
  ~> filtering(&(&1 == target_id))

test = Pathex.set!(post_tree, path_to_post, "x") # just testing replacement

It’s not erroring, but nothing is replaced.

I do have my own (probably horrible) function that’s working, but I think it’s not memory-efficient and runs through more of the posts than necessary:

  # Prevents recursing into children of target post, but still recurses through the rest
  defp set_post_data(%{id: post_id} = post_tree, target_id, new_values) when post_id == target_id do
    # Root post is target; no recursing required
    Map.merge(post_tree, new_values)
  end
  defp set_post_data(%{children: children} = post_tree, target_id, new_values) do
    case Enum.find_index(children, &(&1.id == target_id)) do
      index when is_integer(index) ->
        # One of the children is the target
        new_children = List.update_at(children, index, &(set_post_data(&1, target_id, new_values)))
        Map.put(post_tree, :children, new_children)
      _ ->
        # None of the children are the target; recurse
        new_children = Enum.map(children, &(set_post_data(&1, target_id, new_values)))
        Map.put(post_tree, :children, new_children)
    end
  end

    new_values = %{
      show_reply_form: true,
    }
    post_tree = set_post_data(socket.assigns.post, target_id, new_values)

So I thought I’d see if I could use Pathex. But I’m very open to using a better function than mine, too.

Thanks.

Try using Pathex.at/3 like this

Pathex.at(stuff, path(:key2) ~> star() ~> matching(%{foo3: _}), &Map.take(&1, [:foo, :foo2]))

I hope it’s okay to resurrect this thread. I have a quick question about Pathex. I feel like I may be missing something simple.

If I have a map → list → map structure, is there a way to return multiple keys from the inner map?

e.g.

stuff = %{ 
:key => "value",
:key2 => [ %{ :foo => "bar", :foo2 => "bar", :foo3 => "'baz"}, 
           %{ :foo => "baz", :foo2 => "fizz", :foo3 => "baz"}]
}

Pathex.view!(stuff, path(:key2) ~>  star() ~> matching(%{:foo3 => _}))

The above returns [%{foo: "bar", foo2: "bar", foo3: "'baz"}, %{foo: "baz", foo2: "fizz", foo3: "baz"}]
Can I return the values for :foo and :foo2 but not foo3? Is it only matching on the value?

I can add |> Enum.flat_map(& Map.take(&1, [:foo, :foo2])) to get what I need, just checking that I’m not missing some magic in the match.

Pathex 2.5.0 release

This release contains performance improvements, bug fixes and special functions for creating for_update-friendly lenses for structures and records. For more information, refer to changelog

For example,

iex> import Pathex.Accessibility
iex> uri_scheme_lens = from_struct(URI, :scheme)
iex> %URI{scheme: "http"} == Pathex.force_set(%{}, uri_scheme_lens, "http")
true

This is useful for doing deeply nested force_set and force_update operations

Pathex 2.4.0 release

This release contains bug fixes and improvements in negative indexes for lists and tuples and improvements for force_* operations. For more information, refer to changelog

For example, force_setting a value in list used to result in something like

iex> force_set! [1, 2], path(4), 0
[1, 2, 0]

And now the empty space is filled with nil like this

iex> force_set! [1, 2], path(4), 0
[1, 2, nil, nil, 0]

Pathex 2.3 release is here

Nothing special, just

1. Pathex.Short for shorter path definition. One can use just :x / : y instead of path :x / :y when using Pathex.Short
2. Pathex.pattern for creating patterns from inlined paths. For example,

use Pathex, default_mod: :json
import Pathex

pattern(four, path :x / :y / :z / 3) = %{x: %{y: %{z: [1, 2, 3, 4]}}}

3. Pathex now can be use-d inside functions or anything like this. This is now tested and supported.
4. Paths inlining is now detected for aliased, imported and macro calls. This is done using Macro.Env.lookup* functions, therefore pathex is compatible only with elixir 1.13 or higher
5. Spec fixes here and there, project formatting.

By the way, I’ve tested this release against gradient (from gradualizer project) and it seemed to be able to find some errors in specs, while failing to complete checking with exception and a bunch of false positives. And I’ve used mix_unused tool to find some unused functions (which helped me a lot)

Hi, I’ve just released 2.2.0, you can now use this function:

Yeah, that’s a good idea. I already have this in my TODO list, I’ll try to prioritize it for 2.2 or 2.3 versions then.

Thanks. Missed the matching/1

Do you think there’s a room for Pathex.new/1?

Thinking about:

def new(list \\ [])
  list
  |> Enum.reduce(matching(_), fn r, l -> l ~> r end)
end

I would be heppy to contribute. I get the compile time benefits, but sometimes it’s the way it is