My best try to explain 
sorry I am not native in english
shahryarjb
NduatiK
That is why I added the order list in my suggestion. You can separate your description of the children and information about their order.
Let’s say you have order of UUIDs ["text-1", "text-2", "text-3"], when a user moves the div with ID text-1 down, you can do the following (SwappableList is defined at the end):
order = ["text-1", "text-2", "text-3"]
# Place text-1 after text-2
SwappableList.move_after(order, "text-1", after: "text-2"))
For your usecase, you could have a method that takes elements, the path to the parent, the id you want to move and the location you want to put it after.
# move(elements, "layout", "parent", "text-1", "text-2")
def move(elements, layout_id, parent_id, id, after_id) do
update_in(elements, [:children, layout_id,:children, parent_id, :order], fn order ->
SwappableList.move_after(order, id, after: after_id))
end)
end
SwappableList
defmodule SwappableList do
@doc ~S"""
Inserts
## Examples
# if item_before is nil, move to the front of the list
iex> SwappableList.move_after([1,2,3], 0, after: nil)
[0,1,2,3]
iex> SwappableList.move_after([1,2,3], 0, after: 2)
[1,2,0,3]
# If item already in list, change its location
iex> SwappableList.move_after([1,2,3], 0, after: 4)
[1,2,3]
# Delete all existing occurences
iex> SwappableList.move_after([1,2,3], 2, after: 3)
[1,3,2]
iex> SwappableList.move_after([1,2,2,3], 2, after: 3)
[1,3,2]
iex> SwappableList.move_after([1,2,3], 3, after: 1)
[1,3,2]
"""
def move_after(list, new_item, after: item_before) do
do_move_after([], list, item_before, new_item)
end
defp do_move_after(_, list, nil, new_item) do
[new_item | list]
end
defp do_move_after(head, [item_before | tail], item_before, new_item) do
Enum.reverse(head) ++ [item_before, new_item | Enum.reject(tail, &(&1 == new_item))]
end
defp do_move_after(head, [], _, new_item) do
Enum.reverse(head)
end
defp do_move_after(head, [another_item | tail], item_before, new_item)
when another_item == new_item do
do_move_after(head, tail, item_before, new_item)
end
defp do_move_after(head, [another_item | tail], item_before, new_item) do
do_move_after([another_item | head], tail, item_before, new_item)
end
end
1
NduatiK
Super interesting, Lenses are familiar from Haskell, but I’ve never seen them used in Elixir!
1
shahryarjb
krstfk
Can confirm that pathex is great. It’s one of the libraries that I add to all my projects (almost : except when working on libs where dependencies should be minimised, even then I’d add pathex if necessary).
2
shahryarjb
Yes sure, I want to try it, but I do not want to be dropped inside magic; so I need to review the code and learn some concept this library use.
At the beginning of my project I really needed to keep my project size very small but this is taking up a lot of my time.
Thank you for the confirming
0
hst337
Pathex is just like Elixir’s builtin Access, but structure-friendly, user-friendly, more performant and with some other cool features. They both use the same approach called “Functional optics”. Long story short, this approach is about writing fn functions which can set/get/update value in a structure (like getters or setter in OOP languages), and libraries like Pathex or Access are providing interface to create these functions and compose them together.
This approach is really useful and I suggest everyone to learn some optics, because it is universal way to traverse any nested structure. There are XPaths for XML, there are CSS selectors for HTML, there is dot-notation for structures, there is Access for primitive structures, but these approaches are format-specific, which is strange since everything in Elixir is represented as a combination of maps, lists and tuples. So, Pathex just leverages this feature and significantly reduces amount of stuff one must know to traverse nested data in Elixir. Just master Pathex and you can traverse XML, HTML, nested JSON or anything else using one tool.
So, there’s no magic, there are just functions, hehe
4
Sebb
agree, only that it is most of the time way easier to work in a flat structure. May be a little slower to render, but will not be relevant in this use case.
1