anchor.diff:   (entity-map* :pfx [:A/B :C/D]) ;; fetch all entities with keychain prefix (i.e. ancestor) [:A/B :C/D]
   ----
   
  -## mutation
  +=== mutation
   
   [[app-listing]]
   [source,clojure]
  
positive.code: (= (val  em) {:a 1 :b 2})
  (= (keys em) [:a :b])
  (= (vals em) [1 2])
  ----
  
  ### Keys, keychains, keylinks, and dogtags
  
  A keylink is a namespaced keyword, e.g. `:Foo/Bar`.  A vector of
  keylinks is a keychain, which corresponds to a datastore Key, which
  
negative.code: registered for this thread.` (the test env seems to timeout); if so,
  just run `user=> (ds-reset)`.
  
  === testing
  
  See the link:test/clojure/migae[tests] for lots of examples of how to use
  the library.  Be **be forewarned**, the test cases are in flux; some
  of them are outdated, and the api is changing.
  
  === types
  
  * `migae.datastore.PersistentEntityMap` - migae representation of underlying `com.google.appengine.api.datastore.Entity`.  Implements IPersistentCollection, IPersistentMap, IMapEntry, etc.  See link:doc/Entities.adoc[Entities].
  * `migae.datastore.Keychain`  - migae representation of underlying `com.google.appengine.api.datastore.Key`.  A vector of Clojure keywords.  See link:doc/Keychains.adoc[Keychains].  (**Not yet implemented**)
  
  These are represented in migae as `entity-map` and `keychain`, respectively.
  
  === construction
  
  We have three ways to construct PersistentEntityMap objects:
  
  * local constructor:  `(entity-map <keychain> <map>)`
  * push constructor:   `(entity-map! <keychain> <map>)` - construct locally and push to datastore
  * pull constructor:   `(entity-map* <keychain> <map>)` - pull matching entities from datastore and construct corresponding PersistentEntityMap objects locally
  
  Push: by default the push ctor `entity-map!` first checks to see if an entity with that key already exists, and throws an exception if so; otherwise it constructs the PersistentEntityMap and saves the underlying Entity to the datastore.  This default behavior can be overriden by using the `:force` key, which will make the ctor save the construction absolutely, thus overwriting anything that might have previously been stored with that key.
  
  [[app-listing]]
  [source,clojure]
  ----
  (entity-map! [:A/B] {:a 1 :b 2})        ;; std local ctor expression
  (entity-map! [:A/B C/D] {:a 1 :b 2})    ;; ditto
  (entity-map! [:A] {:a 1 :b 2})          ;; kinded ctor (see below)
  (entity-map! [:A/B :C] {:a 1 :b 2})          ;; kinded ctor (see below)
  (entity-map! :force [:A/B] {:a 9 :b 10}) ;; force replacement
  ----
  
  === structural axioms
  
  [[app-listing]]
  [source,clojure]
  