 
    In such a case, the join would look like this:
 
+         (join has-a-and-b has-b-and-c {:b :blike}) =>
                                            #{{:a 1, :b 2, :blike 2, :c 1}
                                              {:a 1, :b 2, :blike 2, :c 2}
 

  "Add more key/value pairs to `kvs`. They are found by looking up values
  in a [[one-to-one-index-on]] or [[one-to-many-index-on]] index.

  See <<someplace>> for examples.

  The `options` control what maps are returned and how they're merged into the
  original `kvs`. They may be given as N keys and values
  following `kvs` (Smalltalk style) or as a single map. They are:

  :using <index>
    (required) The index to use.
  :via <key>
    (required) A single foreign key or a sequence of them that is used to
    look up a map in the <index>.
  :into <key>
    (optional, relevant only to a one-to-many map). Since a one-to-many map
    can't be [[merge]]d into the `kvs`, it has to be added \"under\" (as the
    value of) a particular `key`.
  :keys <[keys...]>
    (optional) Keys you're interested in (default is all of them)
  :prefix <prefix>
    (optional) Prepend the given prefix to all the keys in the selected map.
    The prefix may be either a string or keyword. The resulting key will be
    of the same type (string or keyword) as the original.
  "

  ([kvs options]

                                             {:a 2, :b 2, :c 1}
                                             {:a 2, :b 2, :c 2}}}

   Alternately, you can use a map to describe which left-hand-side keys should be
   considered the same as which right-hand-side keys. In
   the above case, the sharing could be made explicit with `(join
   has-a-and-b has-b-and-c {:b :b})`.

