CrossClj
full-text documentation search

Project count:
9877

Last update
Jun 16, 2018

How to be listed

Artifact list

Clojurescript

Feedback

RECENT
    Less more depended upon.
    Full-text search for function, var, namespace, project documentation and descriptions for Clojure open-source projects.
    Query syntax supports boolean modifiers (+word, -word), wildcards (* and ?, except for the first character of a word), and phrases ("word1 word2").
    To search for identifiers, use the name search.
    Found 11557 results in 317 projects. Show the first 500.
    widje 0.1.6
    Templating System for ClojureScript
    widje.util/evt->key (cljs)SourceDoc + Usages
    Maps event to readable key names

    eventsourcing 0.1.1
    A Clojure event-sourcing abstraction on configurable storage backends.
    gorillalabs.commons/merge-bySourceDoc + Usages
    Merges a collection coll of maps where the maps share a common key k.

    patchin 0.2.3
    Creates and applies patches to datastructures
    timothypratley.patchin/pathsSourceDoc + Usages
    Creates a sequence of key paths for nested maps.

    patchin 0.2.3
    Creates and applies patches to datastructures
    timothypratley.patchin/paths (cljs)SourceDoc + Usages
    Creates a sequence of key paths for nested maps.

    utils 0.22.0
    Clojure utility functions built by Banzai
    utils.core/find-first-bySourceDoc + Usages
    Finds maps in collection given a key and a value

    utils 0.22.0
    Clojure utility functions built by Banzai
    utils.core/find-bySourceDoc + Usages
    Finds maps in collection given a key and a value

    eventsourcing 0.1.1
    A Clojure event-sourcing abstraction on configurable storage backends.
    gorillalabs.commons/hash-bySourceDoc + Usages
    Maps a collection of maps by a specific key. E.g. a collection of matches (maps) by :uid, see clojure.set/index

    shadow-client 1.3.2
    a cljs library for managed state in the shadows of the DOM
    shadow.ui/group-select-options (cljs)SourceDoc + Usages
    transforms a list of maps into [[group-key [[value-key label] [value-key label]]] ...]

    plumbing 0.5.5
    Prismatic's Clojure utility belt.
    plumbing.map/merge-disjoint (cljs)SourceDoc + Usages
    Like merge, but throws with any key overlap between maps

    plumbing 0.5.5
    Prismatic's Clojure utility belt.
    plumbing.map/merge-disjointSourceDoc + Usages
    Like merge, but throws with any key overlap between maps

    Navigate to every element of the collection. For maps navigates to
              a vector of `[key value]`.

    friend 0.2.3
    Authentication and authorization library for Ring Clojure web apps and services.
    cemerick.friend.util/getsSourceDoc + Usages
    Returns the first value mapped to key found in the provided maps.

    tawny-owl 2.0.0
    tawny-owl enables building OWL ontologies in a programmatic environment.
    tawny.memorise/merge-with-distinctSourceDoc + Usages
    Merges two maps, with key to set of values.
    Returns a sorted map.

    cryogen-core 0.1.61
    Cryogen's compiler
    cryogen-core.klipse/deep-mergeSourceDoc + Usages
    Like clojure.core/merge, but also merges nested maps under the same key.

    milia 0.3.37
    The ona.io Clojure Web API Client.
    chimera.seq/map-list->mapSourceDoc + Usages
    Get the first map from a list of maps with the given value for key.

    chimera 0.0.6
    Collection of useful Clojure(Script) functions.
    chimera.seq/map-list->mapSourceDoc + Usages
    Get the first map from a list of maps with the given value for key.

    hatti 0.4.0
    A cljs dataview from your friends at Ona.io
    chimera.seq/map-list->mapSourceDoc + Usages
    Get the first map from a list of maps with the given value for key.

    bartok-x 0.1
    a set of primitives for musical programming
    utils.utils/in> (cljs)SourceDoc + Usages
    find the first value for kw key in map or nested maps

    bartok-x 0.1
    a set of primitives for musical programming
    utils.utils/in>SourceDoc + Usages
    find the first value for kw key in map or nested maps

    hadoop-config 0.1.2
    Hadoop configuration library
    palletops.hadoop-config/dotted-keys->nested-mapsSourceDoc + Usages
    Takes a map with key names containing dots, and turns them into nested maps.

    Like merge, but throws with any key overlap between maps

    budb 0.0.1
    A CRDT Database for Clojure(script)
    taoensso.encore/reset-val!? (cljs)SourceDoc + Usages
    Maps value to key and returns true iff the mapped value changed or
        was created.

    budb 0.0.1
    A CRDT Database for Clojure(script)
    taoensso.encore/reset-val!? (cljs)SourceDoc + Usages
    Maps value to key and returns true iff the mapped value changed or
        was created.

    re-frame-ipfs-fx 0.0.2
    IPFS Re-Frame handlers.
    taoensso.encore/reset-val!? (cljs)SourceDoc + Usages
    Maps value to key and returns true iff the mapped value changed or
        was created.

    ventas 0.0.6
    The Ventas eCommerce platform
    com.rpl.specter/ALLSourceDoc + Usages
    Navigate to every element of the collection. For maps navigates to
              a vector of `[key value]`.

    ventas 0.0.6
    The Ventas eCommerce platform
    com.rpl.specter/ALLSourceDoc + Usages
    Navigate to every element of the collection. For maps navigates to
              a vector of `[key value]`.

    lexikon 0.1.0
    Reify, manipulate and replay the lexical environment in Clojure
    lexikon.core/contextsSourceDoc + Usages
    The global store for contexts. An atom containing a map of maps:
        `{key -> {symbol -> value}}`

    comfy 1.0.5
    Clojure(script) utils
    madstap.comfy/deep-merge-withSourceDoc + Usages
    Like merge-with, but also merges nested maps under the same key.

    comfy 1.0.5
    Clojure(script) utils
    madstap.comfy/deep-mergeSourceDoc + Usages
    Like merge, but also merges nested maps under the same key.

    clj-stripe 1.0.10
    Clojure binding for Stripe
    clj-stripe.util/merge-mapsSourceDoc + Usages
    Merges several maps into one, removing any key with nil value.

    gadjett 0.5.2
    Inspector tools for clojure[script]
    gadjett.collections/sequence-of-maps->mapSourceDoc + Usages
    Converts a sequence of maps into a map where:
    
      - the keys are extracted from the maps using `key-fn`
      - the vals extracted from the maps using `val-fn`  
      
      ~~~klipse
      (sequence-of-maps->map [{:key :price :value 19}
                              {:key :quantity :value 100}]
                              :key :value)
      ~~~
      

    clj-orient 0.5.0
    Wrapper for the OrientDB Native APIs. It supports version 1.1 of the APIs.
    clj-orient.kv/conjSourceDoc + Usages
    Conjoins the given elements on the data-structure at the key. Works for lists, maps and sets.

    autoremote 0.1.3
    Send AutoRemote messages/notifications to Android devices
    ca.clojurist.autoremote/url-to-keySourceDoc + Usages
    Given an AutoRemote 'personal' URL, return the device key that it
      maps to.

    wgetjava 0.1.3
    Command line application to download Java
    wgetjava.handler/smash-mapsSourceDoc + Usages
    Smash the url maps into a map of all valid key combinations

    verschlimmbesserung 0.1.3
    An etcd client.
    verschlimmbesserung.core/normalise-keySourceDoc + Usages
    Return the key as a sequence of key elements.  A key can be
      specified as a string, symbol, keyword or sequence thereof.
      A nil key maps to [""], the root.

    Return the key as a sequence of key elements.  A key can be
      specified as a string, symbol, keyword or sequence thereof.
      A nil key maps to [""], the root.

    clj-utils 8.3.0
    Shared Clojure Utils for Cider-CI
    cider-ci.utils.map/convert-to-arraySourceDoc + Usages
    Converts a map of maps to an array of maps. The key becomes the value of the
      :name property if and only if :name does no exists already.

    clojure-contracts-sugar 0.2.0
    Some sugar macros for clojure.core.contracts
    clojure-contracts-sugar.utils.walk-forms/walk-keyed-formsSourceDoc + Usages
    walks a collection of keyed source form maps and
       applied the value of each key in keyed-replace-maps to the matching key in each source map

    utilza 0.1.98
    ken's random utilities
    utilza.core/mapifySourceDoc + Usages
    Takes a key and a seq of maps.
       Returns a single map with the keys being item k of the original maps,
       and the vals being the rest of the map minus that key

    konserve 0.5.0-beta3
    Durable cross-platform key-value store protocol with core.async.
    konserve.core/assoc-inSourceDoc + Usages
    Associates the key-vec to the value, any missing collections for
      the key-vec (nested maps and vectors) are newly created.

    konserve 0.5.0-beta3
    Durable cross-platform key-value store protocol with core.async.
    konserve.protocols/-jassoc-inSourceDoc + Usages
    Associates the key-vec to the value, any missing collections for the key-vec (nested maps and vectors) are newly created.

    konserve 0.5.0-beta3
    Durable cross-platform key-value store protocol with core.async.
    konserve.cache/assoc-inSourceDoc + Usages
    Associates the key-vec to the value, any missing collections for
      the key-vec (nested maps and vectors) are newly created.

    zprint 0.4.9
    Pretty print zippers and s-expressions
    zprint.config/remove-elementsSourceDoc + Usages
    Given a key sequence and two maps, remove the elements of the set at
      the key sequence in the second map from set in the first map.

    jdt 0.1.2
    These are not the tools you're looking for.
    jdt.core/get-validSourceDoc + Usages
    Return the value of (get map key). If key is not in map,
       throw an IllegalArgumentException.  Note that 'get' applies to sets as well as maps.

    hitchhiker-tree 0.1.2
    A Hitchhiker Tree Library
    konserve.core/assoc-inSourceDoc + Usages
    Associates the key-vec to the value, any missing collections for
      the key-vec (nested maps and vectors) are newly created.

    hitchhiker-tree 0.1.2
    A Hitchhiker Tree Library
    konserve.protocols/-jassoc-inSourceDoc + Usages
    Associates the key-vec to the value, any missing collections for the key-vec (nested maps and vectors) are newly created.

    zyzanie 0.2.5
    Emacs-like keybinding for your browser. (Clojurescript)
    zyzanie.core/add-key-binding! (cljs)SourceDoc + Usages
    Add a map of the KEY, COMMAND and ELEMENT to `!key-maps'.
      Associate event listeners for every new element.

    budb 0.0.1
    A CRDT Database for Clojure(script)
    konserve.core/assoc-inSourceDoc + Usages
    Associates the key-vec to the value, any missing collections for
      the key-vec (nested maps and vectors) are newly created.

    budb 0.0.1
    A CRDT Database for Clojure(script)
    konserve.protocols/-jassoc-inSourceDoc + Usages
    Associates the key-vec to the value, any missing collections for the key-vec (nested maps and vectors) are newly created.

    budb 0.0.1
    A CRDT Database for Clojure(script)
    konserve.core/assoc-inSourceDoc + Usages
    Associates the key-vec to the value, any missing collections for
      the key-vec (nested maps and vectors) are newly created.

    budb 0.0.1
    A CRDT Database for Clojure(script)
    konserve.protocols/-jassoc-inSourceDoc + Usages
    Associates the key-vec to the value, any missing collections for the key-vec (nested maps and vectors) are newly created.

    ventas 0.0.6
    The Ventas eCommerce platform
    tongue.core/build-dictSourceDoc + Usages
    Collapses nested maps into namespaced keywords:
       { :ns { :key 1 }} => { :ns/key 1 }

    ventas 0.0.6
    The Ventas eCommerce platform
    tongue.core/build-dictSourceDoc + Usages
    Collapses nested maps into namespaced keywords:
       { :ns { :key 1 }} => { :ns/key 1 }

    tongue 0.2.4
    DIY i18n library for Clojure/Script
    tongue.core/build-dictSourceDoc + Usages
    Collapses nested maps into namespaced keywords:
       { :ns { :key 1 }} => { :ns/key 1 }

    Associates the key-vec to the value, any missing collections for the key-vec (nested maps and vectors) are newly created.

    utilza 0.1.98
    ken's random utilities
    utilza.misc/munge-all-columnsSourceDoc + Usages
    Takes a coll of maps and a key map. Returns them with all the values coerced via key-map

    utils 0.22.0
    Clojure utility functions built by Banzai
    utils.core/indexedSourceDoc + Usages
    Turns a list of maps into a map, indexed by index-key. Optional
      order? adds an :order key.

    zyzanie 0.2.5
    Emacs-like keybinding for your browser. (Clojurescript)
    zyzanie.core/remove-key-binding! (cljs)SourceDoc + Usages
    Remove KEY and its COMMAND from `!key-maps'. When ELEMENT
      doesn't have any associated key-bindings, remove the listeners

    mstate 0.1.0
    Durability for Clojure maps.
    mstate.core/decompose-recordSourceDoc + Usages
    Transform a nested map into a list of maps with references from parents
       to children. Nested maps will only be pulled out if they have an :_id key.

    casyn 0.1.2
    Async Thrift based Cassandra Client
    casyn.api/putSourceDoc + Usages
    Accepts cols as vectors or maps to be applied to cols
      constructors (use maps for simple key vals, use vectors if you need
      to set ttl or timestamp

    jdbc-util 1.1.1
    Common JDBC helpers for use in Puppet Labs projects
    puppetlabs.jdbc-util.core/aggregate-submap-bySourceDoc + Usages
    Given a sequence of maps in results where each map contains agg-key
      and agg-val as keys, groups the maps that are identical except for the
      values in agg-key or agg-val. The values of agg-key and agg-val are
      turned into a map and stored in the resulting map under under-key.

    figwheel-sidecar 0.5.16
    ClojureScript Autobuilder/Server which pushes changed files to the browser.
    figwheel-sidecar.config/map-to-vec-buildsSourceDoc + Usages
    Cljsbuild allows a builds to be specified as maps. We acommodate that with this function
       to normalize the map back to the standard vector specification. The key is placed into the
       build under the :id key.

    clojure-contracts-sugar 0.2.0
    Some sugar macros for clojure.core.contracts
    clojure-contracts-sugar.utils.walk-forms/walk-keyed-forms-with-keyed-replace-mapSourceDoc + Usages
    walks a collection of keyed source form maps and
       applied the value of each key in keyed-replace-map to the matching key in each source map

    ring-xml 0.1.1
    Ring middleware for XML requests and responses.
    clojusc.ring.xml/wrap-xml-requestSourceDoc + Usages
    Intercepts incoming requests and attempts to parse the body as XML.
    
      If successful, will add the resulting XML maps to the :params key, the
      :xml-params key, and the :body.

    figwheel-sidecar-immutant 0.5.14
    ClojureScript Autobuilder/Server which pushes changed files to the browser.
    figwheel-sidecar.config/map-to-vec-buildsSourceDoc + Usages
    Cljsbuild allows a builds to be specified as maps. We acommodate that with this function
       to normalize the map back to the standard vector specification. The key is placed into the
       build under the :id key.

    imajes 0.1
    image management library (currently only in s3)
    imajes.core/image-urls-mapSourceDoc + Usages
    returns a seq of maps with the following keys:
       :image - the url to the original image
       :thumb - the url to the thumnail version of the image
       :key   - the key of the object without the '.'

    midje 1.9.2-alpha3
    A TDD library for Clojure that supports top-down ('mockish') TDD, encourages readable
    midje.emission.plugins.util/attractively-stringified-valueSourceDoc + Usages
    Does some standard prettification of forms:
            : a function named `foo`
            : a nicely printed stack trace
            : maps and sets sorted by key.

    kitchensink 2.5.2
    Clojure utility functions
    puppetlabs.kitchensink.core/deep-merge-withSourceDoc + Usages
    Deeply merges like `deep-merge`, but uses `f` to produce a value from the
      conflicting values for a key in multiple maps.

    tesser.core 1.0.2
    Composable concurrent folds for Clojure.
    tesser.utils/map-valsSourceDoc + Usages
    Maps over a key-value map, returning a new map by transforming each value
      with (f v).

    simple-check 0.5.6
    A QuickCheck inspired property-based testing library.
    simple-check.generators/mapSourceDoc + Usages
    Create a generator that generates maps, with keys chosen from
      `key-gen` and values chosen from `val-gen`.

    geom-webgl 0.0.908
    thi.ng geometry kit - WebGL module
    thi.ng.geom.webgl.utils/loop-kv (cljs)SourceDoc + Usages
    A combination of map & doseq specialized for maps. Takes a function `f` and
        a map, calls `f` with each key & value, discards results.

    geom 1.0.0-RC3
    thi.ng geometry kit - meta project spec including all modules
    thi.ng.geom.gl.utils/loop-kv (cljs)SourceDoc + Usages
    A combination of map & doseq specialized for maps. Takes a function `f` and
        a map, calls `f` with each key & value, discards results.

    conf 0.11.0
    Simple configuration/environment library for Clojure.
    conf.core/get-conf-envSourceDoc + Usages
    Parses the value of the env-key from config maps. The value of
      this var informs which additional config files should be loaded.

    double-check 0.6.1
    A QuickCheck inspired property-based testing library.
    clojure.test.check.generators/map (cljs)SourceDoc + Usages
    Create a generator that generates maps, with keys chosen from
      `key-gen` and values chosen from `val-gen`.

    double-check 0.6.1
    A QuickCheck inspired property-based testing library.
    clojure.test.check.generators/mapSourceDoc + Usages
    Create a generator that generates maps, with keys chosen from
      `key-gen` and values chosen from `val-gen`.

    void 0.0.0
    About void and the absence of information
    dvlopt.void/selectSourceDoc + Usages
    Looks for a non-nil value for eack key in `ks`, in the given maps, in the given order.

    void 0.0.0
    About void and the absence of information
    dvlopt.void/obtainSourceDoc + Usages
    Looks for a non-nil value using key `k` on the given maps, in the given order.

    lobos 1.0.0-beta3
    A library to create and manipulate SQL database schemas.
    lobos.metadata/references-metaSourceDoc + Usages
    Returns metadata maps for cross reference of the specified foreign
      table. Results are sorted by their ordinal position and grouped by
      foreign key name.

    toucan 1.1.8
    Functionality for defining your application's models and querying the database.
    toucan.db/transform-keysSourceDoc + Usages
    Replace the keys in any maps in `x` with the result of `(f key)`. Recursively walks `x` using `clojure.walk`.

    kamal 0.8.3
    An application that provides routing based on external sources and OSM data
    hiposfer.kamal.parsers.gtfs.core/datomize!SourceDoc + Usages
    takes a map of gtfs key-name -> content and returns a sequence
      of maps ready to be used for transact

    shadow-devtools 1.0.20170516
    CLJS development tools
    shadow.cljs.build/wait-for-modified-files!SourceDoc + Usages
    blocks current thread waiting for modified files
      return resource maps with a :scan key which is either :new :modified :delete

    shadow-devtools 1.0.20170516
    CLJS development tools
    shadow.cljs.build/scan-filesSourceDoc + Usages
    scans for new and modified files
       returns resources maps with a :scan key with is either :new :modified :delete

    cayenne 0.1.0
    Index and serve CrossRef metadata
    cayenne.item-tree/centre-onSourceDoc + Usages
    Flatten ancestors of an item in item-tree with id. Ancestors of item are
       placed as embedded maps with the parent item type as key.

    cayenne 0.1.0
    Index and serve CrossRef metadata
    cayenne.item-tree/flatten-ancestorsSourceDoc + Usages
    Flatten ancestors of an item in item-tree with id. Ancestors of item are
       placed as embeded maps with the parent item type as key.

    shadow-build 1.0.2017040316
    cljs compiler
    shadow.cljs.build/wait-for-modified-files!SourceDoc + Usages
    blocks current thread waiting for modified files
      return resource maps with a :scan key which is either :new :modified :delete

    shadow-build 1.0.2017040316
    cljs compiler
    shadow.cljs.build/scan-filesSourceDoc + Usages
    scans for new and modified files
       returns resources maps with a :scan key with is either :new :modified :delete

    lean-map 0.4.0
    Lean Hash Array Mapped Trie implementation in ClojureScript
    cljs.lean-map.util/set-maps-to-cljs-map! (cljs)SourceDoc + Usages
    Makes Persistent and Transient ArrayMaps convert to CLJS Maps at the HashMap threshold
      (current 8 key value pairs)

    lean-map 0.4.0
    Lean Hash Array Mapped Trie implementation in ClojureScript
    cljs.lean-map.util/set-maps-to-lean-map! (cljs)SourceDoc + Usages
    Makes Persistent and Transient ArrayMaps convert to Lean Maps at the HashMap threshold
      (current 8 key value pairs)

    lean-map 0.4.0
    Lean Hash Array Mapped Trie implementation in ClojureScript
    cljs.lean-map.util/set-maps-to-cljs-map! (cljs)SourceDoc + Usages
    Makes Persistent and Transient ArrayMaps convert to CLJS Maps at the HashMap threshold
      (current 8 key value pairs)

    lean-map 0.4.0
    Lean Hash Array Mapped Trie implementation in ClojureScript
    cljs.lean-map.util/set-maps-to-lean-map! (cljs)SourceDoc + Usages
    Makes Persistent and Transient ArrayMaps convert to Lean Maps at the HashMap threshold
      (current 8 key value pairs)

    lean-map 0.4.0
    Lean Hash Array Mapped Trie implementation in ClojureScript
    cljs.lean-map.util/set-maps-to-cljs-map! (cljs)SourceDoc + Usages
    Makes Persistent and Transient ArrayMaps convert to CLJS Maps at the HashMap threshold
      (current 8 key value pairs)

    lean-map 0.4.0
    Lean Hash Array Mapped Trie implementation in ClojureScript
    cljs.lean-map.util/set-maps-to-lean-map! (cljs)SourceDoc + Usages
    Makes Persistent and Transient ArrayMaps convert to Lean Maps at the HashMap threshold
      (current 8 key value pairs)

    Takes a sequence of (unique) keys and returns a map
       that maps each unique key to a unique string.

    yz 0.0.1-alpha18
    YZ[ˈiːzi] is simple (easy), laconic, string-based, object query language.
    ru.petrsu.nest.yz.mom-utils/get-s-pathsSourceDoc + Usages
    Gets maps from get-ps and transforms value of :ppath key to
      one string. Returns sequence of this strings.

    madeinqc.tesser.core 1.0.3
    Composable concurrent folds for Clojure. Can now specify the number of threads used.
    tesser.utils/map-valsSourceDoc + Usages
    Maps over a key-value map, returning a new map by transforming each value
      with (f v).

    Builds and excel file with multiple sheets. Expects a params map with a
      sheets key that maps sheet name to data.

    fixpoint 0.1.3
    Simple & Powerful Test Fixtures/Datasources for Clojure
    fixpoint.core/fixture-documents~nil~FixtureSourceDoc + Usages
    Generate a seq of fixture document maps, each one belonging to a single
         datasource identified by the `:fixpoint/datasource` key.

    fixpoint 0.1.3
    Simple & Powerful Test Fixtures/Datasources for Clojure
    fixpoint.core/fixture-documents~IPersistentMap~FixtureSourceDoc + Usages
    Generate a seq of fixture document maps, each one belonging to a single
         datasource identified by the `:fixpoint/datasource` key.

    fixpoint 0.1.3
    Simple & Powerful Test Fixtures/Datasources for Clojure
    fixpoint.core/fixture-documents~Sequential~FixtureSourceDoc + Usages
    Generate a seq of fixture document maps, each one belonging to a single
         datasource identified by the `:fixpoint/datasource` key.

    fixpoint 0.1.3
    Simple & Powerful Test Fixtures/Datasources for Clojure
    fixpoint.core/fixture-documentsSourceDoc + Usages
    Generate a seq of fixture document maps, each one belonging to a single
         datasource identified by the `:fixpoint/datasource` key.

    almonds 0.3.0
    A library for infrastructure automation
    almonds.utils/has-value?SourceDoc + Usages
    Expects a collection of maps. Returns true if any map in the collection has a matching key/value pair.

    clj-arangodb 1.0.2
    A Clojure wrapper for ArangoDB
    clj-arangodb.arangodb.core/insert-docsSourceDoc + Usages
    works with VelocyPack (VPackSlice) and Json (String).
      returns an array list with maps containing keys `:id` `:key` `:new` and `:rev`

    Makes a handler that maps a presenter over data that is retrieved
      from the Liberator context by given data key (by default :data).

    medley 1.0.0
    A lightweight library of useful, mostly pure functions
    medley.core/map-kvSourceDoc + Usages
    Maps a function over the key/value pairs of an associate collection. Expects
      a function that takes two arguments, the key and value, and returns the new
      key and value as a collection of two elements.

    clojure.java-time 0.3.2
    Clojure wrapper for Java 8 Time API
    java-time.util/map-kvSourceDoc + Usages
    Maps a function over the key/value pairs of an associate collection. Expects
      a function that takes two arguments, the key and value, and returns the new
      key and value as a collection of two elements.

    district0x 0.1.20
    district0x Frontend Library
    medley.core/map-kvSourceDoc + Usages
    Maps a function over the key/value pairs of an associate collection. Expects
      a function that takes two arguments, the key and value, and returns the new
      key and value as a collection of two elements.

    comportex 0.0.14
    Functionally composable cortex, an implementation of Hierarchical Temporal Memory
    org.nfrac.comportex.util/group-by-mapsSourceDoc + Usages
    Like the built-in group-by, but taking key-value pairs and building
       maps instead of vectors for the groups. It is tuned for performance
       with many values per key. `f` is a function taking 2 arguments, the
       key and value.

    jdt 0.1.2
    These are not the tools you're looking for.
    jdt.core/map-getSourceDoc + Usages
    Perform GET of a key across multiple maps, returning a lazy sequence of the results of the get.
      Unlike GET, this function requires a KEY-NOT-FOUND value for all lookups.
    
      This function is useful when you're checking for a key in multiple maps, for example, the many
      maps associated with namespaces.
    
      user> (map-get 'map-get :key-not-found (ns-publics *ns*) (ns-map *ns*) (ns-refers *ns*))
      (#'jdtutil.core/map-get #'jdtutil.core/map-get :key-not-found)
      

    s3-deploy 0.1.3
    Push things to S3, but be lazy about it.
    confetti.s3-deploy/diff*SourceDoc + Usages
    Get the difference between objects in a S3 bucket and files on disk.
       If a file is changed the old version {key,md5} will be part of the
       `removed` key.
    
       - `bucket-objects` is expected to be a list bucket object
         summaries as they are returned by `amazonica.aws.s3/list-objects`.
    
       - `file-maps` is a seq of maps containing the following keys: s3-key, file.

    Inputs: [db]
      Returns: {(s/required-key :overloads) {s/Keyword {s/Keyword s/Keyword}}, (s/required-key :originals) {s/Keyword s/Keyword}, (s/required-key :types) {s/Keyword s/Keyword}}
    
      Reads attribute info and uses this to create 3 maps.
      1. Maps overloaded attributes to a map of type->name,
         where the name is the attribute to use for that type.
      2. Maps aliases for the overloaded attribute back to the original.
      3. Maps attribute names to the type of data they hold.

    lacinia 0.28.0-rc-1
    A GraphQL server implementation in Clojure
    com.walmartlabs.lacinia.executor/assert-and-wrap-errorSourceDoc + Usages
    An error returned by a resolver should be nil, a map, or a collection
      of maps, and the map(s) must contain at least a :message key with a string value.
    
      Returns nil, or a collection of one or more valid error maps.

    jiface 0.1.0-dev
    Erlang's JInterface in Idiomatic Clojure
    jiface.erlang.types/mapSourceDoc + Usages
    Provides a Java representation of Erlang maps. Maps are created from one
      or more arbitrary Erlang terms.
    
      The arity of the map is the number of elements it contains. The keys and
      values can be retrieved as arrays and the value for a key can be
      queried.

    pallet-map-merge 0.1.1
    Merging of clojure maps using per-key merge policies.
    pallet.map-merge/merge-keysSourceDoc + Usages
    Returns a map that consists of the rest of the maps conj-ed onto
      the first.  If a key occurs in more than one map, the mapping(s)
      from the latter (left-to-right) will be combined with the mapping in
      the result by calling:
        (merge-key key-algorithms key val-in-result val-in-latter).

    hara 0.7.1
    Utilities library of Functions and Exploratory Programming
    hara.control/reduce-bySourceDoc + Usages
    Returns a maps keyed by the result of key-fn on eachcelement to the 
       result of calling reduce with f (and val if provided) on same-key elements.
       (reduce-by key-fn conj [] coll) is equivalent to (group-by key-fn coll).
       (reduce-by identity (fn [n _] (inc n)) 0 coll) is equivalent to
       (frequencies coll).

    Return a LazyRequest map that transparently derefs values that are delays.
    
      Example:
      (:foo (lazy-request {:foo (delay :bar)}))
      ;; => :bar
    
      LazyRequest's are value-equal to other LazyRequest's that share the same
      underlying map, but not to raw maps. Use `raw` or `realized` to return plain
      maps of original key-vals or realized key-vals, respectively.

    dspec 0.1.0
    Dynamic data validation using registered component specs
    dspec.core/validateSourceDoc + Usages
    Throws a RuntimeException if value does not match the spec
      dynamically generated by registered components, else the (possibly
      destructured) value.
    
      Exception ex-data contains the map of s/explain-data in the form
    
        {:component-a-key {::s/problems '(problem-maps ...)}
         :component-b-key {::s/problems '(problem-maps ...)}}
      

    fairbrook 0.1.0
    Fine-grained map manipulation for the masses.
    fairbrook.path/merge-with-path-fnSourceDoc + Usages
    Returns a function taking two maps, m1 and m2. When called, merges the two
      maps, and if a key collision occurs, associates the key k with
      (f (conj root k) v1 v2) in the resulting map, where v1 and v2 are the values
      associated with k in m1 and m2.

    fairbrook 0.1.0
    Fine-grained map manipulation for the masses.
    fairbrook.key/merge-with-key-fnSourceDoc + Usages
    Returns a function taking two maps m1 and m2. When called, merges the two
      maps, and if a key collision occurs, associates the key k with
      (f k v1 v2) in the resulting map, where v1 and v2 are the values associated
      with k in m1 and m2.

    Embedded Google Map component.
    
      Takes the following options:
        :key (required) - Google Maps API key
        :query (required) - Google Maps query (must be URL escaped)
        :width (optional) - width in CSS units
        :height (optional) - height in CSS units

      Usage:
    
          (map-with-index coll idx-key val-key)
    
    
      Maps a sequence to a sequence of maps with index and value
      For instance:
      
          (map-with-index [10 20 30] :idx :val) =>  '({:idx 0, :val 10} {:idx 1, :val 20} {:idx 2, :val 30}))
      

      Usage:
    
          (map-with-index coll idx-key val-key)
    
    
      Maps a sequence to a sequence of maps with index and value
      For instance:
      
          (map-with-index [10 20 30] :idx :val) =>  '({:idx 0, :val 10} {:idx 1, :val 20} {:idx 2, :val 30}))
      

    pretty 0.1.34
    Clojure library to help print things, prettily
    io.aviso.columns/max-value-lengthSourceDoc + Usages
    A convinience for computing the maximum length of one string property from a collection of values.
    
      coll
      : collection of values
    
      key
      : key that is passed one value and returns the property, typically a keyword when the values are maps

    pod 2.7.2
    Boot pod module–this is included with all pods.
    boot.from.io.aviso.columns/max-value-lengthSourceDoc + Usages
    A convinience for computing the maximum length of one string property from a collection of values.
    
      coll
      : collection of values
    
      key
      : key that is passed one value and returns the property, typically a keyword when the values are maps

    amazonica 0.3.128
    A comprehensive Clojure client for the entire Amazon AWS api.
    amazonica.core/set-root-unwrapping!SourceDoc + Usages
    Enables JSON-like root unwrapping of singly keyed
      top level maps.
        {:root {:key 'foo' :name 'bar'}}
      would become
        {:key 'foo' :name 'bar'}

    darkestperu 1.0.0-rc.2
    Currently a tiny library for assembling JAR files
    darkestperu.manifest/separateSourceDoc + Usages
    Separates M into two maps mt and mf. mt contains the entries of M whose key
      fulfills p, mf contains the entries of M whose key doesn't fulfill p. 

    cljfreechart 0.1.1
    Clojure wrapper for the JFreeChart library
    cljfreechart.core/make-category-datasetSourceDoc + Usages
    Make category dataset (useful for line chart, bar chart etc.) from given arguments.
      Chart data must be a list of maps. Options include:
      :group-key - the key used for not value, but for group name

    dog-tags 1.1.0
    Create a tag cloud or html list of tags. Written in Clojure
    dog-tags.core/rank-tagsSourceDoc + Usages
    Creates a hash-map with the tag name as the key
    and the count of occurrences as the value.
    The input should be a collection of hash-maps with :tags as the key
    and a vector of tags (as strings) as the value.
    Tags are case-insensitive.
    

    timbre-datomic-handler 0.1.3
    A simple Datomic handler that logs via Timbre
    io.aviso.columns/max-value-lengthSourceDoc + Usages
    A convinience for computing the maximum length of one string property from a collection of values.
    
      coll
      : collection of values
    
      key
      : key that is passed one value and returns the property, typically a keyword when the values are maps

    jdbc-fu 0.1.1
    A collection of utility functions on top of java.jdbc
    jdbc-fu.info/primary-keysSourceDoc + Usages
    Retrieves a description of the given table's primary key columns.
      catalog and table(s).
      Returns a sequence of raw maps as yielded by java.jdbc (albeit with
      keywordised keys), unless fns to be applied to map rows or key
      identifiers are provided.

    A convinience for computing the maximum length of one string property from a collection of values.
    
      coll
      : collection of values
    
      key
      : key that is passed one value and returns the property, typically a keyword when the values are maps

    map-lib 0.1.1
    Small Clojure library for maps manipulation
    map-lib.core/map-valsSourceDoc + Usages
    Maps 'fn-name' to the map values.
       Optionally the map key is inside '*key*' variable is available.
    
       (map-vals inc {:a 1 :b 3})
       ;;=> {:a 2 :b 4}

    gadjett 0.5.2
    Inspector tools for clojure[script]
    gadjett.collections/map-2d-vecSourceDoc + Usages
    Maps the values of a `2D` vector where each element of the vector is a key-value pair.
    `f` is a `1-ary` function that receives the key.
    
    ~~~klipse
      (map-2d-vec inc [[:a 1] [:b 2]])
    ~~~
    

    gadjett 0.5.2
    Inspector tools for clojure[script]
    gadjett.collections/map-2d-vecSourceDoc + Usages
    Maps the values of a `2D` vector where each element of the vector is a key-value pair.
    `f` is a `1-ary` function that receives the key.
    
    ~~~klipse
      (map-2d-vec inc [[:a 1] [:b 2]])
    ~~~
    

    component 0.3.2
    Managed lifecycle of stateful objects
    com.stuartsierra.component/system-usingSourceDoc + Usages
    Associates dependency metadata with multiple components in the
      system. dependency-map is a map of keys in the system to maps or
      vectors specifying the dependencies of the component at that key in
      the system, as per 'using'.

    overtone 0.10.3
    Collaborative Programmable Music.
    overtone.sc.defcgen/parse-cgen-paramsSourceDoc + Usages
    Parse a defcgen's param list throwing exceptions where it isn't well-formed
      Returns a list of maps containing at least the key :name

    re-com 2.1.0
    Reusable UI components for Reagent
    re-com.util/remove-id-item (cljs)SourceDoc + Usages
    Takes a vector of maps 'v', each of which has an id-fn (default :id) key.
      Return v where item matching 'id' is excluded

    Return a sequence of maps, representing the fields and locals in a frame.
       Each map has :name, :unmangled-name and :value keys, and either a :field
       or a :local key.

    Takes a vector of maps 'v', each of which has an id-fn (default :id) key.
      Return v where item matching 'id' is excluded

    es 0.2.0
    A simple REST-based Elasticsearch client for Clojure.
    pjstadig.es/piped-json-bodySourceDoc + Usages
    Returns a map with a :body key and a value that is a PipedInputStream of the
      JSON encoding of args.  The arguments should be maps and are merged together
      before JSON encoding.

    es 0.2.0
    A simple REST-based Elasticsearch client for Clojure.
    pjstadig.es/json-bodySourceDoc + Usages
    Returns a map with a :body key and a value that is a JSON encoded string of
      args.  The arguments should be maps and are merged together before JSON
      encoding.

    rejax 0.1.0
    A library that creates nicer API for usage of cljs-ajax in Re-frame
    re-com.util/remove-id-item (cljs)SourceDoc + Usages
    Takes a vector of maps 'v', each of which has an id-fn (default :id) key.
      Return v where item matching 'id' is excluded

    Associates dependency metadata with multiple components in the
      system. dependency-map is a map of keys in the system to maps or
      vectors specifying the dependencies of the component at that key in
      the system, as per 'using'.

    yz 0.0.1-alpha18
    YZ[ˈiːzi] is simple (easy), laconic, string-based, object query language.
    ru.petrsu.nest.yz.mom-utils/check-toSourceDoc + Usages
    Splits vector with paths ('v') into to vectors:
      first vector contains maps where last element of :path key equals 'to',
      second vector otherwise.

    swank-clj 0.1.6
    Another swank for clojure
    swank-clj.jpda.jdi/unmangled-frame-localsSourceDoc + Usages
    Return a sequence of maps, representing the fields and locals in a frame.
       Each map has :name, :unmangled-name and :value keys, and either a :field
       or a :local key.

    feature 0.0.10
    A utility library for language feature creation.
    zensols.nlparse.wordnet/lookup-word-by-senseSourceDoc + Usages
    Lookup a word by verbnet *old* sense key.
    
      For example `buy%2:40:00::` maps to
      [buy/bought](http://wordnet-rdf.princeton.edu/wn31/buy-v).

    component-cljs 0.2.4
    Managed lifecycle of stateful objects
    quile.component/system-usingSourceDoc + Usages
    Associates dependency metadata with multiple components in the
      system. dependency-map is a map of keys in the system to maps or
      vectors specifying the dependencies of the component at that key in
      the system, as per 'using'.

    component-cljs 0.2.4
    Managed lifecycle of stateful objects
    quile.component/system-using (cljs)SourceDoc + Usages
    Associates dependency metadata with multiple components in the
      system. dependency-map is a map of keys in the system to maps or
      vectors specifying the dependencies of the component at that key in
      the system, as per 'using'.

    ritz 0.3.2
    Another swank server for clojure in SLIME
    ritz.jpda.jdi/unmangled-frame-localsSourceDoc + Usages
    Return a sequence of maps, representing the fields and locals in a frame.
       Each map has :name, :unmangled-name and :value keys, and either a :field
       or a :local key.

    edn-ld 0.2.2
    A simple linked data tool
    edn-ld.core/triplify-allSourceDoc + Usages
    Given an optional ResourceMap and a sequence of input maps
       where each map has a :subject-iri key,
       return a lazy sequence of Triples.

    co-dependency 0.3.0
    Co-dependency support for com.stuartsierra.component
    modular.component.co-dependency/system-co-usingSourceDoc + Usages
    Associates dependency metadata with multiple components in the
      system. dependency-map is a map of keys in the system to maps or
      vectors specifying the dependencies of the component at that key in
      the system, as per 'using'.

    ckan 0.1.3
    Clojure client for the CKAN API.
    kixi.ckan.data/fields->lookup-fieldsSourceDoc + Usages
    Takes a vector of maps, each containing a type and id, and converts them
      to a hash-map where key is the field id and value is a type.

    rui 0.3.0
    UI components based on Reagent and Re-frame
    re-com.util/remove-id-item (cljs)SourceDoc + Usages
    Takes a vector of maps 'v', each of which has an id-fn (default :id) key.
      Return v where item matching 'id' is excluded

    azjure 0.1.1
    Encryption Library in Clojure
    org.azjure.cipher.rabbit/resetstatemap!SourceDoc + Usages
    Reset the state at uid in the state-maps atom.  If no
    state map exists at :baseuid one will be generated for efficiencies
    with new IVs for the same key.  Then reset the statemap at :uid.

    destructured-component 0.3.0
    Managed lifecycle of stateful objects - emidln's fork
    com.stuartsierra.component/system-usingSourceDoc + Usages
    Associates dependency metadata with multiple components in the
      system. dependency-map is a map of keys in the system to maps or
      vectors specifying the dependencies of the component at that key in
      the system, as per 'using'.

    serum 0.4.0
    Clojure library of utility functions and macros
    serum.data/index-mapsSourceDoc + Usages
    derives a map from a mapseq (sequence of maps).
      utilizes an index specified by keypath, 'ks', as keys for the resulting map.
      indexed maps need not be unique.  returned maps are grouped in a list for each unique index.
      an optional 'key-proc' parameter is provide to allow key processing of each indexing key
      (such as forcing the case of each index via clojure.string/lower-case, for example).

    cantata 0.1.17
    SQL and database abstraction
    cantata.core/insert!SourceDoc + Usages
    Inserts an entity map or maps into the data source. Unlike `save!`, the
      maps may not include related entity maps.
    
      By default, returns the primary key(s) of the inserted maps.
    
      Multiple maps will be inserted in a transaction.
    
      Options:
    
        :validate    - false to prevent validation.
        :return-keys - false for more efficient insertion of multiple records
                       (using batches) but without returning generated keys

    aerial.utils 1.2.0
    Utility 'tool belt' of functions for common tasks; trees; clustering; probability,
    aerial.utils.coll/merge-with*SourceDoc + Usages
    Merge-with needs to call user supplied F with the KEY as well!!!
      Returns a map that consists of the rest of the maps conj-ed onto the
      first.  If a key occurs in more than one map, the mapping(s) from
      the latter (left-to-right) will be combined with the mapping in the
      result by calling (f key val-in-result val-in-latter).

    tyrion 0.1.9
    Small data analysis and machine learning framework for Clojure
    tyrion.stats/nfreq-bySourceDoc + Usages
    Returns the frequencies of (map fs elmt) for selected keys (ks) in coll.
      The collection can be either list of maps or core.matrix's dataset.
      The fs can be a single function that applied to all supplied keys
      or it can be a map where the key is each key in keys and the val is the function
      to be applied to each of the element for that key.

    readux-eog 0.1.6
    Fork for internal development. clojureScript library for managing state in reagent-based
    readux.core/reducer (cljs)SourceDoc + Usages
    Construct reducer from one (or more) action maps.
    
      Action maps are maps whose key is the action type and whose value is a
      function taking two arguments, 'model' and 'action', outputting the model
      which results from processing the action.
      I.e.
      ---
      {:incr (fn [model action] (update model :value inc))
       :decr (fn [model action] (update model :value dec))}
      ---
    
      NOTE: If several action maps are supplied, they are merged in-order.

    funes 0.1.0
    Infer the shape of data and optionally produce a schema from it
    funes.core/overviewSourceDoc + Usages
    Takes a collection of maps and returns a map that describes all of them.
       For each key, the value will be either:
    
         a) a specific value if it's the same in all maps, or
         b) a pair of smallest and largest number if it's a numeric field, or
         c) a set of all different values, as long as it's smaller than `limit`, or
         d) a Schema otherwise

    djui 1.10
    Library of helper functions as extension to clojure and clojure.contrib.
    clojure.contrib.djui.coll/sort-maps-bySourceDoc + Usages
    Sort a collection of maps on multiple keys. Items with a missing key have
      precedence.
    
      Example:
      (sort-maps-by [{:a 2 :b 2} {:a 1} {:a 2 :b 1}] :a :b)
        => [{:a 1 :b 2} {:a 2 :b 1} {:a 2 :b 2}]

    afterglow 0.2.4
    A live-coding environment for light shows, built on the Open Lighting Architecture,
    afterglow.show/address-mapSourceDoc + Usages
    Returns a sorted map whose keys are the IDs of the universes
      managed by [[*show*]], and whose values are address maps for the
      corresponding universe. The address maps have keys for every channel
      in use by the show in that universe, and the value is the key of the
      fixture using that address.

    suchwow 6.0.2
    Such functions! Such doc strings! Much utility!
    such.relational/one-to-many-index-onSourceDoc + Usages
    `table` should be a sequence of maps. `keyseq` is either a single value
      (corresponding to a traditional `:id` or `:pk` entry) or a sequence of
      values (corresponding to a compound key).
    
      The resulting index provides fast retrieval of vectors of matching maps.
    
          (def index:traditional (one-to-many-index-on table :id))
          (index-select 5 :using index:traditional :keys [:key-i-want]) ; a vector of maps
    
          (def index:compound (one-to-many-index-on table ["intkey" "strkey")))
          (index-select [4 "dawn"] :using index:compound) ; a vector of maps
    
      Keys may be either Clojure keywords or strings.
      

    vice 0.14
    Prismatic schema extensions
    vice.schemas/conditional-on-keySourceDoc + Usages
    Returns a schema that selects from a list of map schemas based on the key value.
    
      You specify a schema for the key which is applied before the conditions are checked. If the
      key fails validation, then no other schemas will be run.
    
      Implicitly adds an :else to the end that returns a helpful error message.
    
      There is no need to re-specify the key value in the other schemas if they are maps.
    
      Usage:
    
      (conditional-on-key
          :vehicle-type s/Keyword
    
          :car
          {:wheels (s/eq 4)}
    
          :bike
          {:wheels (s/eq 2)})
    
      

    shale 0.3.3
    A Clojure-backed Selenium hub replacement
    shale.redis/modelSourceDoc + Usages
    Return a model from a Redis key given a particular schema.
    
      Models understand and serialize most clojure primitives, including shallow
      sequentials, maps, and sets. Int, strings, etc are stored on the hash at the
      model's key, while the rest are stored at keys that share the model's key as
      a prefix. For example,
    
      ```
      > (defmodel Person
          {(s/optional-key :age)          s/Int
           (s/optional-key :nicknames)   #{s/Str}})
      ;; stored as {"age" "10"} at "_shale/Person/<id>" and #{"oli" "joe"}
      ;; at "_shale/Person/<id>/nicknames".
      ```

    babbage 0.1.0
    Intelligent accumulation of statistics over a seq
    babbage.functor/in-mapsSourceDoc + Usages
    With three arguments, return a function which, when called with arity
       maps, applies op to the values of the map (as in fmap).
    
       With more than three arguments, immediately applies op.
    
       If any key in an argument map has a nil value, it will be replaced
       by the default; if any argument is nil, it will be replaced
       by (pure default). The exception is if *all* arguments are nil, in
       which case the result will be nil.
    
       (in-map / 2 0 {:x 6} {:x 2}) --> {:x 3}
    
       Prefer in-nested-maps for computations at the fringes of maps containing maps containing ...
    
       Note that the non-nil arguments determine the results that will
       eventually be present; e.g., if one of the maps is {}, rather
       than nil, the result will be {}.

    Recursively transforms ClojureScript values to JavaScript.
      sets/vectors/lists become Arrays, Keywords and Symbol become Strings,
      Maps become Objects. Arbitrary keys are encoded to by key->js.

    Recursively transforms ClojureScript values to JavaScript.
      sets/vectors/lists become Arrays, Keywords and Symbol become Strings,
      Maps become Objects. Arbitrary keys are encoded to by key->js.

    Returns a map that consists of the rest of the maps conj-ed onto
      the first.  If a key occurs in more than one map, the mapping from
      the latter (left-to-right) will be the mapping in the result.

    clojure 1.10.0-alpha4
    Core language
    clojure.core/mergeSourceDoc + Usages
    Returns a map that consists of the rest of the maps conj-ed onto
      the first.  If a key occurs in more than one map, the mapping from
      the latter (left-to-right) will be the mapping in the result.

    Given a list of maps which contain a single key/value, flatten them all into
      a single map with all the leading spaces removed. If an empty list is provided
      then return nil.

    kitchensink 2.5.2
    Clojure utility functions
    puppetlabs.kitchensink.core/filter-mapSourceDoc + Usages
    Like 'filter', but works on maps.  Returns a map containing the
      key-value pairs in 'm' for which 'pred' returns a truth-y value.
      'pred' must be a function which takes two arguments.

    Deeply merges like `deep-merge`, but uses `f` to produce a value from the
      conflicting values for a key path `ks` that appears in multiple maps, by calling
      `(f ks val-in-result val-in-latter)`.

    typeops 0.1.1
    Alternative type outcomes for arithmetic
    typeops.assign/mergeSourceDoc + Usages
    Returns a map that consists of the rest of the maps conj-ed on to
      the first, using assign semantics.  If a key occurs in more than
      one map, the mapping from the latter (left-to-right) will be the
      mapping in the result.

    cortex 0.9.22
    A neural network toolkit for Clojure.
    cortex.nn.execute/runSourceDoc + Usages
    Run a network on a dataset.  The results are returned as a sequence of maps where the node
      :id is the key for each output value.  There is an option to include outputs required to
      generate the actual network loss.

    chlorine 1.6.4
    A naive Clojure to Javascript translator
    chlorine.js/emit-mapSourceDoc + Usages
    Clojure maps are emitted to javascript key/value objects.
    Keys can only be strings. Keywords and quoted symbols don't really make
     sense in Chlorinejs and that's why they are emitted to plain strings.

    zelkova 0.4.0
    Elm-style FRP for Clojure and ClojureScript
    jamesmacaulay.zelkova.keyboard/directionsSourceDoc + Usages
    Takes a key code to associate with `up`, `down`, `left`, and `right`, and
    returns a signal of maps with `:x` and `:y` keys, and values of -1, 0, or 1
    based on which keys are pressed.

    zelkova 0.4.0
    Elm-style FRP for Clojure and ClojureScript
    jamesmacaulay.zelkova.keyboard/directions (cljs)SourceDoc + Usages
    Takes a key code to associate with `up`, `down`, `left`, and `right`, and
    returns a signal of maps with `:x` and `:y` keys, and values of -1, 0, or 1
    based on which keys are pressed.

    plugin-helpers 0.1.6
    Helper fns for leiningen plugins
    plugin-helpers.format/format-mapSourceDoc + Usages
    Takes a zipper of a map and adds newlines + indentations so
      the output looks nice. Child maps are put onto new lines,
      child seqs are kept on the same line, and key-value pairs are
      put onto new lines.

    momentum 0.3.0-alpha1
    Clojure library for high-performance server and client applications
    momentum.core.async/spliceSourceDoc + Usages
    Returns an async seq that consists of map entries of the values of
      all of the seqs passed in as they materialize and the key
      referencing the If. seq multiple maps are passed, the returned seq
      will assign priority in the order of the arguments.

    tupelo 0.9.76
    Tupelo: Clojure With A Spoonful of Honey
    tupelo.core/contains-elem?SourceDoc + Usages
    For any collection coll & element tgt, returns true if coll contains at least one
      instance of tgt; otherwise returns false. Note that, for maps, each element is a
      vector (i.e MapEntry) of the form [key value].

    clj-stan 0.3.0
    A library to interface with STAN, using the command line interface.
    clj-stan.read-output/vec-assoc-inSourceDoc + Usages
    A version of the `assoc-in` function that defaults to vectors
      rather than maps when adding a new integer key:
    
      ```(vec-assoc-in {} [:a 0] "foo") => {:a ["foo"]}```
    
      This is not safe: `(vec-assoc-in {} [:a 1] 2)` produces an index out
      of range exception.

    dali 0.7.4
    A Clojure library for 2D graphics.
    dali.utils/deep-mergeSourceDoc + Usages
    Merges map b into map a recursively. If both values for a certain
      key are maps, they are deeply merged themselves. If not, the value
      from map b is used unless it's nil.

    stu 0.1.0
    Visualise builds of Clojurescript artifacts
    stu.d3/bar-chart-horizontal! (cljs)SourceDoc + Usages
    HOF returning a fn that mutates a dom div, adding a d3 bar chart.
       The data arg is a seq of maps containing :label, :id and value-key used for bar width.

    clibana 0.1.6
    A Clojure based generator for Kibana 4 objects.
    clibana.internal.common/take-firstSourceDoc + Usages
     From collection of maps, takes all that rhave given key, selects first and returns its value.
     E.g. (<-saved-search [{:saved-search 1} {:saved-search 2}]) -> 1
     

    clibana 0.1.6
    A Clojure based generator for Kibana 4 objects.
    clibana.internal.common/take-first (cljs)SourceDoc + Usages
     From collection of maps, takes all that rhave given key, selects first and returns its value.
     E.g. (<-saved-search [{:saved-search 1} {:saved-search 2}]) -> 1
     

    forked-markdown-clj 0.0.1
    Markdown parser
    markdown.transformers/flatten-metadataSourceDoc + Usages
    Given a list of maps which contain a single key/value, flatten them all into
      a single map with all the leading spaces removed. If an empty list is provided
      then return nil.

    map-helpers 0.1.1
    Functions for working with Clojure maps
    map-helpers.core/merge-with-keysSourceDoc + Usages
    Merges the maps using the key-to-fn map merge functions.
      (merge-with-keys {:add + :mul *) {:add 1 :mul 3} {:add 4 :mul 6}) => {:add 5 :mul 18}

    jdbc-fu 0.1.1
    A collection of utility functions on top of java.jdbc
    jdbc-fu.info/best-row-identifiersSourceDoc + Usages
    Retrieves a description of a table's optimal set of columns that
      uniquely identifies a row. Returns a sequence of raw maps as yielded
      by java.jdbc (albeit with keywordised keys), unless fns to be
      applied to map rows or key identifiers are provided.

    jdbc-fu 0.1.1
    A collection of utility functions on top of java.jdbc
    jdbc-fu.info/schemasSourceDoc + Usages
    Retrieves the schemas available in the given catalog.
      Accepts a schema name pattern to filter results. Returns a sequence
      of raw maps as yielded by java.jdbc (albeit with keywordised keys),
      unless fns to be applied to map rows or key identifiers are
      provided.

    biomart-client 1.1.0
    Clojure client interface to BioMart
    biomart-client.query/querySourceDoc + Usages
    Query the specified datasets and return parsed results. For a
      normal query, a seq of maps keyed on column name is returned. When a
      count is requested (by passing opts {:count true}) the response will
      simply be a single row with key :count.

    fairbrook 0.1.0
    Fine-grained map manipulation for the masses.
    fairbrook.meta/meta-mergeSourceDoc + Usages
    As merge, but will merge the metadata from each map as well. As with merge,
      if more than one of the metadata maps contains the same key, the mapping from
      the latter will be the mapping in the resulting metadata map.

    gyptis 0.2.2
    A library for generating and viewing vega.js plots
    gyptis.core/choroplethSourceDoc + Usages
    Returns a vega.js map choropleth. Each datum should have a
      `geopath` key that maps to a GeoJson object val and a `fill` val
      that can be represented by a quantitative scale. The
      `:geopath-transform` option is passed directly to vega.

    cantata 0.1.17
    SQL and database abstraction
    cantata.query.util/build-result-mapSourceDoc + Usages
    Given field names and values, returns a map that represents a single
      query result. If the :ordered-maps key of opts is true, returns an
      ordered map, otherwise an ordered one.

    twttr 3.2.0
    Twitter API client supporting REST, streaming, and OAuth
    twttr.auth/read-csvSourceDoc + Usages
    Parse `lines` (a seq of strings) as CSV (no quoting or escaping).
      Return a seq of maps, using the first line in `lines` as column headers
      and remapping these headers to desired output key names as specified by
      `column-mapping`.

    sweet-liberty 0.1.4
    A library for building database-backed RESTful services using Clojure
    com.rjmetrics.sweet-liberty.db/update-many-entities-in-storageSourceDoc + Usages
    Run over each entity in data, doing a single entity update for each. Then,
      since our data is a vector of maps, make a map where the key is the value of
      the where item, and merge them together with what's already on the context

    score 0.4.0
    A generic library for musical score generation
    score.mask.mask/maskSourceDoc + Usages
    Maps values from a generator function to a range given by 
      low and high. Low and high may be numbers or bpf's. Optional 
      :exp key/val argument affects the exponent for the mapping. 
      Mapping follows y = x ^(2^exponent).

    Compiles a collection of links into the RFC 5988 format.
      Links are required to be maps. The :href key going into the <> part.
      eg. {:href "/hello" :rel "self" :title "Title"}
          -> </hello>; rel="self" title="Title"

    examine 1.3.1
    Validating Clojure data
    examine.core/renderSourceDoc + Usages
    Creates a localized human readable text from a message. The localizer-fn
      is a one-arg function that maps the text-key of the message to a human
      readable text.
      Message can either be a string or a vector [text args] to fill the
      placeholders.

    asimov 0.1.2
    A clojure client library for the robot operating system ROS.
    asimov.message/dep-graphSourceDoc + Usages
    Calculates a message definition maps dependency graph.
    
    Expects:
     msgs:map The message definitions for which the graph is to be calculated.
    
    Returns a map where each key represents a node in the graph and each value is a set
    of child nodes.

    plumbing 0.5.5
    Prismatic's Clojure utility belt.
    plumbing.map/keep-leaves-and-path (cljs)SourceDoc + Usages
    Takes a nested map and returns a nested map with the same shape, where each
       (non-map) leaf v is transformed to (f key-seq v), or removed if it returns nil.
       key-seq is the sequence of keys to reach this leaf, starting at the root.
       Empty maps produced by this pruning are themselves pruned from the output.

    plumbing 0.5.5
    Prismatic's Clojure utility belt.
    plumbing.map/keep-leaves-and-pathSourceDoc + Usages
    Takes a nested map and returns a nested map with the same shape, where each
       (non-map) leaf v is transformed to (f key-seq v), or removed if it returns nil.
       key-seq is the sequence of keys to reach this leaf, starting at the root.
       Empty maps produced by this pruning are themselves pruned from the output.

    tentacles 0.5.1
    A library for working with the Github API.
    tentacles.gists/edit-gistSourceDoc + Usages
    Edit a gist.
       Options are:
          description -- A string to update the description to.
          files       -- A map of filenames to maps. These submaps may
                         contain either of the following, or both: a
                         :contents key that will replace the gist's
                         contents, and a :filename key that will replace
                         the name of the file. If one of the file keys in
                         the map is associated with 'nil', it'll be deleted.

    data.avl 0.0.17
    Persistent sorted maps and sets with log-time rank queries
    clojure.data.avl/split-keySourceDoc + Usages
    (alpha)
    
      Returns [left e? right], where left and right are collections of
      the same type as coll and containing, respectively, the keys below
      and above k in the ordering determined by coll's comparator, while
      e? is the entry at key k for maps, the stored copy of the key k for
      sets, nil if coll does not contain k.

    data.avl 0.0.17
    Persistent sorted maps and sets with log-time rank queries
    clojure.data.avl/split-key (cljs)SourceDoc + Usages
    (alpha)
    
      Returns [left e? right], where left and right are collections of
      the same type as coll and containing, respectively, the keys below
      and above k in the ordering determined by coll's comparator, while
      e? is the entry at key k for maps, the stored copy of the key k for
      sets, nil if coll does not contain k.

    aesahaettr 0.1.2
    Sharding, partitioning, and consistent hashing. May release spectres.
    æsahættr/even-bytes-partitionerSourceDoc + Usages
    Given a target number of subsets, a minimum key, and a maximum key, returns
      a function which maps byte arrays to an integer in 0..n, in lexicographic
      order. Useful if you want to keep nearby elements in the sequence in the
      same hash bucket.

    skm-ice-utils 1.0.3
    Utility library developed by the ICE project within the danish ministry of taxation
    skm-ice-utils.util/keyaware-merge-withSourceDoc + Usages
    Returns a map that consists of the rest of the maps conj-ed onto
      the first.  If a key occurs in more than one map, the mapping(s)
      from the latter (left-to-right) will be combined with the mapping in
      the result by calling (f key val-in-result val-in-latter).

    skm-ice-utils 1.0.3
    Utility library developed by the ICE project within the danish ministry of taxation
    skm-ice-utils.util/keyaware-merge-withSourceDoc + Usages
    Returns a map that consists of the rest of the maps conj-ed onto
      the first.  If a key occurs in more than one map, the mapping(s)
      from the latter (left-to-right) will be combined with the mapping in
      the result by calling (f key val-in-result val-in-latter).

    tentacles.custom 0.2.9
    A custom release of Tentacles.
    tentacles.gists/edit-gistSourceDoc + Usages
    Edit a gist.
       Options are:
          description -- A string to update the description to.
          files       -- A map of filenames to maps. These submaps may
                         contain either of the following, or both: a
                         :contents key that will replace the gist's
                         contents, and a :filename key that will replace
                         the name of the file. If one of the file keys in
                         the map is associated with 'nil', it'll be deleted.

    Takes a nested map and returns a nested map with the same shape, where each
       (non-map) leaf v is transformed to (f key-seq v), or removed if it returns nil.
       key-seq is the sequence of keys to reach this leaf, starting at the root.
       Empty maps produced by this pruning are themselves pruned from the output.

    code-maat 1.0.1
    A toolset to mine and analyze version control data
    code-maat.app.grouper/text->group-specificationSourceDoc + Usages
    Transforms the given text or regular expression into a
       seq of maps specifying the grouping.
       Each map will have a path key corresponding to a regex pattern
       and a name key corresponding to the grouping logical name:
        {:path #'^some/path/' :name 'some_name'}
        or
        {:path #'^some-regexp$' :name 'some_name'}

    clj-tandem 0.1.6
    Parser for X! Tandem XML formatted result files.
    clj-tandem.core/peptide-infoSourceDoc + Usages
    Returns a hash map of peptide
      info. Including :id, :start, :end, :seq etc. Includes a :mod key
      which is a list of maps containing modification
      information (:type, :at and :modified) and a :peptide-info key
      containing protein level information.

    skm-ice-gui 1.0.0
    GUI library developed by the ICE project within the danish ministry of taxation
    skm-ice-utils.util/keyaware-merge-withSourceDoc + Usages
    Returns a map that consists of the rest of the maps conj-ed onto
      the first.  If a key occurs in more than one map, the mapping(s)
      from the latter (left-to-right) will be combined with the mapping in
      the result by calling (f key val-in-result val-in-latter).

    nlp 0.3.0
    Code examples using Stanford CoreNLP
    damionjunk.nlp.stanford/sentiment-mapsSourceDoc + Usages
    Return a sequence of sentiment-maps, one for each sentence in `text`.
                 Each sentiment map contains a `:sentiment` key, and a `:text` key.
    
                 `sentiment` is [0, 4], from very negative to very positive.
    
                 `text` is plain text. If it is a paragraph of sentences, they are
                        split by the Stanford parser.

    datasplash 0.6.1
    Clojure API for a more dynamic Google Cloud Dataflow and (hopefully) Apache BEAM
    datasplash.datastore/entity->cljSourceDoc + Usages
    Converts a Datastore Entity to a Clojure map with the same properties. Repeated fields are handled as vectors and nested Entities as maps. All keys are turned to keywords. If the entity has a Key, Kind or Namespace, these can be found as :key, :kind, :namespace and :ancestors in the meta of the returned map

    datasplash 0.6.1
    Clojure API for a more dynamic Google Cloud Dataflow and (hopefully) Apache BEAM
    datasplash.datastore/entity->cljSourceDoc + Usages
    Converts a Datastore Entity to a Clojure map with the same properties. Repeated fields are handled as vectors and nested Entities as maps. All keys are turned to keywords. If the entity has a Key, Kind or Namespace, these can be found as :key, :kind, :namespace and :ancestors in the meta of the returned map

    fairbrook 0.1.0
    Fine-grained map manipulation for the masses.
    fairbrook.path/sub-merge-fnSourceDoc + Usages
    Returns a function taking three arguments: root, m1 and m2, which will merge
      the maps m1 and m2. If a key collision occurs, associates the key k with
      (f (conj root k) v1 v2) in the resulting map, where v1 and v2 are the values
      associated with k in m1 and m2.

    gadjett 0.5.2
    Inspector tools for clojure[script]
    gadjett.collections/map-2d-vec-kvSourceDoc + Usages
    Maps the values of a `2D` vector where each element of the vector is a key-value pair.
    `fk` is a `1-ary` function that receives the key.
    `fv` is a `1-ary` function that receives the value.
    
    ~~~klipse
        (map-2d-vec-kv name inc [[:a 1] [:b 2]])
    ~~~
    

    gadjett 0.5.2
    Inspector tools for clojure[script]
    gadjett.collections/map-2d-vec-kvSourceDoc + Usages
    Maps the values of a `2D` vector where each element of the vector is a key-value pair.
    `fk` is a `1-ary` function that receives the key.
    `fv` is a `1-ary` function that receives the value.
    
    ~~~klipse
        (map-2d-vec-kv name inc [[:a 1] [:b 2]])
    ~~~
    

    audit 0.1.1
    Clojure Library for verifying maps
    audit.core/audit-helperSourceDoc + Usages
    Takes two maps, the value map and the audit map.
       checks to see if valid-audit key is truthy, if not it
       doesn't run anything.  If so, it checks every fn in the
       vector and applies the true or false value to the map,
       under the key valid-audit.

    rotary 0.4.1
    Amazon DynamoDB API
    rotary.client/create-tableSourceDoc + Usages
    Create a table in DynamoDB with the given map of properties. The properties
      available are:
        :name - the name of the table (required)
        :hash-key - a map that defines the hash key name and type (required)
        :range-key - a map that defines the range key name and type (optional)
        :throughput - a map that defines the read and write throughput (required)
        :indexes - a vector of maps that defines local secondary indexes on a table (optional)
    
      The hash-key and range-key definitions are maps with the following keys:
        :name - the name of the key
        :type - the type of the key (:s, :n, :ss, :ns)
    
      Where :s is a string type, :n is a number type, and :ss and :ns are sets of
      strings and number respectively. 
    
      The throughput is a map with two keys:
        :read - the provisioned number of reads per second
        :write - the provisioned number of writes per second
      
      The indexes vector is a vector of maps with two keys and two further optional ones
        :name - the name of the Local Secondary Index (required)
        :range-key - a map that defines the range key name and type (required)
        :projection - keyword that defines the projection may be:
        :all, :keys_only, :include (optional - default is :keys-only)
        :included-attrs - a vector of attribute names when :projection is :include (optional)

    component 0.3.2
    Managed lifecycle of stateful objects
    com.stuartsierra.component/system-mapSourceDoc + Usages
    Returns a system constructed of key/value pairs. The system has
      default implementations of the Lifecycle 'start' and 'stop' methods
      which recursively start/stop all components in the system.
    
      System maps print as #<SystemMap> to avoid overwhelming the printer
      with large objects. As a consequence, printed system maps cannot be
      'read'. To disable this behavior and print system maps like normal
      records, call
      (remove-method clojure.core/print-method com.stuartsierra.component.SystemMap)

    palikka 0.5.4
    Metosin palikka
    palikka.sweet/system-mapSourceDoc + Usages
    Returns a system constructed of key/value pairs. The system has
      default implementations of the Lifecycle 'start' and 'stop' methods
      which recursively start/stop all components in the system.
    
      System maps print as #<SystemMap> to avoid overwhelming the printer
      with large objects. As a consequence, printed system maps cannot be
      'read'. To disable this behavior and print system maps like normal
      records, call
      (remove-method clojure.core/print-method com.stuartsierra.component.SystemMap)

    component-cljs 0.2.4
    Managed lifecycle of stateful objects
    quile.component/system-mapSourceDoc + Usages
    Returns a system constructed of key/value pairs. The system has
      default implementations of the Lifecycle 'start' and 'stop' methods
      which recursively start/stop all components in the system.
    
      System maps print as #<SystemMap> to avoid overwhelming the printer
      with large objects. As a consequence, printed system maps cannot be
      'read'. To disable this behavior and print system maps like normal
      records, call
      (remove-method clojure.core/print-method quile.component.SystemMap)

    component-cljs 0.2.4
    Managed lifecycle of stateful objects
    quile.component/system-map (cljs)SourceDoc + Usages
    Returns a system constructed of key/value pairs. The system has
      default implementations of the Lifecycle 'start' and 'stop' methods
      which recursively start/stop all components in the system.
    
      System maps print as #<SystemMap> to avoid overwhelming the printer
      with large objects. As a consequence, printed system maps cannot be
      'read'. To disable this behavior and print system maps like normal
      records, call
      (remove-method clojure.core/print-method quile.component.SystemMap)

    destructured-component 0.3.0
    Managed lifecycle of stateful objects - emidln's fork
    com.stuartsierra.component/system-mapSourceDoc + Usages
    Returns a system constructed of key/value pairs. The system has
      default implementations of the Lifecycle 'start' and 'stop' methods
      which recursively start/stop all components in the system.
    
      System maps print as #<SystemMap> to avoid overwhelming the printer
      with large objects. As a consequence, printed system maps cannot be
      'read'. To disable this behavior and print system maps like normal
      records, call
      (remove-method clojure.core/print-method com.stuartsierra.component.SystemMap)

    mapgraph 0.2.1
    Basic in-memory graph database of maps with links
    com.stuartsierra.mapgraph/pullSourceDoc + Usages
    Returns a map representation of the entity found at lookup ref in
      db. Builds nested maps following a pull pattern.
    
      A pull pattern is a vector containing any of the following forms:
    
         :key  If the entity contains :key, includes it in the result.
    
         '*    (literal symbol asterisk) Includes all keys from the entity
               in the result.
    
         { :key sub-pattern }
               The entity's value for key is a lookup ref or collection of
               lookup refs. Expands each lookup ref to the entity it refers
               to, then applies pull to each of those entities using the
               sub-pattern.

    mapgraph 0.2.1
    Basic in-memory graph database of maps with links
    com.stuartsierra.mapgraph/pullSourceDoc + Usages
    Returns a map representation of the entity found at lookup ref in
      db. Builds nested maps following a pull pattern.
    
      A pull pattern is a vector containing any of the following forms:
    
         :key  If the entity contains :key, includes it in the result.
    
         '*    (literal symbol asterisk) Includes all keys from the entity
               in the result.
    
         { :key sub-pattern }
               The entity's value for key is a lookup ref or collection of
               lookup refs. Expands each lookup ref to the entity it refers
               to, then applies pull to each of those entities using the
               sub-pattern.

    asphalt 0.6.7
    A Clojure library for JDBC access
    asphalt.core/fetch-mapsSourceDoc + Usages
    Given asphalt.type.ISqlSource and java.sql.ResultSet instances fetch a collection of rows as maps. It is required
      for asphalt.type.ISqlSource/read-row to return a vector of all column values for the sql-source.
      Options:
      Key          Type/spec            Default                    Description
      ----         ----------           --------                   ------------
      :fetch-size  positive integer     not applied                fetch-size to be set on java.sql.ResultSet
      :key-maker   (fn [^String label]) asphalt.result/label->key  converts column label to column key

    test.check 0.10.0-alpha3
    A QuickCheck inspired property-based testing library
    clojure.test.check.generators/mapSourceDoc + Usages
    Create a generator that generates maps, with keys chosen from
      `key-gen` and values chosen from `val-gen`.
    
      If the key generator cannot or is unlikely to produce enough distinct
      elements, this generator will fail in the same way as `such-that`.
    
      Available options:
    
        :num-elements  the fixed size of generated maps
        :min-elements  the min size of generated maps
        :max-elements  the max size of generated maps
        :max-tries     the number of times the generator will be tried before
                       failing when it does not produce distinct elements
                       (default 10)
        :ex-fn         a function of one arg that will be called if test.check cannot
                       generate enough distinct keys; it will be passed a map with
                       `:gen` (the key-gen), `:num-elements`, and `:max-tries` and
                       should return an exception

    pine 0.1.6
    A Clojure/ClojureScript router designed for universal applications.
    clojure.test.check.generators/mapSourceDoc + Usages
    Create a generator that generates maps, with keys chosen from
      `key-gen` and values chosen from `val-gen`.
    
      If the key generator cannot or is unlikely to produce enough distinct
      elements, this generator will fail in the same way as `such-that`.
    
      Available options:
    
        :num-elements  the fixed size of generated maps
        :min-elements  the min size of generated maps
        :max-elements  the max size of generated maps
        :max-tries     the number of times the generator will be tried before
                       failing when it does not produce distinct elements
                       (default 10)
        :ex-fn         a function of one arg that will be called if test.check cannot
                       generate enough distinct keys; it will be passed a map with
                       `:gen` (the key-gen), `:num-elements`, and `:max-tries` and
                       should return an exception

    remix 0.0.4
    Mix and match machinery for web and sql.
    remix.mapper/reduce-rowsSourceDoc + Usages
    Reduce rows using m as a template.
    
      m contains nested maps with the following keys:
      :row-key
        Key to use in result map.
      :match-val-fn
        fn to match against a row.
      :ks
        coll of keys to select into the result for matching rows.
      :mappings
        mappings to apply against values of ks for result.
      :children
        collection of template maps.

    clarifai-clj 1.0.0
    Clojure wrapper for Clarifai API.
    clarifai-clj.core/video-conceptsSourceDoc + Usages
    Get Predict API model's concepts (and their certainty) for video.
    
       Returns seq of 'frame maps', where a frame map is:
        {:frame {:index <(int)> :time <(int)>}
         :concepts <seq of concept maps, where a concept map is:
                            {:name <concept's name (str)>
                             :value <concept's certainty (double)>}>}
    
       api-key (str): your Clarifai API Key
       model (keyword): model to use e.g. :general vs. :apparel
       video-url (str): URL where video is hosted

    brukbart 0.1.1
    Some useful stuff
    brukbart.core/deep-mergeSourceDoc + Usages
    Merge nested maps. At each level maps are merged left to right. When all
      maps have a common key whose value is also a map, those maps are merged
      recursively. If any of the values are not a map then the value from the
      right-most map is chosen.
      E.g.:
      user=> (deep-merge {:a {:b 1}} {:a {:c 3}})
      {:a {:c 3, :b 1}}
      user=> (deep-merge {:a {:b 1}} {:a {:b 2}})
      {:a {:b 2}}
      user=> (deep-merge {:a {:b 1}} {:a {:b {:c 4}}})
      {:a {:b {:c 4}}}
      user=> (deep-merge {:a {:b {:c 1}}} {:a {:b {:e 2 :c 15} :f 3}})
      {:a {:f 3, :b {:e 2, :c 15}}}
      Like merge, a key that maps to nil will override the same key in an earlier
      map that maps to a non-nil value:
      user=> (deep-merge {:a {:b {:c 1}, :d {:e 2}}}
                         {:a {:b nil, :d {:f 3}}})
      {:a {:b nil, :d {:f 3, :e 2}}}

    jiraph 0.8.3-beta3
    embedded graph db library for clojure
    jiraph.layer/schema~?~SchemaSourceDoc + Usages
    A map describing the structure of a node with the given id on this layer. Return value will
         be a nested hash. Each hash will contain at least a :type key, describing the data at that
         level (with :any meaning "it could be anything"). Additional keys may be present:
         - For maps, a :fields key descibes the schema for all fields the map may contain - each key
           in the :fields map is a fieldname and its value is the schema for that value. A field with
           the special name :* means any key may be present, in addition to those specifically listed.
         - For other composite types such as sets and lists, an :item-type key describes the schema
           for the items contained within the composite (which should all be the same type).

    jiraph 0.8.3-beta3
    embedded graph db library for clojure
    jiraph.layer/schema~Object~SchemaSourceDoc + Usages
    A map describing the structure of a node with the given id on this layer. Return value will
         be a nested hash. Each hash will contain at least a :type key, describing the data at that
         level (with :any meaning "it could be anything"). Additional keys may be present:
         - For maps, a :fields key descibes the schema for all fields the map may contain - each key
           in the :fields map is a fieldname and its value is the schema for that value. A field with
           the special name :* means any key may be present, in addition to those specifically listed.
         - For other composite types such as sets and lists, an :item-type key describes the schema
           for the items contained within the composite (which should all be the same type).

    jiraph 0.8.3-beta3
    embedded graph db library for clojure
    jiraph.layer/schemaSourceDoc + Usages
    A map describing the structure of a node with the given id on this layer. Return value will
         be a nested hash. Each hash will contain at least a :type key, describing the data at that
         level (with :any meaning "it could be anything"). Additional keys may be present:
         - For maps, a :fields key descibes the schema for all fields the map may contain - each key
           in the :fields map is a fieldname and its value is the schema for that value. A field with
           the special name :* means any key may be present, in addition to those specifically listed.
         - For other composite types such as sets and lists, an :item-type key describes the schema
           for the items contained within the composite (which should all be the same type).

    midje 1.9.2-alpha3
    A TDD library for Clojure that supports top-down ('mockish') TDD, encourages readable
    midje.util.bultitude/classify-dir-entriesSourceDoc + Usages
    Looks for all Clojure (.clj) files in the directory tree rooted at `dir`, a string.
       Returns a seq of maps.
       Each map will contain one of four values for the `:status` key:
         :contains-namespace   (The namespace is the value of key `:namespace-symbol`.)
         :unreadable
         :no-namespace         (There is no `ns` form.)
         :broken-namespace     (An `ns` entry in the file is malformed.)
       The original java.io.File object is under key `:file`.

    squirrel 0.1.2
    Utility functions for translating between Clojure and SQL idioms.
    bugsbio.squirrel/to-cljSourceDoc + Usages
    Converts the snake-case keys of a map into their kebab-case equivalent.
      Can be passed an optional map of clojure-key -> deserializer which will be used
      to deserialize the identified fields into a form required by your Clojure code.
    
      Keys containing double underscores are interpreted as nested maps,
      where the left hand of the underscore is the key of the map and the right
      hand is the key in the nested map.

    serum 0.4.0
    Clojure library of utility functions and macros
    serum.data/index-unique-mapsSourceDoc + Usages
    derives a map from a mapseq (sequence of maps).
      utilizes an index specified by keypath, 'ks', as keys for the resulting map.
      assumes that each indexed map value is unique.
      when duplicate keys are present, last duplicate keyed map will be present in result.
      an optional 'key-proc' parameter is provide to allow key processing of each indexing key
      (such as forcing the case of each index via clojure.string/lower-case, for example).

    om-bootstrap 0.6.1
    Bootstrap meets Om.
    om-bootstrap.util/merge-with-fns (cljs)SourceDoc + Usages
    Returns a map that consists of the rest of the maps conj-ed onto
      the first.  If a key occurs in more than one map, the mapping(s)
      from the latter (left-to-right) will be combined with the mapping in
      the result by looking up the proper merge function and in the
      supplied map of key -> merge-fn and using that for the big merge. If
      a key doesn't have a merge function, the right value wins (as with
      merge).

    nlp 0.3.0
    Code examples using Stanford CoreNLP
    damionjunk.nlp.stanford/sentiment-ner-mapsSourceDoc + Usages
    Return a sequence of sentiment-ner-maps, one for each sentence in `text`.
                 Each sentiment map contains a `:sentiment` key, a ':tokens` key,
                 and a `:text` key.
    
                 `sentiment` is [0, 4], from very negative to very positive.
    
                 `tokens` is a sequence of tokens with POS and NER markup from each
                          bit of `text`. A token looks like:
    
                          {:pos "NNP", :ner "ORGANIZATION", :token "Google"}
    
                 `text` is plain text. If it is a paragraph of sentences, they are
                        split by the Stanford parser.

    Returns a map that consists of the rest of the maps conj-ed onto
      the first.  If a key occurs in more than one map, the mapping(s)
      from the latter (left-to-right) will be combined with the mapping in
      the result by calling (f val-in-result val-in-latter).

    Given a spec and a value x which ought to conform, returns nil if x
      conforms, else a map with at least the key ::problems whose value is
      a collection of problem-maps, where problem-map has at least :path :pred and :val
      keys describing the predicate and the value that failed at that
      path.

    clojure 1.10.0-alpha4
    Core language
    clojure.core/merge-withSourceDoc + Usages
    Returns a map that consists of the rest of the maps conj-ed onto
      the first.  If a key occurs in more than one map, the mapping(s)
      from the latter (left-to-right) will be combined with the mapping in
      the result by calling (f val-in-result val-in-latter).

    spec.alpha 0.1.143
    Specification of data and functions
    clojure.spec.alpha/explain-dataSourceDoc + Usages
    Given a spec and a value x which ought to conform, returns nil if x
      conforms, else a map with at least the key ::problems whose value is
      a collection of problem-maps, where problem-map has at least :path :pred and :val
      keys describing the predicate and the value that failed at that
      path.

    re-frame 0.10.5
    A Clojurescript MVC-like Framework For Writing SPAs Using Reagent.
    re-frame.utils/dissoc-inSourceDoc + Usages
    Dissociates an entry from a nested associative structure returning a new
      nested structure. keys is a sequence of keys. Any empty maps that result
      will not be present in the new structure.
      The key thing is that 'm' remains identical? to istelf if the path was never present

    hasch 0.3.5
    Cryptographic hashing of EDN datastructures.
    cljs.spec/explain-data (cljs)SourceDoc + Usages
    Given a spec and a value x which ought to conform, returns nil if x
      conforms, else a map with at least the key ::problems whose value is
      a collection of problem-maps, where problem-map has at least :path :pred and :val
      keys describing the predicate and the value that failed at that
      path.

    clojure-future-spec 1.9.0-alpha9-1
    Backport of clojure.spec for Clojure 1.8
    clojure.spec/explain-dataSourceDoc + Usages
    Given a spec and a value x which ought to conform, returns nil if x
      conforms, else a map with at least the key ::problems whose value is
      a collection of problem-maps, where problem-map has at least :path :pred and :val
      keys describing the predicate and the value that failed at that
      path.

    kitchensink 2.5.2
    Clojure utility functions
    puppetlabs.kitchensink.core/merge-with-keySourceDoc + Usages
    Returns a map that consists of the rest of the maps conj-ed onto
      the first.  If a key `k` occurs in more than one map, the mapping(s)
      from the latter (left-to-right) will be combined with the mapping in
      the result by calling (f k val-in-result val-in-latter).

    friend 0.2.3
    Authentication and authorization library for Ring Clojure web apps and services.
    cemerick.friend/identitySourceDoc + Usages
    Returns the identity associated with the given request or response.
       This will either be nil (for an anonymous user/session) or a map
       containing:
    
         :current - the name of the current authentication, must be a key into
                    the map in the :authentications slot
         :authentications - a map with values of authentication maps keyed
                    by their :identity.

    superv.async 0.2.9
    Supervised channel management for core.async.
    cljs.spec/explain-data (cljs)SourceDoc + Usages
    Given a spec and a value x which ought to conform, returns nil if x
      conforms, else a map with at least the key ::problems whose value is
      a collection of problem-maps, where problem-map has at least :path :pred and :val
      keys describing the predicate and the value that failed at that
      path.

    dynadoc 1.4.7
    A dynamic documentation generator
    cljs.spec.alpha/explain-data (cljs)SourceDoc + Usages
    Given a spec and a value x which ought to conform, returns nil if x
      conforms, else a map with at least the key ::problems whose value is
      a collection of problem-maps, where problem-map has at least :path :pred and :val
      keys describing the predicate and the value that failed at that
      path.

    re-frame-10x 0.3.3
    Become 10x more productive when developing and debugging re-frame applications.
    mranderson048.re-frame.v0v10v2.re-frame.utils/dissoc-inSourceDoc + Usages
    Dissociates an entry from a nested associative structure returning a new
      nested structure. keys is a sequence of keys. Any empty maps that result
      will not be present in the new structure.
      The key thing is that 'm' remains identical? to istelf if the path was never present

    hoplon-elem-lib 0.2.0
    Tiny element library for Hoplon.
    cljs.spec.alpha/explain-data (cljs)SourceDoc + Usages
    Given a spec and a value x which ought to conform, returns nil if x
      conforms, else a map with at least the key ::problems whose value is
      a collection of problem-maps, where problem-map has at least :path :pred and :val
      keys describing the predicate and the value that failed at that
      path.

    Given a spec and a value x which ought to conform, returns nil if x
      conforms, else a map with at least the key ::problems whose value is
      a collection of problem-maps, where problem-map has at least :path :pred and :val
      keys describing the predicate and the value that failed at that
      path.

    Given a spec and a value x which ought to conform, returns nil if x
      conforms, else a map with at least the key ::problems whose value is
      a collection of problem-maps, where problem-map has at least :path :pred and :val
      keys describing the predicate and the value that failed at that
      path.

    strictly-specking-standalone 0.1.1
    A Clojure library to help validate edn configuration data, and hopefully more
    strictly-specking-standalone.spec/explain-dataSourceDoc + Usages
    Given a spec and a value x which ought to conform, returns nil if x
      conforms, else a map with at least the key ::problems whose value is
      a collection of problem-maps, where problem-map has at least :path :pred and :val
      keys describing the predicate and the value that failed at that
      path.

    async-flow-fx 0.0.10
    A re-frame effects handler for coordinating the kind of async control flow which
    day8.re-frame.async-flow-fx/dissoc-in (cljs)SourceDoc + Usages
    Dissociates an entry from a nested associative structure returning a new
      nested structure. keys is a sequence of keys. Any empty maps that result
      will not be present in the new structure.
      The key thing is that 'm' remains identical? to itself if the path was never present

    dstruct 0.2.1
    Data structures & utilities for CLJ/CLJS
    thi.ng.dstruct.core/deep-mergeSourceDoc + Usages
    Merge fn to be used with `merge-with`. Recursively merges map
      values which are maps or seqs (for the latter `into` is used, only
      if RHS is seq or set as well). If the RHS value has the metadata key
      `:replace` set, it is used as new value without merging.

    lambdacd 0.14.1
    A library to create a continous delivery pipeline in code.
    re-frame.utils/dissoc-inSourceDoc + Usages
    Dissociates an entry from a nested associative structure returning a new
      nested structure. keys is a sequence of keys. Any empty maps that result
      will not be present in the new structure.
      The key thing is that 'm' remains identical? to istelf if the path was never present

    lambdacd 0.14.1
    A library to create a continous delivery pipeline in code.
    re-frame.utils/dissoc-inSourceDoc + Usages
    Dissociates an entry from a nested associative structure returning a new
      nested structure. keys is a sequence of keys. Any empty maps that result
      will not be present in the new structure.
      The key thing is that 'm' remains identical? to istelf if the path was never present

    re-view-hiccup 0.1.15
    Hiccup parser for re-view
    cljs.spec.alpha/explain-data (cljs)SourceDoc + Usages
    Given a spec and a value x which ought to conform, returns nil if x
      conforms, else a map with at least the key ::problems whose value is
      a collection of problem-maps, where problem-map has at least :path :pred and :val
      keys describing the predicate and the value that failed at that
      path.

    pretty-spec 0.1.3
    A pretty printer for clojure.spec forms.
    cljs.spec.alpha/explain-data (cljs)SourceDoc + Usages
    Given a spec and a value x which ought to conform, returns nil if x
      conforms, else a map with at least the key ::problems whose value is
      a collection of problem-maps, where problem-map has at least :path :pred and :val
      keys describing the predicate and the value that failed at that
      path.

    jawsome-core 1.2.0
    A library of functions for dealing with reading and manipulating dirty JSON data
    jawsome-core.xform.xforms.static-injection/default-value-merge-fnSourceDoc + Usages
    Given a `default-value-map` returns a function that that accepts a map
    and returns the map with the corresponding key-value pairs in `default-value-map`
    replacing the values in the supplied map _only if they are missing_.
    
    If the optional `recursive?` parameter is specified, then the
    `default-value-map` will be merged recursively, preserving
    any internal property paths in both maps.

    jawsome-core 1.2.0
    A library of functions for dealing with reading and manipulating dirty JSON data
    jawsome-core.xform.xforms.static-injection/static-value-merge-fnSourceDoc + Usages
    Given a `static-value-map` returns a function that that accepts a map
    and returns the map with the corresponding key-value pairs in `static-value-map`
    replacing the values in the supplied map.
    
    If the optional `recursive?` parameter is specified, then the
    `static-value-map` will be merged recursively, preserving
    any internal property paths in both maps.

    trace 0.1.22
    Tracing and developer tools for re-frame apps
    mranderson047.re-frame.v0v10v2.re-frame.utils/dissoc-inSourceDoc + Usages
    Dissociates an entry from a nested associative structure returning a new
      nested structure. keys is a sequence of keys. Any empty maps that result
      will not be present in the new structure.
      The key thing is that 'm' remains identical? to istelf if the path was never present

    chu.graph 0.2.2
    a graph library
    chu.graph/adjencySourceDoc + Usages
    The map where graph nodes are keys and vals are maps of nodes adjacent to the key node with links params as value.
       Exemple : a -> b(p1) ; a -> c(p2) ; b -> c(p3) => {a {b p1, c p2} b {c p3} c {}}

    chu.graph 0.2.2
    a graph library
    chu.graph.protocol/adjencySourceDoc + Usages
    The map where graph nodes are keys and vals are maps of nodes adjacent to the key node with links params as value.
        Exemple : a -> b(p1) ; a -> c(p2) ; b -> c(p3) => {a {b p1, c p2} b {c p3} c {}}

    The map where graph nodes are keys and vals are maps of nodes adjacent to the key node with links params as value.
        Exemple : a -> b(p1) ; a -> c(p2) ; b -> c(p3) => {a {b p1, c p2} b {c p3} c {}}

    The map where graph nodes are keys and vals are maps of nodes adjacent to the key node with links params as value.
        Exemple : a -> b(p1) ; a -> c(p2) ; b -> c(p3) => {a {b p1, c p2} b {c p3} c {}}

    The map where graph nodes are keys and vals are maps of nodes adjacent to the key node with links params as value.
        Exemple : a -> b(p1) ; a -> c(p2) ; b -> c(p3) => {a {b p1, c p2} b {c p3} c {}}

    The map where graph nodes are keys and vals are maps of nodes adjacent to the key node with links params as value.
        Exemple : a -> b(p1) ; a -> c(p2) ; b -> c(p3) => {a {b p1, c p2} b {c p3} c {}}

    witan.workspace-onyx-plugins 0.1.0
    FIXME: write description
    onyx.plugin.redis/read-batch~RedisWriter~PipelineSourceDoc + Usages
    Reads :onyx/batch-size segments off the incoming data source.
                  Must return a map with key :onyx.core/batch and value seq representing
                  the ingested segments. The seq must be maps of two keys:
    
                  - :input - A keyword representing the task that the message came from
                  - :message - The consumed message

    witan.workspace-onyx-plugins 0.1.0
    FIXME: write description
    onyx.plugin.s3/read-batch~S3Writer~PipelineSourceDoc + Usages
    Reads :onyx/batch-size segments off the incoming data source.
                  Must return a map with key :onyx.core/batch and value seq representing
                  the ingested segments. The seq must be maps of two keys:
    
                  - :input - A keyword representing the task that the message came from
                  - :message - The consumed message

    trapperkeeper-authorization 0.7.0
    Trapperkeeper authorization system
    puppetlabs.trapperkeeper.authorization.acl/ExtensionsSourceDoc + Usages
    Schema for representing SSL Extensions as they come in on a request's
      certificate. Maps from a keyword shortname to a string value by default with
      special casing for more complex keys. The only special key supported now is
      :subject-alt-name which contains a map of keyword to lists of strings (if
      present at all).

    datamos 0.1.6.2
    Messaging platform displaying the capabilities of RDF triples.
    datamos.util/replace-sub-valueSourceDoc + Usages
    Supply map, which contains submaps. Provide key, in submap, for which you want the value to change.
       returns supplied map with changed value. Only works for first nested layer of maps.
       Every key's value, matching k will change to the supplied value.

    iron 0.4.0
    Front-end utilities and support for ClojureScript and re-frame projects
    cljs.spec.alpha/explain-data (cljs)SourceDoc + Usages
    Given a spec and a value x which ought to conform, returns nil if x
      conforms, else a map with at least the key ::problems whose value is
      a collection of problem-maps, where problem-map has at least :path :pred and :val
      keys describing the predicate and the value that failed at that
      path.

    iron 0.4.0
    Front-end utilities and support for ClojureScript and re-frame projects
    re-frame.utils/dissoc-inSourceDoc + Usages
    Dissociates an entry from a nested associative structure returning a new
      nested structure. keys is a sequence of keys. Any empty maps that result
      will not be present in the new structure.
      The key thing is that 'm' remains identical? to istelf if the path was never present

    bacure 1.0.8
    A Clojure wrapper for the BAC4j library... and some nice additions.
    bacure.core/where-or-not-foundSourceDoc + Usages
    Will test with criteria map as a predicate. If the value of a
      key-val pair is a function, use it as a predicate. If the tested map
      value is not found, pass.
    
      For example:
      Criteria map:  {:a #(> % 10) :b "foo"}
      Tested-maps  {:a 20 :b "foo"}  success
                   {:b "foo"}        success
                   {:a nil :b "foo"} fail

    bacure 1.0.8
    A Clojure wrapper for the BAC4j library... and some nice additions.
    bacure.core/whereSourceDoc + Usages
    Will test with criteria map as a predicate. If the value of a
      key-val pair is a function, use it as a predicate. If the tested map
      value is not found, fail.
    
      For example:
      Criteria map:  {:a #(> % 10) :b "foo"}
      Tested-maps  {:a 20 :b "foo"}  success
                   {:b "foo"}        fail
                   {:a nil :b "foo"} fail

    franzy-admin 0.0.6
    A Kafka Clojure Admin client, with support for topic, partition, group, cluster
    franzy.admin.topics/topic-replica-assignmentsSourceDoc + Usages
    Returns the assigned replicas for a given list of topics.
    
      Returns a vector of maps where the key is the topic partition and the values are a vector of assigned replica IDs.
    
      Example:
    
      `{{:topic "cheeses", :partition 0} [1001], {:topic "gigantic-cheeses", :partition 0} [1001]}`

    hvacio-ui 0.1.13
    A common UI for multiple HVAC.IO applications.
    hvacio-ui.util/where (cljs)SourceDoc + Usages
    Will test with criteria map as a predicate. If the value of a
      key-val pair is a function, use it as a predicate. If the tested map
      value is not found, fail.
    
      For example:
      Criteria map:  {:a #(> % 10) :b "foo"}
      Tested-maps  {:a 20 :b "foo"}  success
                   {:b "foo"}        fail
                   {:a nil :b "foo"} fail

    reagent-slider 0.1.2
    Reagent wrapper around react-components/slider
    cljs.spec/explain-data (cljs)SourceDoc + Usages
    Given a spec and a value x which ought to conform, returns nil if x
      conforms, else a map with at least the key ::problems whose value is
      a collection of problem-maps, where problem-map has at least :path :pred and :val
      keys describing the predicate and the value that failed at that
      path.

    Given a spec and a value x which ought to conform, returns nil if x
      conforms, else a map with at least the key ::problems whose value is
      a collection of problem-maps, where problem-map has at least :path :pred and :val
      keys describing the predicate and the value that failed at that
      path.

    onyx-amazon-sqs 0.8.11.0
    Onyx plugin for Amazon SQS
    onyx.plugin.sqs-input/read-batch~SqsInput~PipelineSourceDoc + Usages
    Reads :onyx/batch-size segments off the incoming data source.
                  Must return a map with key :onyx.core/batch and value seq representing
                  the ingested segments. The seq must be maps of two keys:
    
                  - :input - A keyword representing the task that the message came from
                  - :message - The consumed message

    onyx-amazon-sqs 0.8.11.0
    Onyx plugin for Amazon SQS
    onyx.plugin.sqs-output/read-batch~SqsOutput~PipelineSourceDoc + Usages
    Reads :onyx/batch-size segments off the incoming data source.
                  Must return a map with key :onyx.core/batch and value seq representing
                  the ingested segments. The seq must be maps of two keys:
    
                  - :input - A keyword representing the task that the message came from
                  - :message - The consumed message

    fsmviz 0.1.3
    Generate Graphviz diagrams from FSM data.
    cljs.spec.alpha/explain-data (cljs)SourceDoc + Usages
    Given a spec and a value x which ought to conform, returns nil if x
      conforms, else a map with at least the key ::problems whose value is
      a collection of problem-maps, where problem-map has at least :path :pred and :val
      keys describing the predicate and the value that failed at that
      path.

    shadow-devtools 1.0.20170516
    CLJS development tools
    shadow.cljs.build/scan-for-modified-filesSourceDoc + Usages
    scans known sources for modified or deleted files
    
      returns a seq of resource maps with a :scan key which is either :modified :delete
    
      modified macros will cause all files using to to be returned as well
      although the files weren't modified physically the macro output may have changed

    budb 0.0.1
    A CRDT Database for Clojure(script)
    cljs.spec/explain-data (cljs)SourceDoc + Usages
    Given a spec and a value x which ought to conform, returns nil if x
      conforms, else a map with at least the key ::problems whose value is
      a collection of problem-maps, where problem-map has at least :path :pred and :val
      keys describing the predicate and the value that failed at that
      path.

    budb 0.0.1
    A CRDT Database for Clojure(script)
    cljs.spec/explain-data (cljs)SourceDoc + Usages
    Given a spec and a value x which ought to conform, returns nil if x
      conforms, else a map with at least the key ::problems whose value is
      a collection of problem-maps, where problem-map has at least :path :pred and :val
      keys describing the predicate and the value that failed at that
      path.

    re-frame-ipfs-fx 0.0.2
    IPFS Re-Frame handlers.
    re-frame.utils/dissoc-inSourceDoc + Usages
    Dissociates an entry from a nested associative structure returning a new
      nested structure. keys is a sequence of keys. Any empty maps that result
      will not be present in the new structure.
      The key thing is that 'm' remains identical? to istelf if the path was never present

    dali 0.7.4
    A Clojure library for 2D graphics.
    dali.syntax/process-attr-mapSourceDoc + Usages
    Unwraps nested attribute maps (mainly for :stroke and :fill).
    
      Renames some dashed attibutes into camelcase to follow the SVG
      convention. Does the lookup in the attr-key-lookup map.
    
      Converts attribute values that are sequences of numbers into
      space-delimited string, except when it comes to :stroke-dasharray
      which becomes a comma-delimited string.

    lemonade 0.3.0
    High level language for graphical and UI programming. No markup.
    cljs.spec.alpha/explain-data (cljs)SourceDoc + Usages
    Given a spec and a value x which ought to conform, returns nil if x
      conforms, else a map with at least the key ::problems whose value is
      a collection of problem-maps, where problem-map has at least :path :pred and :val
      keys describing the predicate and the value that failed at that
      path.

    lemonade 0.3.0
    High level language for graphical and UI programming. No markup.
    cljs.spec.alpha/explain-data (cljs)SourceDoc + Usages
    Given a spec and a value x which ought to conform, returns nil if x
      conforms, else a map with at least the key ::problems whose value is
      a collection of problem-maps, where problem-map has at least :path :pred and :val
      keys describing the predicate and the value that failed at that
      path.

    Reads :onyx/batch-size segments off the incoming data source.
                  Must return a map with key :onyx.core/batch and value seq representing
                  the ingested segments. The seq must be maps of two keys:
    
                  - :input - A keyword representing the task that the message came from
                  - :message - The consumed message

    ventas 0.0.6
    The Ventas eCommerce platform
    re-frame.utils/dissoc-inSourceDoc + Usages
    Dissociates an entry from a nested associative structure returning a new
      nested structure. keys is a sequence of keys. Any empty maps that result
      will not be present in the new structure.
      The key thing is that 'm' remains identical? to istelf if the path was never present

    ventas 0.0.6
    The Ventas eCommerce platform
    cljs.spec.alpha/explain-data (cljs)SourceDoc + Usages
    Given a spec and a value x which ought to conform, returns nil if x
      conforms, else a map with at least the key ::problems whose value is
      a collection of problem-maps, where problem-map has at least :path :pred and :val
      keys describing the predicate and the value that failed at that
      path.

    ventas 0.0.6
    The Ventas eCommerce platform
    re-frame.utils/dissoc-inSourceDoc + Usages
    Dissociates an entry from a nested associative structure returning a new
      nested structure. keys is a sequence of keys. Any empty maps that result
      will not be present in the new structure.
      The key thing is that 'm' remains identical? to istelf if the path was never present

    ventas 0.0.6
    The Ventas eCommerce platform
    cljs.spec.alpha/explain-data (cljs)SourceDoc + Usages
    Given a spec and a value x which ought to conform, returns nil if x
      conforms, else a map with at least the key ::problems whose value is
      a collection of problem-maps, where problem-map has at least :path :pred and :val
      keys describing the predicate and the value that failed at that
      path.

    com.chpill.re-frankenstein 0.0.2
    The deviant fork of re-frame
    re-frame.utils/dissoc-inSourceDoc + Usages
    Dissociates an entry from a nested associative structure returning a new
      nested structure. keys is a sequence of keys. Any empty maps that result
      will not be present in the new structure.
      The key thing is that 'm' remains identical? to istelf if the path was never present

    google-apps-clj 0.6.1
    A Clojure library that wraps the Google Java API
    google-apps-clj.google-drive/Query->DriveRequestSourceDoc + Usages
    Converts a Query map into an instance of DriveRequest.  All Query maps have at least
      a `:model` and an `:action` key describing the type of operation that they represent.
      The exact class returned depends on the `:model` and `:action` keys of the Query map,
      but all returend classes are ones that implement DriveRequest.

    shadow-build 1.0.2017040316
    cljs compiler
    shadow.cljs.build/scan-for-modified-filesSourceDoc + Usages
    scans known sources for modified or deleted files
    
      returns a seq of resource maps with a :scan key which is either :modified :delete
    
      modified macros will cause all files using to to be returned as well
      although the files weren't modified physically the macro output may have changed

    babel 3.1.0
    A library for natural language generation and parsing
    babel.english.lexicon/exception-generatorSourceDoc + Usages
    _lexicon_ is a map where each key is a root form (a string) mapped to a set of lexical entries (maps) for that root form. 
      For each such lexical entry, generate all possible exceptions, where the exception-generation rules are given below as 'path-and-merge-fn' tuples.

    babel 3.1.0
    A library for natural language generation and parsing
    babel.english.lexicon/exception-generatorSourceDoc + Usages
    _lexicon_ is a map where each key is a root form (a string) mapped to a set of lexical entries (maps) for that root form. 
      For each such lexical entry, generate all possible exceptions, where the exception-generation rules are given below as 'path-and-merge-fn' tuples.

    anki-cljs 0.1.1
    CLJS interface for interacting with Anki
    cljs.spec.alpha/explain-data (cljs)SourceDoc + Usages
    Given a spec and a value x which ought to conform, returns nil if x
      conforms, else a map with at least the key ::problems whose value is
      a collection of problem-maps, where problem-map has at least :path :pred and :val
      keys describing the predicate and the value that failed at that
      path.

    rejax 0.1.0
    A library that creates nicer API for usage of cljs-ajax in Re-frame
    re-frame.utils/dissoc-inSourceDoc + Usages
    Dissociates an entry from a nested associative structure returning a new
      nested structure. keys is a sequence of keys. Any empty maps that result
      will not be present in the new structure.
      The key thing is that 'm' remains identical? to istelf if the path was never present

    rejax 0.1.0
    A library that creates nicer API for usage of cljs-ajax in Re-frame
    cljs.spec.alpha/explain-data (cljs)SourceDoc + Usages
    Given a spec and a value x which ought to conform, returns nil if x
      conforms, else a map with at least the key ::problems whose value is
      a collection of problem-maps, where problem-map has at least :path :pred and :val
      keys describing the predicate and the value that failed at that
      path.

    onyx-null 0.7.2.0
    Onyx plugin to use as a null output
    onyx.plugin.null-output/read-batch~NullOutput~PipelineSourceDoc + Usages
    Reads :onyx/batch-size segments off the incoming data source.
                  Must return a map with key :onyx.core/batch and value seq representing
                  the ingested segments. The seq must be maps of two keys:
    
                  - :input - A keyword representing the task that the message came from
                  - :message - The consumed message

    cmr-client 0.1.0
    A Clojure(Script) Client for NASA's Common Metadata Repository
    cljs.spec.alpha/explain-data (cljs)SourceDoc + Usages
    Given a spec and a value x which ought to conform, returns nil if x
      conforms, else a map with at least the key ::problems whose value is
      a collection of problem-maps, where problem-map has at least :path :pred and :val
      keys describing the predicate and the value that failed at that
      path.

    jdbc-fu 0.1.1
    A collection of utility functions on top of java.jdbc
    jdbc-fu.info/indexesSourceDoc + Usages
    Retrieves a description of the indexes available in the given
      catalog and table(s). 
      If set to true, the unique? and approximate? keys allow for unique
      keys only and out of data values respectively. Returns a sequence of
      raw maps as yielded by java.jdbc (albeit with keywordised keys),
      unless fns to be applied to map rows or key identifiers are
      provided.

    asosio.utils 0.0.4
    The Asosio Utils is a collection of utilities that makes development of clojure
    asosio.utils.test/getvalSourceDoc + Usages
    ensure a unique test-friendly fallback value if 'k' isn't found in m.
    
      NOTE: use this instead of (k m) or (get m k <fallback>) to generate fallback
            values which are sure to cause a test failure should either **or both**
            expected & actual result maps miss the entry for key k.

    Reads :onyx/batch-size segments off the incoming data source.
                  Must return a map with key :onyx.core/batch and value seq representing
                  the ingested segments. The seq must be maps of two keys:
    
                  - :input - A keyword representing the task that the message came from
                  - :message - The consumed message

    Reads :onyx/batch-size segments off the incoming data source.
                  Must return a map with key :onyx.core/batch and value seq representing
                  the ingested segments. The seq must be maps of two keys:
    
                  - :input - A keyword representing the task that the message came from
                  - :message - The consumed message

    cloth 0.3.1
    Clojure(Script) tools for Ethereum
    cljs.spec/explain-data (cljs)SourceDoc + Usages
    Given a spec and a value x which ought to conform, returns nil if x
      conforms, else a map with at least the key ::problems whose value is
      a collection of problem-maps, where problem-map has at least :path :pred and :val
      keys describing the predicate and the value that failed at that
      path.

    Given a spec and a value x which ought to conform, returns nil if x
      conforms, else a map with at least the key ::problems whose value is
      a collection of problem-maps, where problem-map has at least :path :pred and :val
      keys describing the predicate and the value that failed at that
      path.

    Return an Om component that renders a horizontal bar chart
       the cursor is of the form {:data `data` :height `height` :width `width`}
       `data` [required] is a vector of maps of the form
       {"key": <string>
        "value": <integer>}
       `height` is an integer representing the height of the generated chart
       `width` is an integer representing the height of the generated chart

    Return an Om component that renders a horizontal bar chart
       the cursor is of the form {:data `data` :height `height` :width `width`}
       `data` [required] is a vector of maps of the form
       {"key": <string>
        "value": <integer>}
       `height` is an integer representing the height of the generated chart
       `width` is an integer representing the height of the generated chart

    Given a spec and a value x which ought to conform, returns nil if x
      conforms, else a map with at least the key ::problems whose value is
      a collection of problem-maps, where problem-map has at least :path :pred and :val
      keys describing the predicate and the value that failed at that
      path.

    Updates a value in a nested associative structure, where `ks` is a sequence
      of keys and `f` is a function that will take the old value and any supplied
      args and return the new value, and returns a new nested structure. If any key
      does not exist, `not-found` will be used as the old value. If any levels do
      not exist, hash-maps will be created.

    b-plus-tree 0.3.0
    A B+ Tree implemented in Clojure.
    b-plus-tree.core/insertSourceDoc + Usages
    Inserts a key-value pair into the B+ Tree. Returns a vector whose first
      element is the new header, and whose second element is a cache map, which
      maps pointer offsets to the nodes located there, for all nodes which have
      been read.
      If a node is altered, it is given an additional [:altered? true] entry.

    tyan-a-bumfit yan.tan.tethera
    Implementation of the Yan Tan Tethera sheep-counting system
    cljs.spec/explain-data (cljs)SourceDoc + Usages
    Given a spec and a value x which ought to conform, returns nil if x
      conforms, else a map with at least the key ::problems whose value is
      a collection of problem-maps, where problem-map has at least :path :pred and :val
      keys describing the predicate and the value that failed at that
      path.

    Given a spec and a value x which ought to conform, returns nil if x
      conforms, else a map with at least the key ::problems whose value is
      a collection of problem-maps, where problem-map has at least :path :pred and :val
      keys describing the predicate and the value that failed at that
      path.

    reagent-quill 0.1.1
    Reagent wrapper around react-quill
    cljs.spec/explain-data (cljs)SourceDoc + Usages
    Given a spec and a value x which ought to conform, returns nil if x
      conforms, else a map with at least the key ::problems whose value is
      a collection of problem-maps, where problem-map has at least :path :pred and :val
      keys describing the predicate and the value that failed at that
      path.

    asosio-utils 0.0.1
    The Asosio Utils is a collection of utilities that makes development of clojure
    asosio_utils.test/getvalSourceDoc + Usages
    ensure a unique test-friendly fallback value if 'k' isn't found in m.
    
      NOTE: use this instead of (k m) or (get m k <fallback>) to generate fallback
            values which are sure to cause a test failure should either **or both**
            expected & actual result maps miss the entry for key k.

    district0x 0.1.20
    district0x Frontend Library
    cljs.spec.alpha/explain-data (cljs)SourceDoc + Usages
    Given a spec and a value x which ought to conform, returns nil if x
      conforms, else a map with at least the key ::problems whose value is
      a collection of problem-maps, where problem-map has at least :path :pred and :val
      keys describing the predicate and the value that failed at that
      path.

    district0x 0.1.20
    district0x Frontend Library
    re-frame.utils/dissoc-inSourceDoc + Usages
    Dissociates an entry from a nested associative structure returning a new
      nested structure. keys is a sequence of keys. Any empty maps that result
      will not be present in the new structure.
      The key thing is that 'm' remains identical? to istelf if the path was never present

    conwip.modules 0.1.0
    Library for dynamically loading ClojureScript modules
    cljs.spec/explain-data (cljs)SourceDoc + Usages
    Given a spec and a value x which ought to conform, returns nil if x
      conforms, else a map with at least the key ::problems whose value is
      a collection of problem-maps, where problem-map has at least :path :pred and :val
      keys describing the predicate and the value that failed at that
      path.

    conwip.modules 0.1.0
    Library for dynamically loading ClojureScript modules
    cljs.spec/explain-data (cljs)SourceDoc + Usages
    Given a spec and a value x which ought to conform, returns nil if x
      conforms, else a map with at least the key ::problems whose value is
      a collection of problem-maps, where problem-map has at least :path :pred and :val
      keys describing the predicate and the value that failed at that
      path.

    onyx-durable-queue 0.9.15.0
    Onyx plugin for Factual's durable-queue
    onyx.plugin.durable-queue/read-batch~DurableQueueWriter~PipelineSourceDoc + Usages
    Reads :onyx/batch-size segments off the incoming data source.
                  Must return a map with key :onyx.core/batch and value seq representing
                  the ingested segments. The seq must be maps of two keys:
    
                  - :input - A keyword representing the task that the message came from
                  - :message - The consumed message

    onyx-durable-queue 0.9.15.0
    Onyx plugin for Factual's durable-queue
    onyx.plugin.durable-queue/read-batch~DurableQueueReader~PipelineSourceDoc + Usages
    Reads :onyx/batch-size segments off the incoming data source.
                  Must return a map with key :onyx.core/batch and value seq representing
                  the ingested segments. The seq must be maps of two keys:
    
                  - :input - A keyword representing the task that the message came from
                  - :message - The consumed message

    Returns a map that consists of the rest of the maps conj-ed onto
      the first.  If a key occurs in more than one map, the mapping(s)
      from the latter (left-to-right) will be combined with the mapping in
      the result by calling (f val-in-result val-in-latter).

    pine 0.1.6
    A Clojure/ClojureScript router designed for universal applications.
    cljs.spec.alpha/explain-data (cljs)SourceDoc + Usages
    Given a spec and a value x which ought to conform, returns nil if x
      conforms, else a map with at least the key ::problems whose value is
      a collection of problem-maps, where problem-map has at least :path :pred and :val
      keys describing the predicate and the value that failed at that
      path.

    pine 0.1.6
    A Clojure/ClojureScript router designed for universal applications.
    re-frame.utils/dissoc-inSourceDoc + Usages
    Dissociates an entry from a nested associative structure returning a new
      nested structure. keys is a sequence of keys. Any empty maps that result
      will not be present in the new structure.
      The key thing is that 'm' remains identical? to istelf if the path was never present

    faraday 1.10.0
    Clojure DynamoDB client
    taoensso.faraday/items-by-attrsSourceDoc + Usages
    Groups one or more items by one or more attributes, returning a map of form
      {<attr-val> <item> ...} or {{<attr> <val> ...} <item>}.
    
      Good for collecting batch or query/scan items results into useable maps,
      indexed by their 'primary key' (which, remember, may consist of 1 OR 2 attrs).

    gadjett 0.5.2
    Inspector tools for clojure[script]
    cljs.spec/explain-data (cljs)SourceDoc + Usages
    Given a spec and a value x which ought to conform, returns nil if x
      conforms, else a map with at least the key ::problems whose value is
      a collection of problem-maps, where problem-map has at least :path :pred and :val
      keys describing the predicate and the value that failed at that
      path.

    rui 0.3.0
    UI components based on Reagent and Re-frame
    re-frame.utils/dissoc-inSourceDoc + Usages
    Dissociates an entry from a nested associative structure returning a new
      nested structure. keys is a sequence of keys. Any empty maps that result
      will not be present in the new structure.
      The key thing is that 'm' remains identical? to istelf if the path was never present

    rui 0.3.0
    UI components based on Reagent and Re-frame
    cljs.spec.alpha/explain-data (cljs)SourceDoc + Usages
    Given a spec and a value x which ought to conform, returns nil if x
      conforms, else a map with at least the key ::problems whose value is
      a collection of problem-maps, where problem-map has at least :path :pred and :val
      keys describing the predicate and the value that failed at that
      path.

    rui 0.3.0
    UI components based on Reagent and Re-frame
    re-frame.utils/dissoc-inSourceDoc + Usages
    Dissociates an entry from a nested associative structure returning a new
      nested structure. keys is a sequence of keys. Any empty maps that result
      will not be present in the new structure.
      The key thing is that 'm' remains identical? to istelf if the path was never present

    afterglow 0.2.4
    A live-coding environment for light shows, built on the Open Lighting Architecture,
    afterglow.midi/aftertouch-mappingsSourceDoc + Usages
    Functions to be called when MIDI Aftertouch
      (polyphonic key pressure) messages arrive from particular input
      ports. A set of nested maps whose keys are the `MidiDevice.Info`
      on which the message should be watched for, the channel to watch,
      and the note number to watch for. The values are sets of functions
      to be called with each matching message.

    sxml-jaxp 0.2.0
    Tools for using SXML-inspired XML representations with JAXP.
    sxml-jaxp.sax/compiled-sxmlSourceDoc + Usages
    This macro will pre-compile, as a speed optimization, an SXML literal that
      is to be used as input to a JAXP API. Expressions may appear in the SXML form
      in place of text nodes, and cannot affect the element structure. Attributes
      must be literal maps for now, but may contain expressions in both key and
      value positions.

    audit 0.1.1
    Clojure Library for verifying maps
    audit.core/auditSourceDoc + Usages
    Takes two maps audit-map and value-map.  First check to see
       if they have the same keys.  If not, it throws an exception.
       If so, the valid-audit key is set to true in the value-map, and
       the audit-map is reduced using audit-helper. The value-map is
       the initial value for the reduce operation.

    clj-symphony 0.8.0
    A Clojure wrapper around the symphony-java-client library.
    clj-symphony.chat/chatobj->mapSourceDoc + Usages
    Converts a `org.symphonyoss.client.model.Chat` object into a map with these
      keys:
    
      | Key             | Description                                                                                                       |
      |-----------------|-------------------------------------------------------------------------------------------------------------------|
      | `:stream-id`    | The stream id of the chat.                                                                                        |
      | `:last-message` | The last message sent to the chat, as a map (see [[clj-symphony.message/msgobj->map]] for details).               |
      | `:other-users`  | A sequence of maps representing the other users in the chat (see [[clj-symphony.user/userobj->map]] for details). |
      

    kern 1.1.0
    A Parser Combinators Library
    cljs.spec.alpha/explain-data (cljs)SourceDoc + Usages
    Given a spec and a value x which ought to conform, returns nil if x
      conforms, else a map with at least the key ::problems whose value is
      a collection of problem-maps, where problem-map has at least :path :pred and :val
      keys describing the predicate and the value that failed at that
      path.

    inspectable 0.2.2
    Tools for clojure.spec
    cljs.spec.alpha/explain-data (cljs)SourceDoc + Usages
    Given a spec and a value x which ought to conform, returns nil if x
      conforms, else a map with at least the key ::problems whose value is
      a collection of problem-maps, where problem-map has at least :path :pred and :val
      keys describing the predicate and the value that failed at that
      path.

    re-frame-fork 0.10.2-1
    A Clojurescript MVC-like Framework For Writing SPAs Using Reagent.
    re-frame.utils/dissoc-inSourceDoc + Usages
    Dissociates an entry from a nested associative structure returning a new
      nested structure. keys is a sequence of keys. Any empty maps that result
      will not be present in the new structure.
      The key thing is that 'm' remains identical? to istelf if the path was never present

    editable 0.1.4
    lifecycle events for forms using re-frame
    re-frame.utils/dissoc-inSourceDoc + Usages
    Dissociates an entry from a nested associative structure returning a new
      nested structure. keys is a sequence of keys. Any empty maps that result
      will not be present in the new structure.
      The key thing is that 'm' remains identical? to istelf if the path was never present

    onyx-redis-plus 0.8.2.2
    Onyx plugin for redis
    onyx.plugin.redis/read-batch~RedisWriter~PipelineSourceDoc + Usages
    Reads :onyx/batch-size segments off the incoming data source.
                  Must return a map with key :onyx.core/batch and value seq representing
                  the ingested segments. The seq must be maps of two keys:
    
                  - :input - A keyword representing the task that the message came from
                  - :message - The consumed message

    Sets up (lazy-)seq of breeders (maps with a :prob key) in a seq in
      increasing summation, eg. three sources with probabilities [0.1 0.5 0.4] will
      become [0.1 0.6 1.0]. This makes source selection fast and easy. Probabilities
      have to add up to 1.0.

    re-frame-utils 0.1.0
    Fxs and CoFxs for re-frame
    re-frame.utils/dissoc-inSourceDoc + Usages
    Dissociates an entry from a nested associative structure returning a new
      nested structure. keys is a sequence of keys. Any empty maps that result
      will not be present in the new structure.
      The key thing is that 'm' remains identical? to istelf if the path was never present

    cantata 0.1.17
    SQL and database abstraction
    cantata.core/save!SourceDoc + Usages
    Saves entity map values to the database. If the primary key is included in
      the map, the DB record will be updated if it exists. If it doesn't exist, or
      if no primary key is provided, a new record will be inserted.
    
      The map may include nested, related maps, which will in turn be saved and
      associated with the top-level record. Nested rel values may also be bare
      primary key values instead of maps.
    
      All changes happen within a transaction.
    
      Values will be marshalled before being sent to the database. Joda dates,
      for example, will be converted to java.sql dates.
    
      Returns the primary key of the updated or inserted record.
    
      Accepts the following keyword options:
          :validate     - when false, does not validate saved records
          :check-update - when false, assumes presence of PK = update
          :save-rels    - when false, does not save related records

    cantata 0.1.17
    SQL and database abstraction
    cantata.core/save!SourceDoc + Usages
    Saves entity map values to the database. If the primary key is included in
      the map, the DB record will be updated if it exists. If it doesn't exist, or
      if no primary key is provided, a new record will be inserted.
    
      The map may include nested, related maps, which will in turn be saved and
      associated with the top-level record. Nested rel values may also be bare
      primary key values instead of maps.
    
      All changes happen within a transaction.
    
      Values will be marshalled before being sent to the database. Joda dates,
      for example, will be converted to java.sql dates.
    
      Returns the primary key of the updated or inserted record.
    
      Accepts the following keyword options:
          :validate     - when false, does not validate saved records
          :check-update - when false, assumes presence of PK = update
          :save-rels    - when false, does not save related records

    deepfns 0.1.5
    Deeply nested fmap, fapply, and more!
    deepfns.core/zipSourceDoc + Usages
    Similar to zip-list but it handles nested data and maps too. Each
      function in the fs collection will be applied to the argument at
      that position (vectors + seqs) or the matching key (maps). The
      1-arity version will return an infinite seq of the item.
    
      Here is more info on zip-list:
      https://en.wikibooks.org/wiki/Haskell/Applicative_Functors#ZipList
    
      ex:
      (zip [+ -] [1 2 3] [4 5] [6 1])
    
      => [11 -4]
    
       (zip {:a inc :b dec}
         {:a 1 :b {:c 2 :d 3}})
    
      => {:a 2 :b {:c 1 :d 2}}
    
      NOTE: This is not compatible with sets, only lists, seqs, and maps.

    deepfns 0.1.5
    Deeply nested fmap, fapply, and more!
    deepfns.core/zipSourceDoc + Usages
    Similar to zip-list but it handles nested data and maps too. Each
      function in the fs collection will be applied to the argument at
      that position (vectors + seqs) or the matching key (maps). The
      1-arity version will return an infinite seq of the item.
    
      Here is more info on zip-list:
      https://en.wikibooks.org/wiki/Haskell/Applicative_Functors#ZipList
    
      ex:
      (zip [+ -] [1 2 3] [4 5] [6 1])
    
      => [11 -4]
    
       (zip {:a inc :b dec}
         {:a 1 :b {:c 2 :d 3}})
    
      => {:a 2 :b {:c 1 :d 2}}
    
      NOTE: This is not compatible with sets, only lists, seqs, and maps.

    ring-json 0.5.0-beta1
    Ring middleware for handling JSON
    ring.middleware.json/wrap-json-bodySourceDoc + Usages
    Middleware that parses the body of JSON request maps, and replaces the :body
      key with the parsed data structure. Requests without a JSON content type are
      unaffected.
    
      Accepts the following options:
    
      :keywords?          - true if the keys of maps should be turned into keywords
      :bigdecimals?       - true if BigDecimals should be used instead of Doubles
      :malformed-response - a response map to return when the JSON is malformed

    ring-transit 0.1.6
    Ring middleware for handling transit format
    ring.middleware.transit/wrap-transit-bodySourceDoc + Usages
    Middleware that parses the body of Transit request maps, and replaces the :body
      key with the parsed data structure. Requests without a Transit content type are
      unaffected.
    
      Accepts the following options:
    
      :keywords?               - true if the keys of maps should be turned into keywords
      :opts                    - a map of options to be passed to the transit reader
      :malformed-response      - a response map to return when the Transit is malformed
      :malformed-response-fn   - a custom error handler that gets called when the body is malformed
                                 transit. Will be called with three parameters: [exception request handler]

    suchwow 6.0.2
    Such functions! Such doc strings! Much utility!
    such.relational/one-to-one-index-onSourceDoc + Usages
    `table` should be a sequence of maps. `keyseq` is either a single value
      (corresponding to a traditional `:id` or `:pk` entry) or a sequence of
      values (corresponding to a compound key).
    
      The resulting index provides fast access to individual maps.
    
          (def index:traditional (one-to-one-index-on table :id))
          (index-select 5 :using index:traditional :keys [:key1 :key2])
    
          (def index:compound (one-to-one-index-on table ["intkey" "strkey")))
          (index-select [4 "dawn"] :using index:compound)
    
      Note that keys need not be Clojure keywords.
      

    fulcro 2.5.9
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    fulcro.server/wrap-transit-bodySourceDoc + Usages
    Middleware that parses the body of Transit request maps, and replaces the :body
      key with the parsed data structure. Requests without a Transit content type are
      unaffected.
      Accepts the following options:
      :keywords?          - true if the keys of maps should be turned into keywords
      :opts               - a map of options to be passed to the transit reader
      :malformed-response - a response map to return when the JSON is malformed

    untangled-server 0.7.0
    Library for creating Untangled web servers
    untangled.server.impl.middleware/wrap-transit-bodySourceDoc + Usages
    Middleware that parses the body of Transit request maps, and replaces the :body
      key with the parsed data structure. Requests without a Transit content type are
      unaffected.
      Accepts the following options:
      :keywords?          - true if the keys of maps should be turned into keywords
      :opts               - a map of options to be passed to the transit reader
      :malformed-response - a response map to return when the JSON is malformed

    untangled 1.0.0-beta1
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    untangled.server/wrap-transit-bodySourceDoc + Usages
    Middleware that parses the body of Transit request maps, and replaces the :body
      key with the parsed data structure. Requests without a Transit content type are
      unaffected.
      Accepts the following options:
      :keywords?          - true if the keys of maps should be turned into keywords
      :opts               - a map of options to be passed to the transit reader
      :malformed-response - a response map to return when the JSON is malformed

    jepsen.tendermint 0.1.0
    Jepsen tests for the Tendermint Byzantine consensus system
    jepsen.tendermint.validator/configSourceDoc + Usages
    There are two pieces of state we need to handle. The first is the validator
      set, as known to the cluster, which maps public keys to maps like:
    
          {:address
           :pub_key {:type ...
                     :data ...}
           :priv_key {:type ...
                      :data ...}
           :votes    an-int}
    
      And the second is a map of nodes to the validator key they're running:
    
          {"n1" "ABCD..."
           ...}
    
      Additionally, we need a bound :max-byzantine-vote-fraction on the fraction of
      the vote any byzantine validator is allowed to control, a :version, denoting
      the version of the validator set that the cluster knows, and a :node-set, the
      set of nodes that exist.

    uruk 0.3.11
    Clojure wrapper of MarkLogic XML Content Connector For Java (XCC/J)
    uruk.core/submit-requestSourceDoc + Usages
    Construct, submit, and return raw results of request for the given
      `session` using `request-factory` and `query`. Modify it
      with (possibly empty) `options` and `variables` maps. Applies type
      conversion to response according to defaults and
      `xml-type-str->conv-fn`. Variables may be passed as a map of Strings
      or with String names corresponding to maps describing the variable
      using mandatory key `:value` and optional keys `:namespace` and
      `:type`.`

    tesser.core 1.0.2
    Composable concurrent folds for Clojure.
    tesser.core/facetSourceDoc + Usages
    Your inputs are maps, and you want to apply a fold to each value
      independently. Facet generalizes a fold over a single value to operate on
      maps of keys to those values, returning a map of keys to the results of the
      fold over all values for that key. Each key gets an independent instance of
      the fold.
    
      For instance, say you have inputs like
    
          {:x 1, :y 2}
          {}
          {:y 3, :z 4}
    
      Then the fold
    
          (->> (facet)
               (mean))
    
      returns a map for each key's mean value:
    
          {:x 1, :y 2, :z 4}

    merkle-db-core 0.1.0
    Hybrid data store built on merkle trees.
    merkle-db.table/insertSourceDoc + Usages
    Insert some record data into the database, represented by a collection
        of record data maps. Returns an updated table.
    
        Options may include:
    
        - `:update-field`
          A function which will be called with `(f field-key old-val new-val)`, and
          should return the new value to use for that field. By default, `new-val`
          is used directly.
        - `:update-record`
          A function which will be called with `(f record-key old-data new-data)`,
          and should return the data map to use for the record. By default, this
          merges the data maps and removes nil-valued fields.

    stillsuit 0.8.0
    lacinia-datomic utilities
    stillsuit.lacinia.enums/make-enum-mapSourceDoc + Usages
    Look through a decorated lacinia schema, scanning its enum values. For each enum description,
      check for a `:stillsuit/datomic-value` key, representing what value the enum should have in the
      datomic database.
    
      Return a map with an entry for each enum which contains such a key. Inside of this map will be
      two entries: `:stillsuit/datomic-to-lacinia` maps from datomic names to their lacinia enum
      counterparts, and `:stillsuit/lacinia-to-datomic` goes the other way. These maps are stored
      in the app context and used in stillsuit enum resolvers and the `(stillsuit/datomic-enum)` function.

    bestcase 0.1.0
    An A/B testing library for clojure
    bestcase.core/resultsSourceDoc + Usages
    Returns a result map for test-name, where control-alternative-name is
       used as the control (base case) for purposes of statistical analysis.
    
       The result map has the following structure:
    
       {:test-name <keyword>
        :test-type :ab-test
        :alternatives [...]}
    
       where the value of the :alternatives key is itself a list of
       alternative maps:
    
       {:alternative-name <keyword>
        :count <int>
        :control true ;; optional, only set for control alternative
        :goal-results [...]}
    
       where the value of the :goal-results key is itself a list of
       goal maps:
    
       {:goal-name <keyword>
        :score <int>
        :z-score <float>}
    
       The z-score is calculated based on the current control alternative.

    madeinqc.tesser.core 1.0.3
    Composable concurrent folds for Clojure. Can now specify the number of threads used.
    tesser.core/facetSourceDoc + Usages
    Your inputs are maps, and you want to apply a fold to each value
                  independently. Facet generalizes a fold over a single value to operate on
                  maps of keys to those values, returning a map of keys to the results of the
                  fold over all values for that key. Each key gets an independent instance of
                  the fold.
    
                  For instance, say you have inputs like
    
                      {:x 1, :y 2}
                      {}
                      {:y 3, :z 4}
    
                  Then the fold
    
                      (->> (facet)
                           (mean))
    
                  returns a map for each key's mean value:
    
                      {:x 1, :y 2, :z 4}

    clj-symphony 0.8.0
    A Clojure wrapper around the symphony-java-client library.
    clj-symphony.user/userobj->mapSourceDoc + Usages
    Converts a `org.symphonyoss.symphony.clients.model.SymUser` object into a map
      with these keys:
    
      | Key              | Description                            |
      |------------------|----------------------------------------|
      | `:user-id`       | The id of the user.                    |
      | `:username`      | The username of the user.              |
      | `:email-address` | The email address of the user.         |
      | `:title`         | The title of the user.                 |
      | `:first-name`    | The first name of the user.            |
      | `:last-name`     | The last name of the user.             |
      | `:display-name`  | The display name of the user.          |
      | `:company`       | The company of the user.               |
      | `:location`      | The location of the user.              |
      | `:avatars`       | A sequence of avatar maps (see below). |
    
      Avatar maps contain these keys:
    
      | Key     | Description                                                 |
      |---------|-------------------------------------------------------------|
      | `:size` | The 'size string' of the avatar (e.g. `small`, `original`). |
      | `:url`  | The URL of the new avatar image file.                       |
      

    midje 1.9.2-alpha3
    A TDD library for Clojure that supports top-down ('mockish') TDD, encourages readable
    midje.checking.checkables/minimal-failure-mapSourceDoc + Usages
    Failure maps are created by adding on to parser-created maps

    lein-tern 0.1.3
    Migrations as data
    tern.misc/deep-mergeSourceDoc + Usages
    Deep-merge maps. Limited to two maps at the moment.

    alida 0.1.3
    Crawling, scraping and indexing application.
    alida.crawl/directed-crawlSourceDoc + Usages
    Crawls a set of pages, given a crawl-tag and crawl-timestamp to
       distinguish the particular crawl job, sleep-for (delay between
       requests in milliseconds), a seed-uri string (e.g.
       http://www.vixu.com/) and a sequence of selectors to extract
       links to other pages that are to be crawled with. Runs in a
       separate thread, through a future.  Returns a sequence of clj-http
       request maps, with added keys for the uri (:uri), a crawl
       timestamp (:crawled-at) and the document :type (crawled-page).
    
       Each selector in the selectors sequence is a map with at least a
       :selector key mapped to an Enlive selector vector. The :filter key
       is optional and maps to a regular expression pattern that is
       matched against the links to filter them. The :path-filter key is
       similar to the :filter key, but is only matched against the path
       segment of the links. The :next key maps to the sequence of
       selectors that is used to extract links from pages matched by the
       current selector.
    
       The directed-crawl fn is a good match for a relatively small,
       targeted crawl against a single hostname. Call separately for
       different hostnames. This function isn't optimal for exploratory
       crawling or gathering large sets of pages (e.g. the whole of
       Wikipedia), because of the potentially huge results sequence
       that would generate.

    s3-deploy 0.1.3
    Push things to S3, but be lazy about it.
    confetti.s3-deploy/sync!SourceDoc + Usages
    Sync files described by `file-maps` to S3 `bucket-name`.
       The file-maps collection may be ordered in which case S3
       operations will be executed in the same order.
    
       `file-maps`need to have the following keys `:s3-key` & `:file`.
       Optionally a `:metadata` key can be supplied to add custom
       metadata to the uploaded S3 object.
    
       Changes to an objects metadata will only get updated if also
       the object itself changed, i.e. changes only to an objects
       metadata will not cause the remote object to get updated.
    
       Recognized options:
       - `report-fn` takes 1 argument describing an operation and
         will be called for each operation modifying the S3 bucket
       - `dry-run?` if truthy no side effects will be executed.
       - if `prune?` is a truthy value `sync!` will delete files
         from the S3 bucket that are not in `file-map`.

    validata 0.1.8
    Simple data validation for Clojure.
    validata.core/key-string?SourceDoc + Usages
    If key not nil, is the key a string?

    validata 0.1.8
    Simple data validation for Clojure.
    validata.core/key-keyword?SourceDoc + Usages
    If key not nil, is the key a keyword?

    bitcljoin 0.4.5
    BitCoin library for Clojure
    bitcoin.deterministic/derive-keySourceDoc + Usages
    Derive a key for the derived key

    pe-datomic-utils 0.0.18
    A Clojure library of helper functions when working with Datomic.
    pe-datomic-utils.core/change-log-sinceSourceDoc + Usages
    Returns a map with 2 keys: :updates and :deletions.  The value at each key is
      a vector of entities that have either been updated (add/update) or deleted as
      of since-inst.  Each vector contains a collection of entries as maps.
      filter-fn will be invoked for each candidate entity and will return a boolean
      indicating if it should be included in the final set. The parameters
      updated-entry-maker-fn and deleted-entry-maker-fn are used to construct the
      maps.  updated-entry-maker-fn will be used to contruct the maps to go into the
      :updates vector; deleted-entry-maker-fn will be used to construct the maps to
      go into the :deletions vector.  Each of these functions will receive the
      populated Datomic entity, and is to return a map.  Updates and deletions of
      entities containing reqd-attr will be included in the computation.

    useful 0.11.5
    A collection of generally-useful Clojure utility functions
    flatland.useful.utils/adjoinSourceDoc + Usages
    Merge two data structures by combining the contents. For maps, merge recursively by
      adjoining values with the same key. For collections, combine the right and left using
      into or conj. If the left value is a set and the right value is a map, the right value
      is assumed to be an existence map where the value determines whether the key is in the
      merged set. This makes sets unique from other collections because items can be deleted
      from them.

    useful 0.11.5
    A collection of generally-useful Clojure utility functions
    flatland.useful.utils/adjoin-onto~nil~AdjoinSourceDoc + Usages
    Merge two data structures by combining the contents. For maps, merge recursively by
      adjoining values with the same key. For collections, combine the right and left using
      into or conj. If the left value is a set and the right value is a map, the right value
      is assumed to be an existence map where the value determines whether the key is in the
      merged set. This makes sets unique from other collections because items can be deleted
      from them.

    useful 0.11.5
    A collection of generally-useful Clojure utility functions
    flatland.useful.utils/adjoin-onto~Object~AdjoinSourceDoc + Usages
    Merge two data structures by combining the contents. For maps, merge recursively by
      adjoining values with the same key. For collections, combine the right and left using
      into or conj. If the left value is a set and the right value is a map, the right value
      is assumed to be an existence map where the value determines whether the key is in the
      merged set. This makes sets unique from other collections because items can be deleted
      from them.

    useful 0.11.5
    A collection of generally-useful Clojure utility functions
    flatland.useful.utils/adjoin-onto~IPersistentCollection~AdjoinSourceDoc + Usages
    Merge two data structures by combining the contents. For maps, merge recursively by
      adjoining values with the same key. For collections, combine the right and left using
      into or conj. If the left value is a set and the right value is a map, the right value
      is assumed to be an existence map where the value determines whether the key is in the
      merged set. This makes sets unique from other collections because items can be deleted
      from them.

    useful 0.11.5
    A collection of generally-useful Clojure utility functions
    flatland.useful.utils/adjoin-onto~ISeq~AdjoinSourceDoc + Usages
    Merge two data structures by combining the contents. For maps, merge recursively by
      adjoining values with the same key. For collections, combine the right and left using
      into or conj. If the left value is a set and the right value is a map, the right value
      is assumed to be an existence map where the value determines whether the key is in the
      merged set. This makes sets unique from other collections because items can be deleted
      from them.

    useful 0.11.5
    A collection of generally-useful Clojure utility functions
    flatland.useful.utils/adjoin-onto~IPersistentSet~AdjoinSourceDoc + Usages
    Merge two data structures by combining the contents. For maps, merge recursively by
      adjoining values with the same key. For collections, combine the right and left using
      into or conj. If the left value is a set and the right value is a map, the right value
      is assumed to be an existence map where the value determines whether the key is in the
      merged set. This makes sets unique from other collections because items can be deleted
      from them.

    useful 0.11.5
    A collection of generally-useful Clojure utility functions
    flatland.useful.utils/adjoin-onto~IPersistentMap~AdjoinSourceDoc + Usages
    Merge two data structures by combining the contents. For maps, merge recursively by
      adjoining values with the same key. For collections, combine the right and left using
      into or conj. If the left value is a set and the right value is a map, the right value
      is assumed to be an existence map where the value determines whether the key is in the
      merged set. This makes sets unique from other collections because items can be deleted
      from them.

    useful 0.11.5
    A collection of generally-useful Clojure utility functions
    flatland.useful.utils/adjoin-ontoSourceDoc + Usages
    Merge two data structures by combining the contents. For maps, merge recursively by
      adjoining values with the same key. For collections, combine the right and left using
      into or conj. If the left value is a set and the right value is a map, the right value
      is assumed to be an existence map where the value determines whether the key is in the
      merged set. This makes sets unique from other collections because items can be deleted
      from them.

    plumbing 0.5.5
    Prismatic's Clojure utility belt.
    plumbing.core/for-mapSourceDoc + Usages
    Like 'for' for building maps. Same bindings except the body should have a
      key-expression and value-expression. If a key is repeated, the last
      value (according to "for" semantics) will be retained.
    
      (= (for-map [i (range 2) j (range 2)] [i j] (even? (+ i j)))
         {[0 0] true, [0 1] false, [1 0] false, [1 1] true})
    
      An optional symbol can be passed as a first argument, which will be
      bound to the transient map containing the entries produced so far.

    carmine 2.18.1
    Clojure Redis client & message queue
    taoensso.carmine/luaSourceDoc + Usages
    All singing, all dancing Lua script helper. Like `eval*` but allows script
      vars to be provided as {<var> <value> ...} maps:
    
      (lua "redis.call('set', _:my-key, _:my-arg)" {:my-key "foo} {:my-arg "bar"})
    
      Keys are separate from other args as an implementation detail for clustering
      purposes (keys need to all be on same shard).

    utilize 0.2.3
    Compilation of Clojure functions from around the community
    utilize.utils/adjoinSourceDoc + Usages
    Merge two data structures by combining the contents. For maps, merge recursively by
      adjoining values with the same key. For collections, combine the right and left using
      into or conj. If the left value is a set and the right value is a map, the right value
      is assumed to be an existence map where the value determines whether the key is in the
      merged set. This makes sets unique from other collections because items can be deleted
      from them.

    jvm.tools.analyzer 0.6.2
    An interface to Clojure's analyzer
    clojure.jvm.tools.analyzer/analyze-nsSourceDoc + Usages
    Takes a LineNumberingPushbackReader and a namespace symbol.
      Returns a vector of maps, with keys :op, :env. If expressions
      have children, will have :children entry.
    
      Options:
      - :reader  a pushback reader to use to read the namespace forms
      - :opt     a map of analyzer options
        - :children
          when true, include a :children key with all child expressions of each node
        - :java-obj
          when true, include a :java-obj key with the node's corresponding Java object
    
      eg. (analyze-ns 'my-ns :opt {:children true} :reader (pb-reader-for-ns 'my.ns))

    jvm.tools.analyzer 0.6.2
    An interface to Clojure's analyzer
    clojure.jvm.tools.analyzer/analyze-fileSourceDoc + Usages
    Takes a file path and optionally a pushback reader.
      Returns a vector of maps representing the ASTs of the forms
      in the target file.
    
      Options:
      - :reader  a pushback reader to use to read the namespace forms
      - :opt     a map of analyzer options
        - :children
          when true, include a :children key with all child expressions of each node
        - :java-obj
          when true, include a :java-obj key with the node's corresponding Java object
    
      eg. (analyze-file "my/ns.clj")

    hoplon-elem-lib 0.2.0
    Tiny element library for Hoplon.
    clojure.test.check.generators/mapSourceDoc + Usages
    Create a generator that generates maps, with keys chosen from
      `key-gen` and values chosen from `val-gen`.
    
      If the key generator cannot or is unlikely to produce enough distinct
      elements, this generator will fail in the same way as such-that.
    
      Available options:
    
        :num-elements  the fixed size of generated vectors
        :min-elements  the min size of generated vectors
        :max-elements  the max size of generated vectors
        :max-tries     the number of times the generator will be tried before
                       failing when it does not produce distinct elements
                       (default 10)

    cortex 0.9.22
    A neural network toolkit for Clojure.
    cortex.util/vectorizeSourceDoc + Usages
    Recursively turns a data structure into nested vectors. All sequence-like
      types except maps and strings are transformed into vectors, but the structure
      of the data is maintained. Transforms core.matrix vectors into normal Clojure
      vectors.
    
      (vectorize (list 1 2 {"key" #{3 4} (list) (new-vector 3 5)} [6 7]))
      => [1 2 {"key" [4 3], [] [5 5 5]} [6 7]]

    fulcro 2.5.9
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    fulcro.client.primitives/denormalize*SourceDoc + Usages
    Denormalize a data based on query. refs is a data structure which maps idents
       to their values. map-ident is a function taking a ident to another ident,
       used during tempid transition. idents-seen is the set of idents encountered,
       used to limit recursion. union-expr is the current union expression being
       evaluated. recurse-key is key representing the current recursive query being
       evaluted.

    pathom 2.0.4
    A Clojure library designed to provide a collection of helper functions to support
    com.wsscode.pathom.core/map-readerSourceDoc + Usages
    Map reader will try to find the ast key on the current entity and output it. When the value is a map and a
      sub query is present, it will apply the sub query on that value (recursively). When the value is a sequence,
      map-reader will do a join on each of the items (and apply sub queries if it's present and values are maps.
    
      Map-reader will defer the read when the key is not present at entity.

    ataraxy 0.4.0
    A data-driven Ring routing and destructuring library
    ataraxy.core/handlerSourceDoc + Usages
    Create a handler from a data structure of routes and a map of result keys to
      handler functions. If no handler matches, the :default handler is used. If no
      default handler is set, the ataraxy.handler/default function is used.
    
      Optionally, maps of middleware and coercer functions can also be supplied.
      Middleware is applied to any result with metadata matching the key in the
      middleware map. Coercers are applied to any symbol in the result that are
      tagged with the corresponding key in the coercers map.
    
      By default coercers for int and uuid are included.

    handy 1.7.1
    Common utilities to fill in the gaps
    org.timmc.handy/index-onSourceDoc + Usages
    From a table (coll of record maps) produce a map of index key values
    to projections on the other keys. r->k is a function of a record to some
    key value, e.g. #(get % 5) or (juxt :a :b) or just :c.
    
    Example: (index-on [{:a 0, :b 1, :c 2}, {:a 3, :b 4, :c 5}] :a [:b])
             => {0 {:b 1}, 3 {:b 4}}

    schpec 0.1.2
    A utility library for clojure.spec
    com.gfredericks.schpec/excl-keysSourceDoc + Usages
    Like [[s/keys]], but closed for extension.
    
      The generator for this spec will only generate maps with explicitly
      specified keys.
    
      The :check-keys? keyword argument (true by default) determines if
      the limitation on the keys is enforced. This is useful if you'd like
      to merge the key-specs later: [[s/merge]] assumes that the data
      satisfies the individual specs as well. You can limit the keys
      allowed in a key spec later using [[limit-keys]].

    protobuf 0.6.2
    Clojure-protobuf provides a clojure interface to Google's protocol buffers.
    protobuf.core/adjoin-onto~PersistentProtocolBufferMap~AdjoinSourceDoc + Usages
    Merge two data structures by combining the contents. For maps, merge recursively by
      adjoining values with the same key. For collections, combine the right and left using
      into or conj. If the left value is a set and the right value is a map, the right value
      is assumed to be an existence map where the value determines whether the key is in the
      merged set. This makes sets unique from other collections because items can be deleted
      from them.

    Return a leaven component to forward a core-async channel via sente events.
      The `:channel` key specifies a leaven component for the target
      channel.  The `sente` key specifies a sente component to which
      events are sent.  The `ex-handler` may be used to specify an
      exception handler for the core.async `go-loop` that implements the
      forwarding.
    
      Event values on the channel are maps with `:user-id` and `:event`
      keys for the server side (clojure) and `:event`, `:timeout-ms` and
      `:cb-fn` keys for the client (clojurescript).

    bakery-sente 0.3.1
    A leaven component for sente
    com.palletops.bakery.sente.core-async-bridge/bridgeSourceDoc + Usages
    Return a leaven component to forward a core-async channel via sente events.
      The `:channel` key specifies a leaven component for the target
      channel.  The `sente` key specifies a sente component to which
      events are sent.  The `ex-handler` may be used to specify an
      exception handler for the core.async `go-loop` that implements the
      forwarding.
    
      Event values on the channel are maps with `:user-id` and `:event`
      keys for the server side (clojure) and `:event`, `:timeout-ms` and
      `:cb-fn` keys for the client (clojurescript).

    clj-service-locator 0.3.0
    Clojure Service Locator library.
    clj-service-locator.core/all-missing-functionsSourceDoc + Usages
    Returns all service namespaces as maps with servy keys as keys and list of missing function names.
       If a service key has no missing functions (meaning the namespace has complete coverage of
       the service functions), then the service key is not part of the result.
       If the result is nil, then no registered service keys are missing any functions and there is
       complete coverage of all registered service keys.

    lemonade 0.3.0
    High level language for graphical and UI programming. No markup.
    clojure.test.check.generators/mapSourceDoc + Usages
    Create a generator that generates maps, with keys chosen from
      `key-gen` and values chosen from `val-gen`.
    
      If the key generator cannot or is unlikely to produce enough distinct
      elements, this generator will fail in the same way as such-that.
    
      Available options:
    
        :num-elements  the fixed size of generated vectors
        :min-elements  the min size of generated vectors
        :max-elements  the max size of generated vectors
        :max-tries     the number of times the generator will be tried before
                       failing when it does not produce distinct elements
                       (default 10)

    lemonade 0.3.0
    High level language for graphical and UI programming. No markup.
    clojure.test.check.generators/mapSourceDoc + Usages
    Create a generator that generates maps, with keys chosen from
      `key-gen` and values chosen from `val-gen`.
    
      If the key generator cannot or is unlikely to produce enough distinct
      elements, this generator will fail in the same way as such-that.
    
      Available options:
    
        :num-elements  the fixed size of generated vectors
        :min-elements  the min size of generated vectors
        :max-elements  the max size of generated vectors
        :max-tries     the number of times the generator will be tried before
                       failing when it does not produce distinct elements
                       (default 10)

    clodash 0.43.0
    FIXME: write description
    clodash.map/for-mapSourceDoc + Usages
    Like 'for' for building maps. Same bindings except the body should have a
      key-expression and value-expression. If a key is repeated, the last
      value (according to "for" semantics) will be retained.
      (= (for-map [i (range 2) j (range 2)] [i j] (even? (+ i j)))
         {[0 0] true, [0 1] false, [1 0] false, [1 1] true})
      An optional symbol can be passed as a first argument, which will be
      bound to the transient map containing the entries produced so far.

    nlp 0.3.0
    Code examples using Stanford CoreNLP
    damionjunk.nlp.stanford/pos-ner-mapsSourceDoc + Usages
    Return a sequence of pos-ner-maps, one for each sentence in `text`.
                 Each sentiment map contains a ':tokens` key, and a `:text` key.
    
                 `tokens` is a sequence of tokens with POS and NER markup from each
                          bit of `text`. A token looks like:
    
                          {:pos "NNP", :ner "ORGANIZATION", :token "Google"}
    
                 `text` is plain text. If it is a paragraph of sentences, they are
                        split by the Stanford parser.

    Denormalize a data based on query. refs is a data structure which maps idents
       to their values. map-ident is a function taking a ident to another ident,
       used during tempid transition. idents-seen is the set of idents encountered,
       used to limit recursion. union-expr is the current union expression being
       evaluated. recurse-key is key representing the current recursive query being
       evaluted.

    Denormalize a data based on query. refs is a data structure which maps idents
       to their values. map-ident is a function taking a ident to another ident,
       used during tempid transition. idents-seen is the set of idents encountered,
       used to limit recursion. union-expr is the current union expression being
       evaluated. recurse-key is key representing the current recursive query being
       evaluted.

    ona-viewer 1.1.30
    Ona viewer that connects to the Ona API.
    ona.client.components.rich-select/rich-select (cljs)SourceDoc + Usages
    Return an Om component that renders a widget with <select> element behaviour
       but allowing for arbitrary internal markup.
       The `options` property is a vector of maps each containing any number of
       key/value pairs, but at minimum, having the following form
       {:label <label> :value <value>}. It could, for example, have an :avatar-url
       key that the option-component determines how to deal with.

    ona-viewer 1.1.30
    Ona viewer that connects to the Ona API.
    ona.client.components.rich-select/rich-select (cljs)SourceDoc + Usages
    Return an Om component that renders a widget with <select> element behaviour
       but allowing for arbitrary internal markup.
       The `options` property is a vector of maps each containing any number of
       key/value pairs, but at minimum, having the following form
       {:label <label> :value <value>}. It could, for example, have an :avatar-url
       key that the option-component determines how to deal with.

    locksmith 0.1.0
    Change all your keys between idiomatic clojure and GraphQL
    locksmith.core/for-mapSourceDoc + Usages
    Like 'for' for building maps. Same bindings except the body should have a
      key-expression and value-expression. If a key is repeated, the last
      value (according to "for" semantics) will be retained.
      (= (for-map [i (range 2) j (range 2)] [i j] (even? (+ i j)))
         {[0 0] true, [0 1] false, [1 0] false, [1 1] true})
      An optional symbol can be passed as a first argument, which will be
      bound to the transient map containing the entries produced so far.

    cellophane 0.3.5
    Server-side rendering for Om Next components
    cellophane.next/denormalize*SourceDoc + Usages
    Denormalize a data based on query. refs is a data structure which maps idents
       to their values. map-ident is a function taking a ident to another ident,
       used during tempid transition. idents-seen is the set of idents encountered,
       used to limit recursion. union-expr is the current union expression being
       evaluated. recurse-key is key representing the current recursive query being
       evaluted.

    babbage 0.1.0
    Intelligent accumulation of statistics over a seq
    babbage.util/layersSourceDoc + Usages
    Given a DAG consisting of seq of nodes (represented as maps with a
       label under the :provides key and outgoing edges under
       the :requires key), return a seq of seqs of nodes s.t. the first
       element contains the nodes with no incoming edges, the second
       contains the nodes with incoming edges from the first, etc.
    
       Throws exceptions if a node :requires a nonexistent node or in the
       case of circular dependencies.

    unclogged 0.9.1
    Clojure syslog abstraction
    unclogged.core/->syslog!SourceDoc + Usages
    Consumes elems on source and sends them to syslog as specified by
      the connection map & defaults.
    
      Values in message maps override values in the defaults; values in
      the defaults override unclogged's default-defaults. This prevents
      NullPointerExceptions when you forget to provide a facility or
      severity, for example.
    
      Returns a map containing the syslog client object under the :syslog
      key. This is only provided for inspection; mutating that object is
      not guaranteed to have desired effects. It also contains the input
      stream under the :stream key.

    muicljs 0.1.01
    Mui cljs test
    om.next/denormalize*SourceDoc + Usages
    Denormalize a data based on query. refs is a data structure which maps idents
       to their values. map-ident is a function taking a ident to another ident,
       used during tempid transition. idents-seen is the set of idents encountered,
       used to limit recursion. union-expr is the current union expression being
       evaluated. recurse-key is key representing the current recursive query being
       evaluted.

    clarifai-clj 1.0.0
    Clojure wrapper for Clarifai API.
    clarifai-clj.core/conceptsSourceDoc + Usages
    Get Predict API model's concepts (and their certainty) for image.
    
       Returns seq of 'concept maps', where a concept map is:
        {:name <concept's name (str)>
         :value <concept's certainty (double)>}
    
       api-key (str): your Clarifai API Key
       model (keyword): model to use e.g. :general vs. :apparel
       image-url (str): URL where image is hosted

    gadjett 0.5.2
    Inspector tools for clojure[script]
    clojure.test.check.generators/mapSourceDoc + Usages
    Create a generator that generates maps, with keys chosen from
      `key-gen` and values chosen from `val-gen`.
    
      If the key generator cannot or is unlikely to produce enough distinct
      elements, this generator will fail in the same way as such-that.
    
      Available options:
    
        :num-elements  the fixed size of generated vectors
        :min-elements  the min size of generated vectors
        :max-elements  the max size of generated vectors
        :max-tries     the number of times the generator will be tried before
                       failing when it does not produce distinct elements
                       (default 10)

    gadjett 0.5.2
    Inspector tools for clojure[script]
    clojure.test.check.generators/mapSourceDoc + Usages
    Create a generator that generates maps, with keys chosen from
      `key-gen` and values chosen from `val-gen`.
    
      If the key generator cannot or is unlikely to produce enough distinct
      elements, this generator will fail in the same way as such-that.
    
      Available options:
    
        :num-elements  the fixed size of generated vectors
        :min-elements  the min size of generated vectors
        :max-elements  the max size of generated vectors
        :max-tries     the number of times the generator will be tried before
                       failing when it does not produce distinct elements
                       (default 10)

    pallet-test-env 0.1.8
    Test environment for pallet tests
    pallet.test-env/test-envSourceDoc + Usages
    Declare a test environment for clojure.test tests.
      node-spec-metas is a map keyed on provider keyword, with values
      of sequences of node-spec-meta maps.
      options is a map of options for multi-test/test-ns, with an extra
      :project-map key, which can be passed a leiningen configuration map
      (e.g. as stored by configleaf), where :pallet/test-env key
      specifies :service and :selectors keys.

    inspectable 0.2.2
    Tools for clojure.spec
    clojure.test.check.generators/mapSourceDoc + Usages
    Create a generator that generates maps, with keys chosen from
      `key-gen` and values chosen from `val-gen`.
    
      If the key generator cannot or is unlikely to produce enough distinct
      elements, this generator will fail in the same way as such-that.
    
      Available options:
    
        :num-elements  the fixed size of generated vectors
        :min-elements  the min size of generated vectors
        :max-elements  the max size of generated vectors
        :max-tries     the number of times the generator will be tried before
                       failing when it does not produce distinct elements
                       (default 10)

    arbol 0.2.1
    Arbol is a mixed data type tree transformer using simple selectors available in
    arbol.internal/traverseSourceDoc + Usages
    Recursively traverses structure, in place consumes stack.
       Vectors and sequentials preserve order.
       Maps lose any key order which shouldn't be depended on anyway.
       Each level first adds path information, and then applies test.
       If the selector is an empty vector, it matches root object and returns.
       The overloaded form should probably not be available as a public method.
       Note no predicates are allowed for the key/val itself in a map traversal.
       When the process arrives at the value, the predicates are tested - core types.

    arbol 0.2.1
    Arbol is a mixed data type tree transformer using simple selectors available in
    arbol.internal/traverse (cljs)SourceDoc + Usages
    Recursively traverses structure, in place consumes stack.
       Vectors and sequentials preserve order.
       Maps lose any key order which shouldn't be depended on anyway.
       Each level first adds path information, and then applies test.
       If the selector is an empty vector, it matches root object and returns.
       The overloaded form should probably not be available as a public method.
       Note no predicates are allowed for the key/val itself in a map traversal.
       When the process arrives at the value, the predicates are tested - core types.

    clj-ioc 0.2.0
    Clojure Inversion-of-Control (IOC) library.
    clj-ioc.core/all-missing-functionsSourceDoc + Usages
    Returns all IOC namespaces as maps with IOC keys as keys and list of missing function names.
       If an IOC key has no missing functions (meaning the namespace has complete coverage of
       the IOC functions), then the IOC key is not part of the result.
       If the result is nil, then no registered IOC keys are missing any functions and there is
       complete coverage of all registered IOC keys.

    clash 1.4.1
    A clojure library that applies customizable structures to text files and quick
    clash.tools/mv-freqsSourceDoc + Usages
    Map value frequencies, is a replacement for (collect-value-frequencies) that supports multiple key-path,
      key-sets per data schema. This supports finding value frequencies for multiple schema keys at different nest levels.
    
      'kpsets' A vector of maps that detail schema paths and sets or a custom fx
      'kp' A specific schema path
      'ks' The schema keys for the 'kp' above
      'kvfx' A function for retrieving collection data from nested structures, or other, this is painful right now (see below)
    
      typical usage:
      (mv-freqs data :kpsets [{:kp [:cost] :ks [:amount :tax]} {:kvfx #(some-fn)}])
    
      Nested array of maps (ugly):
      (mv-freqs data :kpsets [{:kvfx #(mv-freqs (:key %) :kpsets [{:ks [:subkey]}])}])
      

    seesaw 1.5.0
    A Swing wrapper/DSL for Clojure. You want seesaw.core, FYI. See http://seesaw-clj.org
    seesaw.table/table-modelSourceDoc + Usages
    Creates a TableModel from column and row data. Takes two options:
    
        :columns - a list of keys, or maps. If a key, then (name key) is used as the 
                   column name. If a map, it can be in the form 
                   {:key key :text text :class class} where key is use to index the 
                   row data, text (optional) is used as the column name, and 
                   class (optional) specifies the object class of the column data
                   returned by getColumnClass. The order establishes the order of the
                   columns in the table.
    
        :rows - a sequence of maps or vectors, possibly mixed. If a map, must contain
                row data indexed by keys in :columns. Any additional keys will
                be remembered and retrievable with (value-at). If a vector, data
                is indexed by position in the vector.
    
      Example:
    
        (table-model :columns [:name
                               {:key :age :text "Age" :class java.lang.Integer}]
                     :rows [ ["Jim" 65]
                             {:age 75 :name "Doris"}])
    
        This creates a two column table model with columns "name" and "Age"
        and two rows.
    
      See:
        (seesaw.core/table)
        http://download.oracle.com/javase/6/docs/api/javax/swing/table/TableModel.html
      

    utilize 0.2.3
    Compilation of Clojure functions from around the community
    utilize.map/merge-inSourceDoc + Usages
    Merge multiple nested maps.

    core.typed.rt 0.5.2
    An optional type system for Clojure — zero-dependency artifact for annotations only.
    clojure.core.typed/HMapSourceDoc + Usages
    HMap is a type for heterogeneous maps.

    ring-http-response 0.9.0
    Handling HTTP Statuses with Clojure(Script)
    ring.util.http-status/statusSourceDoc + Usages
    Maps status to name and description

    ring-http-response 0.9.0
    Handling HTTP Statuses with Clojure(Script)
    ring.util.http-status/status (cljs)SourceDoc + Usages
    Maps status to name and description

    lcmap-config 0.5.0
    LCMAP Configuration Library
    lcmap.config.helpers/ConfigSourceDoc + Usages
    A schema for config maps

    Converts keys in maps to keywords

    Converts keys in maps to keywords

    clj-campfire 2.2.0
    thin wrapper for Campfire's API
    clj-campfire.utils/keyword-keys~Object~KeywordKeysSourceDoc + Usages
    Converts keys in maps to keywords

    clj-campfire 2.2.0
    thin wrapper for Campfire's API
    clj-campfire.utils/keyword-keys~nil~KeywordKeysSourceDoc + Usages
    Converts keys in maps to keywords

    clj-campfire 2.2.0
    thin wrapper for Campfire's API
    clj-campfire.utils/keyword-keysSourceDoc + Usages
    Converts keys in maps to keywords

    sparkling 2.1.3
    A Clojure Library for Apache Spark
    sparkling.format/rdd-of-maps->data-frameSourceDoc + Usages
    Convert an RDD of Maps to a DataFrame

    district-cljs-utils 1.0.3
    Set of functions helpful for working with Clojurescript
    district.cljs-utils/merge-in (cljs)SourceDoc + Usages
    Merge multiple nested maps.

    full.core 1.0.5
    FullContact's core Clojure(Script) library - logging, configuration and sugar.
    full.core.sugar/deep-mergeSourceDoc + Usages
    Deep merge two maps

    systems-toolbox 0.6.36
    Toolbox for building Systems in Clojure
    matthiasn.systems-toolbox.switchboard.init/cmp-maps-setSourceDoc + Usages
    Returns a set with component maps.

    district-server-config 1.0.1
    district0x server component for loading configuration
    district.server.config/merge-in (cljs)SourceDoc + Usages
    Merge multiple nested maps.

    zprint 0.4.9
    Pretty print zippers and s-expressions
    zprint.config/diff-mapSourceDoc + Usages
    Diff two maps.

    lacinia 0.28.0-rc-1
    A GraphQL server implementation in Clojure
    com.walmartlabs.lacinia.parser/element->mapSourceDoc + Usages
    Maps a parsed element to a map.

    discovery-api-runtime 0.1.2
    A runtime dependency for APIs generated by discovery-api
    com.palletops.discovery.runtime/key-coercerSourceDoc + Usages
    Coerce the keys in maps.

    merge maps at leave level.

    locos 0.1.3
    Logic based Configuration Functions
    palletops.locos/deep-mergeSourceDoc + Usages
    Recursively merge maps.

    If maps, merge, otherwise replace

    farmhand 0.9.1
    Simple and powerful background jobs
    farmhand.utils/map-seqSourceDoc + Usages
    Like seq, but for maps.

    aesahaettr 0.1.2
    Sharding, partitioning, and consistent hashing. May release spectres.
    æsahættr/consistent-longSourceDoc + Usages
    Maps a long to an integer bucket.

    aesahaettr 0.1.2
    Sharding, partitioning, and consistent hashing. May release spectres.
    æsahættr/consistent-hashcodeSourceDoc + Usages
    Maps a hashcode to an integer bucket.

    frinj 0.2.5
    Practical unit-of-measure calculator DSL for Clojure
    frinj.ops/map-fj-operatorsSourceDoc + Usages
    Maps (fj) operators to tokens

    frinj 0.2.5
    Practical unit-of-measure calculator DSL for Clojure
    frinj.ops/map-fj-operators (cljs)SourceDoc + Usages
    Maps (fj) operators to tokens

    varspotting 0.0.2
    Spotting Clojure Vars for fun and profit!
    varspotting.core/mapsSourceDoc + Usages
    Spotter for Vars holding maps.

    solrclj 0.1.2
    A clojure library for using Apache Solr.
    solrclj/addSourceDoc + Usages
    Adds maps as documents to the SolrServer.

    Maps n to m

    Recursively merge maps.

    metabase 0.1.0
    Metabase Community Edition
    metabase.util/sequence-of-maps?SourceDoc + Usages
    Is COLL a sequence of maps?

    clodash 0.43.0
    FIXME: write description
    clodash.map/rmergeSourceDoc + Usages
    Recursive merge of the provided maps.

    wile 0.0.0-3
    A few simple wrapper functions for datomic.
    wile.core/lmapSourceDoc + Usages
    Maps the result of a ListenableFuture.

    clarity 0.5.6
    Clojure GUI library, based on Swing.
    clarity.table/rows-as-mapSourceDoc + Usages
    Seq of maps of rows.

    dropbox-repl 0.1.1
    Dropbox Clojure REPL
    dropbox-repl.core/merge*SourceDoc + Usages
    Deep-merge a list of maps.

    cantata 0.1.17
    SQL and database abstraction
    cantata.core/with-query-maps*SourceDoc + Usages
    Helper function for with-query-maps

    kits 1.38.5
    Staples SparX core libraries.
    kits.map/rmergeSourceDoc + Usages
    Recursive merge of the provided maps.

    kits 1.38.5
    Staples SparX core libraries.
    kits.foundation/rmergeSourceDoc + Usages
    Recursive merge of the provided maps.

    utilza 0.1.98
    ken's random utilities
    utilza.misc/groupifySourceDoc + Usages
    Takes k and coll of maps ms. 
       Groups the maps by k into a map of maps, and dissocs k from the maps.

    miscellany 0.0.4
    A motley assortment of Clojure bits and pieces
    miscellany.collections/deep-mergeSourceDoc + Usages
    Deep-merge nested maps.

    taika 0.1.4
    A wrapper around the Firebase REST API
    taika.core/recursive-mergeSourceDoc + Usages
    Recursively merge hash maps.

    s3-deploy 0.1.3
    Push things to S3, but be lazy about it.
    confetti.s3-deploy/FileMapSourceDoc + Usages
    Schema for file-maps

    normal 0.1.0
    Normalize nested data according to a relationship schema
    normal.core/deep-mergeSourceDoc + Usages
    Recursively merge the given maps.

    lein-pallet-crate 0.1.3
    A lein plugin for managing pallet crates
    lein-pallet-crate.plugin/deep-mergeSourceDoc + Usages
    Recursively merge maps.

    lein-test-env 0.1.8
    Leiningen plugin to provide profiles for test-env
    lein-test-env.plugin/deep-mergeSourceDoc + Usages
    Recursively merge maps.

    Recursively maps for [[emap-kv]].

    Recursively maps for [[emap]].

    nodisassemble 0.1.3
    FIXME: write description
    no.disassemble.r/constant-modifiersSourceDoc + Usages
    Maps keywords to IModifierConstants

    yle-clj-common 3.2.0
    Code to support the way that Yle (Clojure) APIs are implemented.
    yle-clj-common.properties/parse-env-or-propertiesSourceDoc + Usages
    Get a value from environment variables or if not found fallback to given properties map.
    
      The properties map needs to be flat and cannot have nested maps.
      The given key must be a kebab-cased keyword.
      Keywords can contain periods. Periods are transformed to dashes for environment lookup.
      Environment variable names are transformed to kebab case before lookup.
    
      Examples:
      `(parse-env-or-properties :port properties)`
      This finds an environment variable named `PORT` or a property with the key `:port`.
    
      `(parse-env-or-properties :db.admin-host properties)`
      This finds an environment variable named `DB_ADMIN_HOST` or property with the key `:db.admin-host`.

    suchwow 6.0.2
    Such functions! Such doc strings! Much utility!
    such.relational/index-selectSourceDoc + Usages
    Produce a map by looking a key up in an index.
    
      See [the wiki](https://github.com/marick/suchwow/wiki/such.relational) for examples.
    
      `key` is a unique or compound key that's been indexed with [[one-to-one-index-on]]
      or [[one-to-many-index-on]]. The `options` may be given as N keys and values
      following `key` (Smalltalk style) or as a single map. They are:
    
          :using <index>
            (required) The index to use.
          :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.
    
      The return value depends on the index. If it is `one-to-one`, a map is returned.
      If it is `one-to-many`, a vector of maps is returned.
      

    ezglib 0.1.7
    Make WebGL games in ClojureScript.
    ezglib.core/state (cljs)SourceDoc + Usages
    Makes a game state with specified handlers. Options:
    
      :update (optional) - a function called once a frame while this game state is active.
    
      :render (optional) - a function called after :update and default rendering for custom drawing.
    
      :handlers (optional) - a map of event-types to handler functions. When
      the event is trigger and the given event-type is pushed to the event-queue, all
      handlers in the game state are called.
    
      :world (optional) - a world created via ezglib.core/world that encapsulates
      entities, systems, and components.
    
      :key-press, :key-release, :key-down (optional) - maps of keys as keywords to handlers.
      For example, to log to console when the space bar is pressed, one would add
      the option :key-press {:space (fn [key-event] (.log js/console "Space Pressed!"))}

    parkour 0.6.4-alpha1
    Hadoop MapReduce in idiomatic Clojure.
    parkour.mapreduce.sink/emit-keySourceDoc + Usages
    Emit `key` to `sink` as the key of a key-only tuple.

    carica 1.2.2
    A flexible configuration library
    carica.core/get-configsSourceDoc + Usages
    Takes a data structure of config resources (URLs) in priority order and
      merges them together.  The resources can be a simple list where first-in wins.
      Additionally the structure may contain maps where the key becomes the
      effective namespace of the resources in the value.
    
      Each node is handled by type:
      - resources (URL): load the config
      - collections (except for maps): merge the members
      - all others, return as is
    
      E.g., the following:
      [#<URL file:/some/path1>
       {:ns1 [#<URL file:/some/path2> #<URL file:/some/path3>]}]
    
      would become:
      {<keys and values from /some/path>
       :ns1 {<the merged keys and value from path2 and path3>}}

    functional-vaadin 0.2.2
    A functional interface to Vaadin
    functional-vaadin.data-binding/add-hierarchySourceDoc + Usages
    Add data to a Container$Hierarchical. The data are (recursively) a Sequence of Maps, each Map defining a parent (the key)
      and the children (the value, another Sequence of Maps).
    
      add-as determines how items are added. :gen-id causes item ids to be generated, based on add index, :as-id uses the parent itself
      as the id. The former is generally used when adding to a container with item properties (such as a TreeTable), the later when the
      container only consideres the item ids themselves (as in a Tree). In the :gen-id case, keys and values are assumed to be Collections,
      and are mapped by index to the Container properties.

    alida 0.1.3
    Crawling, scraping and indexing application.
    alida.crawl/get-crawlable-links-for-documentSourceDoc + Usages
    Expects a base-uri (the currently crawled page; to determine prefix
       in the absolute uri), an request map containing a :body keyword
       mapping to a string with the HTML for the page, and a sequence of
       selector maps. Each selector map needs to have a :selector key with
       an Enlive selector for the desired links. Optional keys
       are :filter (with a regular expression pattern to filter uri
       strings) and :next (a sequence of selectors to run on pages matched
       by this selector).
    
       Returns a sequence of maps with :uri containing an absolute uri for
       a link and :selectors containing the selectors to gather links with
       on the subsequent page the :uri links to.

    clj.where 0.1.0
    A library to query maps in sequence.
    clj.where/whereSourceDoc + Usages
    where for arrays of maps.
       For example, you have a vector of key-value maps,such as:
    
        (def cats
           [
             {
              :name  "Bubbles"
              :favoriteFood "mice"
              :age 1
             },
             {
              :name "Sparkle"
              :favoriteFood "tuna"
             },
             {
              :name "flyingCat"
              :favoriteFood "mice"
              :age 1
             }
          ])
    
    You want to filter with some properties,like:
    
        user=> (where cats {:age 1})
        ({:age 1, :name "Bubbles", :favoriteFood "mice"} {:age 1, :name "flyingCat", :favoriteFood "mice"})
    
        user=> (where cats {:age 1 :name "Bubbles"})
         ({:age 1, :name "Bubbles", :favoriteFood "mice"})
    
        user=> (where cats {:age 1, :favoriteFood "tuna"})
        ()
      

    pod 2.7.2
    Boot pod module–this is included with all pods.
    boot.from.io.aviso.exception/parse-exceptionSourceDoc + Usages
    Given a chunk of text for an exception report (as with `.printStackTrace`), attempts to
      piece together the same information provided by [[analyze-exception]].  The result
      is ready to pass to [[write-exception*]].
    
      This code does not attempt to recreate properties associated with the exceptions; in most
      exception's cases, this is not necessarily written to the output. For clojure.lang.ExceptionInfo,
      it is hard to distinguish the message text from the printed exception map.
    
      The options are used when processing the stack trace and may include the :filter and :frame-limit keys.
    
      Returns a sequence of exception maps; the final map will include the :stack-trace key (a vector
      of stack trace element maps).  The exception maps are ordered outermost to innermost (that final map
      is the root exception).
    
      This should be considered experimental code; there are many cases where it may not work properly.
    
      It will work quite poorly with exceptions whose message incorporates a nested exception's
      .printStackTrace output. This happens too often with JDBC exceptions, for example.

    Given a chunk of text for an exception report (as with `.printStackTrace`), attempts to
      piece together the same information provided by [[analyze-exception]].  The result
      is ready to pass to [[write-exception*]].
    
      This code does not attempt to recreate properties associated with the exceptions; in most
      exception's cases, this is not necessarily written to the output. For clojure.lang.ExceptionInfo,
      it is hard to distinguish the message text from the printed exception map.
    
      The options are used when processing the stack trace and may include the :filter and :frame-limit keys.
    
      Returns a sequence of exception maps; the final map will include the :stack-trace key (a vector
      of stack trace element maps).  The exception maps are ordered outermost to innermost (that final map
      is the root exception).
    
      This should be considered experimental code; there are many cases where it may not work properly.
    
      It will work quite poorly with exceptions whose message incorporates a nested exception's
      .printStackTrace output. This happens too often with JDBC exceptions, for example.

    crud 0.2.0
    Create, Read, Update, Delete. Done!
    crud.entity/defentitySourceDoc + Usages
    Defines an entity
    
    `:schema` should be a map (possibly nested) that represents any schematic constraints required by this entity. It
      is currently assumed that the schema will be a Prismatic schema but in the future, I'd like to add support for
      other schema specification syntaxes (e.g. herbert) (PATCHES welcome :-))
    
    `:links` should be a sequence of maps that represent the relationships in which this entity is involved. Each link
      must conform to the `Link` schema. When `find-by` returns a value, it will have keys for each Link. The `link`
      function provides syntax sugar for constructing Links.
    
    `:storable` should be a sequence of maps that representing the storable part of the entity. Transformations may be
      represented using storage agents which are just maps with :name and :callable keys
    
    `:uniqueness` if specified should be a map where each key represents a unique attribute. As long as it's 'truthy'
      CrudDB implementations are free to further refine the definition of uniqueness in an implementation specific way
    

    Given a database connection, a table name, a map of column name/value
      pairs, and an optional options map, return any matching rows.
    
      An :order-by option may be supplied to sort the rows, e.g.,
    
          {:order-by [{:name :asc} {:age :desc} {:income :asc}]}
          ;; equivalent to:
          {:order-by [:name {:age :desc} :income]}
    
      The :order-by value is a sequence of column names (to sort in ascending
      order) and/or maps from column names to directions (:asc or :desc). The
      directions may be strings or keywords and are not case-sensitive. They
      are mapped to ASC or DESC in the generated SQL.
    
      Note: if a ordering map has more than one key, the order of the columns
      in the generated SQL ORDER BY clause is unspecified (so such maps should
      only contain one key/value pair).

    Takes a context which is a Lisp form and returns a transformed context.
    
      The result is a list of maps, each map represents a level of the
      context from inside to outside. Map has `:idx` and `:form` values,
      and `:map-role` if the level is a map. `:idx` defines the position
      of prefix (or the form containing prefix) on the current
      level (number for lists and vectors, key or value for maps).
    
      Example: `(dotimes [i 10] ({:foo {:baz __prefix__}, :bar 42} :quux))`
    
      Transformed it looks like:
    
      `({:idx :baz, :map-role :value, :form {:baz __prefix__}}
        {:idx :foo, :map-role :key, :form {:foo {:baz __prefix__}, :bar 42}}
        {:idx 0, :form ({:foo {:baz __prefix__}, :bar 42} :quux)}
        {:idx 2, :form (dotimes [i 10] ({:foo {:baz __prefix__}, :bar 42} :quux))})`.

    compliment 0.3.6
    The Clojure completion library you deserve
    compliment.context/parse-contextSourceDoc + Usages
    Takes a context which is a Lisp form and returns a transformed context.
    
      The result is a list of maps, each map represents a level of the
      context from inside to outside. Map has `:idx` and `:form` values,
      and `:map-role` if the level is a map. `:idx` defines the position
      of prefix (or the form containing prefix) on the current
      level (number for lists and vectors, key or value for maps).
    
      Example: `(dotimes [i 10] ({:foo {:baz __prefix__}, :bar 42} :quux))`
    
      Transformed it looks like:
    
      `({:idx :baz, :map-role :value, :form {:baz __prefix__}}
        {:idx :foo, :map-role :key, :form {:foo {:baz __prefix__}, :bar 42}}
        {:idx 0, :form ({:foo {:baz __prefix__}, :bar 42} :quux)}
        {:idx 2, :form (dotimes [i 10] ({:foo {:baz __prefix__}, :bar 42} :quux))})`.

    clj-symphony 0.8.0
    A Clojure wrapper around the symphony-java-client library.
    clj-symphony.user/update-user!SourceDoc + Usages
    Updates the details of an existing user, returning it as a map (see
      [[userobj->map]] for details). The new user details are provided as a map with
      these keys:
    
      | Key              | Description                                                      |
      |------------------|------------------------------------------------------------------|
      | `:user-id`       | The id of the user to update.                                    |
      | `:username`      | The new username of the user.  *#### This might be create-only?* |
      | `:email-address` | The new email address of the user.                               |
      | `:title`         | The new title of the user.                                       |
      | `:first-name`    | The new first name of the user.                                  |
      | `:last-name`     | The new last name of the user.                                   |
      | `:display-name`  | The new display name of the user.                                |
      | `:company`       | The new company of the user.  *#### This might be read-only?*    |
      | `:location`      | The new location of the user.                                    |
      | `:avatars`       | A sequence of avatar maps (see below).                           |
    
      `:user-id` is mandatory (it must be present and cannot be `nil`).
    
      Avatar maps contain these keys:
    
      | Key     | Description                                                 |
      |---------|-------------------------------------------------------------|
      | `:size` | The 'size string' of the avatar (e.g. `small`, `original`). |
      | `:url`  | The URL of the new avatar image file.                       |
    
    
      Note: calling this fn requires that the service account have the 'user
      administration' entitlement.

    data.json 0.2.6
    Generating/parsing JSON from/to Clojure data structures
    clojure.data.json/writeSourceDoc + Usages
    Write JSON-formatted output to a java.io.Writer. Options are
       key-value pairs, valid options are:
    
        :escape-unicode boolean
    
           If true (default) non-ASCII characters are escaped as \uXXXX
    
        :escape-js-separators boolean
    
           If true (default) the Unicode characters U+2028 and U+2029 will
           be escaped as \u2028 and \u2029 even if :escape-unicode is
           false. (These two characters are valid in pure JSON but are not
           valid in JavaScript strings.)
    
        :escape-slash boolean
    
           If true (default) the slash / is escaped as \/
    
        :key-fn function
    
            Single-argument function called on map keys; return value will
            replace the property names in the output. Must return a
            string. Default calls clojure.core/name on symbols and
            keywords and clojure.core/str on everything else.
    
        :value-fn function
    
            Function to transform values in maps before writing. For each
            key-value pair in an input map, called with two arguments: the
            key (BEFORE transformation by key-fn) and the value. The
            return value of value-fn will replace the value in the output.
            If the return value is a number, boolean, string, or nil it
            will be included literally in the output. If the return value
            is a non-map collection, it will be processed recursively. If
            the return value is a map, it will be processed recursively,
            calling value-fn again on its key-value pairs. If value-fn
            returns itself, the key-value pair will be omitted from the
            output. This option does not apply to non-map collections.

    receipt 1.0.1
    FIXME: write description
    clojure.data.json/writeSourceDoc + Usages
    Write JSON-formatted output to a java.io.Writer. Options are
       key-value pairs, valid options are:
    
        :escape-unicode boolean
    
           If true (default) non-ASCII characters are escaped as \uXXXX
    
        :escape-js-separators boolean
    
           If true (default) the Unicode characters U+2028 and U+2029 will
           be escaped as \u2028 and \u2029 even if :escape-unicode is
           false. (These two characters are valid in pure JSON but are not
           valid in JavaScript strings.)
    
        :escape-slash boolean
    
           If true (default) the slash / is escaped as \/
    
        :key-fn function
    
            Single-argument function called on map keys; return value will
            replace the property names in the output. Must return a
            string. Default calls clojure.core/name on symbols and
            keywords and clojure.core/str on everything else.
    
        :value-fn function
    
            Function to transform values in maps before writing. For each
            key-value pair in an input map, called with two arguments: the
            key (BEFORE transformation by key-fn) and the value. The
            return value of value-fn will replace the value in the output.
            If the return value is a number, boolean, string, or nil it
            will be included literally in the output. If the return value
            is a non-map collection, it will be processed recursively. If
            the return value is a map, it will be processed recursively,
            calling value-fn again on its key-value pairs. If value-fn
            returns itself, the key-value pair will be omitted from the
            output. This option does not apply to non-map collections.

    torus-pong 0.1.0
    A multiplayer take on the classic Game of Pong. Entry for Clojure Cup 2013.
    clojure.data.json/writeSourceDoc + Usages
    Write JSON-formatted output to a java.io.Writer. Options are
       key-value pairs, valid options are:
    
        :escape-unicode boolean
    
           If true (default) non-ASCII characters are escaped as \uXXXX
    
        :escape-js-separators boolean
    
           If true (default) the Unicode characters U+2028 and U+2029 will
           be escaped as \u2028 and \u2029 even if :escape-unicode is
           false. (These two characters are valid in pure JSON but are not
           valid in JavaScript strings.)
    
        :escape-slash boolean
    
           If true (default) the slash / is escaped as \/
    
        :key-fn function
    
            Single-argument function called on map keys; return value will
            replace the property names in the output. Must return a
            string. Default calls clojure.core/name on symbols and
            keywords and clojure.core/str on everything else.
    
        :value-fn function
    
            Function to transform values in maps before writing. For each
            key-value pair in an input map, called with two arguments: the
            key (BEFORE transformation by key-fn) and the value. The
            return value of value-fn will replace the value in the output.
            If the return value is a number, boolean, string, or nil it
            will be included literally in the output. If the return value
            is a non-map collection, it will be processed recursively. If
            the return value is a map, it will be processed recursively,
            calling value-fn again on its key-value pairs. If value-fn
            returns itself, the key-value pair will be omitted from the
            output. This option does not apply to non-map collections.

    leancloud.data.json 0.1.0-RC4
    FIXME: write description
    clojure.data.json/writeSourceDoc + Usages
    Write JSON-formatted output to a java.io.Writer. Options are
       key-value pairs, valid options are:
    
        :escape-unicode boolean
    
           If true (default) non-ASCII characters are escaped as \uXXXX
    
        :escape-js-separators boolean
    
           If true (default) the Unicode characters U+2028 and U+2029 will
           be escaped as \u2028 and \u2029 even if :escape-unicode is
           false. (These two characters are valid in pure JSON but are not
           valid in JavaScript strings.)
    
        :escape-slash boolean
    
           If true (default) the slash / is escaped as \/
    
        :key-fn function
    
            Single-argument function called on map keys; return value will
            replace the property names in the output. Must return a
            string. Default calls clojure.core/name on symbols and
            keywords and clojure.core/str on everything else.
    
        :value-fn function
    
            Function to transform values in maps before writing. For each
            key-value pair in an input map, called with two arguments: the
            key (BEFORE transformation by key-fn) and the value. The
            return value of value-fn will replace the value in the output.
            If the return value is a number, boolean, string, or nil it
            will be included literally in the output. If the return value
            is a non-map collection, it will be processed recursively. If
            the return value is a map, it will be processed recursively,
            calling value-fn again on its key-value pairs. If value-fn
            returns itself, the key-value pair will be omitted from the
            output. This option does not apply to non-map collections.

    entity-core 0.1.0
    A library to define domain types
    entity.aggregate/aggregateSourceDoc + Usages
    Aggregate from a (possibly empty) data structure to the
      target entity reference. Provides for the common cases of
      structure building.
    
      The structure root is always a map. Non-unique keys result in
      a vector whose entries are themselves maps. The key of a vector
      result is always supplied by the caller as the option :set-name
      By default instances are held as their unqualified type name or any
      alias that was defined in the declaration.
    
       - data : the structure being built. Must be a map and always the
                root even in successive calls to this function.
       - opts : options as follows:
         :from <path>   a vector path to the thing being aggregated from.
                        This is only absent when seeding the structure
                        with its initial value (or vector of values, in the
                        case of a non-unique key). When passing through
                        a vector in the structure indicate this using '>'
         :to <type-ref> mandatory - the type being joined in the structure.
         :key-val       when :from is present, by default it will be used
                        as the value for the target type's :primary key, however
                        this behaviour is overridden by key-val, which may
                        be either the return value of make-key or a vector tuple
                        of [key-name key-value], a keyword identifying a
                        known key or a function (see below).
         :instance-name the map key to use when placing single instances in the
                        structure. This applies whether the key being applied
                        is unique or not. The name will be used in all
                        map children housing each instance. Optional and if
                        absent the unqualified name or any alias is used.
         :set-name      the map key for the vector returned by non-unique keys
                        when placed in the parent map. Mandatory when a non-unique
                        key is being used, otherwise ignored.
         :merge         Any existing value will always be replaced by a new one.
                        In the case of a non-unique key, an existing vector
                        will be replaced unless this option specifies
                        either :primary or a function. The option of :primary
                        will merge current and new values into the result
                        vector by the primary key set. A function must accept
                        three arguments, the instance-name, current and new
                        vectors, and return a vector containing the required merge.
         :must-join     If true, when aggregating to a vector, the map child will
                        be removed for any instances that don't join with the
                        target. Otherwise the vector entry remains with a
                        nil child where there is no join.
         :for-each      A function called after the aggregation. Will be passed
                        the parent node
         :read-f        The dispatching value for the read-fn multimethod. By default
                        entity.core/read-entity will be called,
      If key-val is a function it must accept three arguments. These are
       - parent : the parent node in the structure
       - from   : the value being aggregated from
       - f-opts : a map containing :key <key-name>, :key-val,
                                   :entity <the type being joined>,
                                   :set-name and :instance-name

    buddy-sign 3.0.0
    High level message signing for Clojure
    buddy.sign.util/resolve-key~java.security.Key~IKeyProviderSourceDoc + Usages
    Resolve a key

    buddy-sign 3.0.0
    High level message signing for Clojure
    buddy.sign.util/resolve-key~IFn~IKeyProviderSourceDoc + Usages
    Resolve a key

    buddy-sign 3.0.0
    High level message signing for Clojure
    buddy.sign.util/resolve-key~String~IKeyProviderSourceDoc + Usages
    Resolve a key

    buddy-sign 3.0.0
    High level message signing for Clojure
    buddy.sign.util/resolve-key~?~IKeyProviderSourceDoc + Usages
    Resolve a key

    buddy-sign 3.0.0
    High level message signing for Clojure
    buddy.sign.util/resolve-keySourceDoc + Usages
    Resolve a key

    iroh 0.1.11
    simple class reflection
    iroh.common/is-selected-keySourceDoc + Usages
    is-selected-key

    reverie-core 0.8.2
    The core of reverie; a CMS for power users
    reverie.internal.memory/delete-storage~MemStore~IInternalStorageSourceDoc + Usages
    Delete key

    reverie-core 0.8.2
    The core of reverie; a CMS for power users
    reverie.internal.memory/read-storage~MemStore~IInternalStorageSourceDoc + Usages
    Read key

    reverie-core 0.8.2
    The core of reverie; a CMS for power users
    reverie.internal/delete-storageSourceDoc + Usages
    Delete key