Inline Tree Declarations in Grace

The Grace value class is a pretty useful container for tree-data. It walks and quacks like an associative array that, combined with the foreach macro makes it easy to inspect and manipulate tree structures using compact code like this:


void printListOfPersons (const value &persons)
{
 foreach (p, persons)
 {
   fout.writeln ("%s <%s>" %format (p["name"], p["email"]));
 }
}

Getting data into such a structure posed to be a bit of a challenge, though. You ended up with huge blocks of code with lots of repetitions:

persons["john"]["name"] = "John Smith";
persons["john"]["email"] = "jsmith@example.net";
persons["steve"]["name"] = "Steve McSmith";
persons["steve"]["email"] = "steve@example.net";

The repetitive nature wasn’t only straining on the hands, the build-up here also involved looking up the node for ‘john’ and ‘steve’ twice. Using the negative array index to refer to the last node was a nice timesaver in this respect:

persons["john"]["name"] = "John Smith";
persons[-1]["email"] = "jsmith@example.net";

The problem with this approach, apart from it still being pretty repetitive, is that it starts you thinking that the idiom persons[-1] means “the node I created in the line before”, but there are lots of situations where you cannot really know this. Take this example:

persons = listPersons();
persons["john"]["favoriteColor"] = "blue";
persons[-1]["favoriteSwallowType"] = "African";

All it takes for this code to break is the inclusion of the key ‘john’ in the result set of listPersons() at a position that is not the last one in the array. This may sound like a mistake that is easy to avoid, but in an application that sees a bit of growth, the assumptions you make in this respect may stop being valid in the future, and you’ll have forgotten all about them.

The solution to this problem came to me as an inspiration from jQuery’s clever discovery of this one symbol in the C-like namespace that managed to remain completely overlooked by most library builders: The dollar sign. On the global level, two variations of the function $(…) are defined that create a retainable pointer to a value object:

• $(“value”) creates an array and adds a node with “value” as its value data.
• $(“key”,”value”) creates a dictionary and adds a node with the key “key” and “value” as its value data.

These functions create a pointer to a value object, so the library also defines value::$(…). Now you can chain nodes together, like this:

value v = $("john",
             $("name", "John Doe") ->
             $("email", "jdoe@example.net") ->
             $("favoriteColors",
                 $("Titanium White") ->
                 $("Cadmium Yellow")
              ) ->
             $("favoriteNumber", 42)
          ) ->
         $("steve",
             $("name", "Steve Jibs") ->
             $("email", "sjibs@example.net") ->
             $("favoriteColors", $("Black")) ->
             $("favoriteNumber", 1)
          );

The result is pretty compact on a scale from 1 to JSON. There are some extra functions that will come of use:

• $attr(key,value) Sets an attribute.
• $type(type) Sets the value’s type().
• $val(otherval) Sets the value’s data only to that of otherval.
• $merge(otherval) Merges the child nodes and attributes of another value.

After these functions were added to grace, I started using them religiously. Inline declarations are a powerful way to keep your code readable. Thanks, jQuery.