Dusty
Are nested structs an anti-pattern?
In the course of working on a tree-like data structure, I have designed a struct for each node in the tree. Since there are only 5 fields in each node, and all nodes have the same 5 fields, using a struct made sense to me.
However, one of the %Node{} struct fields contains the children of the node, which is a list of %Node{} structs, each of which can have its own children, and so on.
Given the challenges of accessing nested structs, I am beginning to question my original decision to use a struct instead of a map. I see that there are a number of posts already on how to access nested structs, but I’m still left asking: What does a struct really offer me here? Basically, it offers me the ability to limit the keys for each node. But is that a worthwhile tradeoff, given that the number of nested levels could be very high? Is it really a problem to just use a map?
The nature of the code is such that reaching down many levels at once is unlikely to be needed. For the most part, the tree will be walked one level at a time, but it will frequently be necessary to match on or modify fields in the node’s children (1 level down). It seems that the risk of unintended fields on the struct is perhaps not worth the complexity of using a struct in the first place.
Thoughts?
Most Liked
NobbZ
Not beeing able to use Access out of the box for your Node structs is actually a feature in my opinion. This enables you to come up with an implementation of Access that would make even more sense for a tree.
NobbZ
You can’t have circular references in immutable data structures.
You can of course simulate them using a flat datastructure and mentioning IDs.
dimitarvp
You can draw inspiration from my extremely amateurish Trie library which was basically my first ever Elixir code somewhere back in 2016, here: https://github.com/dimitarvp/trie/blob/master/lib/trie.ex#L202. This demonstrates a basic Access.get implementation. Once your struct has that you could easily use get_in with instances of the struct as parameters.
Also check out Access docs. You need only implement a few functions to be able to use get_in and put_in.
domvas
Your struct is a good idea. It’s in fact better than a bare map because you need the field where children are stored. Without it, some of your code can break.
Regarding your node data / properties, you can have anything you want if you specify a filed for them like this:
@type t :: %Node{
children: [Node.t], # This is mandatory for each node
id: integer, # This is an example data that must be defined for each node
properties: map # Other data specific to the node
}
Regarding the missing Enumerable, you have two solutions:
- Implement it for your struct
- or the easy way: Map.from_struct/1

But on in all, it can be interesting to code your own traversal to have more control on what it’s done. Something like Node.update(depth, filter_fn, update_fn) could be nice for example.
Additionnally, if you want to go back and forth in your structure while updating it may be useful to investigate Zippers.
Hard to code but pure delight afterwards when using it.
NobbZ
I don’t see how accessing nested structs is different from nested maps, as structs are just maps with some additional field from this point of view.
Structs, nested or not, enable you to have at least limited compiletime checking of fieldnames.
Using bare maps you won’t have that.







