Need help with this nested list

Questions / Help
1

I have the following list:


[
  :juridical_person_document,
  [re_developments: [[properties: [[re_development: [:re_developer]]]]]],
  :legal_address
]

And my desired output would be this:

[
  :juridical_person_document, 
  re_developments: [properties: [re_development: 
  [:re_developer]]],
  :legal_address
]

In other words, I want to remove the unnecessary square brackets. How can I achieve that?

2 
[
  :juridical_person_document, 
  re_developments: [properties: [re_development: [:re_developer]]],
  :legal_address
]

As a literal, this isn’t valid syntax and makes the compiler complain:

** (SyntaxError) iex:18:67: unexpected expression after keyword list. Keyword lists must always come last in lists and maps. Therefore, this is not allowed:

    [some: :value, :another]
    %{some: :value, another => value}

Instead, reorder it to be the last entry:

    [:another, some: :value]
    %{another => value, some: :value}

Syntax error after: ','
    |
 18 |   re_developments: [properties: [re_development: [:re_developer]]],
    |                                                                   ^

The closest you can get is:

[
  :juridical_person_document, 
  {:re_developments, [properties: [re_development: [:re_developer]]]},
  :legal_address
]

It’s certainly possible to remove the extra lists wrapped around some elements, but I’d start by looking into where this data comes from - specifically, why every keyword list seems to end up with an extra list wrapped around it.

2 Likes
3

Welcome to the forum.

As @al2o3cr points out, your desired output is not even legal syntax. But if you put the atoms in front and the lists at the bottom then it becomes legal:

[
  :juridical_person_document,
  :legal_address,
  re_developments: [properties: [re_development: [:re_developer]]]
]

Note that this is actually a short-hand / convenient form of:

[
  :juridical_person_document,
  :legal_address,
  {:re_developments, [properties: [re_development: [:re_developer]]]}
]

Your original problem is solveable if you can do a recursive visit function that converts double-nested lists – e.g. [ [elements, ...] ] – to normal lists (e.g. [elements, ...]).

We can give you the solution if you are truly stuck, no worries, but it’s usually a good idea for you to learn. So what have you tried?

Secondly, avoid the XY problem and let us know the original problem you are grappling with that led to this conundrum. Maybe we’ll be able to help better.

3 Likes
4

@al2o3cr Indeed, this is not valid syntax. Thanks for letting me know.

@dimitarvp I discovered that Macro.postwalk(list, fn [[x]] -> [x]; x -> x end) works for this case. But you’re right about the fact that I should learn how to handle this, I will take some time to study recursion better.