anchor.diff:  `in`.  We can easily support these using metadata syntax.  For `in`,
   use `some`.
   
  -==== key filters
  +=== [[keys]] key filters
   
   E.g. fetch entities with kind :Person whose key is greater than some k K:
   
  
positive.code: (entity-map! :transaction :into [:A/B] {:x 9}) ;;
  ----
  
  === Schema support
  
  * associate e.g. Prismatic schema specification with kind keyword
  * postfix '?' on kind keyword means "validate against schema"; e.g.
  
negative.code: * enhance ctors/co-ctors to work with edn
  * implement edn emitter, e.g. `entity-edn`, `to-edn`, or the like
  
  == [[ctors]] ctors
  
  * modal keywords:  `:replace, :transaction, :into, :merge, :conj` etc.
  * keyword `:replace` - use `:!' instead?
  * pull ctor `entity-map*` - default to homomorphisms, support `:iso` to force isomorphic matches
  
  === [[entity-tree]] entity-tree ctor
  
  Use case: add a tree of entities, such that parent entity key is
  parent key of child.  For example:
  
  [source,clojure]
  ----
  ^{:migae/keychain [:Parent/A]} {:a 1}
  ^{:migae/keychain [:Parent/A Child/A]} {:b 1}
  ^{:migae/keychain [:Parent/A Child/A Grandchild/A]} {:c 1}
  ^{:migae/keychain [:Parent/A Child/B]} {:b 2}
  ^{:migae/keychain [:Parent/A Child/C]} {:b 3}
  ----
  
  Suppose further that we want to use kinded keys, letting the Datastore
  autogen ids for at least some of the parent entities.  In that case we
  would have to push the parent, extract its key, and then use that key
  to construct the children.  The `entity-tree` constructor will sugar
  this; something along the lines of:
  
  [source,clojure]
  ----
  (entity-tree [^{:migae/keychain [:Parent]} {:a 1}
  	       [^{:migae/keychain [:Child/A]} {:b 1}
  	         [^{:migae/keychain [:Grandchild/A]} {:c 1}
  	        ^{:migae/keychain [:Child/B]} {:b 2}
  		^{:migae/keychain [:Child/C]} {:b 3}]])
  ;; or, even sweeter:
  (entity-tree [[:Parent] {:a 1}
  	       [;; vector of entity-tree nodes
  	        [[:Child/A] {:b 1}
  	          [[:Grandchild/A] {:c 1}]]
  	        [[:Child/B] {:b 2}]
  		[[:Child/C] {:b 3}]]])
  ----
  
  A node in the tree is a vector containing a parent kinded entity-edn
  and a vector of child tree nodes.
  
  
  == [[filters]] filters (pull ctor patterns)
  
  i.e. query filters.
  
  