anchor.diff:  `p/join`:: Satisfy a to-one join, and continue parsing.
   `p/join-seq`:: Satisfy a to-many join, and continue parsing
   `p/entity-attr!`:: Look up a (required) attribute from the current entity (context). Throws if missing.
  -`p/map-reader`:: A reader that assumes the current contextual entity is a map, and tries to use it to satisfy queries
  +`p/map-reader`:: The map reader, as discussed previously.
  +
  +Our example first starts with the expected preamble:
   
   [source,clojure]
   ----
   (ns pathom-docs.hello-entities
     (:require [com.wsscode.pathom.core :as p]))
  -
  +----
  +
  +Next we define some pretend database tables where the key is our pretend row ID, and the value is a pretend entity. Since
  +we're using keywords as IDs, you'll also note that our "relations" are either simple keywords (to-one) or vectors of
  +keywords (to-many):
  +
  +[source,clojure]
  +----
   ; define some data of tv shows, as a simple map-based table
   (def tv-shows
     {:rm  #:tv-show{:title         "Rick and Morty"
  
positive.code:    :arya    #:character{:name "Arya Stark" :tv-show-id :got}
     :morty   #:character{:name "Morty Smith" :tv-show-id :rm}
     :ygritte #:character{:name "Ygritte" :tv-show-id :got}})
  
  ; Helper functions are always handy when parsing.
  ; In this case we only need the db from our parsing environment,
  ; but taking env as a parameter makes calling it easier and enables
  ; evolution of env without intrusive API changes.
  (defn characters-by-ids
    "Return a list of charaters for the given character IDs from the current parsing env"
    [{::keys [db] :as env} ids]
    (map (get @db :characters) ids))
  
  (def computed
    ; example of a "global attribute": returns a random character from our
    ; database, and can be fetched without regard for context.
    {:characters/random
     ; pretend the db is your datomic database or a Postgres connection,
     ; anything that would enable you to reach the data
     (fn [{::keys [db] :as env}]
       (let [character (rand-nth (-> @db :characters vals vec))]
         ; Use `join` to recursively parse the sub-query with the new to-one entity context
  
negative.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* `:reader` part of the environment, allowing you to *replace* it when doing a recursive parser call:
  
  ```clojure
  (ns pathom-dynamic-reader
  