Parsing a Struct String - Code.eval_string/3? Custom Parser? Other Options?

Give us an example what would your users type?

If it’s something as simple as name: "James", phone: 123 then you can get away with just using String and Enum.

Code.eval_string/3 is not safe, as you have full access to the runtime system, you can read the warning in the documentation.

My use case is more involved. I can have nested children up to 3 levels deep.

For example, this is possible:

%Parent{
    field: "Value",
    another_field: "Another value",
    child_list: [
        %Child{
            child_field: "Child 1 data",
            grandchildren_list: [%GrandChild{field: "Value"}, %GrandChild{field: "Some other value"}]
        },
        %Child{
            child_field: "Child 2 data"
        }
    ]
}

So your users basically type Elixir data structures?

Just use Code.string_to_quoted and traverse the AST. It is very easy to do

Exactly

I’ll try this and get back to you.

Thank you

For the data you showed perhaps just consider JSON as the user-facing format? Non-evaling conversion to maps/structs without much work by you?

You’re right. The AST is easy to parse.

I might settle for this approach.

Thanks for pointing this out.

Thanks, @kip

JSON would have been my goto approach.

However, there are two nuances I have to consider:

1. Any of Parent, Child, and GrandChild in the example above can be the root node, and the system’s behavior adjusts accordingly.

2. GrandChild can be of multiple types and the keys for each are different (imagine TypeOne{some_key: "Value",...}, TypeTwo{another_key: "Value"...}…)

If I go with JSON, handling these nuances might mean tagging each sub(object) with {"type": "NodeNameHere", ...}.

For our largely non-technical user base, requiring this tag (along with requiring quotes around each JSON key) will be too verbose.

Atom-keyed Elixir structs feel more succinct and expressive.

# JSON
{
  "type": "Parent",
  "field": "Value",
  "another_field": "Another value",
  "child_list": [
      {
          "type": "Child"
          "child_field": "Child 1 data",
          "grandchildren_list": [
            {
              "type": "TypeOne",
              "field": "Value"
            },
            {
              "type": "TypeTwo",
              "another_field": "Some other value"
            }
        ]
      },
      {
          "type": "Child",
          "child_field": "Child 2 data"
      }
  ]
}

vs

# Struct
%Parent{
  field: "Value",
  another_field: "Another value",
  child_list: [
      %Child{
          child_field: "Child 1 data",
          grandchildren_list: [
            %TypeOne{field: "Value"},
            %TypeTwo{another_field: "Some other value"}
        ]
      },
      %Child{child_field: "Child 2 data"}
  ]
}

If there’s a workaround to reduce this verbosity, I’ll surely want to know 'cause parsing JSON will be an almost zero-stress approach for me.