   which will load the specific entity (assuming your server responsds with it) into you client database. This could be
   used, for example, to refresh a particular entity in your client database.
 
-  Giving a post mutation would allow you to further integrate that entity into you views.
-
-  NOTE: the `untangled.core/integrate-ident!` function is particularly handy for peppering the resulting ident
-  around the views in a post mutation.
+  Giving a post mutation as a parameter would allow you to further integrate that entity into you views. Post mutations are 
+  run after the query, and allow you to modify the application state as you see fit.
+
+  NOTE: the `untangled.core/integrate-ident!` function is particularly handy for peppering the ident of the resulting item
+  around the views via a post mutation.
 
   #### Use case - Loading a collection into an entity
 

        ...
        (dom/button #js { :onClick #(df/load-field this :comments) } \"Load comments\")
        ...)

  ;; Note that the call to load field above is the same as:
      (df/load-data this (om/full-query this [:comments])
        :ident (om/get-ident this)
        :refresh [(om/get-ident this)])
  ```

  then clicking the button will result in the following query to the server:

  ```
  [{[:item/by-id 32] [{:comments [:other :props]]}]
  ```

  and the code to write for the server is now trivial. The dispatch key is :item/by-id, the 32 is accessible on the AST,
  and the query is a pull fragment that will work relative to an item in your (assuming Datomic) database!

  Furthermore, the underlying code can easily put a marker in place of that data in the app state so you can show the
  'load in progress' marker of your choice.


  One common operation is to load data in response to a user interaction. Interestingly, the query that you might
  have used in the initial load use case might have included UI queries for data you didn't want to fetch yet. So, we want
  to note that the initial load use-case supports eliding part of the query. For example, you can for example load an item without
  comments. Later, when the user wants to see comments you can supply a button that can load the comments on demand. The earlier
  use case on startup demonstrated this technique.

  The `load-field` function, which derives the query to send to the server from the component itself, can be used to trigger the 
  load of the subsequent data:

  ```
  (load-field this :comments)
