anchor.diff:  seen in any code that you plug in to process the query.
   
   There are some predefined (namespaced) keys that have special meaning to the parser. In particular
  -`:com.wsscode.pathom.core/reader` can be used to supply a reader function for the parser to use.  The `reader` is
  -simply a function that is asked "read *this* particular thing (e.g. `:person/name`) in the current environment
  -from whatever data source can supply it".
  +`:com.wsscode.pathom.core/reader` can be used to supply reader(s) for the parser to use.  The `reader` can be a map from
  +attributes to functions, a plain function, or even a vector of functions. It is asked to read the value for the elements
  +of the query using the current environment. We'll expand on that as we go, or you can read more in the <<Readers,Readers section>>.
   
   == A Trivial Parser
   
  
positive.code: 
  Recursive calls are widespread during parsing, and Om.next makes it even easier by providing the current parser as part of the environment. The problem is that if you just call the same parser recursively then there is no chance to change how the reading *process* operates.
  
  In order to improve this situation `pathom` makes the `:parser` *and* `r:eader` part of the environment, allowing you to *replace* it when doing a recursive parser call:
  
  ```clojure
  (ns pathom-dynamic-reader
  
negative.code: 
  = Pathom Core Engine
  
  == Readers [[Readers]]
  
  A reader is a function that will process a single entry from the query. For example, given the following query:
  `[:name :age]`. If you ask an `om.next` parser to read this the reader function will be called twice; once for `:name` and another one for `:age`. Note that in the case of joins, the parser will only be called for the join entry, but not for it's children (not automatically), for example: given the query `[:name :age {:parent [:name :gender]}]`. The reader function will be called 3 times now, one for `:name`, one for `:age` and one for `:parent`, when reading `:parent`, your reader code is responsible for checking that it has a children query, and do a recursive call (or anything else you want to do to handle this join). During this documentation, we are going to see many ways to implement those readers.
  