ListAndHash

>Despite the fact that list 'n' hashes are very common, there are times I wish I was using a thoughtful tree representation. Such a model can provide richer navigation operations.

Specter[1] provides something like this for Clojure, allowing rich navigation and transformation abilities to deeply nested structures.

[1]: http://nathanmarz.com/blog/functional-navigational-programmi...

I've thought about this topic a lot recently. Many times I find myself working with API endpoints which return deeply nested JSON or XML "documents" which I have no real desire to learn their schema. (AWS and ElastiSearch)

I ended up creating a Python Library to perform key lookups on these deeply nested documents. For Example:

    >>> from nested_lookup import nested_lookup

    >>> document = [ { 'taco' : 42 } , { 'salsa' : [ { 'burrito' : { 'taco' : 69 } } ] } ]

    >>> print(nested_lookup('taco', document))
    [42, 69]

Check it out here:

* https://pypi.python.org/pypi/nested-lookup

* https://github.com/russellballestrini/nested-lookup

I've always wanted to write something like regular expressions for lists of objects. So, for example the example of writing a parser, one could use a regex to match chars to tokens, then write another that gathers tokens into blocks and etc. Essentially, bottom-up parsing without resorting to parser generators that take over everything. A similar tool would be interesting for querying trees directly.

Going into it I assumed this article was about data structures like the PHP "array", which are basically ordered hashtables that allow the programmer to treat them like either lists or hashes depending on context and still get reasonable performance. (I haven't seen this pattern used much elsewhere, has anyone?)

I'm not sure I understand why "S-expression" doesn't fit as a name for this data structure.

I wonder if the .Net/Java approach of "Iterables And Objects" with generic sequence operators either is ListAndHash or is the equivalent in more strongly typed languages. You essentially replace String->Object Hashes with Objects and Lambda lookup functions.

Finding out about "alists" and their lispy incarnation made me so happy. It was just so neat that something in some regards more capable than a typical hash table (key shadowing, references needn't be to the entire structure, ...) could spring to life, expressed in terms of barely anything atop the humble cons cell.

tldr you can have list or hashes to represent your data model, trivial observation