anchor.diff:     :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.
  +----
  +
  +thus, the `:character/tv-show-id :got` entry in the characters table is a pointer to the Game of Thrones (got) TV show in the
  +TV shows table.
  +
  +
  +Next we'll define a helper function that will help us look up things in these tables.
  +
  +NOTE: we'll combine the tables above together into our parsing environment as `:db` in a later step, like this `{:db (atom {:characters characters :tv-shows tv-shows})}`. Our helpers assume this.
  +
  +[source,clojure]
  +----
   (defn characters-by-ids
  -  "Return a list of charaters for the given character IDs from the current parsing env"
  +  "This helper is given the parsing environment (where we'll pass in our database) and a list of character IDs.
  +   It returns the sequence of rows in the table that match those IDs."
     [{::keys [db] :as env} ids]
     (map (get @db :characters) ids))
  -
  +----
  +
  +and next a map-based reader for "resolving" a few things that are derived from either
  +the context, or a more complex "query" of the database.  Note that we're parsing a graph
  +query, so whenever we expect an attribute to be used as a join we must use the join helpers
  +to tell the parser to continue processing the subquery of the join:
  +
  +[source,clojure]
  +----
  +;; an example of a reader that doesn't need any context: This returns a random character from our database.
   (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
  
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: <div class="space"></div>
  ++++
  
  = Pathom Connect [[Connect]]
  
  In the previous sections we saw a way to implement parsers that are mostly driven by taking
  an attribute and responding to it. But this implemention is opaque, you have no way to
  