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 16594 results in 257 projects. Show the first 500.
    clj-osf 0.1.2
    Clojure API for Open Semantic Framework web services queries
    clj-osf.core/->getSourceDoc + Usages
    Specify that the query is a HTTP GET query

    hara.object 2.8.6
    patterns and utilities
    hara.object.read/create-read-methodSourceDoc + Usages
    creates a method based on a template
       (read/create-read-method (reflect/query-class Dog ["getName" :#])
                                "get"
                                read/+read-get-template+
                                nil)
       => (contains-in [:name {:prefix "get", :template fn?}])

    fook 0.3.0
    Small utilities for datomic
    fook.query/get-querySourceDoc + Usages
    Get part of a query

    couchbase-clj 0.2.0
    A Clojure client for Couchbase Server 2.x.
    couchbase-clj.query/get-query~CouchbaseCljQuery~ICouchbaseCljQuerySourceDoc + Usages
    Get the Query object.

    couchbase-clj 0.2.0
    A Clojure client for Couchbase Server 2.x.
    couchbase-clj.query/get-querySourceDoc + Usages
    Get the Query object.

    suricatta 0.2.2
    High level sql toolkit for clojure (backed by jooq library)
    suricatta.format/get-bind-values~suricatta.types.Deferred~IRendererSourceDoc + Usages
    Get query bind values.

    suricatta 0.2.2
    High level sql toolkit for clojure (backed by jooq library)
    suricatta.format/get-bind-values~org.jooq.Query~IRendererSourceDoc + Usages
    Get query bind values.

    suricatta 0.2.2
    High level sql toolkit for clojure (backed by jooq library)
    suricatta.proto/get-bind-valuesSourceDoc + Usages
    Get query bind values.

    elastics 0.1.1
    Data driven clojure client for Elasticsearch.
    elastics.search/countSourceDoc + Usages
    Executes a query to get the number of matches for that query.

    sliimp 0.2.6
    An image processing library
    sliimp.film/sampling-fnSourceDoc + Usages
    Get sampling fn for a film

    gd-io 0.1.0
    File I/O for google drive
    gd-io.internal/get-filesSourceDoc + Usages
    get files matching a gdrive query

    pradpi 0.2.2
    A library to simplify working with the Amazon Product Advertising API
    pradpi.url/querySourceDoc + Usages
    Get the query portion of the given url

    suricatta 0.2.2
    High level sql toolkit for clojure (backed by jooq library)
    suricatta.format/get-bind-valuesSourceDoc + Usages
    Get bind values from query

    clj-assorted-utils 1.18.2
    Unsorted bunch of helper and utility functions.
    clj-assorted-utils.util/get-fn-arglists-mSourceDoc + Usages
    Macro version of get-fn-arglists.

    clj-assorted-utils 1.18.2
    Unsorted bunch of helper and utility functions.
    clj-assorted-utils.util/fn-nameSourceDoc + Usages
    Get the name of the given fn f.

    er-cassandra 0.15
    a simple cassandra conector
    er-cassandra.drift.migrations/current-versionSourceDoc + Usages
    drift fn - get the current version

    loudmoauth 0.1.3
    A single user multi provider oauth2 client library.
    loudmoauth.provider/query-param-stringSourceDoc + Usages
    Get query-param string from query parameter map.

    Returns the absolute query for a given component, not relative like
       om.next/get-query.

    Returns the absolute query for a given component, not relative like
       om.next/get-query.

    Returns the absolute query for a given component, not relative like
       om.next/get-query.

    Returns the absolute query for a given component, not relative like
       om.next/get-query.

    cellophane 0.3.5
    Server-side rendering for Om Next components
    cellophane.next/full-querySourceDoc + Usages
    Returns the absolute query for a given component, not relative like
       om.next/get-query.

    cellophane 0.3.5
    Server-side rendering for Om Next components
    cellophane.next/full-querySourceDoc + Usages
    Returns the absolute query for a given component, not relative like
       om.next/get-query.

    muicljs 0.1.01
    Mui cljs test
    om.next/full-querySourceDoc + Usages
    Returns the absolute query for a given component, not relative like
       om.next/get-query.

    muicljs 0.1.01
    Mui cljs test
    om.next/full-querySourceDoc + Usages
    Returns the absolute query for a given component, not relative like
       om.next/get-query.

    blackwater 0.0.9
    Pretty logging for SQL queries in JDBC for Clojure
    black.water.jdbc/decorate-query!SourceDoc + Usages
    decorate c.j.j/query, wraps the fn var.

    fulcro 2.5.9
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    fulcro.client.primitives/get-query-idSourceDoc + Usages
    Get the query id that is cached in the component's props.

    fulcro 2.5.9
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    fulcro.client.routing/get-dynamic-router-querySourceDoc + Usages
    Get the query for the router with the given router-id.

    alia-component 4.2.1
    Component integration for Alia
    qbits.alia.component/->querySourceDoc + Usages
    Get a function which executes a query, preparing the statement.

    paramType will default to query for GET, body for POST

    tech.s3 0.3.0
    Library for accessing S3
    tech.s3.core/update-creds!SourceDoc + Usages
    Do a vault query to get new vault creds.

    couchbase-clj 0.2.0
    A Clojure client for Couchbase Server 2.x.
    couchbase-clj.client/view-valSourceDoc + Usages
    Get the value of query result from ViewRow object.

    couchbase-clj 0.2.0
    A Clojure client for Couchbase Server 2.x.
    couchbase-clj.client/view-keySourceDoc + Usages
    Get the key of query result from ViewRow object.

    couchbase-clj 0.2.0
    A Clojure client for Couchbase Server 2.x.
    couchbase-clj.client/view-idSourceDoc + Usages
    Get the ID of query result from ViewRow object.

    jiraph 0.8.3-beta3
    embedded graph db library for clojure
    jiraph.layer/query-fn~Object~OptimizedSourceDoc + Usages
    Get a function for performing an optimized read on the layer at a specified node. See
        documentation of Optimized for the general contract of Optimized functions. The function
        returned by query-fn should, when called, call f (presumably in some optimized way) on the data
        at keyseq (or not-found if no data is present), and return f's result.
    
        For example, a layer might store a node's edge-count in a separate field which can be read
        without reading the edges themselves; in that case, (query-fn layer [node-name :edges] count)
        should return a function like (fn [] (get-from-db (str node-name ":edge-count"))).

    jiraph 0.8.3-beta3
    embedded graph db library for clojure
    jiraph.layer/query-fnSourceDoc + Usages
    Get a function for performing an optimized read on the layer at a specified node. See
        documentation of Optimized for the general contract of Optimized functions. The function
        returned by query-fn should, when called, call f (presumably in some optimized way) on the data
        at keyseq (or not-found if no data is present), and return f's result.
    
        For example, a layer might store a node's edge-count in a separate field which can be read
        without reading the edges themselves; in that case, (query-fn layer [node-name :edges] count)
        should return a function like (fn [] (get-from-db (str node-name ":edge-count"))).

    sqlosure 0.2.0
    Compositional relational queries.
    sqlosure.query-comprehension/run-query-comprehensionSourceDoc + Usages
    Run the query comprehension against an empty state, and return the
      result. To actually create an executable query use [[build-query!]]
      or [[get-query]].

    cljs-iota 1.0.1
    ClojureScript API for IOTA JavaScript API
    cljs-iota.js-utils/prop-or-clb-fn (cljs)SourceDoc + Usages
    Constructor to create an fn to get properties or to get properties and apply
      a callback function.

    views.sql 0.1
    Plain SQL view implementation for views
    views.sql.view/viewSourceDoc + Usages
    Creates a SQL view that uses a JDBC database configuration.
    
       Arguments are:
       - id: an id for this view that is unique within the view system
       - db-or-db-fn: either a database connection map, or a function that will get
                      passed a namespace and should return a database connection map
       - sql-fn: a function that returns a JDBC-style vector containing a SELECT
                 query followed by any parameters. this query will be run whenever
                 this view needs to be refreshed.
    
       Options are:
       - row-fn: a function that if specified will be run against each row in the
                 view's result set before returning it.
       - result-set-fn: a function that will be run against the entire view's result
                        set before returning it.
    
       NOTE:
       If the SQL being run cannot be parsed (e.g. due to use of database-specific
       extensions, or other limitations of JSqlParser), you will need to manually
       specify the list of table names (as keywords) that the SQL query will affect
       as the optional tables argument.

    validation-clj 0.5.6
    A validation library for Clojure.
    validation.core/extract-valueSourceDoc + Usages
    Extract the validation attributes from record. Keywords are read
      with get, vectors with get-in and fn by applying the fn to the
      record.

    Returns a function that will apply a query and map the results via map-fn.

    Issues a GET to /reflect with a single query-parameter string.
      Calls cb with the result.

    fulcro 2.5.9
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    fulcro.client.impl.data-fetch/data-querySourceDoc + Usages
    Get the query that will be sent to the server as a result of the given data state marker

    fulcro 2.5.9
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    fulcro.client.impl.data-fetch/data-querySourceDoc + Usages
    Get the query that will be sent to the server as a result of the given data state marker

    fulcro 2.5.9
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    fulcro.client.primitives/get-static-querySourceDoc + Usages
    Get the statically-declared query of IQuery from a given class.

    lein-instant-cheatsheet 2.2.2
    Leiningen plugin to create a cheatsheet for your Clojure project <3
    instant-cheatsheet.api/sorted-matchesSourceDoc + Usages
    Get first 100 matches for QUERY-STRING, sorted by Levenshtein distance.

    untangled 1.0.0-beta1
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    untangled.client.impl.data-fetch/data-exclusionsSourceDoc + Usages
    Get the keywords that should be (recursively) removed from the query that will be sent to the server.

    untangled 1.0.0-beta1
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    untangled.client.impl.data-fetch/data-querySourceDoc + Usages
    Get the query that will be sent to the server as a result of the given data state marker

    untangled 1.0.0-beta1
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    untangled.client.impl.data-fetch/data-querySourceDoc + Usages
    Get the query that will be sent to the server as a result of the given data state marker

    clj-apache-https 1.0.18
    Clojure HTTP library using the Apache HttpClient. Based on clj-apache-http, but
    com.twinql.clojure.http/getSourceDoc + Usages
    Submit an HTTP get request. The query string is appended to the URI.

    clj-apache-http 2.3.2
    Clojure HTTP library using the Apache HttpClient.
    com.twinql.clojure.http/getSourceDoc + Usages
    Submit an HTTP get request. The query string is appended to the URI.

    untangled-client 0.8.2
    Client-side code for Untangled Webapps
    untangled.client.impl.data-fetch/data-exclusionsSourceDoc + Usages
    Get the keywords that should be (recursively) removed from the query that will be sent to the server.

    untangled-client 0.8.2
    Client-side code for Untangled Webapps
    untangled.client.impl.data-fetch/data-querySourceDoc + Usages
    Get the query that will be sent to the server as a result of the given data state marker

    untangled-client 0.8.2
    Client-side code for Untangled Webapps
    untangled.client.impl.data-fetch/data-querySourceDoc + Usages
    Get the query that will be sent to the server as a result of the given data state marker

    fulcro-sql 0.3.2
    A library for using SQL databases as components, writing integration tests, and
    fulcro-sql.core/column-spec*SourceDoc + Usages
    Get the database-specific column query specification for a given SQL prop.

    clj-jenkins 0.1.8
    Clojure client for Jenkins
    clj-jenkins.core/get-jsonSourceDoc + Usages
    Execute a GET query with optional basic-auth and return json

    hiroba 0.1.0-alpha
    A minimalistic Clojure library for the Foursquare REST API
    mochify.hiroba.rest/getSourceDoc + Usages
    Performs an HTTP GET of a URI, with optional query string parameters.

    couchbase-clj 0.2.0
    A Clojure client for Couchbase Server 2.x.
    couchbase-clj.client/view-docSourceDoc + Usages
    Get the document of query result when include-docs is set to true.

    incanter-core 1.9.3
    Incanter-core is the core module of the Incanter project.
    incanter.core/query-datasetSourceDoc + Usages
      Queries the given dataset using the query-map, returning a new dataset.
      The query-map uses the the dataset's column-names as keys and a
      simple variant of the MongoDB query language.
    
      For instance, given a dataset with two columns, :x and :category,  to query
      for rows where :x equals 10, use the following query-map: {:x 10}.
    
      To indicate that :x should be between 10 and 20, use {:x {:$gt 10 :$lt 20}}.
    
      To indicate that :category should also be either :red, :green, or :blue, use :$in
      {:x {:$gt 10 :$lt 20} :y {:$in #{:green :blue :red}}}
    
      And to indicate that :category should not include :red, :green, or :blue, use :$nin
      {:x {:$gt 10 :$lt 20} :y {:$nin #{:green :blue :red}}}
    
      The available query terms include :$gt, :$lt, :$gte, :$lte, :$eq, :$ne, :$in, :$nin, $fn.
    
      A row predicate function can be used instead of a query-map. The function must accept
      a map, representing a row of the dataset, and return a boolean value indicating whether
      the row should be included in the new dataset.
    
      Examples:
        (use '(incanter core datasets))
        (def cars (get-dataset :cars))
    
        (view (query-dataset cars {:speed 10}))
        (view (query-dataset cars {:speed {:$in #{17 14 19}}}))
        (view (query-dataset cars {:speed {:$lt 20 :$gt 10}}))
        (view (query-dataset cars {:speed {:$fn #(> (log %) 3)}}))
    
        ;; use a row predicate function instead of a query map.
        (view (query-dataset cars (fn [row] (> (/ (row "speed") (row "dist")) 1/2))))
         (assoc data :rows
                 (for [row (:rows data) :when (query-map row)] row))
      

    modelo 0.1.0
    Relational database abstraction for Clojure
    modelo.db.none/with-tuples*~NoDb~IDatabaseSourceDoc + Usages
    Takes an entity and query, performs the query, then calls body-fn with
         [keys tuples] as arguments. tuples is a lazy sequence.

    modelo 0.1.0
    Relational database abstraction for Clojure
    modelo.db.sql/with-tuples*~SqlDb~IDatabaseSourceDoc + Usages
    Takes an entity and query, performs the query, then calls body-fn with
         [keys tuples] as arguments. tuples is a lazy sequence.

    modelo 0.1.0
    Relational database abstraction for Clojure
    modelo.db/with-tuples*SourceDoc + Usages
    Takes an entity and query, performs the query, then calls body-fn with
         [keys tuples] as arguments. tuples is a lazy sequence.

    eat-static 0.1.0
    Eat Static, a library for type checking and validation of Clojure maps and functions.
    eat-static.validations/get-desc-symSourceDoc + Usages
    Helper for get-desc-fn. Given a symbol, returns either the make fn or the pred fn defined previously for the symbol

    Given a database connection, a vector containing SQL and optional parameters,
      return a reducible collection. When reduced, it will start the database query
      and reduce the result set, and then close the connection:
        (transduce (map :cost) + (reducible-query db sql-params))
    
      The following options from query etc are not accepted here:
        :as-arrays? :explain :explain-fn :result-set-fn :row-fn
      See prepare-statement for additional options that may be passed through.
    
      If :raw? true is specified, the rows of the result set are not converted to
      hash maps, and it as if the following options were specified:
        :identifiers identity :keywordize? false :qualifier nil
      In addition, the rows of the result set may only be read as if they were hash
      maps (get, keyword lookup, select-keys) but the sequence representation is
      not available (so, no keys, no vals, and no seq calls). This is much faster
      than converting each row to a hash map but it is also more restrictive.

    clj-apache-https 1.0.18
    Clojure HTTP library using the Apache HttpClient. Based on clj-apache-http, but
    com.twinql.clojure.async-client/get-full-urlSourceDoc + Usages
    Returns the full URL. If method is :get and there is a query string,
       or if method is :post and there is a query string and a body. Otherwise,
       returns the url unchanged.

    clj-instagram 0.2.0
    Clojure client for Instagram API
    clj-instagram.requests/search-usersSourceDoc + Usages
    Get a list of users matching the query.
    
      Parameters:
        q     - a query string
        count - number of users to return (optional)

    hara.reflect 2.8.6
    patterns and utilities
    hara.reflect.element.field/arg-paramsSourceDoc + Usages
    arguments for getters and setters of fields
     
       (-> (query/query-class String ["hash" :#])
           (field/arg-params :set))
       => [java.lang.String Integer/TYPE]
     
       (-> (query/query-class String ["hash" :#])
           (field/arg-params :get))
       => [java.lang.String]

    clj-jdbcutil 0.1.0
    JDBC utility functions for Clojure
    clj-jdbcutil.core/table-namesSourceDoc + Usages
    Return table names from the collection returned by get-tables fn.

    clj-dbspec 0.3
    Clj-DBSpec is a common configuration spec for dealing with relational databases e.g.
    org.bituf.clj-dbspec/table-namesSourceDoc + Usages
    Return table names from the collection returned by get-tables fn.

    autodoc-collect 1.1.4
    Support library for autodoc
    autodoc-collect.collect-info/var-specsSourceDoc + Usages
    Get {:args ..., :ret ..., :fn } spec for v or nil if none

    rulescript 0.7.0
    Comprehensive DSL for document validation.
    rulescript.lang.invocations/apply-rule-innerSourceDoc + Usages
    Get a fn by rule-name from the vars map, and apply it to args

    rainboots 0.12.0
    Protect yourself from the grossness of writing a MUD server
    rainboots.hooks/installed-hook-pairsSourceDoc + Usages
    Get the list of [name, installed hook fn] names for
       the given hook

    re-frame-utils 0.1.0
    Fxs and CoFxs for re-frame
    vimsical.re-frame.cofx.inject/injectSourceDoc + Usages
    Inject the `:sub` cofx.
    
      If `query-vector-or-event->query-vector-fn` is a subscription vector, subscribe and
      dereference that subscription before assoc'ing its value in the coeffects map
      under the id of the subscription and disposing of it.
    
      If `query-vector-or-event->query-vector-fn` is a fn, it should take a single
      argument which is the event args vector for that handler (similar to the
      2-arity of `re-frame.core/reg-sub`). Its return value should be a query-vector
      or nil. From there on the behavior is similar to when passing a query-vector.
    
      NOTE that if there are no components subscribed to that subscription the cofx
      will dispose of it in order to prevent leaks. However there is a performance
      penalty to doing this since we pay for a re-frame subscription cache miss
      every time we inject it. In such cases the cofx will log a warning which can
      be ignored by setting `:ignore-dispose` on the subscription vector's meta. A
      rule of thumb for what to do here would be that if an injected sub is disposed
      of very often, we should either rework the subscription graph so that it ends
      up used by a component and thus cached, or we should extract the db lookup
      logic into a function that can be used to get the value straight from the db
      inside the handler. It seems safe to decide to ignore the warning when the
      disposal doesn't happen too often and it is just more convenient to reuse the
      subscription's logic.
    
      Examples:
    
      (require '[vimsical.re-frame.cofx.inject :as inject])
    
      ;; Injecting a simple subscription:
    
      (re-frame/reg-sub ::simple ...)
    
      (re-frame/reg-event-fx
       ::simple-handler
       [(re-frame/inject-cofx ::inject/sub [::simple]]]
       (fn [{:as cofx {::keys [simple]} params]
         ...)
    
    
      ;; Injecting a dynamic subscription depending on the event parameters:
    
      (re-frame/reg-sub ::dynamic (fn [_ [_ arg1 arg2]] ...))
    
      (re-frame/reg-event-fx
       ::dynamic-handler
       [(re-frame/inject-cofx ::inject/sub
          (fn [[_ arg1 arg2]]
            ...
            [::dynamic arg1 arg2]))]
       (fn [{:as cofx {::keys [dynamic]} [_ arg1 arg-2]]
         ...)
      

    re-frame-utils 0.1.0
    Fxs and CoFxs for re-frame
    vimsical.re-frame.cofx.inject/injectSourceDoc + Usages
    Inject the `:sub` cofx.
    
      If `query-vector-or-event->query-vector-fn` is a subscription vector, subscribe and
      dereference that subscription before assoc'ing its value in the coeffects map
      under the id of the subscription and disposing of it.
    
      If `query-vector-or-event->query-vector-fn` is a fn, it should take a single
      argument which is the event args vector for that handler (similar to the
      2-arity of `re-frame.core/reg-sub`). Its return value should be a query-vector
      or nil. From there on the behavior is similar to when passing a query-vector.
    
      NOTE that if there are no components subscribed to that subscription the cofx
      will dispose of it in order to prevent leaks. However there is a performance
      penalty to doing this since we pay for a re-frame subscription cache miss
      every time we inject it. In such cases the cofx will log a warning which can
      be ignored by setting `:ignore-dispose` on the subscription vector's meta. A
      rule of thumb for what to do here would be that if an injected sub is disposed
      of very often, we should either rework the subscription graph so that it ends
      up used by a component and thus cached, or we should extract the db lookup
      logic into a function that can be used to get the value straight from the db
      inside the handler. It seems safe to decide to ignore the warning when the
      disposal doesn't happen too often and it is just more convenient to reuse the
      subscription's logic.
    
      Examples:
    
      (require '[vimsical.re-frame.cofx.inject :as inject])
    
      ;; Injecting a simple subscription:
    
      (re-frame/reg-sub ::simple ...)
    
      (re-frame/reg-event-fx
       ::simple-handler
       [(re-frame/inject-cofx ::inject/sub [::simple]]]
       (fn [{:as cofx {::keys [simple]} params]
         ...)
    
    
      ;; Injecting a dynamic subscription depending on the event parameters:
    
      (re-frame/reg-sub ::dynamic (fn [_ [_ arg1 arg2]] ...))
    
      (re-frame/reg-event-fx
       ::dynamic-handler
       [(re-frame/inject-cofx ::inject/sub
          (fn [[_ arg1 arg2]]
            ...
            [::dynamic arg1 arg2]))]
       (fn [{:as cofx {::keys [dynamic]} [_ arg1 arg-2]]
         ...)
      

    cspbox-runtime 0.1.2
    runtime lib for cspbox system
    cspbox.runtime.sys.utils.util/get-fn-varSourceDoc + Usages
    get var (bind with fn) by name-space and fn name, when aot, resolve not work

    stub-fn 0.1.0
    A macro to stub arbitrary Clojure functions.
    fhofherr.stub-fn.core/get-stub-fn-nameSourceDoc + Usages
    Get `stubbed-fn`'s name.
    
      Returns `nil` if the `stubbed-function` is not a stub.
    
      Arguments:
    
      * `stubbed-fn`: the stubbed function

    clj-safejdbc 0.2.8
    A fast library for accessing JDBC in Clojure
    clj-safejdbc.core/querySourceDoc + Usages
    Returns a fn that (when called with a Connection) executes the
       sql query and passes the ResultSet over to the rs-fn.  The
       result of the rs-fn is then returned.
       Examples:
       (query "SELECT * FROM Customers")
       (query ["SELECT * FROM Customers WHERE Age=?" 21])

    hara.reflect 2.8.6
    patterns and utilities
    hara.reflect.pretty.display/select-terms-fnSourceDoc + Usages
    creates a function that selects terms to output
     
       (-> (query/query-class (type []) ["create"])
           ((display/select-terms-fn {:select-terms [:name]})))
       => ["create"]

    alia 4.2.1
    Cassandra CQL3 client for Clojure - datastax/java-driver wrapper
    qbits.alia/lazy-querySourceDoc + Usages
    Takes a session, a query (raw or prepared) and a query modifier fn (that
      receives the last query and last chunk and returns a new query or nil).
      The first chunk will be the original query result, then for each
      subsequent chunk the query will be the result of last query
      modified by the modifier fn unless the fn returns nil,
      which would causes the iteration to stop.
    
      It also accepts any of `execute` options.
    
      ex: (lazy-query session
                    (select :items (limit 2) (where {:x (int 1)}))
                            (fn [q coll]
                              (merge q (where {:si (-> coll last :x inc)})))
                    {:consistency :quorum :tracing? true})

    Updates a session by applying reducer-fn to the command, and handles
       query-listener so query bindings resulting from command can be tracked.

    asphalt 0.6.7
    A Clojure library for JDBC access
    asphalt.param/set-params-with-query-timeoutSourceDoc + Usages
    Return a params setter fn usable with asphalt.core/query, that times out on query execution and throws a
      java.sql.SQLTimeoutException instance. Supported by JDBC 4.0 (and higher) drivers only.

    fulcro 2.5.9
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    fulcro.client.routing/current-routeSourceDoc + Usages
    Get the current route (an ident) from the router with the given id. You can pass the entire app database, the routers table,
      or the props of a component that has queried for the router table as the first argument to this function.
      Thus, it can be used easily from within a mutation or in a component to find (and display) the current route:
    
      ```
      (defmutation do-something-with-routes [params]
        (action [{:keys [state]}]
          (let [current (r/current-route state :top-router)]
          ...)))
    
      (defsc NavBar [this props]
        {:query (fn [] [[r/routers-table '_]])
         :initial-state (fn [params] {})}
        (let [current (r/current-route props :top-router)]
          ...))
      ```
      

    fulcro 2.5.9
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    fulcro.client.impl.data-fetch/data-query-keySourceDoc + Usages
    Get the 'primary' query key of the data fetch. This is defined as the first keyword of the overall query (which might
      be a simple prop or join key for example)

    fulcro 2.5.9
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    fulcro.client.impl.data-fetch/data-query-keySourceDoc + Usages
    Get the 'primary' query key of the data fetch. This is defined as the first keyword of the overall query (which might
      be a simple prop or join key for example)

    fulcro 2.5.9
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    fulcro.client.primitives/legal-keysSourceDoc + Usages
    Find the legal keys in a query. NOTE: This is at compile time, so the get-query calls are still embedded (thus cannot
         use the AST)

    untangled 1.0.0-beta1
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    untangled.client.impl.data-fetch/data-query-keySourceDoc + Usages
    Get the 'primary' query key of the data fetch. This is defined as the first keyword of the overall query (which might
      be a simple prop or join key for example)

    untangled 1.0.0-beta1
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    untangled.client.impl.data-fetch/data-query-keySourceDoc + Usages
    Get the 'primary' query key of the data fetch. This is defined as the first keyword of the overall query (which might
      be a simple prop or join key for example)

    untangled-client 0.8.2
    Client-side code for Untangled Webapps
    untangled.client.impl.data-fetch/data-query-keySourceDoc + Usages
    Get the 'primary' query key of the data fetch. This is defined as the first keyword of the overall query (which might
      be a simple prop or join key for example)

    untangled-client 0.8.2
    Client-side code for Untangled Webapps
    untangled.client.impl.data-fetch/data-query-keySourceDoc + Usages
    Get the 'primary' query key of the data fetch. This is defined as the first keyword of the overall query (which might
      be a simple prop or join key for example)

    clj-instagram 0.2.0
    Clojure client for Instagram API
    clj-instagram.endpoints/search-usersSourceDoc + Usages
    Get a list of users matching the query.
    
      Parameters:
        q     - a query string
        count - number of users to return (optional)
        opts  - map of endpoint call options

    xml-picker-seq 0.0.2
    A Clojure wrapper for reading large XML files with XOM.
    xml-picker-seq.core/xpath-querySourceDoc + Usages
    Takes a XPath query string and optionally a context object, extract-fn
       to run on each result node and final-fn to run on the results.
       Returns a function that takes the element to run the query on.

    Get a component's static query from the indexer. For recursive queries, recurses
       up the data path. Falls back to `get-class-or-instance-query` if nothing is
       found in the indexer.

    Get a component's static query from the indexer. For recursive queries, recurses
       up the data path. Falls back to `get-class-or-instance-query` if nothing is
       found in the indexer.

    sweet-liberty 0.1.4
    A library for building database-backed RESTful services using Clojure
    com.rjmetrics.sweet-liberty.core/transform-post-to-getSourceDoc + Usages
    Takes a ring request of method POST and transforms it into a GET,
      replacing the POST body as query parameters. This is typically used to
      create an endpoint that interprets a POST as a GET, which circumvents
      query string length limitations. Yes, this is a hack.

    cellophane 0.3.5
    Server-side rendering for Om Next components
    cellophane.next/get-indexed-querySourceDoc + Usages
    Get a component's static query from the indexer. For recursive queries, recurses
       up the data path. Falls back to `get-class-or-instance-query` if nothing is
       found in the indexer.

    Get a component's static query from the indexer. For recursive queries, recurses
       up the data path. Falls back to `get-class-or-instance-query` if nothing is
       found in the indexer.

    clojure-saxon 0.9.4
    Clojure wrapper for the Saxon XSLT and XQuery processor.
    saxon/querySourceDoc + Usages
    Run query on node. Arity of two accepts (1) string or compiled query fn & (2) node;
      arity of three accepts (1) string query, (2) namespace map, & (3) node.

    pedestal-lacinia 0.1.1
    Pedestal infrastructure supporting Lacinia GraphQL
    com.walmartlabs.lacinia.pedestal/extract-querySourceDoc + Usages
    For GraphQL queries, returns the query document ready to be parsed.
    
      For the GET method, this is expected to be a query parameter named `query`.
    
      For the POST method, this is the body of the request.
    
      For other methods, returns nil.

    clara-rules 0.18.0
    Clara Rules Engine
    clara.rules/querySourceDoc + Usages
    Runs the given query with the optional given parameters against the session.
       The optional parameters should be in map form. For example, a query call might be:
    
       (query session get-by-last-name :last-name "Jones")
    
       The query itself may be either the var created by a defquery statement,
       or the actual name of the query.
       

    clarango 0.7.1
    A Clojure client for the HTTP API of ArangoDB
    clarango.query/validateSourceDoc + Usages
    Validates a query without executing it.
      As a return value you get a map containing the names of the collections and the vars used in the query.
      If the query is not valid also an error will be thrown including an error message with the problem found in the query.
    
      Takes as only argument the query string to be evaluated.

    curd 0.1.4
    Easy and sweet crud without hassle
    curd.core/do-querySourceDoc + Usages
    Wrapper for java.jdbc's query function.
      Input connection can be either db's spec or transaction.
      Takes optional result-set-fn and row-fn processing functions.

    engine 0.1.1
    A workflow engine that implements query -> logic -> updates.
    engine.core/-ifq~Engine~EngineFlowSourceDoc + Usages
    If the query-fn is true of the engine, call true-fn on the
        engine, else call false-fn on the engine. If the engine was
        in failure mode, call fail-fn on it instead. Both false-fn
        and fail-fn can be nil, indicating no action should be taken.

    engine 0.1.1
    A workflow engine that implements query -> logic -> updates.
    engine.core/-ifqSourceDoc + Usages
    If the query-fn is true of the engine, call true-fn on the
        engine, else call false-fn on the engine. If the engine was
        in failure mode, call fail-fn on it instead. Both false-fn
        and fail-fn can be nil, indicating no action should be taken.

    preflex 0.4.0
    Metrics, Instrumentation and Resilience for Clojure
    preflex.instrument.jdbc/make-jdbc-event-factorySourceDoc + Usages
    Make a preflex.instrument.jdbc.JdbcEventFactory instance from given event generator options:
      :connection-create     - (fn []) -> event
      :connection-close      - (fn []) -> event
      :statement-create      - (fn []) -> event
      :statement-close       - (fn []) -> event
      :prepared-create       - (fn [sql]) -> event
      :callable-create       - (fn [sql]) -> event
      :statement-sql-execute - (fn [sql]) -> event
      :statement-sql-query   - (fn [sql]) -> event
      :statement-sql-update  - (fn [sql]) -> event
      :prepared-sql-execute  - (fn [sql]) -> event
      :prepared-sql-query    - (fn [sql]) -> event
      :prepared-sql-update   - (fn [sql]) -> event

    qarth 0.1.3
    OAuth for serious people
    qarth.oauth/requestorSourceDoc + Usages
    Multimethod. Usage:
      (let [r (requestor service record)]
        (r opts))
    
      Returns a fn that can be used to make requests to the auth service.
      The requestor works similarly to the Clojure library clj-http.
      If the record is inactive (perhaps it expired or was never activated),
      throws a Slingshot exception {::qarth.core/unauthorized true}.
    
      Mandatory opt:
      :url -- the request URL
    
      Supported opts:
      :method -- :GET, :PUT, :POST, :DELETE, default :GET
      :body -- the HTTP body for PUT or POST. Overrides form-params.
      Can be anything usable by clojure.java.io (e.g. a String or byte array).
      :form-params -- the form parameters
      :query-params -- the query parameters
      :headers -- a string->string map
      :follow-redirects -- true or false, default true
      :as -- coerce to something else, must support at least :stream
    
      Returns a Ring-Style response map containing at least:
      :status -- the status code
      :headers -- the http headers
      :body -- a string or InputStream or something else
      (if it's an InputStream, be sure to close it when you're done!)
    
      If an exceptional status code happens, throws an Exception instead.
      Other implementations might support more opts and return more stuff.
      
      A default implementation is provided for implementors. It adds the param
      :access_token to the form params if it's a POST, and the query if it's a GET.

    makes a wrapper function that takes a format-spec map,
       gets a value from it using the fn-find-arg fn
       and calls the fn-find-spec fn with the found value to get the result spec

    Loop through all the `clause->handler` entries; if the query contains a given clause, apply the handler fn.

    blackwater 0.0.9
    Pretty logging for SQL queries in JDBC for Clojure
    black.water.jdbc/query-hookSourceDoc + Usages
    Hook for c.j.j query, destructures sql from arguments
       and times the run-time, sending the results to the log fn.

    rage-db 1.0
    Lightweight disk based json database
    rage-db.core/?SourceDoc + Usages
    Query the dataset with a function i.e
         (? db :users (fn [row] (= :email row) "owain@owainlewis.com"

    sails-forth 0.8.1
    A Salesforce library
    sails-forth.client/resolve-field-pathSourceDoc + Usages
    Derives a seq of record keys for the given seq of fields, suitable for
       applying to the result of the underlying query! fn

    specmonstah 1.1.1
    Generate and process arbitrary graphs of dependencies
    reifyhealth.specmonstah.core/doallSourceDoc + Usages
    Calls `dotree`, and also calls `do-fn` on each element in the key
      `::query` of the map returned by `gen-tree`

    Example return:
       (route GET "/widgets" widgets/query)
       (authroute POST "/widgets" widgets/create! friend/auth)

    fulcro 2.5.9
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    fulcro.client.impl.data-fetch/data-paramsSourceDoc + Usages
    Get the parameters that the user wants to add to the first join/keyword of the data fetch query.

    fulcro 2.5.9
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    fulcro.client.impl.data-fetch/data-refreshSourceDoc + Usages
    Get the list of query keywords that should be refreshed (re-rendered) when this load completes.

    untangled 1.0.0-beta1
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    untangled.client.impl.data-fetch/data-paramsSourceDoc + Usages
    Get the parameters that the user wants to add to the first join/keyword of the data fetch query.

    untangled 1.0.0-beta1
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    untangled.client.impl.data-fetch/data-refreshSourceDoc + Usages
    Get the list of query keywords that should be refreshed (re-rendered) when this load completes.

    untangled-client 0.8.2
    Client-side code for Untangled Webapps
    untangled.client.impl.data-fetch/data-paramsSourceDoc + Usages
    Get the parameters that the user wants to add to the first join/keyword of the data fetch query.

    untangled-client 0.8.2
    Client-side code for Untangled Webapps
    untangled.client.impl.data-fetch/data-refreshSourceDoc + Usages
    Get the list of query keywords that should be refreshed (re-rendered) when this load completes.

    untangled-client 0.8.2
    Client-side code for Untangled Webapps
    untangled.client.impl.data-fetch/get-ready-querySourceDoc + Usages
    Get the query for items that are ready to load into the given app state. Can be called any number of times
      (side effect free).

    dynohub 1.1.0
    Clojure DynamoDB client with or without Transaction layer
    ozjongwon.dynohub/merge-moreSourceDoc + Usages
    Enables auto paging for batch batch-get/write, query/scan requests - useful for throughput limitations.

    clj-puppetdb 0.1.1
    A Clojure client for the PuppetDB REST API
    clj-puppetdb.schema/GetParamsSourceDoc + Usages
    Params ready to be passed to GET. Similar to PagingParams, except
      that everything is optional and :query (if present) must be a string.

    faraday 1.10.0
    Clojure DynamoDB client
    taoensso.faraday/merge-moreSourceDoc + Usages
    Enables auto paging for batch batch-get/write and query/scan requests.
      Particularly useful for throughput limitations.

    om-style 0.0.2
    Prerendered stylesheets from colocated styles for om.next
    om-style.core/get-styleSourceDoc + Usages
    Gets the colocated style of either a component or a class.
      An analogue to om/get-query. Used for composing styles upwards.

    couchbase-clj 0.2.0
    A Clojure client for Couchbase Server 2.x.
    couchbase-clj.client/view-doc-jsonSourceDoc + Usages
    Get the JSON string document of query result converted to Clojure data
      when include-docs is set to true.

    couchbase-clj 0.2.0
    A Clojure client for Couchbase Server 2.x.
    couchbase-clj.client/view-val-jsonSourceDoc + Usages
    Get the JSON string value of query result from ViewRow object,
      converted to Clojure data.

    couchbase-clj 0.2.0
    A Clojure client for Couchbase Server 2.x.
    couchbase-clj.client/view-key-jsonSourceDoc + Usages
    Get the JSON string key of query result from ViewRow object,
      converted to Clojure data.

    pradpi 0.2.2
    A library to simplify working with the Amazon Product Advertising API
    pradpi.hmac/signedSourceDoc + Usages
    Get a signed url for use in the ad API. Adds Timestamp, and Signature query params

    fulcro 2.5.9
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    fulcro.client.primitives/get-querySourceDoc + Usages
    Get the query for the given class or factory. If called without a state map, then you'll get the declared static
      query of the class. If a state map is supplied, then the dynamically set queries in that state will result in
      the current dynamically-set query according to that state.

    geheimtur 0.3.4
    a secret door to your Pedestal application
    geheimtur.impl.oauth2/authenticate-handlerSourceDoc + Usages
    Creates a handler that redirects users to OAuth2 providers based on a map of providers.
    
       Example:
       (def providers
           {:github {:auth-url           "https://github.com/login/oauth/authorize"
                     :client-id          "your-client-id"
                     :client-secret      "your-client-secret"
                     :scope              "user:email"
                     :client-params      {:foo "bar"}
                     :token-url          "https://github.com/login/oauth/access_token"
                     :token-parse-fn     (fn [resp] (parse-string (:body resp)))
                     :user-info-url      "https://api.github.com/user"
                     :user-info-parse-fn (fn [resp] (parse-string (:body resp)))
                     :on-success-handler on-github-success}})
    
      The following keys in provider's configuration are optional:
          :client-params      - a map of extra query parameters to be included in the authorization request
          :token-parse-fn     - a function that accepts the token endpoint response and returns a map with the parsed
                                OAuth2 token response. The successfuly parsed response must have at least :access_token key.
          :user-info-url      - if defined, will be used to get user's details after successful access token acquisition
          :user-info-parse-fn - if defined, will be applied to the response of user's details endpoint
          :on-success-handler - a function that accepts a request context and an obtained identity/access token map and returns a correct ring response.
                                It is called only if an identity/access token is resolved.

    fulcro 2.5.9
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    fulcro.client.primitives/defscSourceDoc + Usages
    Define a stateful component. This macro emits a React UI class with a query,
       optional ident (if :ident is specified in options), optional initial state, optional css, lifecycle methods,
       and a render method. It can also cause the class to implement additional protocols that you specify. Destructuring is
       supported in the argument list.
    
       The template (data-only) versions do not have any arguments in scope
       The lambda versions have arguments in scope that make sense for those lambdas, as listed below:
    
       ```
       (defsc Component [this {:keys [db/id x] :as props} {:keys [onSelect] :as computed} css-classmap]
         {
          ;; stateful component options
          ;; query template is literal. Use the lambda if you have ident-joins or unions.
          :query [:db/id :x] ; OR (fn [] [:db/id :x]) ; this in scope
          ;; ident template is table name and ID property name
          :ident [:table/by-id :id] ; OR (fn [] [:table/by-id id]) ; this and props in scope
          ;; initial-state template is magic..see dev guide. Lambda version is normal.
          :initial-state {:x :param/x} ; OR (fn [params] {:x (:x params)}) ; this in scope
          :css [] ; garden css rules
          :css-include [] ; list of components that have CSS to compose towards root.
    
          ; React Lifecycle Methods (this in scope)
          :initLocalState            (fn [] ...)
          :shouldComponentUpdate     (fn [next-props next-state] ...)
          :componentWillReceiveProps (fn [next-props] ...)
          :componentWillUpdate       (fn [next-props next-state] ...)
          :componentDidUpdate        (fn [prev-props prev-state] ...)
          :componentWillMount        (fn [] ...)
          :componentDidMount         (fn [] ...)
          :componentWillUnmount      (fn [] ...)
          ;; React 16:
          :componentDidCatch         (fn [error info])
    
          NOTE: shouldComponentUpdate should generally not be overridden other than to force it false so
          that other libraries can control the sub-dom. If you do want to implement it, then old props can
          be obtained from (prim/props this), and old state via (gobj/get (. this -state) "fulcro$state").
    
          ; Custom literal protocols (Object ok, too, to add arbitrary methods. Nothing automatically in scope.)
          :protocols [YourProtocol
                      (method [this] ...)]} ; nothing is automatically in scope
          ; BODY forms. May be omitted IFF there is an options map, in order to generate a component that is used only for queries/normalization.
          (dom/div #js {:onClick onSelect} x))
       ```
    
       See the Developer's Guide at book.fulcrologic.com for more details.
       

    clj-momo 0.2.23
    Library code produced by the Cisco ThreatGrid team for building swagger backed API
    clj-momo.test-helpers.http-assert-2/with-port-fnSourceDoc + Usages
    Helper to compose a fn that knows how to lookup an HTTP port with
       an HTTP method fn (from above)
       Example:
         (def test-get (http-assert-2/with-port-fn get-http-port http-assert-2/test-get))

    hottop 0.1.4
    HoTToP is a resource-oriented web application framework.
    hottop.resource/create-readonly-html-resourceSourceDoc + Usages
    Returns a resource that will only respond to a GET request. get-fn should be
    a function of the ring request. html-fn should be a function of one argument (it
    is passed the result of get-fn) and should return well-formed HTML. You can also
    pass in a single function that takes the ring request and returns HTML directly.

    alia 4.2.1
    Cassandra CQL3 client for Clojure - datastax/java-driver wrapper
    qbits.alia/executeSourceDoc + Usages
    Executes a query against a session.
      Returns a collection of rows.
    
      The query can be a raw string, a PreparedStatement (returned by
      `prepare`) with values passed via the `:values` option key will be bound by
      `execute`, BoundStatement (returned by `qbits.alia/bind`).
    
      The following options are supported:
    
    * `:values` : values to be bound to a prepared query
    * `:consistency` : Keyword, consistency
    * `:serial-consistency` : Keyword, consistency
    * `:routing-key` : ByteBuffer
    * `:retry-policy` : one of qbits.alia.policy.retry/*
    * `:tracing?` : Bool, toggles query tracing (available via query result metadata)
    * `:fetch-size` : Number, sets query fetching size
    * `:timestamp` : Number, sets the timestamp for query (if not specified in CQL)
    * `:idempotent?` : Whether this statement is idempotent, i.e. whether
      it can be applied multiple times without changing the result beyond
      the initial application
    * `:paging-state` : Expects a com.datastax.driver.core.PagingState
      instance. This will cause the next execution of this statement to
      fetch results from a given page, rather than restarting from the
      beginning
    * `:result-set-fn` : Defaults to `clojure.core/seq` By default a
      result-set is an unchunked lazy seq, you can control this using this
      option. If you pass a function that supports IReduceInit you can
      have full control over how the resultset is formed (chunked,
      unchunked, eager or not, etc). A common use is to pass `#(into [] %)`
      as result-set-fn, you then get an eager value, with minimal copies,
      no intermediary seq and potentially better performance. This can be
      very powerfull when used right (for instance with transducers
      `#(into [] xform %))`.
    * `:row-generator` : implements alia.codec/RowGenerator, Defaults to
      `alia.codec/row-gen->map` : A RowGenerator dicts how we construct rows.
    * `:codec` : map of `:encoder` `:decoder` functions that control how to
      apply extra modifications on data sent/received (defaults to
      `qbits.alia.codec/default`).
    * `:read-timeout` : Read timeout in milliseconds
    
      Possible values for consistency:
    
    :all :any :each-quorum :local-one :local-quorum :local-serial :one :quorum
    :serial :three :two

    Navigate to the result of running `parse-fn` on the value. For
              transforms, the transformed value then has `unparse-fn` run on
              it to get the final value at this point.

    cortex 0.9.22
    A neural network toolkit for Clojure.
    cortex.keyword-fn/get-keyword-fnSourceDoc + Usages
    Get a fn from either a keyword or a map containing
    {:fn kwd
    :args nil-or-arg-seqable}
    
    function returned will look like:
    (partial kwd args).

    ventas 0.0.6
    The Ventas eCommerce platform
    com.rpl.specter/parserSourceDoc + Usages
    Navigate to the result of running `parse-fn` on the value. For
              transforms, the transformed value then has `unparse-fn` run on
              it to get the final value at this point.

    ventas 0.0.6
    The Ventas eCommerce platform
    com.rpl.specter/parserSourceDoc + Usages
    Navigate to the result of running `parse-fn` on the value. For
              transforms, the transformed value then has `unparse-fn` run on
              it to get the final value at this point.

    stub-fn 0.1.0
    A macro to stub arbitrary Clojure functions.
    fhofherr.stub-fn.core/get-stub-invocationsSourceDoc + Usages
    Get all available information about `stubbed-fn`'s invocations.
    
      Returns `nil` if the `stubbed-function` is not a stub.
    
      Arguments:
    
      * `stubbed-fn`: the stubbed function

    stub-fn 0.1.0
    A macro to stub arbitrary Clojure functions.
    fhofherr.stub-fn.core/get-stub-infoSourceDoc + Usages
    Get all available information about the `stubbed-fn`.
    
      Returns `nil` if the `stubbed-function` is not a stub.
    
      Arguments:
    
      * `stubbed-fn`: the stubbed function

    reagent 0.8.1
    A simple ClojureScript interface to React
    reagent.core/create-class (cljs)SourceDoc + Usages
    Create a component, React style. Should be called with a map,
      looking like this:
    
        {:get-initial-state (fn [this])
         :component-will-receive-props (fn [this new-argv])
         :should-component-update (fn [this old-argv new-argv])
         :component-will-mount (fn [this])
         :component-did-mount (fn [this])
         :component-will-update (fn [this new-argv])
         :component-did-update (fn [this old-argv])
         :component-will-unmount (fn [this])
         :reagent-render (fn [args....])}   ;; or :render (fn [this])
    
      Everything is optional, except either :reagent-render or :render.

    re-frame-10x 0.3.3
    Become 10x more productive when developing and debugging re-frame applications.
    mranderson048.reagent.v0v7v0.reagent.core/create-class (cljs)SourceDoc + Usages
    Create a component, React style. Should be called with a map,
      looking like this:
    
        {:get-initial-state (fn [this])
         :component-will-receive-props (fn [this new-argv])
         :should-component-update (fn [this old-argv new-argv])
         :component-will-mount (fn [this])
         :component-did-mount (fn [this])
         :component-will-update (fn [this new-argv])
         :component-did-update (fn [this old-argv])
         :component-will-unmount (fn [this])
         :reagent-render (fn [args....])}   ;; or :render (fn [this])
    
      Everything is optional, except either :reagent-render or :render.

    Create a component, React style. Should be called with a map,
      looking like this:
    
        {:get-initial-state (fn [this])
         :component-will-receive-props (fn [this new-argv])
         :should-component-update (fn [this old-argv new-argv])
         :component-will-mount (fn [this])
         :component-did-mount (fn [this])
         :component-will-update (fn [this new-argv])
         :component-did-update (fn [this old-argv])
         :component-will-unmount (fn [this])
         :reagent-render (fn [args....])}   ;; or :render (fn [this])
    
      Everything is optional, except either :reagent-render or :render.

    lambdacd 0.14.1
    A library to create a continous delivery pipeline in code.
    reagent.core/create-class (cljs)SourceDoc + Usages
    Create a component, React style. Should be called with a map,
      looking like this:
    
        {:get-initial-state (fn [this])
         :component-will-receive-props (fn [this new-argv])
         :should-component-update (fn [this old-argv new-argv])
         :component-will-mount (fn [this])
         :component-did-mount (fn [this])
         :component-will-update (fn [this new-argv])
         :component-did-update (fn [this old-argv])
         :component-will-unmount (fn [this])
         :reagent-render (fn [args....])}   ;; or :render (fn [this])
    
      Everything is optional, except either :reagent-render or :render.

    lambdacd 0.14.1
    A library to create a continous delivery pipeline in code.
    reagent.core/create-class (cljs)SourceDoc + Usages
    Create a component, React style. Should be called with a map,
      looking like this:
    
        {:get-initial-state (fn [this])
         :component-will-receive-props (fn [this new-argv])
         :should-component-update (fn [this old-argv new-argv])
         :component-will-mount (fn [this])
         :component-did-mount (fn [this])
         :component-will-update (fn [this new-argv])
         :component-did-update (fn [this old-argv])
         :component-will-unmount (fn [this])
         :reagent-render (fn [args....])}   ;; or :render (fn [this])
    
      Everything is optional, except either :reagent-render or :render.

    trace 0.1.22
    Tracing and developer tools for re-frame apps
    mranderson047.reagent.v0v7v0.reagent.core/create-class (cljs)SourceDoc + Usages
    Create a component, React style. Should be called with a map,
      looking like this:
    
        {:get-initial-state (fn [this])
         :component-will-receive-props (fn [this new-argv])
         :should-component-update (fn [this old-argv new-argv])
         :component-will-mount (fn [this])
         :component-did-mount (fn [this])
         :component-will-update (fn [this new-argv])
         :component-did-update (fn [this old-argv])
         :component-will-unmount (fn [this])
         :reagent-render (fn [args....])}   ;; or :render (fn [this])
    
      Everything is optional, except either :reagent-render or :render.

    reagent-patched 0.8.0-alpha1
    A simple ClojureScript interface to React
    reagent.core/create-class (cljs)SourceDoc + Usages
    Create a component, React style. Should be called with a map,
      looking like this:
    
        {:get-initial-state (fn [this])
         :component-will-receive-props (fn [this new-argv])
         :should-component-update (fn [this old-argv new-argv])
         :component-will-mount (fn [this])
         :component-did-mount (fn [this])
         :component-will-update (fn [this new-argv])
         :component-did-update (fn [this old-argv])
         :component-will-unmount (fn [this])
         :reagent-render (fn [args....])}   ;; or :render (fn [this])
    
      Everything is optional, except either :reagent-render or :render.

    iron 0.4.0
    Front-end utilities and support for ClojureScript and re-frame projects
    reagent.core/create-class (cljs)SourceDoc + Usages
    Create a component, React style. Should be called with a map,
      looking like this:
    
        {:get-initial-state (fn [this])
         :component-will-receive-props (fn [this new-argv])
         :should-component-update (fn [this old-argv new-argv])
         :component-will-mount (fn [this])
         :component-did-mount (fn [this])
         :component-will-update (fn [this new-argv])
         :component-did-update (fn [this old-argv])
         :component-will-unmount (fn [this])
         :reagent-render (fn [args....])}   ;; or :render (fn [this])
    
      Everything is optional, except either :reagent-render or :render.

    reagent-slider 0.1.2
    Reagent wrapper around react-components/slider
    reagent.core/create-class (cljs)SourceDoc + Usages
    Create a component, React style. Should be called with a map,
      looking like this:
    
        {:get-initial-state (fn [this])
         :component-will-receive-props (fn [this new-argv])
         :should-component-update (fn [this old-argv new-argv])
         :component-will-mount (fn [this])
         :component-did-mount (fn [this])
         :component-will-update (fn [this new-argv])
         :component-did-update (fn [this old-argv])
         :component-will-unmount (fn [this])
         :reagent-render (fn [args....])}   ;; or :render (fn [this])
    
      Everything is optional, except either :reagent-render or :render.

    Create a component, React style. Should be called with a map,
      looking like this:
    
        {:get-initial-state (fn [this])
         :component-will-receive-props (fn [this new-argv])
         :should-component-update (fn [this old-argv new-argv])
         :component-will-mount (fn [this])
         :component-did-mount (fn [this])
         :component-will-update (fn [this new-argv])
         :component-did-update (fn [this old-argv])
         :component-will-unmount (fn [this])
         :reagent-render (fn [args....])}   ;; or :render (fn [this])
    
      Everything is optional, except either :reagent-render or :render.

    budb 0.0.1
    A CRDT Database for Clojure(script)
    reagent.core/create-class (cljs)SourceDoc + Usages
    Create a component, React style. Should be called with a map,
      looking like this:
    
        {:get-initial-state (fn [this])
         :component-will-receive-props (fn [this new-argv])
         :should-component-update (fn [this old-argv new-argv])
         :component-will-mount (fn [this])
         :component-did-mount (fn [this])
         :component-will-update (fn [this new-argv])
         :component-did-update (fn [this old-argv])
         :component-will-unmount (fn [this])
         :reagent-render (fn [args....])}   ;; or :render (fn [this])
    
      Everything is optional, except either :reagent-render or :render.

    budb 0.0.1
    A CRDT Database for Clojure(script)
    reagent.core/create-class (cljs)SourceDoc + Usages
    Create a component, React style. Should be called with a map,
      looking like this:
    
        {:get-initial-state (fn [this])
         :component-will-receive-props (fn [this new-argv])
         :should-component-update (fn [this old-argv new-argv])
         :component-will-mount (fn [this])
         :component-did-mount (fn [this])
         :component-will-update (fn [this new-argv])
         :component-did-update (fn [this old-argv])
         :component-will-unmount (fn [this])
         :reagent-render (fn [args....])}   ;; or :render (fn [this])
    
      Everything is optional, except either :reagent-render or :render.

    re-frame-ipfs-fx 0.0.2
    IPFS Re-Frame handlers.
    reagent.core/create-class (cljs)SourceDoc + Usages
    Create a component, React style. Should be called with a map,
      looking like this:
    
        {:get-initial-state (fn [this])
         :component-will-receive-props (fn [this new-argv])
         :should-component-update (fn [this old-argv new-argv])
         :component-will-mount (fn [this])
         :component-did-mount (fn [this])
         :component-will-update (fn [this new-argv])
         :component-did-update (fn [this old-argv])
         :component-will-unmount (fn [this])
         :reagent-render (fn [args....])}   ;; or :render (fn [this])
    
      Everything is optional, except either :reagent-render or :render.

    live-components 1.2.0
    Don't duplicate server state on the client and get realtime collaboration for free
    reagent.core/create-class (cljs)SourceDoc + Usages
    Create a component, React style. Should be called with a map,
      looking like this:
    
        {:get-initial-state (fn [this])
         :component-will-receive-props (fn [this new-argv])
         :should-component-update (fn [this old-argv new-argv])
         :component-will-mount (fn [this])
         :component-did-mount (fn [this])
         :component-will-update (fn [this new-argv])
         :component-did-update (fn [this old-argv])
         :component-will-unmount (fn [this])
         :reagent-render (fn [args....])}   ;; or :render (fn [this])
    
      Everything is optional, except either :reagent-render or :render.

    aramis 0.1.1
    A library providing a Promise.all()-like capabilities for re-frame.
    reagent.core/create-class (cljs)SourceDoc + Usages
    Create a component, React style. Should be called with a map,
      looking like this:
    
        {:get-initial-state (fn [this])
         :component-will-receive-props (fn [this new-argv])
         :should-component-update (fn [this old-argv new-argv])
         :component-will-mount (fn [this])
         :component-did-mount (fn [this])
         :component-will-update (fn [this new-argv])
         :component-did-update (fn [this old-argv])
         :component-will-unmount (fn [this])
         :reagent-render (fn [args....])}   ;; or :render (fn [this])
    
      Everything is optional, except either :reagent-render or :render.

    vee 0.2.4
    Native Mobile Tooling for Clojure
    reagent.core/create-class (cljs)SourceDoc + Usages
    Create a component, React style. Should be called with a map,
    looking like this:
    {:get-initial-state (fn [this])
    :component-will-receive-props (fn [this new-argv])
    :should-component-update (fn [this old-argv new-argv])
    :component-will-mount (fn [this])
    :component-did-mount (fn [this])
    :component-will-update (fn [this new-argv])
    :component-did-update (fn [this old-argv])
    :component-will-unmount (fn [this])
    :reagent-render (fn [args....])   ;; or :render (fn [this])
    }
    
    Everything is optional, except either :reagent-render or :render.
    

    ventas 0.0.6
    The Ventas eCommerce platform
    reagent.core/create-class (cljs)SourceDoc + Usages
    Create a component, React style. Should be called with a map,
      looking like this:
    
        {:get-initial-state (fn [this])
         :component-will-receive-props (fn [this new-argv])
         :should-component-update (fn [this old-argv new-argv])
         :component-will-mount (fn [this])
         :component-did-mount (fn [this])
         :component-will-update (fn [this new-argv])
         :component-did-update (fn [this old-argv])
         :component-will-unmount (fn [this])
         :reagent-render (fn [args....])}   ;; or :render (fn [this])
    
      Everything is optional, except either :reagent-render or :render.

    ventas 0.0.6
    The Ventas eCommerce platform
    reagent.core/create-class (cljs)SourceDoc + Usages
    Create a component, React style. Should be called with a map,
      looking like this:
    
        {:get-initial-state (fn [this])
         :component-will-receive-props (fn [this new-argv])
         :should-component-update (fn [this old-argv new-argv])
         :component-will-mount (fn [this])
         :component-did-mount (fn [this])
         :component-will-update (fn [this new-argv])
         :component-did-update (fn [this old-argv])
         :component-will-unmount (fn [this])
         :reagent-render (fn [args....])}   ;; or :render (fn [this])
    
      Everything is optional, except either :reagent-render or :render.

    skm-ice-gui 1.0.0
    GUI library developed by the ICE project within the danish ministry of taxation
    reagent.core/create-class (cljs)SourceDoc + Usages
    Create a component, React style. Should be called with a map,
      looking like this:
    
        {:get-initial-state (fn [this])
         :component-will-receive-props (fn [this new-argv])
         :should-component-update (fn [this old-argv new-argv])
         :component-will-mount (fn [this])
         :component-did-mount (fn [this])
         :component-will-update (fn [this new-argv])
         :component-did-update (fn [this old-argv])
         :component-will-unmount (fn [this])
         :reagent-render (fn [args....])}   ;; or :render (fn [this])
    
      Everything is optional, except either :reagent-render or :render.

    rejax 0.1.0
    A library that creates nicer API for usage of cljs-ajax in Re-frame
    reagent.core/create-class (cljs)SourceDoc + Usages
    Create a component, React style. Should be called with a map,
      looking like this:
    
        {:get-initial-state (fn [this])
         :component-will-receive-props (fn [this new-argv])
         :should-component-update (fn [this old-argv new-argv])
         :component-will-mount (fn [this])
         :component-did-mount (fn [this])
         :component-will-update (fn [this new-argv])
         :component-did-update (fn [this old-argv])
         :component-will-unmount (fn [this])
         :reagent-render (fn [args....])}   ;; or :render (fn [this])
    
      Everything is optional, except either :reagent-render or :render.

    reepl 1.0.1
    A configurable in-browser clojurescript REPL
    reagent.core/create-class (cljs)SourceDoc + Usages
    Create a component, React style. Should be called with a map,
    looking like this:
    {:get-initial-state (fn [this])
    :component-will-receive-props (fn [this new-argv])
    :should-component-update (fn [this old-argv new-argv])
    :component-will-mount (fn [this])
    :component-did-mount (fn [this])
    :component-will-update (fn [this new-argv])
    :component-did-update (fn [this old-argv])
    :component-will-unmount (fn [this])
    :reagent-render (fn [args....])   ;; or :render (fn [this])
    }
    
    Everything is optional, except either :reagent-render or :render.
    

    react-bootstrap-wrapper 0.1.1
    A wrapper of react-bootstrap for reagent
    reagent.core/create-class (cljs)SourceDoc + Usages
    Create a component, React style. Should be called with a map,
      looking like this:
    
        {:get-initial-state (fn [this])
         :component-will-receive-props (fn [this new-argv])
         :should-component-update (fn [this old-argv new-argv])
         :component-will-mount (fn [this])
         :component-did-mount (fn [this])
         :component-will-update (fn [this new-argv])
         :component-did-update (fn [this old-argv])
         :component-will-unmount (fn [this])
         :reagent-render (fn [args....])}   ;; or :render (fn [this])
    
      Everything is optional, except either :reagent-render or :render.

    gyptis 0.2.2
    A library for generating and viewing vega.js plots
    reagent.core/create-class (cljs)SourceDoc + Usages
    Create a component, React style. Should be called with a map,
    looking like this:
    {:get-initial-state (fn [this])
    :component-will-receive-props (fn [this new-argv])
    :should-component-update (fn [this old-argv new-argv])
    :component-will-mount (fn [this])
    :component-did-mount (fn [this])
    :component-will-update (fn [this new-argv])
    :component-did-update (fn [this old-argv])
    :component-will-unmount (fn [this])
    :reagent-render (fn [args....])   ;; or :render (fn [this])
    }
    
    Everything is optional, except either :reagent-render or :render.
    

    Create a component, React style. Should be called with a map,
      looking like this:
    
        {:get-initial-state (fn [this])
         :component-will-receive-props (fn [this new-argv])
         :should-component-update (fn [this old-argv new-argv])
         :component-will-mount (fn [this])
         :component-did-mount (fn [this])
         :component-will-update (fn [this new-argv])
         :component-did-update (fn [this old-argv])
         :component-will-unmount (fn [this])
         :reagent-render (fn [args....])}   ;; or :render (fn [this])
    
      Everything is optional, except either :reagent-render or :render.

    Create a component, React style. Should be called with a map,
      looking like this:
    
        {:get-initial-state (fn [this])
         :component-will-receive-props (fn [this new-argv])
         :should-component-update (fn [this old-argv new-argv])
         :component-will-mount (fn [this])
         :component-did-mount (fn [this])
         :component-will-update (fn [this new-argv])
         :component-did-update (fn [this old-argv])
         :component-will-unmount (fn [this])
         :reagent-render (fn [args....])}   ;; or :render (fn [this])
    
      Everything is optional, except either :reagent-render or :render.

    reagent-quill 0.1.1
    Reagent wrapper around react-quill
    reagent.core/create-class (cljs)SourceDoc + Usages
    Create a component, React style. Should be called with a map,
      looking like this:
    
        {:get-initial-state (fn [this])
         :component-will-receive-props (fn [this new-argv])
         :should-component-update (fn [this old-argv new-argv])
         :component-will-mount (fn [this])
         :component-did-mount (fn [this])
         :component-will-update (fn [this new-argv])
         :component-did-update (fn [this old-argv])
         :component-will-unmount (fn [this])
         :reagent-render (fn [args....])}   ;; or :render (fn [this])
    
      Everything is optional, except either :reagent-render or :render.

    district0x 0.1.20
    district0x Frontend Library
    reagent.core/create-class (cljs)SourceDoc + Usages
    Create a component, React style. Should be called with a map,
      looking like this:
    
        {:get-initial-state (fn [this])
         :component-will-receive-props (fn [this new-argv])
         :should-component-update (fn [this old-argv new-argv])
         :component-will-mount (fn [this])
         :component-did-mount (fn [this])
         :component-will-update (fn [this new-argv])
         :component-did-update (fn [this old-argv])
         :component-will-unmount (fn [this])
         :reagent-render (fn [args....])}   ;; or :render (fn [this])
    
      Everything is optional, except either :reagent-render or :render.

    pine 0.1.6
    A Clojure/ClojureScript router designed for universal applications.
    reagent.core/create-class (cljs)SourceDoc + Usages
    Create a component, React style. Should be called with a map,
      looking like this:
    
        {:get-initial-state (fn [this])
         :component-will-receive-props (fn [this new-argv])
         :should-component-update (fn [this old-argv new-argv])
         :component-will-mount (fn [this])
         :component-did-mount (fn [this])
         :component-will-update (fn [this new-argv])
         :component-did-update (fn [this old-argv])
         :component-will-unmount (fn [this])
         :reagent-render (fn [args....])}   ;; or :render (fn [this])
    
      Everything is optional, except either :reagent-render or :render.

    rui 0.3.0
    UI components based on Reagent and Re-frame
    reagent.core/create-class (cljs)SourceDoc + Usages
    Create a component, React style. Should be called with a map,
      looking like this:
    
        {:get-initial-state (fn [this])
         :component-will-receive-props (fn [this new-argv])
         :should-component-update (fn [this old-argv new-argv])
         :component-will-mount (fn [this])
         :component-did-mount (fn [this])
         :component-will-update (fn [this new-argv])
         :component-did-update (fn [this old-argv])
         :component-will-unmount (fn [this])
         :reagent-render (fn [args....])}   ;; or :render (fn [this])
    
      Everything is optional, except either :reagent-render or :render.

    rui 0.3.0
    UI components based on Reagent and Re-frame
    reagent.core/create-class (cljs)SourceDoc + Usages
    Create a component, React style. Should be called with a map,
      looking like this:
    
        {:get-initial-state (fn [this])
         :component-will-receive-props (fn [this new-argv])
         :should-component-update (fn [this old-argv new-argv])
         :component-will-mount (fn [this])
         :component-did-mount (fn [this])
         :component-will-update (fn [this new-argv])
         :component-did-update (fn [this old-argv])
         :component-will-unmount (fn [this])
         :reagent-render (fn [args....])}   ;; or :render (fn [this])
    
      Everything is optional, except either :reagent-render or :render.

    skm-ice-stateviewer 1.0.0
    Clojurescript library developed by the ICE project within the danish ministry of
    reagent.core/create-class (cljs)SourceDoc + Usages
    Create a component, React style. Should be called with a map,
      looking like this:
    
        {:get-initial-state (fn [this])
         :component-will-receive-props (fn [this new-argv])
         :should-component-update (fn [this old-argv new-argv])
         :component-will-mount (fn [this])
         :component-did-mount (fn [this])
         :component-will-update (fn [this new-argv])
         :component-did-update (fn [this old-argv])
         :component-will-unmount (fn [this])
         :reagent-render (fn [args....])}   ;; or :render (fn [this])
    
      Everything is optional, except either :reagent-render or :render.

    editable 0.1.4
    lifecycle events for forms using re-frame
    reagent.core/create-class (cljs)SourceDoc + Usages
    Create a component, React style. Should be called with a map,
      looking like this:
    
        {:get-initial-state (fn [this])
         :component-will-receive-props (fn [this new-argv])
         :should-component-update (fn [this old-argv new-argv])
         :component-will-mount (fn [this])
         :component-did-mount (fn [this])
         :component-will-update (fn [this new-argv])
         :component-did-update (fn [this old-argv])
         :component-will-unmount (fn [this])
         :reagent-render (fn [args....])}   ;; or :render (fn [this])
    
      Everything is optional, except either :reagent-render or :render.

    re-frame-utils 0.1.0
    Fxs and CoFxs for re-frame
    reagent.core/create-class (cljs)SourceDoc + Usages
    Create a component, React style. Should be called with a map,
      looking like this:
    
        {:get-initial-state (fn [this])
         :component-will-receive-props (fn [this new-argv])
         :should-component-update (fn [this old-argv new-argv])
         :component-will-mount (fn [this])
         :component-did-mount (fn [this])
         :component-will-update (fn [this new-argv])
         :component-did-update (fn [this old-argv])
         :component-will-unmount (fn [this])
         :reagent-render (fn [args....])}   ;; or :render (fn [this])
    
      Everything is optional, except either :reagent-render or :render.

    hara.reflect 2.8.6
    patterns and utilities
    hara.reflect.pretty.display/merge-terms-fnSourceDoc + Usages
    creates a function that returns the first element of the list
     
       (-> (query/query-class (type []) ["create"])
           ((display/merge-terms-fn {:merge true})))
       ;;=> #[create :: ([java.util.List]), ([clojure.lang.ISeq]),
       ;;               ([clojure.lang.IReduceInit]), ([java.lang.Object[]]),
       ;;               ([java.lang.Iterable])]
       

    clj-momo 0.2.23
    Library code produced by the Cisco ThreatGrid team for building swagger backed API
    clj-momo.test-helpers.http/with-port-fnSourceDoc + Usages
    Helper to compose a fn that knows how to lookup an HTTP port with
      an HTTP method fn (from above)
      Example:
        (def post (http/with-port-fn get-http-port http/post))

    finds elegible candidates based upon argument list
     
       (-> (query/query-class clojure.lang.PersistentVector ["create" :#])
           (get-in [:lookup :method 1])
           (multi/elegible-candidates [java.util.List]))
       ;;=> (#[create :: (java.util.List) -> clojure.lang.PersistentVector]
       ;;    #[create :: (java.lang.Iterable) -> clojure.lang.PersistentVector])
       

    clojure-hbase 0.92.4
    A convenient Clojure interface to HBase.
    clojure-hbase.core/querySourceDoc + Usages
    Performs the given query actions (Get/Scan) on the given HTable. The return
       value will be a sequence of equal length, with each slot containing the
       results of the query in the corresponding position.
    
       DEPRECATED: Use 'execute' instead.

    ring-sse-middleware 0.1.2
    Ring middleware to emit Server-sent Events
    ring-sse-middleware.core/query-token-matchSourceDoc + Usages
    Given a query string token and a Ring request map, check whether the HTTP method is GET and whether the request
      contains the specified query string token. Return the request if there is a match, nil otherwise.

    monte.server 0.0.1
    monte.server is a server with monte library wrapped
    reagent.core/create-class (cljs)SourceDoc + Usages
    Create a component, React style. Should be called with a map,
    looking like this:
    {:get-initial-state (fn [this])
    :component-will-receive-props (fn [this new-argv])
    :should-component-update (fn [this old-argv new-argv])
    :component-will-mount (fn [this])
    :component-did-mount (fn [this])
    :component-will-update (fn [this new-argv])
    :component-did-update (fn [this old-argv])
    :component-will-unmount (fn [this])
    :render (fn [this])}
    
    Everything is optional, except :render.
    

    qualityclj 0.2.3
    Assess Clojure libraries based on a number of different metrics.
    reagent.core/create-class (cljs)SourceDoc + Usages
    Create a component, React style. Should be called with a map,
    looking like this:
    {:get-initial-state (fn [this])
    :component-will-receive-props (fn [this new-argv])
    :should-component-update (fn [this old-argv new-argv])
    :component-will-mount (fn [this])
    :component-did-mount (fn [this])
    :component-will-update (fn [this new-argv])
    :component-did-update (fn [this old-argv])
    :component-will-unmount (fn [this])
    :render (fn [this])}
    
    Everything is optional, except :render.
    

    lein-browserific 0.1.2-alpha4
    A Leiningen build tool for unified app development
    reagent.core/create-class (cljs)SourceDoc + Usages
    Create a component, React style. Should be called with a map,
    looking like this:
    {:get-initial-state (fn [this])
    :component-will-receive-props (fn [this new-argv])
    :should-component-update (fn [this old-argv new-argv])
    :component-will-mount (fn [this])
    :component-did-mount (fn [this])
    :component-will-update (fn [this new-argv])
    :component-did-update (fn [this old-argv])
    :component-will-unmount (fn [this])
    :render (fn [this])}
    
    Everything is optional, except :render.
    

    clj-rpc 0.3.5
    simple rpc using clojure
    clj-rpc.helper/start-serverSourceDoc + Usages
    start test server, given a cookie-key
       and a fn-get-context function (optional)

    views 2.0.1
    A view to the past helps navigate the future.
    views.core/view-namespaceSourceDoc + Usages
    Get the namespace, either out of the view signature first, or if missing via the namespace-fn.

    friend-jaas 0.1.1
    Helps Chas Emerick's Friend library to use JAAS.
    friend-jaas/jaas-credential-fnSourceDoc + Usages
    A JAAS-using credentials function that is intended to be used 
       with `cemerick.friend/authenticate` or individual authentication workflows.
    
       Example use:
    
         (let [get-roles-fn (fn [username] #{::user})
               jaas-credential-fn* (partial jaas-credential-fn name-of-a-jaas-login-ctx get-roles-fn) ;; 
               auth-config {:workflows [(interactive-form :credential-fn jaas-credential-fn*)]}]
           (authenticate ring-handler-to-be-secured auth-config))
    
       ...where:
    
         get-roles-fn outputs a (possibly empty) collection of roles when given a username
    
         name-of-a-jaas-login-ctx is a string that is the name of a JAAS login.conf entry
           that, in this case (because of the use of interactive-form), supports username&password credentials

    hara.coerce.map 2.1.1
    General purpose utilities library
    hara.coerce.map/get-inSourceDoc + Usages
    get-in

    hara.coerce.map 2.1.1
    General purpose utilities library
    hara.coerce.map/getSourceDoc + Usages
    get

    matrix-client-server-api r0.3.0
    Client library of matrix-client-server-api
    matrix-client-server-api.api.user-data/get-display-nameSourceDoc + Usages
    Get the user's display name.
      Get the user's display name. This API may be used to fetch the user's
    own displayname or to query the name of other users; either locally or
    on remote homeservers.

    matrix-client-server-api r0.3.0
    Client library of matrix-client-server-api
    matrix-client-server-api.api.user-data/get-display-name-with-http-infoSourceDoc + Usages
    Get the user's display name.
      Get the user's display name. This API may be used to fetch the user's
    own displayname or to query the name of other users; either locally or
    on remote homeservers.

    matrix-client-server-api r0.3.0
    Client library of matrix-client-server-api
    matrix-client-server-api.api.user-data/get-avatar-urlSourceDoc + Usages
    Get the user's avatar URL.
      Get the user's avatar URL. This API may be used to fetch the user's
    own avatar URL or to query the URL of other users; either locally or
    on remote homeservers.

    matrix-client-server-api r0.3.0
    Client library of matrix-client-server-api
    matrix-client-server-api.api.user-data/get-avatar-url-with-http-infoSourceDoc + Usages
    Get the user's avatar URL.
      Get the user's avatar URL. This API may be used to fetch the user's
    own avatar URL or to query the URL of other users; either locally or
    on remote homeservers.

    geom 1.0.0-RC3
    thi.ng geometry kit - meta project spec including all modules
    thi.ng.geom.spatialtree/select-withSourceDoc + Usages
    Produces a vector of points in the tree within a given region.
      Uses two predicate fns to logically define the query region:
    
      `isec?`  : single-arg fn to check if the bounds of a tree node
      intersect the query region
      `inside?`: single-arg fn to check if a point lies within the region.

    geom-types 0.0.908
    thi.ng geometry kit - types module
    thi.ng.geom.spatialtree/select-withSourceDoc + Usages
    Produces a vector of points in the tree within a given region.
      Uses two predicate fns to logically define the query region:
    
      `isec?`  : single-arg fn to check if the bounds of a tree node
      intersect the query region
      `inside?`: single-arg fn to check if a point lies within the region.

    gardendb 0.2.0
    GardenDB is an embedded, file-backed document store specifically for Clojure, influenced
    gardendb.util/query-map-listSourceDoc + Usages
    Query a map with a query map (optional). Returns a list or vector of matching documents.
       argument map m: {:where [(fn [x] (true)) (fn [x] (false))] (optional; if no :where, return all)
                        :where-predictate :and|:or (optional; defaults to :and)
                        :order-by :first-level-map-key-only (optional)}

    hara.extend.abstract 2.8.6
    patterns and utilities
    hara.extend.abstract/protocol-basisSourceDoc + Usages
    Helper function that transforms the functions in the protocol to
       the neccessary format in preparation for extend-abstract and extend-implementations
     
       (defprotocol IVal
         (-set [this val])
         (-get [this]))
     
       (protocol-basis IVal '- 'pre- '-tail)
       => (contains '({:args [this], :fn pre-get-tail, :name -get}
                      {:args [this val], :fn pre-set-tail, :name -set})
                    :in-any-order)

    bounce.mux 0.0.1-alpha2
    A CLJS router for Bounce systems, based on Bidi
    bounce.mux/make-router (cljs)SourceDoc + Usages
    Makes a Router Bounce component - to be passed to the other
      functions in this namespace.
    
      When the browser history changes, the following happens:
    
      1. The token mapper is asked to translate the token to a new
      location (i.e. handler, route-params and query-params)
    
      2. The current page's unmount-fn is called (most of these check
      'same-handler?' to see whether they _actually_ need to unmount)
    
      3. We get the new page fn out of the pages map, and call
      it. (Likewise, it checks 'same-handler?' to see what it needs to
      mount.) It returns a Page (pair of 'page value' and unmount-fn) by
      calling mux/->page.
    
      4. 'listener' is called with the new location and the page value.
    
      Parameters:
    
      token-mapper :: bounce.mux.protocols/TokenMapper (see bounce.mux.bidi for an example implementation)
      listener :: ({:keys [location page]} -> ())
      default-location :: location
      pages :: {handler-key -> ({:keys [old-location new-location same-handler?]} -> Page)}
    
      Usage:
    
      (require '[bounce.core :as bc]
               '[bounce.mux :as mux]
               '[bounce.mux.bidi :as mux.bidi]
               '[reagent.core :as r])
    
      (defn make-system-map []
        {:!app (fn []
                 (bc/->component (r/atom {})))
    
         :router (-> (fn []
                       (mux/make-router {:token-mapper (mux.bidi/token-mapper ["" {"/" ::home-page
                                                                                   ...}])
                                         :listener (fn [{:keys [location page]}]
                                                     (reset! (r/cursor (bc/ask :!app) [:location]) location)
                                                     (reset! (r/cursor (bc/ask :!app) [::root-component]) page))
    
                                         :default-location {:handler ::home-page}
    
                                         :pages {::home-page (fn [{:keys [old-location new-location same-handler?]}]
                                                               (when-not same-handler?
                                                                 ;; mount!
                                                                 )
    
                                                               (mux/->page (fn []
                                                                             [home-page-view])
    
                                                                           (fn [{:keys [old-location new-location same-handler?]}]
                                                                             (when-not same-handler?
                                                                               ;; unmount!
                                                                               ))))
    
                                                 ...}}))
                     (bc/using #{:!app}))
    
         ...})
    
      

    Arms an input (text) with autocomplete behavior.
    
      callbacks/options:
      :on-search - a fn that takes one parameter, the query or current text of the input.  This fn typically performs
        a search pased on the query and loads a dropdown (see show-dropdown), but it doesn't have to.
      :on-select - a fn that take a dropdown payload ([<display name> <value>]) and is called when a dropdown item
        is selected.
      :throttle - number of millisecond.  Searches will not take place more frequently then the specified period.
        By default, every change will trigger a search.
      :smallest-query-length - minimum size of query term to issue a search query.  Default 1

    clj-safejdbc 0.2.8
    A fast library for accessing JDBC in Clojure
    clj-safejdbc.core/query-single-valueSourceDoc + Usages
    Returns a fn that (when called with a Connection) executes the
       sql query and returns a single value as a result.
       Examples:
       (query-single-value "SELECT count(*) FROM Customers")
       (query-single-value ["SELECT count(*) FROM Customers WHERE Name=?" 
                           "Jan"])

    clj-safejdbc 0.2.8
    A fast library for accessing JDBC in Clojure
    clj-safejdbc.core/query-firstSourceDoc + Usages
    Returns a fn that (when called with a Connection) executes the
       sql query and returns just the first row as a result.
       Examples:
       (query-first "SELECT * FROM Customers WHERE Id=42")
       (query-first ["SELECT * FROM Customers WHERE Name=? AND Age=?" "Jan" 37])

    fulcro 2.5.9
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    fulcro.client.impl.data-fetch/inject-query-paramsSourceDoc + Usages
    Inject parameters into elements of the top-level query.
    
      `params` is a map from keyword (on the query in the AST) to parameter maps. So, given the AST for this query:
    
      ```
      [:a :b :c]
      ```
    
      and a `params` of `{:a {:x 1} :c {:y 2}}` you'll get an AST representing:
    
      ```
      [(:a {:x 1}) :b (:c {:y 2})]
      ```
      

    untangled 1.0.0-beta1
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    untangled.client.impl.data-fetch/inject-query-paramsSourceDoc + Usages
    Inject parameters into elements of the top-level query.
    
      `params` is a map from keyword (on the query in the AST) to parameter maps. So, given the AST for this query:
    
      ```
      [:a :b :c]
      ```
    
      and a `params` of `{:a {:x 1} :c {:y 2}}` you'll get an AST representing:
    
      ```
      [(:a {:x 1}) :b (:c {:y 2})]
      ```
      

    zesql 0.1.3-beta1
    SQL library based on Yesql and Selmer
    zesql.core/defqueriesSourceDoc + Usages
    Defines several query functions, as defined in the given SQL file.
      Each query in the file must begin with a `-- name: <function-name>` marker,
      followed by optional comment lines (which form the docstring), followed by
      the query itself.
    
      options
        :connection - db-spec described in clojure.java.jdbc/get-connection, (delay db-spec) can also.

    untangled-client 0.8.2
    Client-side code for Untangled Webapps
    untangled.client.impl.data-fetch/inject-query-paramsSourceDoc + Usages
    Inject parameters into elements of the top-level query.
    
      `params` is a map from keyword (on the query in the AST) to parameter maps. So, given the AST for this query:
    
      ```
      [:a :b :c]
      ```
    
      and a `params` of `{:a {:x 1} :c {:y 2}}` you'll get an AST representing:
    
      ```
      [(:a {:x 1}) :b (:c {:y 2})]
      ```
      

    matrix-client-server-api r0.3.0
    Client library of matrix-client-server-api
    matrix-client-server-api.api.room-participation/get-room-eventsSourceDoc + Usages
    Get a list of events for this room
      This API returns a list of message and state events for a room. It uses
    pagination query parameters to paginate history in the room.

    matrix-client-server-api r0.3.0
    Client library of matrix-client-server-api
    matrix-client-server-api.api.room-participation/get-room-events-with-http-infoSourceDoc + Usages
    Get a list of events for this room
      This API returns a list of message and state events for a room. It uses
    pagination query parameters to paginate history in the room.

    metabase 0.1.0
    Metabase Community Edition
    metabase.util.stats/execution-metricsSourceDoc + Usages
    Get metrics based on executions.
      This should be done in a single pass, as there might
      be a LOT of query executions in a normal instance
      TODO: characterize by ad hoc vs cards

    shopify 0.1.1
    A library for interacting with the Shopify platform.
    shopify.resources.client/wrap-generic-params-keySourceDoc + Usages
    Middleware which renames `:params` to `:query-params` when method is GET, HEAD, or DELETE. For other methods, `:params` becomes `:form-params`.

    When no caching is involved this will get both the role and permission names in
       one sql query, potentially useful for authorization off of roles and permissions.

    clj-webdriver 0.7.2
    Clojure API for Selenium-WebDriver
    clj-webdriver.taxi/set-finder!SourceDoc + Usages
    Set a default finder function, which will be used with all `q` parameters in functions that require an Element.
    
       Examples:
       =========
    
       ;;
       ;; Simple example
       ;;
       (set-finder! xpath-finder)
    
       ;;
       ;; Derivative finder function
       ;;
       ;; Takes the query string and always prepends "div#container ", which would be
       ;; useful in situations where you know you're always inside that particular div.
       ;; (Note that this same functionality is provided by `find-element-under`, but
       ;; you get the idea.)
       ;;
       (set-finder! (fn [q]
                      (if (element-like? q)
                        q
                        (css-finder (str "div#container " q)))))
    
       ;;
       ;; Custom finder function
       ;;
       ;; If you want to easily switch between using CSS and XPath (e.g., because
       ;; XPath has the text() function for which no CSS equivalent exists), then
       ;; you could write something like this, where `q` would become either the map
       ;; {:css "query"} or {:xpath "query"} instead of just a string.
       ;;
       (set-finder! (fn [q]
                      (if (element-like? q)
                        q
                        (case (first (keys q))
                          :css   (core/find-elements-by *driver* (by-css (first (values q))))
                          :xpath (core/find-elements-by *driver* (by-xpath (first (values q))))))))
    
       ;;
       ;; (Note: This last example is written to show how to use the lowest-level functions
       ;; `find-elements-by`, `by-css` and `by-xpath`. The maps `{:css "query"}` and
       ;; `{:xpath "query"}` are themselves acceptable arguments to the `find-elements`,
       ;; function, so that function could have been used instead without the `case` statement.)
       ;;

    clj-webdriver-vonrosen 0.7.3
    Clojure API for Selenium-WebDriver
    clj-webdriver.taxi/set-finder!SourceDoc + Usages
    Set a default finder function, which will be used with all `q` parameters in functions that require an Element.
    
       Examples:
       =========
    
       ;;
       ;; Simple example
       ;;
       (set-finder! xpath-finder)
    
       ;;
       ;; Derivative finder function
       ;;
       ;; Takes the query string and always prepends "div#container ", which would be
       ;; useful in situations where you know you're always inside that particular div.
       ;; (Note that this same functionality is provided by `find-element-under`, but
       ;; you get the idea.)
       ;;
       (set-finder! (fn [q]
                      (if (element-like? q)
                        q
                        (css-finder (str "div#container " q)))))
    
       ;;
       ;; Custom finder function
       ;;
       ;; If you want to easily switch between using CSS and XPath (e.g., because
       ;; XPath has the text() function for which no CSS equivalent exists), then
       ;; you could write something like this, where `q` would become either the map
       ;; {:css "query"} or {:xpath "query"} instead of just a string.
       ;;
       (set-finder! (fn [q]
                      (if (element-like? q)
                        q
                        (case (first (keys q))
                          :css   (core/find-elements-by *driver* (by-css (first (values q))))
                          :xpath (core/find-elements-by *driver* (by-xpath (first (values q))))))))
    
       ;;
       ;; (Note: This last example is written to show how to use the lowest-level functions
       ;; `find-elements-by`, `by-css` and `by-xpath`. The maps `{:css "query"}` and
       ;; `{:xpath "query"}` are themselves acceptable arguments to the `find-elements`,
       ;; function, so that function could have been used instead without the `case` statement.)
       ;;

    honeysql-phoenix 0.2.1
    Clojure SQL for HBase Phoenix
    phoenix.db/exec-rawSourceDoc + Usages
    Execute raw sql, either in query (select) or update mode. In the query mode,
       options such as :row-fn, :result-fn could be supplied to transform queried
       result, return seq of rows. E.g.:
    
      (exec-raw ["SELECT * FROM user WHERE username = ? LIMIT ?" "jack" 1]
                :db my-db
                :row-fn identity)
    
      While in update mode, return seq of number of rows affected. Phoenix does
      not yet support generated keys in update mode.
    
      See also jdbc/query, jdbc/execute!.
      

    metabase 0.1.0
    Metabase Community Edition
    metabase.driver/process-query-in-contextSourceDoc + Usages
    *OPTIONAL*. Similar to `sync-in-context`, but for running queries rather than syncing. This should be used to do things like open DB connections
         that need to remain open for the duration of post-processing. This function follows a middleware pattern and is injected into the QP
         middleware stack immediately after the Query Expander; in other words, it will receive the expanded query.
         See the Mongo and H2 drivers for examples of how this is intended to be used.
    
           (defn process-query-in-context [driver qp]
             (fn [query]
               (qp query)))

    alumbra 0.2.6
    Simple and Elegant GraphQL for Clojure
    alumbra.core/executorSourceDoc + Usages
    Creates a function that takes a query string, as well as an option map,
       returning the result of running the query.
    
       ```clojure
       (def run-query
         (alumbra.core/executor
           {:schema (io/resource "Schema.gql")
            :query  QueryRoot}))
    
       (run-query "{ person { name } }")
       ;; => {:status :success, :data {"person" {"name" ...}}}
       ```
    
       Allowed options are:
    
       - `:operation-name`: for multi-operation queries, sets the one to execute,
       - `:variables`: a map of variable name strings to their value,
       - `:context`: a context map to-be-merged into the resolution environment.
    
       All [[handler]] options (except `:context-fn`) are suppored.

    modelo 0.1.0
    Relational database abstraction for Clojure
    modelo.core/get*SourceDoc + Usages
    Returns the first entity row that matches the given query args. Any
      related entities selected will be joined in the same database query
      and then nested automatically.
    
      Unlike get, the query will NOT be forced to return one row (i.e., :limit 1)
      so it's up to the caller to prevent excessive result sets from being
      generated.
    
      See build-query for query argument format.

    trapperkeeper-rpc 1.0.0
    RPC server/client library for Trapperkeeper services
    puppetlabs.trapperkeeper.rpc.core/remote-serviceSourceDoc + Usages
    Converts this:
      (remote-service FooService
                      (add [this x y])
                      (divide [this x y] {:retry true :timeout 1000}))
    
      Into a form roughly like this:
      (service
        FooService
        [[:ConfigService get-in-config]]
        (add [this x y] (call-remote-svc-fn (get-in-config [:rpc]) {:svc-id :FooService :fn-name :add :args [x y]}))
        (divide [this x y] (call-remote-svc-fn (get-in-config [:rpc]) {:retry true :timeout 1000 :svc-id :FooService :fn-name :divide :args [x y]})))
      

    refactor-nrepl 2.3.1
    nREPL middleware to support editor-agnostic refactoring
    mranderson047.http-kit.v2v1v19.org.httpkit.client/requestSourceDoc + Usages
    Issues an async HTTP request and returns a promise object to which the value
      of `(callback {:opts _ :status _ :headers _ :body _})` or
         `(callback {:opts _ :error _})` will be delivered.
    
      When unspecified, `callback` is the identity
    
      ;; Asynchronous GET request (returns a promise)
      (request {:url "http://www.cnn.com"})
    
      ;; Asynchronous GET request with callback
      (request {:url "http://www.cnn.com" :method :get}
        (fn [{:keys [opts status body headers error] :as resp}]
          (if error
            (println "Error on" opts)
            (println "Success on" opts))))
    
      ;; Synchronous requests
      @(request ...) or (deref (request ...) timeout-ms timeout-val)
    
      ;; Issue 2 concurrent requests, then wait for results
      (let [resp1 (request ...)
            resp2 (request ...)]
        (println "resp1's status: " (:status @resp1))
        (println "resp2's status: " (:status @resp2)))
    
      Output coercion:
      ;; Return the body as a byte stream
      (request {:url "http://site.com/favicon.ico" :as :stream})
      ;; Coerce as a byte-array
      (request {:url "http://site.com/favicon.ico" :as :byte-array})
      ;; return the body as a string body
      (request {:url "http://site.com/string.txt" :as :text})
      ;; Try to automatically coerce the output based on the content-type header, currently supports :text :stream, (with automatic charset detection)
      (request {:url "http://site.com/string.txt" :as :auto})
    
      Request options:
        :url :method :headers :timeout :query-params :form-params :as
        :client :body :basic-auth :user-agent :filter :worker-pool

    org.curbside.http-kit 2.2.0+sni
    High-performance event-driven HTTP client/server for Clojure
    org.httpkit.client/requestSourceDoc + Usages
    Issues an async HTTP request and returns a promise object to which the value
      of `(callback {:opts _ :status _ :headers _ :body _})` or
         `(callback {:opts _ :error _})` will be delivered.
    
      When unspecified, `callback` is the identity
    
      ;; Asynchronous GET request (returns a promise)
      (request {:url "http://www.cnn.com"})
    
      ;; Asynchronous GET request with callback
      (request {:url "http://www.cnn.com" :method :get}
        (fn [{:keys [opts status body headers error] :as resp}]
          (if error
            (println "Error on" opts)
            (println "Success on" opts))))
    
      ;; Synchronous requests
      @(request ...) or (deref (request ...) timeout-ms timeout-val)
    
      ;; Issue 2 concurrent requests, then wait for results
      (let [resp1 (request ...)
            resp2 (request ...)]
        (println "resp1's status: " (:status @resp1))
        (println "resp2's status: " (:status @resp2)))
    
      Output coercion:
      ;; Return the body as a byte stream
      (request {:url "http://site.com/favicon.ico" :as :stream})
      ;; Coerce as a byte-array
      (request {:url "http://site.com/favicon.ico" :as :byte-array})
      ;; return the body as a string body
      (request {:url "http://site.com/string.txt" :as :text})
      ;; Try to automatically coerce the output based on the content-type header, currently supports :text :stream, (with automatic charset detection)
      (request {:url "http://site.com/string.txt" :as :auto})
    
      Request options:
        :url :method :headers :timeout :query-params :form-params :as
        :client :body :basic-auth :user-agent :filter :worker-pool

    incanter-core 1.9.3
    Incanter-core is the core module of the Incanter project.
    incanter.core/$group-bySourceDoc + Usages
      Returns a map of datasets keyed by a query-map corresponding the group.
    
      Examples:
    
        (use '(incanter core datasets))
        ($group-by :Species (get-dataset :iris))
    
        ($group-by [:hair :eye] (get-dataset :hair-eye-color))
    
        (with-data (get-dataset :hair-eye-color)
          ($group-by [:hair :eye]))
      

    reitit-swagger 0.1.2
    Reitit: Swagger-support
    reitit.swagger/swagger-featureSourceDoc + Usages
    Feature for handling swagger-documentation for routes.
      Works both with Middleware & Interceptors. Does not participate
      in actual request processing, just provides specs for the new
      documentation keys for the route data. Should be accompanied by a
      [[swagger-spec-handler]] to expose the swagger spec.
    
      New route data keys contributing to swagger docs:
    
      | key           | description |
      | --------------|-------------|
      | :swagger      | map of any swagger-data. Must have `:id` (keyword or sequence of keywords) to identify the api
      | :no-doc       | optional boolean to exclude endpoint from api docs
      | :tags         | optional set of strings of keywords tags for an endpoint api docs
      | :summary      | optional short string summary of an endpoint
      | :description  | optional long description of an endpoint. Supports http://spec.commonmark.org/
    
      Also the coercion keys contribute to swagger spec:
    
      | key           | description |
      | --------------|-------------|
      | :parameters   | optional input parameters for a route, in a format defined by the coercion
      | :responses    | optional descriptions of responess, in a format defined by coercion
    
      Example:
    
          ["/api"
           {:swagger {:id :my-api}
            :middleware [reitit.swagger/swagger-feature]}
    
           ["/swagger.json"
            {:get {:no-doc true
                   :swagger {:info {:title "my-api"}}
                   :handler reitit.swagger/swagger-spec-handler}}]
    
           ["/plus"
            {:get {:tags #{:math}
                   :summary "adds numbers together"
                   :description "takes `x` and `y` query-params and adds them together"
                   :parameters {:query {:x int?, :y int?}}
                   :responses {200 {:body {:total pos-int?}}}
                   :handler (fn [{:keys [parameters]}]
                              {:status 200
                               :body (+ (-> parameters :query :x)
                                        (-> parameters :query :y)})}}]]

    systems-toolbox 0.6.36
    Toolbox for building Systems in Clojure
    matthiasn.systems-toolbox.switchboard/wire-all-out-channelsSourceDoc + Usages
    Function for calling the system-ready-fn on each component, which will pipe
       the channel used by the put-fn to the out-chan when the system is connected.
       Otherwise, messages sent before all channels are wired would get lost.

    route-ccrs 3.6.0
    A library for calculating part/routing end dates and CCRs
    route-ccrs.util.schema-dispatch/get-schema-methodSourceDoc + Usages
    Like `get-method` but for multimethods dispatching on schemas.
    
      Returns the dispatch fn, from `mm`, that applies to the schema that
      matches the dispatch value `v`, the default dispatch fn if no schemas
      apply, or `nil` if none apply and there is no default.

    metabase 0.1.0
    Metabase Community Edition
    metabase.api.common.internal/route-fn-nameSourceDoc + Usages
    Generate a symbol suitable for use as the name of an API endpoint fn.
       Name is just METHOD + ROUTE with slashes replaced by underscores.
       `(route-fn-name GET "/:id") -> GET_:id`

    bidi-swagger 0.1.3
    A small Clojure library for creating swagger docs from bidi routes.
    bidi-swagger.core/swag-routesSourceDoc + Usages
    Takes a set of bidi routes and additional documentation and returns swagger API documenttation.
      Docs-fn should be a function (fn [docs handler]) that returns appropriate documentation for a
      handler id. The default implementation is (get docs handler).

    alida 0.1.3
    Crawling, scraping and indexing application.
    alida.scrape/get-links-jsoupSourceDoc + Usages
    Returns a set of absolute URIs for all links in a given html string
       using the provided current-uri as a base. This fn provides less
       control than the get-links-enlive fn, but offers much better
       performance.

    hara.function.dispatch 2.8.6
    patterns and utilities
    hara.function.dispatch/msgSourceDoc + Usages
    Message dispatch for object orientated type calling convention.
     
       (def obj {:a 10
                 :b 20
                 :get-sum (fn [this]
                           (+ (:b this) (:a this)))})
     
       (msg obj :get-sum) => 30

    hara 0.7.1
    Utilities library of Functions and Exploratory Programming
    hara.common/msgSourceDoc + Usages
    Message dispatch for object orientated type calling convention.
    
        (def obj {:a 10
                  :b 20
                  :get-sum (fn [this]
                            (+ (:b this) (:a this)))})
    
        (msg obj :get-sum) ;=> 30
      

    asosio.utils 0.0.4
    The Asosio Utils is a collection of utilities that makes development of clojure
    asosio.utils.timequery/index-querySourceDoc + Usages
    Takes a query, a map of supplied request parameters
      and returns a map containing the query and its arguments.
      If a deletion table query (for tables where resources can
      be deleted) are supplied, the final deletion query and its
      arguments are returned as well.
    
      query        -
      rq-params    - See 'Request Parameters'
      opts         - See 'Options' section.
    
      Request Parameters:
      'before'     -
      'after'      -
      'since'      -
      'limit'      - actual number of requested items - will by limited
                     by index-limit (see 'Options')
    
      Query Types:
      * Refresh Query  - Get entries who have changed since some timestamp
                         (':update-col' determines when the item was last modified)
    
      * Before-Query   - Get entries which are older than some date.
                         (':created-col ' determines entry age)
    
      * After-Query    - Get entries which are newer than some date
                         specified by the 'after' request parameter.
    
      NOTE: All queries except 'after-query' are organised from newest to oldest
            and every query is still subject to 'index' (request parameter) and
            'index-limit' (option).
    
      Options:
      :del-query   - a statement map containing the query to discover
                     deleted entries.
                     (default: nil)
      :index-limit - maximum number of entries to return in one 'page'
                     (default: 10)
      :created-col - name of the column in the queries table, holding
                     the timestamp of the entry's creation.
                     (default: :created_at)
      :updated-col - name of the column in the queried table, holding
                     the timestamp of the last time the entry was modified.
                     (default: :updated_at)
      :deleted-col - name of the column in the table tracking deletions
                     which holds the timestamp of the entry's deletion.
                     (default: deleted_at)
    
      Return:
      a map of queries and their query args (on success) or nil
      if the parameter combination employed aren't supported.
    
      return map keys:
      :query           - the (modified) statement map for fetching entries.
      :query-args      - arguments to be supplied the query.
      :del-query       - the (modified) statement map for fetching
                         records marking deleted entries.
      :del-query-args  - arguments to be supplied the deletion query.

    asosio-utils 0.0.1
    The Asosio Utils is a collection of utilities that makes development of clojure
    asosio_utils.timequery/index-querySourceDoc + Usages
    Takes a query, a map of supplied request parameters
      and returns a map containing the query and its arguments.
      If a deletion table query (for tables where resources can
      be deleted) are supplied, the final deletion query and its
      arguments are returned as well.
    
      query        -
      rq-params    - See 'Request Parameters'
      opts         - See 'Options' section.
    
      Request Parameters:
      'before'     - 
      'after'      - 
      'since'      - 
      'limit'      - actual number of requested items - will by limited
                     by index-limit (see 'Options')
    
      Query Types:
      * Refresh Query  - Get entries who have changed since some timestamp
                         (':update-col' determines when the item was last modified)
    
      * Before-Query   - Get entries which are older than some date.
                         (':created-col ' determines entry age)
    
      * After-Query    - Get entries which are newer than some date
                         specified by the 'after' request parameter.
    
      NOTE: All queries except 'after-query' are organised from newest to oldest
            and every query is still subject to 'index' (request parameter) and
            'index-limit' (option).
    
      Options:
      :del-query   - a statement map containing the query to discover
                     deleted entries.
                     (default: nil)
      :index-limit - maximum number of entries to return in one 'page'
                     (default: 10)
      :created-col - name of the column in the queries table, holding 
                     the timestamp of the entry's creation.
                     (default: :created_at)
      :updated-col - name of the column in the queried table, holding 
                     the timestamp of the last time the entry was modified.
                     (default: :updated_at)
      :deleted-col - name of the column in the table tracking deletions
                     which holds the timestamp of the entry's deletion.
                     (default: deleted_at)
    
      Return: 
      a map of queries and their query args (on success) or nil
      if the parameter combination employed aren't supported.
      
      return map keys:
      :query           - the (modified) statement map for fetching entries.
      :query-args      - arguments to be supplied the query.
      :del-query       - the (modified) statement map for fetching
                         records marking deleted entries.
      :del-query-args  - arguments to be supplied the deletion query.

    compojure-api 2.0.0-alpha20
    Compojure Api
    compojure.api.resource/resourceSourceDoc + Usages
    Creates a nested compojure-api Route from enchanced ring-swagger operations map.
      By default, applies both request- and response-coercion based on those definitions.
    
      Extra keys:
    
      - **:middleware**     Middleware in duct-format either at top-level or under methods.
                            Top-level mw are applied first if route matches, method-level
                            mw are applied next if method matches
    
      - **:coercion**       A function from request->type->coercion-matcher, used
                            in resource coercion for :body, :string and :response.
                            Setting value to `(constantly nil)` disables both request- &
                            response coercion. See tests and wiki for details.
    
      Enchancements to ring-swagger operations map:
    
      1) :parameters use ring request keys (query-params, path-params, ...) instead of
      swagger-params (query, path, ...). This keeps things simple as ring keys are used in
      the handler when destructuring the request.
    
      2) at resource root, one can add any ring-swagger operation definitions, which will be
      available for all operations, using the following rules:
    
        2.1) :parameters are deep-merged into operation :parameters
        2.2) :responses are merged into operation :responses (operation can fully override them)
        2.3) all others (:produces, :consumes, :summary,...) are deep-merged by compojure-api
    
      3) special keys `:handler` and/or `:async-handler` either under operations or at top-level.
      They should be 1-ary and 3-ary Ring handler functions, respectively, that are responsible
      for the actual request processing. Handler lookup order is the following:
    
        3.1) If called asynchronously, operations-level :async-handler
        3.2) Operations-level :handler
        3.3) If called asynchronously, top-level :async-handler
        3.4) Top-level :handler
    
      4) request-coercion is applied once, using deep-merged parameters for a given
      operation or resource-level if only resource-level handler is defined.
    
      5) response-coercion is applied once, using merged responses for a given
      operation or resource-level if only resource-level handler is defined.
    
      Note: Swagger operations are generated only from declared operations (:get, :post, ..),
      despite the top-level handler could process more operations.
    
      Example:
    
      (resource
        {:parameters {:query-params {:x Long}}
         :responses {500 {:schema {:reason s/Str}}}
         :get {:parameters {:query-params {:y Long}}
               :responses {200 {:schema {:total Long}}}
               :handler (fn [request]
                          (ok {:total (+ (-> request :query-params :x)
                                         (-> request :query-params :y))}))}
         :post {}
         :handler (constantly
                    (internal-server-error {:reason "not implemented"}))})

    untangled 1.0.0-beta1
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    untangled.client.routing/defrouterSourceDoc + Usages
    Generates a component with a union query that can route among the given screen, which MUST be
    in cljc files. The first screen listed will be the 'default' screen that the router will be initialized to show.
    
    - All screens *must* implement InitialAppState
    - All screens *must* have a UI query
    - Add screens *must* have state that the ident-fn can use to determine which query to run. E.g. the left member
    of running (ident-fn Screen initial-screen-state) => [:kw-for-screen some-id]
    

    clj-ravendb 1.1.0
    A Clojure library designed to consume a RavenDB HTTP API.
    clj-ravendb.client/query-indexSourceDoc + Usages
    Query an index, where the 'query' takes the form:
      `(let [qry {:index index-name
                 :x 1
                 :y 2}])`
    
      Invoke using the following:
    
      `(query-index client qry options)`
    
      Optionally takes a map of options.
    
      `:max-attempts` is the maximum number of times to try
      and hit a non stale index.
    
      `:wait` is the time interval to wait before trying to
      hit a non stale index.
    
      `:request-builder` is a custom request builder fn.
    
      `:response-parser` is a customer response parser fn.

    untangled-client 0.8.2
    Client-side code for Untangled Webapps
    untangled.client.routing/defrouterSourceDoc + Usages
    Generates a component with a union query that can route among the given screen, which MUST be
    in cljc files. The first screen listed will be the 'default' screen that the router will be initialized to show.
    
    - All screens *must* implement InitialAppState
    - All screens *must* have a UI query
    - Add screens *must* have state that the ident-fn can use to determine which query to run. E.g. the left member
    of running (ident-fn Screen initial-screen-state) => [:kw-for-screen some-id]
    

    gardendb 0.2.0
    GardenDB is an embedded, file-backed document store specifically for Clojure, influenced
    gardendb.core/query-via-mapSourceDoc + Usages
    Query a collection with a query map. Every query map setting is optional. Returns a list or vector of matching documents.
       argument map m: {:where [(fn [x] (true)) (fn [x] (false))] (if no :where, return all)
                        :where-predictate :and|:or (defaults to :and)
                        :order-by :first-level-map-key-only
                        :keys [:list :of :keys :to :be :in :result]
                        :fields [:list :of :keys :to :be :in :result] ; synonym for :keys
                        :limit number-of-docs-in-result
                        :into string ; stores the result into collection specified}

    fulcro-sql 0.3.2
    A library for using SQL databases as components, writing integration tests, and
    fulcro-sql.core/query-forSourceDoc + Usages
    Returns an SQL query to get the true data columns that exist for the graph-query. Joins will contribute to this
      query iff there is a column on the target table that is needed in order to process the join.
    
      graph-join-prop : nil if the id-set is on the table of this query itself, otherwise the fulcro query keyword that was used to follow a join.
      graph-query : the things to pull from the databsae. Table will be derived from this, so you must pull more than just the ID.
      id-set : The ids of the rows you want to pull. If join-col is set, that will be the join column matched against these. Otherwise the PK of the table.

    clj-rpc 0.3.5
    simple rpc using clojure
    clj-rpc.command/filter-commandsSourceDoc + Usages
    get all the functions as commands in the namespace ns
       if statify (prd var-fn) is true 
      return a map that key is function-name and value is a command

    fsrun 0.1.2
    High Order Plugin to run some tasks on fs change
    com.makkalot.testrun/get-file-listSourceDoc + Usages
    Fn takes a list of files/globbing paths and
       Returns back a sequence of ^File objects
       Usage : (get-file-list ["/file/path" "/path/*.js"])
       

    collaj 0.8.0
    A state management system for Clojure/ClojureScript based on Redux
    com.ben-allred.collaj.core/apply-middlewareSourceDoc + Usages
    Creates an enhancer out of one or more fns that take get-state
        And return a function that takes dispatch and returns a new dispatch fn.

    digitalocean 1.2
    Clojure Digital Ocean Client
    digitalocean.v2.core/genericSourceDoc + Usages
    The function does the bulk of the work in abstracting away repetitive
       REST like requests.
       i.e (generic :get :domains) => (fn [token] ;; domain fetching logic)

    clojure-contracts-maps 0.1.0
    Simple map accessors with contracts
    clojure-contracts-maps/define-map-get-accessorSourceDoc + Usages
    define the get function
       the generated fn takes a map and, optional default value
       returns the value in the map, the dynamic default or static default

    clojure-contracts-maps 0.1.0
    Simple map accessors with contracts
    clojure-contracts-maps/define-canonical-map-get-accessorSourceDoc + Usages
    define the get function
       the generated fn takes a map and, optional default value
       returns the value in the map, the dynamic default or static default

    clojure-contracts-maps 0.1.0
    Simple map accessors with contracts
    clojure-contracts-maps/form-map-get-accessorSourceDoc + Usages
    make the form to define the get accessor
       the generated fn takes a map and, optional default value
       returns the value in the map, the dynamic default or static default

    metabase 0.1.0
    Metabase Community Edition
    metabase.driver.druid/do-requestSourceDoc + Usages
    Perform a JSON request using REQUEST-FN against URL.
       Tho
    
         (do-request http/get "http://my-json-api.net")

    contrail 0.2.0
    An interactive tracing facility for Clojure
    contrail.core/get-advice-fnSourceDoc + Usages
    Returns a function wrapping its argument `f` with trace reporting
      as specified by the remaining arguments to `get-advice-fn`, and
      which is suitable for passing to `richelieu/advise-var`.

    riemann-discovery 0.3.0
    Service discovery for Riemann (riemann.io)
    riemann-discovery.core/discovery-taskSourceDoc + Usages
    takes the discovery global configuration and the discovery specific configuration
       Returns a fn which get the current services, send events to the Riemann index, and update the services atom.

    dataset 0.0.11
    Generate, split into folds or train/test and cache a dataset
    zensols.dataset.db/instance-by-idSourceDoc + Usages
    Get a specific instance by its ID.
    
      This returns a map that has the following keys:
    
      * **:instance** the instance data, which was set with
      **:create-instances-fn** in [[elasticsearch-connection]]

    webica 3.0.0-beta2-clj0
    A Clojure binding for Selenium WebDriver
    webica.web-driver-wait/conditionSourceDoc + Usages
    Create a condition for wait. For example,
      (condition
        (fn [driver]
          (string/starts-with?
            (string/lower-case (driver/get-title driver))
            'cheese!'))))

    alida 0.1.3
    Crawling, scraping and indexing application.
    alida.crawl/get-pageSourceDoc + Usages
    Wrapper around clj-http.client/get fn that requests the provided
       uri and supresses any exceptions (will return nil if something goes
       wrong).

    tumalo 0.2.1
    Clojure Elasticsearch Indexing Tools
    tumalo.es/get-next-s3-object-batch!SourceDoc + Usages
    Inputs: [s3-client :- AmazonS3Client s3-chan :- ManyToManyChannel object-batch :- ObjectListing processing-fn]
    
      Get next batch of S3 objects and put them on the `chan`

    datomish 0.3.6
    A persistent, embedded knowledge base inspired by Datomic and DataScript.
    datomish.query.projection/symbol->projectionSourceDoc + Usages
    Given a variable symbol, produce a projection pair.
       `lookup-fn` will be used to find a column. For a non-aggregate query,
       this will typically be a lookup into the CC's bindings. For an
       aggregate query it'll be a qualification of the same var into the
       subquery.
       `known-types` is a type map to decide whether to project a type tag.
       `type-projection-fn` is like `lookup-fn` but for type tag columns.

    riemann-clojure-client 0.4.5
    Clojure client for the Riemann monitoring system
    riemann.codec/encode-pb-querySourceDoc + Usages
    Transforms a Query to a protobuf Query.

    riemann-jmx-clj 0.1.1
    A JMX connector to riemann
    riemann.codec/encode-pb-querySourceDoc + Usages
    Transforms a Query to a protobuf Query.

    metabase 0.1.0
    Metabase Community Edition
    metabase.query-processor/mbql-query?SourceDoc + Usages
    Is the given query an MBQL query?

    cloact 0.1.0
    A simple ClojureScript interface to React
    cloact.core/create-class (cljs)SourceDoc + Usages
    Create a component, React style. Should be called with a map,
    looking like this:
    {:get-initial-state (fn [this])
    :component-will-receive-props (fn [this new-props])
    :should-component-update (fn [this old-props new-props old-children new-children])
    :component-did-update (fn [this old-props old-children])
    :component-will-unmount (fn [this])
    :render (fn [props children this])}
    
    Everything is optional, except :render.
    

    tumalo 0.2.1
    Clojure Elasticsearch Indexing Tools
    tumalo.es/get-lazy-doc-seqSourceDoc + Usages
    Inputs: ([pool index mapping-type query] [pool :- Connection index :- s/Str mapping-type :- s/Str query :- {s/Any s/Any} scroll-duration :- s/Str])
      Returns: (s/if vector? [] clojure.lang.LazySeq)
    
      Get a lazy-seq of docs from the ES `index` and `mapping-type` for the given `query`.
    
      The scroll query will be kept open for `scroll-duration`, which defaults to 1m.

    clj-sql 0.0.5
    Changes and extensions to clojure.contrib.sql
    clj-sql.core/with-query-results-keysSourceDoc + Usages
    Executes a query, then evaluates body with results bound to a seq of the
    results whose keys have been mapped with key-fn.
      sql-params is a vector containing a string providing
    the (optionally parameterized) SQL query followed by values for any
    parameters.

    com.chpill.re-frankenstein 0.0.2
    The deviant fork of re-frame
    re-frame.core/reg-sub-rawSourceDoc + Usages
    Associate a given `query id` with a given subscription handler function `handler-fn`
       which is expected to take two arguments: app-db and query vector, and return
       a `reaction`.
    
      This is a low level, advanced function.  You should probably be using reg-sub
      instead.

    asosio.utils 0.0.4
    The Asosio Utils is a collection of utilities that makes development of clojure
    asosio.utils.db/format-querySourceDoc + Usages
    Construct SQL query from a statement map (honeysql) and
      a map of parameters.
      fn-name - name of calling function (used for logging).
      stmt-map - statement map (built with honeysql)
      stmt-params - (OPTIONAL) parameters to be inserted into stmt-map query

    asosio-utils 0.0.1
    The Asosio Utils is a collection of utilities that makes development of clojure
    asosio_utils.db/format-querySourceDoc + Usages
    Construct SQL query from a statement map (honeysql) and
      a map of parameters.
      fn-name - name of calling function (used for logging).
      stmt-map - statement map (built with honeysql)
      stmt-params - (OPTIONAL) parameters to be inserted into stmt-map query

    district0x 0.1.20
    district0x Frontend Library
    re-frame.core/reg-sub-rawSourceDoc + Usages
    Associate a given `query id` with a given subscription handler function `handler-fn`
       which is expected to take two arguments: app-db and query vector, and return
       a `reaction`.
    
      This is a low level, advanced function.  You should probably be using reg-sub
      instead.

    editable 0.1.4
    lifecycle events for forms using re-frame
    re-frame.core/reg-sub-rawSourceDoc + Usages
    Associate a given `query id` with a given subscription handler function `handler-fn`
       which is expected to take two arguments: app-db and query vector, and return
       a `reaction`.
    
      This is a low level, advanced function.  You should probably be using reg-sub
      instead.

    clj-assorted-utils 1.18.2
    Unsorted bunch of helper and utility functions.
    clj-assorted-utils.util/get-fn-arglistsSourceDoc + Usages
    Returns a map that contains the actual fn that was passed as argument and its arglists.
       The result will be a map of form: {:fn f :args <f-args>}.
       This function is intended to be used from within a macor.
       For a macro version of this functionality please use get-fn-arglists-m.

    deepfns 0.1.5
    Deeply nested fmap, fapply, and more!
    deepfns.core/map-fapplySourceDoc + Usages
    Similar to ss-fapply, this is a helper fn for the map type. It also uses
      fn-name as a callback fn to recurse with. The seed variable is for what
      the applicative will reduce into. With deepfapply we'll want to save all
      values but with filterapply it will get rid of values by using an empty
      map as the seed.

    scenari 1.2.1
    A BDD - Behavior Driven Development - library for Clojure
    scenari.core/exec-scenario-with-examplesSourceDoc + Usages
    run the scenario for each example rows, then
       for each step sentence find the fn which have a regex that match
       get the parameters value from the example and replace the parameter in the sentence
       then execute that fn with the parameters and input the return as first param of the next fn

    spexec 1.2.0
    A BDD - Behavior Driven Development - library for Clojure
    spexec.core/exec-scenario-with-examplesSourceDoc + Usages
    run the scenario for each example rows, then
       for each step sentence find the fn which have a regex that match
       get the parameters value from the example and replace the parameter in the sentence
       then execute that fn with the parameters and input the return as first param of the next fn

    sweatkit 0.1.4
    A Clojure library to work with sports activities data
    sweatkit.core/stepsSourceDoc + Usages
    Takes a measured object and an optional reducing fn. When the fn is not
       given, yields the whole Steps track, otherwise, it returns a single value.
       rfn can be any fn reducing point-vals or the :total keyword to get the
       accumulated value

    sweatkit 0.1.4
    A Clojure library to work with sports activities data
    sweatkit.core/caloriesSourceDoc + Usages
    Takes a measured object and an optional reducing fn. When the fn is not
       given, yields the whole Calories track, otherwise it returns a single value.
       rfn can be any fn reducing point-vals or the :total keyword to get the
       accumulated value

    basenji 0.1.1
    A HBase Clojure Client library
    basenji.core/get-rowSourceDoc + Usages
    Get a row from HBase
       takes a table-name and row-key
       Also some functions which will be used for processing result
       row-fn - Will be appled to row-key bytes
       qual-fn - Will be applied to qualifier bytes
       val-fn - Will be applied to value bytes

    scenarior 1.2.0
    A BDD - Behavior Driven Development - library for Clojure
    spexec.core/exec-scenario-with-examplesSourceDoc + Usages
    run the scenario for each example rows, then
       for each step sentence find the fn which have a regex that match
       get the parameters value from the example and replace the parameter in the sentence
       then execute that fn with the parameters and input the return as first param of the next fn

    context-io-clj 0.1.2
    Context.IO API wrapper for Clojure
    context-io.oauth/sign-querySourceDoc + Usages
    Returns the signing parameters given information about a request
    
       oauth-creds - The OAuthCredentials to sign the request with.
       action      - The HTTP action for the request (:get, :post, etc.).
       uri         - The URI for the request.
       :query      - The query parameters for the request (optional).
    
       Returns a map of parameters to put in the OAuth header string.

    context-io 0.0.3
    Context.IO API wrapper for Clojure
    context-io.oauth/sign-querySourceDoc + Usages
    Returns the signing parameters given information about a request
    
       oauth-creds - The OAuthCredentials to sign the request with.
       action      - The HTTP action for the request (:get, :post, etc.).
       uri         - The URI for the request.
       :query      - The query parameters for the request (optional).
    
       Returns a map of parameters to put in the OAuth header string.

    sql-tie 0.1.4
    Sql query utility
    tie.core/get-moduleSourceDoc + Usages
    -> Get tie module. If not found add error to tie module.
          Split query string and convert it to vector.
          Update query module sql key.
    
      @param {map} db "Tie modules as map"
      @param {keyword} name "Name of the tie module."
      @return "Tie module as map "

    specmonstah 1.1.1
    Generate and process arbitrary graphs of dependencies
    reifyhealth.specmonstah.core/add-query-term-relationsSourceDoc + Usages
    Recusively unpacks the query DSL, inserting referenced entities. For example,
      if the query includes the term
      
      [::book {:author-id :a1}]
      
      Then this function will insert a copy of 
      (get-in relations [::author ::template]) at [::author :a1].
    
      Also merges all attributes specified for referenced entities

    hara.object 2.8.6
    patterns and utilities
    hara.object.map-like/read-proxy-functionsSourceDoc + Usages
    creates a proxy access through a field in the object
     
       (read-proxy-functions {:school [:name :raw]})
       => '{:name (clojure.core/fn [obj]
                    (clojure.core/let [proxy (hara.object.access/get obj :school)]
                      (hara.object.access/get proxy :name))),
            :raw (clojure.core/fn [obj]
                   (clojure.core/let [proxy (hara.object.access/get obj :school)]
                    (hara.object.access/get proxy :raw)))}

    alia-component 4.2.1
    Component integration for Alia
    qbits.alia.component/query-functionsSourceDoc + Usages
    Given a cluster, keyspace, and query map, yield a function
       which executes queries by nickname. If no cluster-name
       is provided, assume a single-cluster registry and fetch
       the first from the registry.
    
       The query function has three arities: 1, 2, and 3.
       The first argument is always the nickname, the optional
       second one is a vector of values to attach to the prepared
       query, the last one additional options to override when
       sending the query.
    
       Here, options accept an addition `:execute-fn` key which
       determine which function should be used to send the
       query out, defaulting to `alia/execute`.
    
       Each query can be configured with global configuration defaults,
       code-supplied defaults, and query-specific configuration overrides,
       processed in that order as documented in `query`.

    geom 1.0.0-RC3
    thi.ng geometry kit - meta project spec including all modules
    thi.ng.geom.mesh.ops/find-in-treeSourceDoc + Usages
    Takes a query radius `eps`, returns a fn which queries an octree
      with a spherical region around `p` using the pre-configured radius.
      Returns the closest point found (if any).

    geom-meshops 0.0.908
    thi.ng geometry kit - CSG module
    thi.ng.geom.mesh.ops/find-in-treeSourceDoc + Usages
    Takes a query radius `eps`, returns a fn which queries an octree
      with a spherical region around `p` using the pre-configured radius.
      Returns the closest point found (if any).

    hara.object 2.8.6
    patterns and utilities
    hara.object.write/create-write-methodSourceDoc + Usages
    create a write method from the template
     
       (-> ((-> (write/create-write-method (reflect/query-class Cat ["setName" :#])
                                           "set"
                                           write/default-write-template
                                           )
                second
                :fn) (test.Cat. "spike") "fluffy")
          (.getName))
       => "fluffy"

    riemann 0.3.1
    A network event stream processor. Intended for analytics, metrics, and alerting;
    riemann.query/funSourceDoc + Usages
    Transforms an AST into a fn [event] which returns true if the query matches
      that event. Example:
    
      ```clojure
      (def q (fun (ast "metric > 2")))
      (q {:metric 1}) => false
      (q {:metric 3}) => true
      ```

    riemann 0.3.1
    A network event stream processor. Intended for analytics, metrics, and alerting;
    riemann.query/funSourceDoc + Usages
    Transforms an AST into a fn [event] which returns true if the query matches
      that event. Example:
    
      ```clojure
      (def q (fun (ast "metric > 2")))
      (q {:metric 1}) => false
      (q {:metric 3}) => true
      ```

    via 0.11.0
    A re-frame library for WebSocket based messaging
    via.authenticator/authenticateSourceDoc + Usages
    Authenticates the user identified by `id` and `password` and returns a hash map
      with `:id` and `:token` (JWT token) in addition to any other data returned by
      the query-fn if the authentication is successful. A nil is returned if the authentication
      fails.

    via 0.11.0
    A re-frame library for WebSocket based messaging
    via.authenticator/authenticateSourceDoc + Usages
    Authenticates the user identified by `id` and `password` and returns a hash map
      with `:id` and `:token` (JWT token) in addition to any other data returned by
      the query-fn if the authentication is successful. A nil is returned if the authentication
      fails.

    clojure-hbase 0.92.4
    A convenient Clojure interface to HBase.
    clojure-hbase.core/executeSourceDoc + Usages
    Performs the given HBase table operations (anything implementing the
       HBaseOperation protocol, such as Get/Scan/Put/Delete) on the given
       HTableInterface. The return value will be a sequence of equal length,
       with each slot containing the results of the query in the corresponding
       position.

    tophat 0.1.5
    Tophat is a Clojure library for handling HTTP request and response documents/maps.
    tophat.core/get-paramsSourceDoc + Usages
    Extracts parameters from query parameter string.
      ex. (get-parameters "foo=bar&baz=23&ans=42") => {:foo "bar" :baz "23" :ans "42"}

    carmine-sentinel 0.1.0-RC6
    A Clojure library designed to connect redis by sentinel, make carmine to support
    carmine-sentinel.core/get-sentinel-redis-specSourceDoc + Usages
    Get redis spec by sentinel-group and master name.
       If it is not resolved, it will query from sentinel and
       cache the result in memory.
       Recommend to call this function at your app startup  to reduce
       resolving cost.

    odin 0.2.0
    A declarative query DSL for Clojure
    com.tbaldridge.odin.contexts.data/querySourceDoc + Usages
    Given a Clojure datastructure, query it, binding p to the `get-in` path
      of each value. `v` is bound to the values in the collection. `a` is bound
      to the attribute that connects a `p` and a `v`. `coll` must be bound,
      but `p`, `a` and `v` are fully relational. 

    asosio.utils 0.0.4
    The Asosio Utils is a collection of utilities that makes development of clojure
    asosio.utils.db/count-num-rowsSourceDoc + Usages
    Get number of rows returned by executing the query.
    
      NOTE - count() should only use columnds for which there's an
      index. In such cases, the value is derived without a full
      table scan. sql_calc_found_rows() should be used otherwise.

    sweet-liberty 0.1.4
    A library for building database-backed RESTful services using Clojure
    com.rjmetrics.sweet-liberty.query/get-filter-mapSourceDoc + Usages
    Returns the filters from the query params Map as a Map of keyword fields to values.
      (:attributes table-struct) acts as a whitelist for which items to take.
      (get-filter-map {:columnA value1 :_fields ["name"]'} returns {:columnA value1}

    asosio-utils 0.0.1
    The Asosio Utils is a collection of utilities that makes development of clojure
    asosio_utils.db/count-num-rowsSourceDoc + Usages
    Get number of rows returned by executing the query.
    
      NOTE - count() should only use columnds for which there's an
      index. In such cases, the value is derived without a full
      table scan. sql_calc_found_rows() should be used otherwise.

    dunaj-lite 0.7.0
    Dunaj lite - An alternative core API for Clojure.
    dunaj.uri/UriSourceDoc + Usages
    A URI type.
    
      Use dunaj.coll/get to obtains parts of the URI. Following keys are
      supported: `:scheme`, `:scheme-specific-part`, `:authority`,
      `:user-info`, `:host`, `:port`, `:path`, `:query` and `:fragment`.

    clj-osf 0.1.2
    Clojure API for Open Semantic Framework web services queries
    clj-osf.revision.lister/listerSourceDoc + Usages
    Revision: Lister query.
    
      **Required**
    
      ##### Usage
    
      ```
      ;; Get all the revisions of the test:bob record
      (revision/lister
        (revision/dataset "http://sandbox.opensemanticframework.org/datasets/test/")
        (revision/uri "http://sandbox.opensemanticframework.org/datasets/test/bob")
        (revision/short-results))
      ```

    clj-osf 0.1.2
    Clojure API for Open Semantic Framework web services queries
    clj-osf.revision.read/readSourceDoc + Usages
    Revision: Read query.
    
      **Required**
    
      ##### Usage
    
      ```
      (revision-r/read
        (revision-r/dataset "http://sandbox.opensemanticframework.org/datasets/test/")
        (revision-r/uri "http://sandbox.opensemanticframework.org/datasets/test/revisions/1417180339.0395")
        (revision-r/get-revision))
      ```

    If the argument is a java.sql.ResultSet, turn it into a result-set-seq,
      else return it as-is. This makes working with metadata easier.
      Also accepts an option map containing :identifiers, :keywordize?, :qualifier,
      :as-arrays?, :row-fn,and :result-set-fn to control how the ResultSet is
      transformed and returned. See query for more details.

    specmonstah 1.1.1
    Generate and process arbitrary graphs of dependencies
    reifyhealth.specmonstah.core/dotreeSourceDoc + Usages
    Generates the entire graph necessary for `query` to exist, and
      calls `do-fn` on each node of that graph. `do-fn` expects one
      argument, a vector, where the first elemeent is a type (typically a
      spec, like `::book`), and the second element is data generated by
      `gen-tree`.

    nanoql 0.3.5
    A lib for declarative schemaless data querying.
    nanoql.core/executeSourceDoc + Usages
    Executes a query against a node or a value in an optional context.
        A node is:
        - a map of nodes and/or values
        - a vector of nodes and/or values
        - a function (ctx, AST -> node or value)
        - a function (ctx, AST -> promise with node or value)
        A value is anything else.
        Nodes get queried according to the query's structure, values get returned as they are.

    pipeline 0.2.1
    A pipeline for GraphQL execution, as well as a Ring handler.
    alumbra.pipeline.steps/runSourceDoc + Usages
    Runs the given `state` through the pipeline. It has to be a map of:
    
       - `:query`:          the GraphQL query string,
       - `:operation-name`: the GraphQL operation to run (if multiple are given),
       - `:variables`:      a map of variable names and values,
       - `:context`:        a map describing the context of the operation (e.g. session information).
    
       This returns an execution result consisting of the input state, plus:
    
       - `:status`: either `:success`, `:exception` or `:error`.
       - `:data`: the execution result data (if available),
       - `:exception`: a potentially thrown exception,
       - `:error`: a keyword describing the kind of error encountered,
       - `:errors`: a map describing the encountered errors.
    
       `opts` has to be a map of alumbra.spec-compliant components:
    
       - `:parser-fn`
       - `:validator-fn`
       - `:canonicalize-fn`
       - `:executor-fn`
    
       

    consimilo 0.1.0
    A Clojure library for querying large data-sets on similarity
    consimilo.core/similarity-kSourceDoc + Usages
    Query forest for top-k items, returns a hashmap: {item-key1 sim-fn-result1 item-key-k sim-fn-result-k}. Available
      similarity functions are Jaccard similarity, cosine distance, and Hamming distance. sim-fn is defaulted to :jaccard,
      but can be overridden by passing the optional :sim-fn key and :jaccard, :cosine, or :hamming. similarity-k Dispatches
      based on input: string, file, or feature-vector.

    ring-sse-middleware 0.1.2
    Ring middleware to emit Server-sent Events
    ring-sse-middleware.core/streaming-middlewareSourceDoc + Usages
    Given a Ring handler fn, an event streaming fn and the following optional args, return a wrapped handler that
      responds to matching requests by repeatedly fetching data and emitting Server-Sent Events (SSE) streams at specified
      interval.
      Argument         Type                     Default         Description
      --------         ----                     -------         -----------
      request-matcher  (fn [request]) -> match  query string    fn returning request upon match, nil otherwise
                                                'stream=true'
      empty-response   Ring response map        SSE headers     Ring response map without :body
      chunk-generator  (fn [request]) -> chunk  wrapped handler fn returning next chunk in the stream
      max-connections  long                     10              maximum allowed concurrent conncections

    re-posh 0.2.0
    Use your re-frame with DataScript as a data storage
    re-posh.subs/reg-subSourceDoc + Usages
    For a given `query-id` register a `config` function and input `signals`
    
      At an abstract level, a call to this function allows you to register 'the mechanism'
      to later fulfil a call to `(subscribe [query-id ...])`.
    
      To say that another way, reg-sub allows you to create a template for a node
      in the signal graph. But note: reg-sub does not cause a node to be created.
      It simply allows you to register the template from which such a
      node could be created, if it were needed, sometime later, when the call
      to `subscribe` is made.
    
      reg-sub needs three things:
        - a `query-id`
        - the required inputs for this node
        - a function that generates config for query or pull for this node
    
      The `query-id` is always the 1st argument to reg-sub and it is typically
      a namespaced keyword.
    
      A config function is always the last argument and it has this general form:
      `(input-signals, query-vector) -> a-value`
    
      What goes in between the 1st and last args can vary, but whatever is there will
      define the input signals part of the template, and, as a result, it will control
      what values the config functions gets as a first argument.
      There's 3 ways this function can be called - 3 ways to supply input signals:
    
      1. No input signals given:
    
         (reg-sub
           :query-id
           a-config-fn)   ;; (fn [db v]  ... a-value)
         The node's input signal defaults to datascript database, and the value within `ds` is
         is given as the 1st argument to the computation function.
    
      2. A signal function is supplied:
    
         (reg-sub
           :query-id
           signal-fn     ;; <-- here, the form is (fn [db v] ... signal | [signal])
           config-fn)
    
         When a node is created from the template, the `signal-fn` will be called and it
         is expected to return the input signal(s) as either a singleton, if there is only
         one, or a sequence if there are many.
         The values from the nominated signals will be supplied as the 1st argument to the
         config function - either a singleton or sequence, paralleling
         the structure returned by the signal function.
         Here, is an example signal-fn, which returns a vector of input signals.
           (fn [query-vec]
             [(subscribe [:a-sub])
              (subscribe [:b-sub])])
         For that signal function, the config function must be written
         to expect a vector of values for its first argument.
           (fn [[a b] _] ....)
         If the signal function was simpler and returned a singleton, like this:
            (fn [query-vec dynamic-vec]
              (subscribe [:a-sub]))
         then the config function must be written to expect a single value
         as the 1st argument:
            (fn [a _] ...)
    
      3. Syntax Sugar
    
         (reg-sub
           :a-b-sub
           :<- [:a-sub]
           :<- [:b-sub]
           (fn [[a b] [_]] {:a a :b b}))
    
      This 3rd variation is syntactic sugar for the 2nd. Pairs are supplied instead
      of an `input signals` functions. Each pair starts with a `:<-` and a subscription
      vector follows.
      

    yz 0.0.1-alpha18
    YZ[ˈiːzi] is simple (easy), laconic, string-based, object query language.
    ru.petrsu.nest.yz.parsing/do-qSourceDoc + Usages
    Takes query and runs query rule with this query.

    yz 0.0.1-alpha18
    YZ[ˈiːzi] is simple (easy), laconic, string-based, object query language.
    ru.petrsu.nest.yz.parsing/do-qSourceDoc + Usages
    Takes query and runs query rule with this query.

    sqlosure 0.2.0
    Compositional relational queries.
    sqlosure.query-comprehension/outerSourceDoc + Usages
    Embed a RA query as an outer query into the current query.

    Given a Java expression that extracts metadata (in the context of with-db-metadata),
      and a map of options like metadata-result, manage the connection for a single
      metadata-based query. Example usage:
    
      (with-db-metadata [meta db-spec]
        (metadata-query (.getTables meta nil nil nil (into-array String ["TABLE"]))
          {:row-fn ... :result-set-fn ...}))

    select-om-all 0.1.4
    Flexible select-style component for use in Om apps
    select-om-all.core/make-completions (cljs)SourceDoc + Usages
    Make completions function which takes a query and returns the channel that
      will receive items. User can provide custom either `completions`,
      or `search-fn` which filters given dataset with query, or rely on default
      search function. Also, `index-fn` is a function to prepare data for search
      (e.g. `first` to search only in first column in case of array data)
      Dataset is to be supplied with `:datasource` option of component.

    gardendb 0.2.0
    GardenDB is an embedded, file-backed document store specifically for Clojure, influenced
    gardendb.core/querySourceDoc + Usages
    Query a collection with argument pairs. Every query pairs is optional. Returns a list or vector of matching documents.
       argument pairs   :where [(fn [x] (true)) (fn [x] (false))] (if no :where, return all)
                        :where-predictate :and|:or (defaults to :and)
                        :order-by :first-level-map-key-only
                        :keys [:list :of :keys :to :be :in :result]
                        :fields [:list :of :keys :to :be :in :result] ; synonym for :keys
                        :limit number-of-docs-in-result
                        :into string ; stores the result into collection specified

    clj-rpc 0.3.5
    simple rpc using clojure
    clj-rpc.server/startSourceDoc + Usages
    start jetty server
       options :
          base on options of run-jetty  of ring jetty adaptor
          and add several more
          :fn-get-context  => function to get the context (fn-get-context token)
          :token-cookie-key => the cookie name according to the token
          :cookie-attrs => the cookie default attributes, include domain or others
                           reference ring wrap-session
          :commands => the custom commands (atom of map) to be exported. (optional) 

    kafka-clj 4.0.3
    fast kafka library implemented in clojure
    kafka-clj.consumer.work-organiser/check-invalid-offsets!SourceDoc + Usages
    Check for https://github.com/gerritjvv/kafka-fast/issues/10
       if a saved-offset > max-offset the redis offset is reset
       optional args
          redis-f (fn [redis-conn group-name topic partition offset] ) used to save the offset, the default impl is used to save to redis
          get-saved-offset (fn [state max-kafka-offset topic partition] ) get the last saved offset, default impl is get-saved-offset
    
          stats-atom (atom (map usefullstats))

    two fetches - use the lookup-key to get the uber-key, then
       get the record from the primary table.
    
       the lookup query may return multiple records, all of which will be
       dereferenced against the primary table, with nil results from
       dangling lookups being filtered out.
    
       this means that the lookup query may specify a partition-key and
       some clustering column condition (given as a :where option)

    clj-sql 0.0.5
    Changes and extensions to clojure.contrib.sql
    clj-sql.core/with-query-results*SourceDoc + Usages
    Executes a query, then evaluates func passing in a seq of the results as
    an argument. The first argument is a vector containing the (optionally
    parameterized) sql query string followed by values for any parameters.
       This version of with-query-results also takes and optional keyword
    argument, :key-fn, that will be used to map the column names of the result
    set into keys of the returned maps. The default version of this mapping
    function behaves in the same way as resultset-seq.

    fulcro 2.5.9
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    fulcro.client/new-fulcro-clientSourceDoc + Usages
    Entry point for creating a new fulcro client. Instantiates an Application with default values, unless
      overridden by the parameters. If you do not supply a networking object, one will be provided that connects to the
      same server the application was served from, at `/api`.
    
      If you supply a `:request-transform` it must be a function:
    
      ```
     (fn [{:keys [body headers]}] {:body body' :headers headers'})
      ```
    
      it can replace the outgoing EDN of body or headers (returning both as a vector). NOTE: Both of these are clojurescript types.
      The edn will be encoded with transit, and the headers will be converted to a js map. IMPORTANT: Only supported
      when using the default built-in single-remote networking.
    
      `:initial-state` is your applications initial state. If it is an atom, it *must* be normalized. Fulcro databases
      always have normalization turned on (for server data merging). If it is not an atom, it will be auto-normalized.
    
      `:started-callback` is an optional function that will receive the intiailized fulcro application after it is
      mounted in the DOM, and is useful for triggering initial loads, routing mutations, etc. The reconciler is available
      under the `:reconciler` key (and you can access the app state, root node, etc from there.)
    
      `:network-error-callback` is a function of three arguments, the app state atom, status code, and the error, which will be invoked for
      every network error (status code >= 400, or no network found). Only works if you choose to use the default built-in
      networking (ignored if you also specify :networking).
    
      `:migrate` is optional. It is a (fn [state tid->rid] ... state') that should return a new state where all tempids
      (the keys of `tid->rid`) are rewritten to real ids (the values of tid->rid). This defaults to a full recursive
      algorithm against all data in the app-state, which is correct but possibly slow).  Note that tempids will have an tempid data type.
      See reconciler documentation for further information.
    
      `:transit-handlers` (optional). A map with keys for `:read` and `:write`, which contain maps to be used for the read
      and write side of transit to extend the supported data types. See `make-fulcro-network` in network.cljs. Only used
      when you default to the built-in networking.
    
      `:shared` (optional). A map of arbitrary values to be shared across all components, accessible to them via (prim/shared this)
    
      `:read-local` (optional). An read function for the Parser. (fn [env k params] ...). If supplied,
      it will be called once for each root-level query key. If it returns `nil` or `false` for that key then the built-in Fulcro read will handle that
      branch of the root query. If it returns a map with the shape `{:value ...}`, then that will be used for the response. This is *not*
      recursive. If you begin handling a *branch* (e.g. a join), you must finish doing so (though if using recursion, you can technically handle just
      the properties that need your custom handling). At any time you can use `prim/db->tree` to get raw graph data from the database for a branch.
      NOTE: *it will be allowed* to trigger remote reads. This is not recommended, as you will probably have to augment the networking layer to
      get it to do what you mean. Use `load` instead. You have been warned. Triggering remote reads is allowed, but discouraged and unsupported.
    
      `:query-interpreter` (optional). A custom query engine (parser and interpreter) that will be used to satisfy all
      local client queries from the local state database. Cannot be used with `:read-local`.
      It must be a `(fn [env query] )` that returns the result for the given query. It will not be given mutations.
      The `env` will contain the `:state` atom, `:shared`, and `:parser`. It may also contain the `:reconciler`.
    
      `:networking` (optional). An instance of FulcroNetwork that will act as the default remote (named :remote). If
      you want to support multiple remotes, then this should be a map whose keys are the keyword names of the remotes
      and whose values are FulcroNetwork instances.
    
      `:mutation-merge (optional). A function `(fn [state mutation-symbol return-value])` that receives the app state as a
      map (NOT an atom) and should return the new state as a map. This function is run when network results are being merged,
      and is called once for each mutation that had a return value on the server. Returning nil from this function is safe, and will be ignored
      with a console message for debugging. If you need information about the original mutation arguments then you must reflect
      them back from the server in your return value. By default such values are discarded.
      
      `:reconciler-options (optional). A map that will be merged into the reconciler options. Currently it's mostly
      useful to override things like :root-render and :root-unmount for React Native Apps.`
    
      There is currently no way to circumvent the encoding of the body into transit. If you want to talk to other endpoints
      via alternate protocols you must currently implement that outside of the framework (e.g. global functions/state).
      

    fulcro 2.5.9
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    fulcro.client/new-fulcro-clientSourceDoc + Usages
    Entry point for creating a new fulcro client. Instantiates an Application with default values, unless
      overridden by the parameters. If you do not supply a networking object, one will be provided that connects to the
      same server the application was served from, at `/api`.
    
      If you supply a `:request-transform` it must be a function:
    
      ```
     (fn [{:keys [body headers]}] {:body body' :headers headers'})
      ```
    
      it can replace the outgoing EDN of body or headers (returning both as a vector). NOTE: Both of these are clojurescript types.
      The edn will be encoded with transit, and the headers will be converted to a js map. IMPORTANT: Only supported
      when using the default built-in single-remote networking.
    
      `:initial-state` is your applications initial state. If it is an atom, it *must* be normalized. Fulcro databases
      always have normalization turned on (for server data merging). If it is not an atom, it will be auto-normalized.
    
      `:started-callback` is an optional function that will receive the intiailized fulcro application after it is
      mounted in the DOM, and is useful for triggering initial loads, routing mutations, etc. The reconciler is available
      under the `:reconciler` key (and you can access the app state, root node, etc from there.)
    
      `:network-error-callback` is a function of three arguments, the app state atom, status code, and the error, which will be invoked for
      every network error (status code >= 400, or no network found). Only works if you choose to use the default built-in
      networking (ignored if you also specify :networking).
    
      `:migrate` is optional. It is a (fn [state tid->rid] ... state') that should return a new state where all tempids
      (the keys of `tid->rid`) are rewritten to real ids (the values of tid->rid). This defaults to a full recursive
      algorithm against all data in the app-state, which is correct but possibly slow).  Note that tempids will have an tempid data type.
      See reconciler documentation for further information.
    
      `:transit-handlers` (optional). A map with keys for `:read` and `:write`, which contain maps to be used for the read
      and write side of transit to extend the supported data types. See `make-fulcro-network` in network.cljs. Only used
      when you default to the built-in networking.
    
      `:shared` (optional). A map of arbitrary values to be shared across all components, accessible to them via (prim/shared this)
    
      `:read-local` (optional). An read function for the Parser. (fn [env k params] ...). If supplied,
      it will be called once for each root-level query key. If it returns `nil` or `false` for that key then the built-in Fulcro read will handle that
      branch of the root query. If it returns a map with the shape `{:value ...}`, then that will be used for the response. This is *not*
      recursive. If you begin handling a *branch* (e.g. a join), you must finish doing so (though if using recursion, you can technically handle just
      the properties that need your custom handling). At any time you can use `prim/db->tree` to get raw graph data from the database for a branch.
      NOTE: *it will be allowed* to trigger remote reads. This is not recommended, as you will probably have to augment the networking layer to
      get it to do what you mean. Use `load` instead. You have been warned. Triggering remote reads is allowed, but discouraged and unsupported.
    
      `:query-interpreter` (optional). A custom query engine (parser and interpreter) that will be used to satisfy all
      local client queries from the local state database. Cannot be used with `:read-local`.
      It must be a `(fn [env query] )` that returns the result for the given query. It will not be given mutations.
      The `env` will contain the `:state` atom, `:shared`, and `:parser`. It may also contain the `:reconciler`.
    
      `:networking` (optional). An instance of FulcroNetwork that will act as the default remote (named :remote). If
      you want to support multiple remotes, then this should be a map whose keys are the keyword names of the remotes
      and whose values are FulcroNetwork instances.
    
      `:mutation-merge (optional). A function `(fn [state mutation-symbol return-value])` that receives the app state as a
      map (NOT an atom) and should return the new state as a map. This function is run when network results are being merged,
      and is called once for each mutation that had a return value on the server. Returning nil from this function is safe, and will be ignored
      with a console message for debugging. If you need information about the original mutation arguments then you must reflect
      them back from the server in your return value. By default such values are discarded.
      
      `:reconciler-options (optional). A map that will be merged into the reconciler options. Currently it's mostly
      useful to override things like :root-render and :root-unmount for React Native Apps.`
    
      There is currently no way to circumvent the encoding of the body into transit. If you want to talk to other endpoints
      via alternate protocols you must currently implement that outside of the framework (e.g. global functions/state).
      

    trackit-core 0.7.1
    TRACKit! A Clojure developer friendly wrapper for Yammer's Metrics library.
    samsara.trackit/track-timeSourceDoc + Usages
    It track the distribution of the time it takes to
      execute the body and the rate at which it is processed.
    
      This is useful to measure things such as: the time it
      takes to query the database, or to process a request,
      or to send a request to another services.
      Anytime you what to know about *how long* it takes
      to run a part of your code use this tracker.
    
         (track-time "myapp.db.search"
           (let [connection (get-connection db)]
             (db-query connection a-query)))
    
      It returns the result of `body` execution.
      

    fulcro 2.5.9
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    fulcro.ui.forms/subforms*SourceDoc + Usages
    Returns a map whose keys are the query key-path from the component's query that point to subforms, and whose values are the
       defui component of that form (e.g. `{ [:k :k2] Subform }`). This will give you ALL of the current subforms declared in the static query and IForm
       fields. NOTE: union queries in grouped forms are not supported, since there would be no way to auto-gather non-displayed
       forms in the 'current' state.
    
       Use get-forms to obtain the current state of active forms. It is a gathering mechanism only.

    trackit 0.3.0
    TRACKit! A Clojure developer friendly wrapper for Yammer's Metrics library.
    samsara.trackit/track-timeSourceDoc + Usages
    It track the distribution of the time it takes to
      execute the body and the rate at which it is processed.
    
      This is useful to measure things such as: the time it
      takes to query the database, or to process a request,
      or to send a request to another services.
      Anytime you what to know about *how long* it takes
      to run a part of your code use this tracker.
    
         (track-time "db.search"
           (let [connection (get-connection db)]
             (db-query connection a-query)))
    
      It returns the result of `body` execution.
      

    untangled 1.0.0-beta1
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    untangled.ui.forms/subforms*SourceDoc + Usages
    Returns a map whose keys are the query key-path from the component's query that point to subforms, and whose values are the
       defui component of that form (e.g. `{ [:k :k2] Subform }`). This will give you ALL of the current subforms declared in the static query and IForm
       fields. NOTE: union queries in grouped forms are not supported, since there would be no way to auto-gather non-displayed
       forms in the 'current' state.
    
       Use get-forms to obtain the current state of active forms. It is a gathering mechanism only.

    untangled-ui 1.0.0-alpha5
    Untangled Components is a library of pre-built CSS and active components for use
    untangled.ui.forms/subforms*SourceDoc + Usages
    Returns a map whose keys are the query key-path from the component's query that point to subforms, and whose values are the
       defui component of that form (e.g. `{ [:k :k2] Subform }`). This will give you ALL of the current subforms declared in the static query and IForm
       fields. NOTE: union queries in grouped forms are not supported, since there would be no way to auto-gather non-displayed
       forms in the 'current' state.
    
       Use get-forms to obtain the current state of active forms. It is a gathering mechanism only.

    untangled-components 1.0.0
    Untangled Components is a library of pre-built CSS and active components for use
    untangled.ui.forms/subforms*SourceDoc + Usages
    Returns a map whose keys are the query key-path from the component's query that point to subforms, and whose values are the
       defui component of that form (e.g. `{ [:k :k2] Subform }`). This will give you ALL of the current subforms declared in the static query and IForm
       fields. NOTE: union queries in grouped forms are not supported, since there would be no way to auto-gather non-displayed
       forms in the 'current' state.
    
       Use get-forms to obtain the current state of active forms. It is a gathering mechanism only.

    clojure-miniprofiler 0.5.0
    a simple but effective profiler for clojure web applications
    clojure-miniprofiler/custom-timingSourceDoc + Usages
    wraps some of your code with a timing, so that it will show up
       in the miniprofiler results.
      takes 3 other arguments:
      call-type:
        the type of timed call this is. Examples might be "sql" or "redis"
    
      execute-type:
        within the call-type, what kind of request this is.
        Examples might be "get" or "query" or "execute"
    
      command-string:
        a pretty printed string of what this is executing.
        For SQL, this would be the query, for datomic the query or
        transaction data, for redis the key you're getting etc.

    sqlosure 0.2.0
    Compositional relational queries.
    sqlosure.db-connection/run-querySourceDoc + Usages
    Takes a database connection and a query and runs it against the database.
    
      Example:
    
          (def db-spec { ... })  ;; Your db-connection map.
          (def kv-table (table "kv" {"key" $integer-t
                                     "value" $string-t}))
          ;; Get all records from kv-table where "key" is less than 10.
          (run-query (db-connect db-spec)
                     (query [kv (<- kv-table)]
                            (restrict ($> (! k "key")
                                        ($integer 10)))
                            (project {"value" (! kv "value")})))

    clj-sql 0.0.5
    Changes and extensions to clojure.contrib.sql
    clj-sql.core/with-query-results-cursorSourceDoc + Usages
    Executes a query, then calls func (fn [res] ...) each time fetch-size has
       been retrieved from the database. The res argument to func is a seq of
       the results.
       sql-params is a vector containing a string providing
       the (optionally parameterized) SQL query followed by values for any
       parameters.
       Takes an optional keyword :keyfn that will be used to map column names
       into keys of the returned maps.
       This functions relies on the database and the JDBC driver supporting
       the .setFetchSize method on statement objects and is known not to
       use cursors with H2, Derby and Mysql.
         e.g
           (with-connection db
             (with-query-results-cursor
                50
                ["select * from table where department = ?" "XFiles"]
                (fn [res]
                  ;; do something with a sequence of up to 50 maps
                  )))

    ring-logging 0.3.3
    Logs ring requests and responses
    ring-logging.core/deep-select-keysSourceDoc + Usages
    A utility function for filtering requests and responses.  Behaves
      like select-keys, but with arbitrary nesting. When a value is missing
      in the source map, it will not be included in the result.  For
      example:
    
      ``` clojure
      (deep-select-keys
        {:method       :get
         :url          "http://google.com"
         :query-params {:a        "some"
                        :password "safe"}
         :headers      {"Authentication" "safe"}}
        [:method :url :form-params {:query-params [:a :b]}])
    
      ; =>
        {:method       :get
         :url          "http://google.com"
         :query-params {:a "some"}}
      ```
    
      And
    
      ``` clojure
      (deep-select-keys
        {:status  302
         :headers {"Location"     "http://elsewhere.com"
                   "Authencation" "safe"}
         :body    {:number 25
                   :key    :xyz}}
        [:status {:headers "Location"
                  :body    :number}])
    
      ; =>
        {:status  302
         :headers {"Location" "http://elsewhere.com"}
         :body    {:number 25}}
      ```

    re-frame 0.10.5
    A Clojurescript MVC-like Framework For Writing SPAs Using Reagent.
    re-frame.subs/reg-subSourceDoc + Usages
    For a given `query-id`, register a `computation` function and input `signals`.
    
      At an abstract level, a call to this function allows you to register 'the mechanism'
      to later fulfil a call to `(subscribe [query-id ...])`.
    
      To say that another way, reg-sub allows you to create a template for a node
      in the signal graph. But note: reg-sub does not cause a node to be created.
      It simply allows you to register the template from which such a
      node could be created, if it were needed, sometime later, when the call
      to `subscribe` is made.
    
      reg-sub needs three things:
        - a `query-id`
        - the required inputs for this node
        - a computation function for this node
    
      The `query-id` is always the 1st argument to reg-sub and it is typically
      a namespaced keyword.
    
      A computation function is always the last argument and it has this general form:
        `(input-signals, query-vector) -> a-value`
    
      What goes in between the 1st and last args can vary, but whatever is there will
      define the input signals part of the template, and, as a result, it will control
      what values the computation functions gets as a first argument.
    
      There's 3 ways this function can be called - 3 ways to supply input signals:
    
      1. No input signals given:
    
         (reg-sub
           :query-id
           a-computation-fn)   ;; (fn [db v]  ... a-value)
    
         The node's input signal defaults to `app-db`, and the value within `app-db` is
         is given as the 1st argument to the computation function.
    
      2. A signal function is supplied:
    
         (reg-sub
           :query-id
           signal-fn     ;; <-- here
           computation-fn)
    
         When a node is created from the template, the `signal-fn` will be called and it
         is expected to return the input signal(s) as either a singleton, if there is only
         one, or a sequence if there are many, or a map with the signals as the values.
    
         The values from the nominated signals will be supplied as the 1st argument to the
         computation function - either a singleton, sequence or map of them, paralleling
         the structure returned by the signal function.
    
         Here, is an example signal-fn, which returns a vector of input signals.
    
           (fn [query-vec dynamic-vec]
             [(subscribe [:a-sub])
              (subscribe [:b-sub])])
    
         For that signal function, the computation function must be written
         to expect a vector of values for its first argument.
           (fn [[a b] _] ....)
    
         If the signal function was simpler and returned a singleton, like this:
            (fn [query-vec dynamic-vec]
              (subscribe [:a-sub]))
    
         then the computation function must be written to expect a single value
         as the 1st argument:
    
            (fn [a _] ...)
    
      3. Syntax Sugar
    
         (reg-sub
           :a-b-sub
           :<- [:a-sub]
           :<- [:b-sub]
           (fn [[a b] [_]] {:a a :b b}))
    
      This 3rd variation is syntactic sugar for the 2nd. Pairs are supplied instead
      of an `input signals` functions. Each pair starts with a `:<-` and a subscription
      vector follows.
    
      For further understanding, read `/docs`, and look at the detailed comments in
      /examples/todomvc/src/subs.cljs
      

    re-frame-10x 0.3.3
    Become 10x more productive when developing and debugging re-frame applications.
    mranderson048.re-frame.v0v10v2.re-frame.subs/reg-subSourceDoc + Usages
    For a given `query-id`, register a `computation` function and input `signals`.
    
      At an abstract level, a call to this function allows you to register 'the mechanism'
      to later fulfil a call to `(subscribe [query-id ...])`.
    
      To say that another way, reg-sub allows you to create a template for a node
      in the signal graph. But note: reg-sub does not cause a node to be created.
      It simply allows you to register the template from which such a
      node could be created, if it were needed, sometime later, when the call
      to `subscribe` is made.
    
      reg-sub needs three things:
        - a `query-id`
        - the required inputs for this node
        - a computation function for this node
    
      The `query-id` is always the 1st argument to reg-sub and it is typically
      a namespaced keyword.
    
      A computation function is always the last argument and it has this general form:
        `(input-signals, query-vector) -> a-value`
    
      What goes in between the 1st and last args can vary, but whatever is there will
      define the input signals part of the template, and, as a result, it will control
      what values the computation functions gets as a first argument.
    
      There's 3 ways this function can be called - 3 ways to supply input signals:
    
      1. No input signals given:
    
         (reg-sub
           :query-id
           a-computation-fn)   ;; (fn [db v]  ... a-value)
    
         The node's input signal defaults to `app-db`, and the value within `app-db` is
         is given as the 1st argument to the computation function.
    
      2. A signal function is supplied:
    
         (reg-sub
           :query-id
           signal-fn     ;; <-- here
           computation-fn)
    
         When a node is created from the template, the `signal-fn` will be called and it
         is expected to return the input signal(s) as either a singleton, if there is only
         one, or a sequence if there are many, or a map with the signals as the values.
    
         The values from the nominated signals will be supplied as the 1st argument to the
         computation function - either a singleton, sequence or map of them, paralleling
         the structure returned by the signal function.
    
         Here, is an example signal-fn, which returns a vector of input signals.
    
           (fn [query-vec dynamic-vec]
             [(subscribe [:a-sub])
              (subscribe [:b-sub])])
    
         For that signal function, the computation function must be written
         to expect a vector of values for its first argument.
           (fn [[a b] _] ....)
    
         If the signal function was simpler and returned a singleton, like this:
            (fn [query-vec dynamic-vec]
              (subscribe [:a-sub]))
    
         then the computation function must be written to expect a single value
         as the 1st argument:
    
            (fn [a _] ...)
    
      3. Syntax Sugar
    
         (reg-sub
           :a-b-sub
           :<- [:a-sub]
           :<- [:b-sub]
           (fn [[a b] [_]] {:a a :b b}))
    
      This 3rd variation is syntactic sugar for the 2nd. Pairs are supplied instead
      of an `input signals` functions. Each pair starts with a `:<-` and a subscription
      vector follows.
    
      For further understanding, read `/docs`, and look at the detailed comments in
      /examples/todomvc/src/subs.cljs
      

    lambdacd 0.14.1
    A library to create a continous delivery pipeline in code.
    re-frame.subs/reg-subSourceDoc + Usages
    For a given `query-id`, register a `computation` function and input `signals`.
    
      At an abstract level, a call to this function allows you to register 'the mechanism'
      to later fulfil a call to `(subscribe [query-id ...])`.
    
      To say that another way, reg-sub allows you to create a template for a node
      in the signal graph. But note: reg-sub does not cause a node to be created.
      It simply allows you to register the template from which such a
      node could be created, if it were needed, sometime later, when the call
      to `subscribe` is made.
    
      reg-sub needs three things:
        - a `query-id`
        - the required inputs for this node
        - a computation function for this node
    
      The `query-id` is always the 1st argument to reg-sub and it is typically
      a namespaced keyword.
    
      A computation function is always the last argument and it has this general form:
        `(input-signals, query-vector) -> a-value`
    
      What goes in between the 1st and last args can vary, but whatever is there will
      define the input signals part of the template, and, as a result, it will control
      what values the computation functions gets as a first argument.
    
      There's 3 ways this function can be called - 3 ways to supply input signals:
    
      1. No input signals given:
    
         (reg-sub
           :query-id
           a-computation-fn)   ;; (fn [db v]  ... a-value)
    
         The node's input signal defaults to `app-db`, and the value within `app-db` is
         is given as the 1st argument to the computation function.
    
      2. A signal function is supplied:
    
         (reg-sub
           :query-id
           signal-fn     ;; <-- here
           computation-fn)
    
         When a node is created from the template, the `signal-fn` will be called and it
         is expected to return the input signal(s) as either a singleton, if there is only
         one, or a sequence if there are many, or a map with the signals as the values.
    
         The values from the nominated signals will be supplied as the 1st argument to the
         computation function - either a singleton, sequence or map of them, paralleling
         the structure returned by the signal function.
    
         Here, is an example signal-fn, which returns a vector of input signals.
    
           (fn [query-vec dynamic-vec]
             [(subscribe [:a-sub])
              (subscribe [:b-sub])])
    
         For that signal function, the computation function must be written
         to expect a vector of values for its first argument.
           (fn [[a b] _] ....)
    
         If the signal function was simpler and returned a singleton, like this:
            (fn [query-vec dynamic-vec]
              (subscribe [:a-sub]))
    
         then the computation function must be written to expect a single value
         as the 1st argument:
    
            (fn [a _] ...)
    
      3. Syntax Sugar
    
         (reg-sub
           :a-b-sub
           :<- [:a-sub]
           :<- [:b-sub]
           (fn [[a b] [_]] {:a a :b b}))
    
      This 3rd variation is syntactic sugar for the 2nd. Pairs are supplied instead
      of an `input signals` functions. Each pair starts with a `:<-` and a subscription
      vector follows.
    
      For further understanding, read `/docs`, and look at the detailed comments in
      /examples/todomvc/src/subs.cljs
      

    lambdacd 0.14.1
    A library to create a continous delivery pipeline in code.
    re-frame.subs/reg-subSourceDoc + Usages
    For a given `query-id`, register a `computation` function and input `signals`.
    
      At an abstract level, a call to this function allows you to register 'the mechanism'
      to later fulfil a call to `(subscribe [query-id ...])`.
    
      To say that another way, reg-sub allows you to create a template for a node
      in the signal graph. But note: reg-sub does not cause a node to be created.
      It simply allows you to register the template from which such a
      node could be created, if it were needed, sometime later, when the call
      to `subscribe` is made.
    
      reg-sub needs three things:
        - a `query-id`
        - the required inputs for this node
        - a computation function for this node
    
      The `query-id` is always the 1st argument to reg-sub and it is typically
      a namespaced keyword.
    
      A computation function is always the last argument and it has this general form:
        `(input-signals, query-vector) -> a-value`
    
      What goes in between the 1st and last args can vary, but whatever is there will
      define the input signals part of the template, and, as a result, it will control
      what values the computation functions gets as a first argument.
    
      There's 3 ways this function can be called - 3 ways to supply input signals:
    
      1. No input signals given:
    
         (reg-sub
           :query-id
           a-computation-fn)   ;; (fn [db v]  ... a-value)
    
         The node's input signal defaults to `app-db`, and the value within `app-db` is
         is given as the 1st argument to the computation function.
    
      2. A signal function is supplied:
    
         (reg-sub
           :query-id
           signal-fn     ;; <-- here
           computation-fn)
    
         When a node is created from the template, the `signal-fn` will be called and it
         is expected to return the input signal(s) as either a singleton, if there is only
         one, or a sequence if there are many, or a map with the signals as the values.
    
         The values from the nominated signals will be supplied as the 1st argument to the
         computation function - either a singleton, sequence or map of them, paralleling
         the structure returned by the signal function.
    
         Here, is an example signal-fn, which returns a vector of input signals.
    
           (fn [query-vec dynamic-vec]
             [(subscribe [:a-sub])
              (subscribe [:b-sub])])
    
         For that signal function, the computation function must be written
         to expect a vector of values for its first argument.
           (fn [[a b] _] ....)
    
         If the signal function was simpler and returned a singleton, like this:
            (fn [query-vec dynamic-vec]
              (subscribe [:a-sub]))
    
         then the computation function must be written to expect a single value
         as the 1st argument:
    
            (fn [a _] ...)
    
      3. Syntax Sugar
    
         (reg-sub
           :a-b-sub
           :<- [:a-sub]
           :<- [:b-sub]
           (fn [[a b] [_]] {:a a :b b}))
    
      This 3rd variation is syntactic sugar for the 2nd. Pairs are supplied instead
      of an `input signals` functions. Each pair starts with a `:<-` and a subscription
      vector follows.
    
      For further understanding, read `/docs`, and look at the detailed comments in
      /examples/todomvc/src/subs.cljs
      

    trace 0.1.22
    Tracing and developer tools for re-frame apps
    mranderson047.re-frame.v0v10v2.re-frame.subs/reg-subSourceDoc + Usages
    For a given `query-id`, register a `computation` function and input `signals`.
    
      At an abstract level, a call to this function allows you to register 'the mechanism'
      to later fulfil a call to `(subscribe [query-id ...])`.
    
      To say that another way, reg-sub allows you to create a template for a node
      in the signal graph. But note: reg-sub does not cause a node to be created.
      It simply allows you to register the template from which such a
      node could be created, if it were needed, sometime later, when the call
      to `subscribe` is made.
    
      reg-sub needs three things:
        - a `query-id`
        - the required inputs for this node
        - a computation function for this node
    
      The `query-id` is always the 1st argument to reg-sub and it is typically
      a namespaced keyword.
    
      A computation function is always the last argument and it has this general form:
        `(input-signals, query-vector) -> a-value`
    
      What goes in between the 1st and last args can vary, but whatever is there will
      define the input signals part of the template, and, as a result, it will control
      what values the computation functions gets as a first argument.
    
      There's 3 ways this function can be called - 3 ways to supply input signals:
    
      1. No input signals given:
    
         (reg-sub
           :query-id
           a-computation-fn)   ;; (fn [db v]  ... a-value)
    
         The node's input signal defaults to `app-db`, and the value within `app-db` is
         is given as the 1st argument to the computation function.
    
      2. A signal function is supplied:
    
         (reg-sub
           :query-id
           signal-fn     ;; <-- here
           computation-fn)
    
         When a node is created from the template, the `signal-fn` will be called and it
         is expected to return the input signal(s) as either a singleton, if there is only
         one, or a sequence if there are many, or a map with the signals as the values.
    
         The values from the nominated signals will be supplied as the 1st argument to the
         computation function - either a singleton, sequence or map of them, paralleling
         the structure returned by the signal function.
    
         Here, is an example signal-fn, which returns a vector of input signals.
    
           (fn [query-vec dynamic-vec]
             [(subscribe [:a-sub])
              (subscribe [:b-sub])])
    
         For that signal function, the computation function must be written
         to expect a vector of values for its first argument.
           (fn [[a b] _] ....)
    
         If the signal function was simpler and returned a singleton, like this:
            (fn [query-vec dynamic-vec]
              (subscribe [:a-sub]))
    
         then the computation function must be written to expect a single value
         as the 1st argument:
    
            (fn [a _] ...)
    
      3. Syntax Sugar
    
         (reg-sub
           :a-b-sub
           :<- [:a-sub]
           :<- [:b-sub]
           (fn [[a b] [_]] {:a a :b b}))
    
      This 3rd variation is syntactic sugar for the 2nd. Pairs are supplied instead
      of an `input signals` functions. Each pair starts with a `:<-` and a subscription
      vector follows.
    
      For further understanding, read `/docs`, and look at the detailed comments in
      /examples/todomvc/src/subs.cljs
      

    iron 0.4.0
    Front-end utilities and support for ClojureScript and re-frame projects
    re-frame.subs/reg-subSourceDoc + Usages
    For a given `query-id`, register a `computation` function and input `signals`.
    
      At an abstract level, a call to this function allows you to register 'the mechanism'
      to later fulfil a call to `(subscribe [query-id ...])`.
    
      To say that another way, reg-sub allows you to create a template for a node
      in the signal graph. But note: reg-sub does not cause a node to be created.
      It simply allows you to register the template from which such a
      node could be created, if it were needed, sometime later, when the call
      to `subscribe` is made.
    
      reg-sub needs three things:
        - a `query-id`
        - the required inputs for this node
        - a computation function for this node
    
      The `query-id` is always the 1st argument to reg-sub and it is typically
      a namespaced keyword.
    
      A computation function is always the last argument and it has this general form:
        `(input-signals, query-vector) -> a-value`
    
      What goes in between the 1st and last args can vary, but whatever is there will
      define the input signals part of the template, and, as a result, it will control
      what values the computation functions gets as a first argument.
    
      There's 3 ways this function can be called - 3 ways to supply input signals:
    
      1. No input signals given:
    
         (reg-sub
           :query-id
           a-computation-fn)   ;; (fn [db v]  ... a-value)
    
         The node's input signal defaults to `app-db`, and the value within `app-db` is
         is given as the 1st argument to the computation function.
    
      2. A signal function is supplied:
    
         (reg-sub
           :query-id
           signal-fn     ;; <-- here
           computation-fn)
    
         When a node is created from the template, the `signal-fn` will be called and it
         is expected to return the input signal(s) as either a singleton, if there is only
         one, or a sequence if there are many, or a map with the signals as the values.
    
         The values from the nominated signals will be supplied as the 1st argument to the
         computation function - either a singleton, sequence or map of them, paralleling
         the structure returned by the signal function.
    
         Here, is an example signal-fn, which returns a vector of input signals.
    
           (fn [query-vec dynamic-vec]
             [(subscribe [:a-sub])
              (subscribe [:b-sub])])
    
         For that signal function, the computation function must be written
         to expect a vector of values for its first argument.
           (fn [[a b] _] ....)
    
         If the signal function was simpler and returned a singleton, like this:
            (fn [query-vec dynamic-vec]
              (subscribe [:a-sub]))
    
         then the computation function must be written to expect a single value
         as the 1st argument:
    
            (fn [a _] ...)
    
      3. Syntax Sugar
    
         (reg-sub
           :a-b-sub
           :<- [:a-sub]
           :<- [:b-sub]
           (fn [[a b] [_]] {:a a :b b}))
    
      This 3rd variation is syntactic sugar for the 2nd. Pairs are supplied instead
      of an `input signals` functions. Each pair starts with a `:<-` and a subscription
      vector follows.
    
      For further understanding, read `/docs`, and look at the detailed comments in
      /examples/todomvc/src/subs.cljs
      

    re-frame-ipfs-fx 0.0.2
    IPFS Re-Frame handlers.
    re-frame.subs/reg-subSourceDoc + Usages
    For a given `query-id`, register a `computation` function and input `signals`.
    
      At an abstract level, a call to this function allows you to register 'the mechanism'
      to later fulfil a call to `(subscribe [query-id ...])`.
    
      To say that another way, reg-sub allows you to create a template for a node
      in the signal graph. But note: reg-sub does not cause a node to be created.
      It simply allows you to register the template from which such a
      node could be created, if it were needed, sometime later, when the call
      to `subscribe` is made.
    
      reg-sub needs three things:
        - a `query-id`
        - the required inputs for this node
        - a computation function for this node
    
      The `query-id` is always the 1st argument to reg-sub and it is typically
      a namespaced keyword.
    
      A computation function is always the last argument and it has this general form:
        `(input-signals, query-vector) -> a-value`
    
      What goes in between the 1st and last args can vary, but whatever is there will
      define the input signals part of the template, and, as a result, it will control
      what values the computation functions gets as a first argument.
    
      There's 3 ways this function can be called - 3 ways to supply input signals:
    
      1. No input signals given:
    
         (reg-sub
           :query-id
           a-computation-fn)   ;; (fn [db v]  ... a-value)
    
         The node's input signal defaults to `app-db`, and the value within `app-db` is
         is given as the 1st argument to the computation function.
    
      2. A signal function is supplied:
    
         (reg-sub
           :query-id
           signal-fn     ;; <-- here
           computation-fn)
    
         When a node is created from the template, the `signal-fn` will be called and it
         is expected to return the input signal(s) as either a singleton, if there is only
         one, or a sequence if there are many, or a map with the signals as the values.
    
         The values from the nominated signals will be supplied as the 1st argument to the
         computation function - either a singleton, sequence or map of them, paralleling
         the structure returned by the signal function.
    
         Here, is an example signal-fn, which returns a vector of input signals.
    
           (fn [query-vec dynamic-vec]
             [(subscribe [:a-sub])
              (subscribe [:b-sub])])
    
         For that signal function, the computation function must be written
         to expect a vector of values for its first argument.
           (fn [[a b] _] ....)
    
         If the signal function was simpler and returned a singleton, like this:
            (fn [query-vec dynamic-vec]
              (subscribe [:a-sub]))
    
         then the computation function must be written to expect a single value
         as the 1st argument:
    
            (fn [a _] ...)
    
      3. Syntax Sugar
    
         (reg-sub
           :a-b-sub
           :<- [:a-sub]
           :<- [:b-sub]
           (fn [[a b] [_]] {:a a :b b}))
    
      This 3rd variation is syntactic sugar for the 2nd. Pairs are supplied instead
      of an `input signals` functions. Each pair starts with a `:<-` and a subscription
      vector follows.
    
      For further understanding, read `/docs`, and look at the detailed comments in
      /examples/todomvc/src/subs.cljs
      

    ventas 0.0.6
    The Ventas eCommerce platform
    re-frame.subs/reg-subSourceDoc + Usages
    For a given `query-id`, register a `computation` function and input `signals`.
    
      At an abstract level, a call to this function allows you to register 'the mechanism'
      to later fulfil a call to `(subscribe [query-id ...])`.
    
      To say that another way, reg-sub allows you to create a template for a node
      in the signal graph. But note: reg-sub does not cause a node to be created.
      It simply allows you to register the template from which such a
      node could be created, if it were needed, sometime later, when the call
      to `subscribe` is made.
    
      reg-sub needs three things:
        - a `query-id`
        - the required inputs for this node
        - a computation function for this node
    
      The `query-id` is always the 1st argument to reg-sub and it is typically
      a namespaced keyword.
    
      A computation function is always the last argument and it has this general form:
        `(input-signals, query-vector) -> a-value`
    
      What goes in between the 1st and last args can vary, but whatever is there will
      define the input signals part of the template, and, as a result, it will control
      what values the computation functions gets as a first argument.
    
      There's 3 ways this function can be called - 3 ways to supply input signals:
    
      1. No input signals given:
    
         (reg-sub
           :query-id
           a-computation-fn)   ;; (fn [db v]  ... a-value)
    
         The node's input signal defaults to `app-db`, and the value within `app-db` is
         is given as the 1st argument to the computation function.
    
      2. A signal function is supplied:
    
         (reg-sub
           :query-id
           signal-fn     ;; <-- here
           computation-fn)
    
         When a node is created from the template, the `signal-fn` will be called and it
         is expected to return the input signal(s) as either a singleton, if there is only
         one, or a sequence if there are many, or a map with the signals as the values.
    
         The values from the nominated signals will be supplied as the 1st argument to the
         computation function - either a singleton, sequence or map of them, paralleling
         the structure returned by the signal function.
    
         Here, is an example signal-fn, which returns a vector of input signals.
    
           (fn [query-vec dynamic-vec]
             [(subscribe [:a-sub])
              (subscribe [:b-sub])])
    
         For that signal function, the computation function must be written
         to expect a vector of values for its first argument.
           (fn [[a b] _] ....)
    
         If the signal function was simpler and returned a singleton, like this:
            (fn [query-vec dynamic-vec]
              (subscribe [:a-sub]))
    
         then the computation function must be written to expect a single value
         as the 1st argument:
    
            (fn [a _] ...)
    
      3. Syntax Sugar
    
         (reg-sub
           :a-b-sub
           :<- [:a-sub]
           :<- [:b-sub]
           (fn [[a b] [_]] {:a a :b b}))
    
      This 3rd variation is syntactic sugar for the 2nd. Pairs are supplied instead
      of an `input signals` functions. Each pair starts with a `:<-` and a subscription
      vector follows.
    
      For further understanding, read `/docs`, and look at the detailed comments in
      /examples/todomvc/src/subs.cljs
      

    ventas 0.0.6
    The Ventas eCommerce platform
    re-frame.subs/reg-subSourceDoc + Usages
    For a given `query-id`, register a `computation` function and input `signals`.
    
      At an abstract level, a call to this function allows you to register 'the mechanism'
      to later fulfil a call to `(subscribe [query-id ...])`.
    
      To say that another way, reg-sub allows you to create a template for a node
      in the signal graph. But note: reg-sub does not cause a node to be created.
      It simply allows you to register the template from which such a
      node could be created, if it were needed, sometime later, when the call
      to `subscribe` is made.
    
      reg-sub needs three things:
        - a `query-id`
        - the required inputs for this node
        - a computation function for this node
    
      The `query-id` is always the 1st argument to reg-sub and it is typically
      a namespaced keyword.
    
      A computation function is always the last argument and it has this general form:
        `(input-signals, query-vector) -> a-value`
    
      What goes in between the 1st and last args can vary, but whatever is there will
      define the input signals part of the template, and, as a result, it will control
      what values the computation functions gets as a first argument.
    
      There's 3 ways this function can be called - 3 ways to supply input signals:
    
      1. No input signals given:
    
         (reg-sub
           :query-id
           a-computation-fn)   ;; (fn [db v]  ... a-value)
    
         The node's input signal defaults to `app-db`, and the value within `app-db` is
         is given as the 1st argument to the computation function.
    
      2. A signal function is supplied:
    
         (reg-sub
           :query-id
           signal-fn     ;; <-- here
           computation-fn)
    
         When a node is created from the template, the `signal-fn` will be called and it
         is expected to return the input signal(s) as either a singleton, if there is only
         one, or a sequence if there are many, or a map with the signals as the values.
    
         The values from the nominated signals will be supplied as the 1st argument to the
         computation function - either a singleton, sequence or map of them, paralleling
         the structure returned by the signal function.
    
         Here, is an example signal-fn, which returns a vector of input signals.
    
           (fn [query-vec dynamic-vec]
             [(subscribe [:a-sub])
              (subscribe [:b-sub])])
    
         For that signal function, the computation function must be written
         to expect a vector of values for its first argument.
           (fn [[a b] _] ....)
    
         If the signal function was simpler and returned a singleton, like this:
            (fn [query-vec dynamic-vec]
              (subscribe [:a-sub]))
    
         then the computation function must be written to expect a single value
         as the 1st argument:
    
            (fn [a _] ...)
    
      3. Syntax Sugar
    
         (reg-sub
           :a-b-sub
           :<- [:a-sub]
           :<- [:b-sub]
           (fn [[a b] [_]] {:a a :b b}))
    
      This 3rd variation is syntactic sugar for the 2nd. Pairs are supplied instead
      of an `input signals` functions. Each pair starts with a `:<-` and a subscription
      vector follows.
    
      For further understanding, read `/docs`, and look at the detailed comments in
      /examples/todomvc/src/subs.cljs
      

    rejax 0.1.0
    A library that creates nicer API for usage of cljs-ajax in Re-frame
    re-frame.subs/reg-subSourceDoc + Usages
    For a given `query-id`, register a `computation` function and input `signals`.
    
      At an abstract level, a call to this function allows you to register 'the mechanism'
      to later fulfil a call to `(subscribe [query-id ...])`.
    
      To say that another way, reg-sub allows you to create a template for a node
      in the signal graph. But note: reg-sub does not cause a node to be created.
      It simply allows you to register the template from which such a
      node could be created, if it were needed, sometime later, when the call
      to `subscribe` is made.
    
      reg-sub needs three things:
        - a `query-id`
        - the required inputs for this node
        - a computation function for this node
    
      The `query-id` is always the 1st argument to reg-sub and it is typically
      a namespaced keyword.
    
      A computation function is always the last argument and it has this general form:
        `(input-signals, query-vector) -> a-value`
    
      What goes in between the 1st and last args can vary, but whatever is there will
      define the input signals part of the template, and, as a result, it will control
      what values the computation functions gets as a first argument.
    
      There's 3 ways this function can be called - 3 ways to supply input signals:
    
      1. No input signals given:
    
         (reg-sub
           :query-id
           a-computation-fn)   ;; (fn [db v]  ... a-value)
    
         The node's input signal defaults to `app-db`, and the value within `app-db` is
         is given as the 1st argument to the computation function.
    
      2. A signal function is supplied:
    
         (reg-sub
           :query-id
           signal-fn     ;; <-- here
           computation-fn)
    
         When a node is created from the template, the `signal-fn` will be called and it
         is expected to return the input signal(s) as either a singleton, if there is only
         one, or a sequence if there are many, or a map with the signals as the values.
    
         The values from the nominated signals will be supplied as the 1st argument to the
         computation function - either a singleton, sequence or map of them, paralleling
         the structure returned by the signal function.
    
         Here, is an example signal-fn, which returns a vector of input signals.
    
           (fn [query-vec dynamic-vec]
             [(subscribe [:a-sub])
              (subscribe [:b-sub])])
    
         For that signal function, the computation function must be written
         to expect a vector of values for its first argument.
           (fn [[a b] _] ....)
    
         If the signal function was simpler and returned a singleton, like this:
            (fn [query-vec dynamic-vec]
              (subscribe [:a-sub]))
    
         then the computation function must be written to expect a single value
         as the 1st argument:
    
            (fn [a _] ...)
    
      3. Syntax Sugar
    
         (reg-sub
           :a-b-sub
           :<- [:a-sub]
           :<- [:b-sub]
           (fn [[a b] [_]] {:a a :b b}))
    
      This 3rd variation is syntactic sugar for the 2nd. Pairs are supplied instead
      of an `input signals` functions. Each pair starts with a `:<-` and a subscription
      vector follows.
    
      For further understanding, read `/docs`, and look at the detailed comments in
      /examples/todomvc/src/subs.cljs
      

    pine 0.1.6
    A Clojure/ClojureScript router designed for universal applications.
    re-frame.subs/reg-subSourceDoc + Usages
    For a given `query-id`, register a `computation` function and input `signals`.
    
      At an abstract level, a call to this function allows you to register 'the mechanism'
      to later fulfil a call to `(subscribe [query-id ...])`.
    
      To say that another way, reg-sub allows you to create a template for a node
      in the signal graph. But note: reg-sub does not cause a node to be created.
      It simply allows you to register the template from which such a
      node could be created, if it were needed, sometime later, when the call
      to `subscribe` is made.
    
      reg-sub needs three things:
        - a `query-id`
        - the required inputs for this node
        - a computation function for this node
    
      The `query-id` is always the 1st argument to reg-sub and it is typically
      a namespaced keyword.
    
      A computation function is always the last argument and it has this general form:
        `(input-signals, query-vector) -> a-value`
    
      What goes in between the 1st and last args can vary, but whatever is there will
      define the input signals part of the template, and, as a result, it will control
      what values the computation functions gets as a first argument.
    
      There's 3 ways this function can be called - 3 ways to supply input signals:
    
      1. No input signals given:
    
         (reg-sub
           :query-id
           a-computation-fn)   ;; (fn [db v]  ... a-value)
    
         The node's input signal defaults to `app-db`, and the value within `app-db` is
         is given as the 1st argument to the computation function.
    
      2. A signal function is supplied:
    
         (reg-sub
           :query-id
           signal-fn     ;; <-- here
           computation-fn)
    
         When a node is created from the template, the `signal-fn` will be called and it
         is expected to return the input signal(s) as either a singleton, if there is only
         one, or a sequence if there are many, or a map with the signals as the values.
    
         The values from the nominated signals will be supplied as the 1st argument to the
         computation function - either a singleton, sequence or map of them, paralleling
         the structure returned by the signal function.
    
         Here, is an example signal-fn, which returns a vector of input signals.
    
           (fn [query-vec dynamic-vec]
             [(subscribe [:a-sub])
              (subscribe [:b-sub])])
    
         For that signal function, the computation function must be written
         to expect a vector of values for its first argument.
           (fn [[a b] _] ....)
    
         If the signal function was simpler and returned a singleton, like this:
            (fn [query-vec dynamic-vec]
              (subscribe [:a-sub]))
    
         then the computation function must be written to expect a single value
         as the 1st argument:
    
            (fn [a _] ...)
    
      3. Syntax Sugar
    
         (reg-sub
           :a-b-sub
           :<- [:a-sub]
           :<- [:b-sub]
           (fn [[a b] [_]] {:a a :b b}))
    
      This 3rd variation is syntactic sugar for the 2nd. Pairs are supplied instead
      of an `input signals` functions. Each pair starts with a `:<-` and a subscription
      vector follows.
    
      For further understanding, read `/docs`, and look at the detailed comments in
      /examples/todomvc/src/subs.cljs
      

    rui 0.3.0
    UI components based on Reagent and Re-frame
    re-frame.subs/reg-subSourceDoc + Usages
    For a given `query-id`, register a `computation` function and input `signals`.
    
      At an abstract level, a call to this function allows you to register 'the mechanism'
      to later fulfil a call to `(subscribe [query-id ...])`.
    
      To say that another way, reg-sub allows you to create a template for a node
      in the signal graph. But note: reg-sub does not cause a node to be created.
      It simply allows you to register the template from which such a
      node could be created, if it were needed, sometime later, when the call
      to `subscribe` is made.
    
      reg-sub needs three things:
        - a `query-id`
        - the required inputs for this node
        - a computation function for this node
    
      The `query-id` is always the 1st argument to reg-sub and it is typically
      a namespaced keyword.
    
      A computation function is always the last argument and it has this general form:
        `(input-signals, query-vector) -> a-value`
    
      What goes in between the 1st and last args can vary, but whatever is there will
      define the input signals part of the template, and, as a result, it will control
      what values the computation functions gets as a first argument.
    
      There's 3 ways this function can be called - 3 ways to supply input signals:
    
      1. No input signals given:
    
         (reg-sub
           :query-id
           a-computation-fn)   ;; (fn [db v]  ... a-value)
    
         The node's input signal defaults to `app-db`, and the value within `app-db` is
         is given as the 1st argument to the computation function.
    
      2. A signal function is supplied:
    
         (reg-sub
           :query-id
           signal-fn     ;; <-- here
           computation-fn)
    
         When a node is created from the template, the `signal-fn` will be called and it
         is expected to return the input signal(s) as either a singleton, if there is only
         one, or a sequence if there are many, or a map with the signals as the values.
    
         The values from the nominated signals will be supplied as the 1st argument to the
         computation function - either a singleton, sequence or map of them, paralleling
         the structure returned by the signal function.
    
         Here, is an example signal-fn, which returns a vector of input signals.
    
           (fn [query-vec dynamic-vec]
             [(subscribe [:a-sub])
              (subscribe [:b-sub])])
    
         For that signal function, the computation function must be written
         to expect a vector of values for its first argument.
           (fn [[a b] _] ....)
    
         If the signal function was simpler and returned a singleton, like this:
            (fn [query-vec dynamic-vec]
              (subscribe [:a-sub]))
    
         then the computation function must be written to expect a single value
         as the 1st argument:
    
            (fn [a _] ...)
    
      3. Syntax Sugar
    
         (reg-sub
           :a-b-sub
           :<- [:a-sub]
           :<- [:b-sub]
           (fn [[a b] [_]] {:a a :b b}))
    
      This 3rd variation is syntactic sugar for the 2nd. Pairs are supplied instead
      of an `input signals` functions. Each pair starts with a `:<-` and a subscription
      vector follows.
    
      For further understanding, read `/docs`, and look at the detailed comments in
      /examples/todomvc/src/subs.cljs
      

    rui 0.3.0
    UI components based on Reagent and Re-frame
    re-frame.subs/reg-subSourceDoc + Usages
    For a given `query-id`, register a `computation` function and input `signals`.
    
      At an abstract level, a call to this function allows you to register 'the mechanism'
      to later fulfil a call to `(subscribe [query-id ...])`.
    
      To say that another way, reg-sub allows you to create a template for a node
      in the signal graph. But note: reg-sub does not cause a node to be created.
      It simply allows you to register the template from which such a
      node could be created, if it were needed, sometime later, when the call
      to `subscribe` is made.
    
      reg-sub needs three things:
        - a `query-id`
        - the required inputs for this node
        - a computation function for this node
    
      The `query-id` is always the 1st argument to reg-sub and it is typically
      a namespaced keyword.
    
      A computation function is always the last argument and it has this general form:
        `(input-signals, query-vector) -> a-value`
    
      What goes in between the 1st and last args can vary, but whatever is there will
      define the input signals part of the template, and, as a result, it will control
      what values the computation functions gets as a first argument.
    
      There's 3 ways this function can be called - 3 ways to supply input signals:
    
      1. No input signals given:
    
         (reg-sub
           :query-id
           a-computation-fn)   ;; (fn [db v]  ... a-value)
    
         The node's input signal defaults to `app-db`, and the value within `app-db` is
         is given as the 1st argument to the computation function.
    
      2. A signal function is supplied:
    
         (reg-sub
           :query-id
           signal-fn     ;; <-- here
           computation-fn)
    
         When a node is created from the template, the `signal-fn` will be called and it
         is expected to return the input signal(s) as either a singleton, if there is only
         one, or a sequence if there are many, or a map with the signals as the values.
    
         The values from the nominated signals will be supplied as the 1st argument to the
         computation function - either a singleton, sequence or map of them, paralleling
         the structure returned by the signal function.
    
         Here, is an example signal-fn, which returns a vector of input signals.
    
           (fn [query-vec dynamic-vec]
             [(subscribe [:a-sub])
              (subscribe [:b-sub])])
    
         For that signal function, the computation function must be written
         to expect a vector of values for its first argument.
           (fn [[a b] _] ....)
    
         If the signal function was simpler and returned a singleton, like this:
            (fn [query-vec dynamic-vec]
              (subscribe [:a-sub]))
    
         then the computation function must be written to expect a single value
         as the 1st argument:
    
            (fn [a _] ...)
    
      3. Syntax Sugar
    
         (reg-sub
           :a-b-sub
           :<- [:a-sub]
           :<- [:b-sub]
           (fn [[a b] [_]] {:a a :b b}))
    
      This 3rd variation is syntactic sugar for the 2nd. Pairs are supplied instead
      of an `input signals` functions. Each pair starts with a `:<-` and a subscription
      vector follows.
    
      For further understanding, read `/docs`, and look at the detailed comments in
      /examples/todomvc/src/subs.cljs
      

    re-frame-fork 0.10.2-1
    A Clojurescript MVC-like Framework For Writing SPAs Using Reagent.
    re-frame.subs/reg-subSourceDoc + Usages
    For a given `query-id`, register a `computation` function and input `signals`.
    
      At an abstract level, a call to this function allows you to register 'the mechanism'
      to later fulfil a call to `(subscribe [query-id ...])`.
    
      To say that another way, reg-sub allows you to create a template for a node
      in the signal graph. But note: reg-sub does not cause a node to be created.
      It simply allows you to register the template from which such a
      node could be created, if it were needed, sometime later, when the call
      to `subscribe` is made.
    
      reg-sub needs three things:
        - a `query-id`
        - the required inputs for this node
        - a computation function for this node
    
      The `query-id` is always the 1st argument to reg-sub and it is typically
      a namespaced keyword.
    
      A computation function is always the last argument and it has this general form:
        `(input-signals, query-vector) -> a-value`
    
      What goes in between the 1st and last args can vary, but whatever is there will
      define the input signals part of the template, and, as a result, it will control
      what values the computation functions gets as a first argument.
    
      There's 3 ways this function can be called - 3 ways to supply input signals:
    
      1. No input signals given:
    
         (reg-sub
           :query-id
           a-computation-fn)   ;; (fn [db v]  ... a-value)
    
         The node's input signal defaults to `app-db`, and the value within `app-db` is
         is given as the 1st argument to the computation function.
    
      2. A signal function is supplied:
    
         (reg-sub
           :query-id
           signal-fn     ;; <-- here
           computation-fn)
    
         When a node is created from the template, the `signal-fn` will be called and it
         is expected to return the input signal(s) as either a singleton, if there is only
         one, or a sequence if there are many, or a map with the signals as the values.
    
         The values from the nominated signals will be supplied as the 1st argument to the
         computation function - either a singleton, sequence or map of them, paralleling
         the structure returned by the signal function.
    
         Here, is an example signal-fn, which returns a vector of input signals.
    
           (fn [query-vec dynamic-vec]
             [(subscribe [:a-sub])
              (subscribe [:b-sub])])
    
         For that signal function, the computation function must be written
         to expect a vector of values for its first argument.
           (fn [[a b] _] ....)
    
         If the signal function was simpler and returned a singleton, like this:
            (fn [query-vec dynamic-vec]
              (subscribe [:a-sub]))
    
         then the computation function must be written to expect a single value
         as the 1st argument:
    
            (fn [a _] ...)
    
      3. Syntax Sugar
    
         (reg-sub
           :a-b-sub
           :<- [:a-sub]
           :<- [:b-sub]
           (fn [[a b] [_]] {:a a :b b}))
    
      This 3rd variation is syntactic sugar for the 2nd. Pairs are supplied instead
      of an `input signals` functions. Each pair starts with a `:<-` and a subscription
      vector follows.
    
      For further understanding, read `/docs`, and look at the detailed comments in
      /examples/todomvc/src/subs.cljs
      

    re-frame-utils 0.1.0
    Fxs and CoFxs for re-frame
    re-frame.subs/reg-subSourceDoc + Usages
    For a given `query-id`, register a `computation` function and input `signals`.
    
      At an abstract level, a call to this function allows you to register 'the mechanism'
      to later fulfil a call to `(subscribe [query-id ...])`.
    
      To say that another way, reg-sub allows you to create a template for a node
      in the signal graph. But note: reg-sub does not cause a node to be created.
      It simply allows you to register the template from which such a
      node could be created, if it were needed, sometime later, when the call
      to `subscribe` is made.
    
      reg-sub needs three things:
        - a `query-id`
        - the required inputs for this node
        - a computation function for this node
    
      The `query-id` is always the 1st argument to reg-sub and it is typically
      a namespaced keyword.
    
      A computation function is always the last argument and it has this general form:
        `(input-signals, query-vector) -> a-value`
    
      What goes in between the 1st and last args can vary, but whatever is there will
      define the input signals part of the template, and, as a result, it will control
      what values the computation functions gets as a first argument.
    
      There's 3 ways this function can be called - 3 ways to supply input signals:
    
      1. No input signals given:
    
         (reg-sub
           :query-id
           a-computation-fn)   ;; (fn [db v]  ... a-value)
    
         The node's input signal defaults to `app-db`, and the value within `app-db` is
         is given as the 1st argument to the computation function.
    
      2. A signal function is supplied:
    
         (reg-sub
           :query-id
           signal-fn     ;; <-- here
           computation-fn)
    
         When a node is created from the template, the `signal-fn` will be called and it
         is expected to return the input signal(s) as either a singleton, if there is only
         one, or a sequence if there are many, or a map with the signals as the values.
    
         The values from the nominated signals will be supplied as the 1st argument to the
         computation function - either a singleton, sequence or map of them, paralleling
         the structure returned by the signal function.
    
         Here, is an example signal-fn, which returns a vector of input signals.
    
           (fn [query-vec dynamic-vec]
             [(subscribe [:a-sub])
              (subscribe [:b-sub])])
    
         For that signal function, the computation function must be written
         to expect a vector of values for its first argument.
           (fn [[a b] _] ....)
    
         If the signal function was simpler and returned a singleton, like this:
            (fn [query-vec dynamic-vec]
              (subscribe [:a-sub]))
    
         then the computation function must be written to expect a single value
         as the 1st argument:
    
            (fn [a _] ...)
    
      3. Syntax Sugar
    
         (reg-sub
           :a-b-sub
           :<- [:a-sub]
           :<- [:b-sub]
           (fn [[a b] [_]] {:a a :b b}))
    
      This 3rd variation is syntactic sugar for the 2nd. Pairs are supplied instead
      of an `input signals` functions. Each pair starts with a `:<-` and a subscription
      vector follows.
    
      For further understanding, read `/docs`, and look at the detailed comments in
      /examples/todomvc/src/subs.cljs
      

    clojure-contrib 1.2.0
    Clojure user contributions library.
    clojure.contrib.datalog.magic/adorn-querySourceDoc + Usages
    Adorn a query

    datalog 0.1.1
    contrib.datalog brought back to life
    datalog.magic/adorn-querySourceDoc + Usages
    Adorn a query

    clj-momo 0.2.23
    Library code produced by the Cisco ThreatGrid team for building swagger backed API
    clj-momo.lib.es.query/termsSourceDoc + Usages
    Terms Query

    clj-momo 0.2.23
    Library code produced by the Cisco ThreatGrid team for building swagger backed API
    clj-momo.lib.es.query/termSourceDoc + Usages
    Term Query

    clj-momo 0.2.23
    Library code produced by the Cisco ThreatGrid team for building swagger backed API
    clj-momo.lib.es.query/filteredSourceDoc + Usages
    Filtered query

    clj-momo 0.2.23
    Library code produced by the Cisco ThreatGrid team for building swagger backed API
    clj-momo.lib.es.query/boolSourceDoc + Usages
    Boolean Query

    postgres-gateway 1.12.1
    ClanHR postgres-gateway
    clanhr.postgres-gateway.core/trackSourceDoc + Usages
    Tracks a query

    cleancr 1.0-beta3
    Finds and optionally removes carriage return characters from your project text files
    clojure.contrib.datalog.magic/adorn-querySourceDoc + Usages
    Adorn a query

    qseq 0.6.3
    qseq: a lazy sequence for simply and efficiently consuming Korma
    qseq.korma/executeSourceDoc + Usages
    execute a query

    clj-gae-ds 0.3.1
    a datastore library on Google App Engine for Clojure
    am.ik.clj-gae-ds.core/prepareSourceDoc + Usages
    parepare query.

    clj-gae-ds 0.3.1
    a datastore library on Google App Engine for Clojure
    am.ik.clj-gae-ds.core/qSourceDoc + Usages
    aliase of (query)

    clj-gae-ds 0.3.1
    a datastore library on Google App Engine for Clojure
    am.ik.clj-gae-ds.core/querySourceDoc + Usages
    create query.

    fook 0.3.0
    Small utilities for datomic
    fook.query/assoc-querySourceDoc + Usages
    Assoc into a query

    bacwn 0.1.0
    Deep studies in Clojure.
    bacwn.datalog.impl.magic/adorn-querySourceDoc + Usages
    Adorn a query

    suricatta 0.2.2
    High level sql toolkit for clojure (backed by jooq library)
    suricatta.impl/query~PersistentVector~IQuerySourceDoc + Usages
    Build a query.

    suricatta 0.2.2
    High level sql toolkit for clojure (backed by jooq library)
    suricatta.impl/query~String~IQuerySourceDoc + Usages
    Build a query.

    suricatta 0.2.2
    High level sql toolkit for clojure (backed by jooq library)
    suricatta.proto/querySourceDoc + Usages
    Build a query.

    riemann-clojure-client 0.4.5
    Clojure client for the Riemann monitoring system
    riemann.codec/decode-pb-querySourceDoc + Usages
    Transforms a java protobuf Query to a Query.

    macros 0.2.63
    Clojure macros for web and mobile development
    workflo.macros.query.om-util/param-querySourceDoc + Usages
    Returns the query of a parameterized query expression.

    riemann-jmx-clj 0.1.1
    A JMX connector to riemann
    riemann.codec/decode-pb-querySourceDoc + Usages
    Transforms a java protobuf Query to a Query.

    query-engine 0.1.30
    Execute Om Next queries against various data layers
    workflo.query-engine.query.process/param-querySourceDoc + Usages
    Returns the query of a parameterized query expression.

    query-engine 0.1.30
    Execute Om Next queries against various data layers
    workflo.query-engine.query.process/join-querySourceDoc + Usages
    Returns the query of a join query expression.

    docker 0.2.0
    A work in progress docket API client
    docker.client/stringify-optionsSourceDoc + Usages
    turns query map into query string

    clopp 0.2.0
    clopp : appliation components in clojure
    clopp.dataset/querySourceDoc + Usages
    run the query with id <query-id>

    sqlosure 0.2.0
    Compositional relational queries.
    sqlosure.core/<-SourceDoc + Usages
    Embed a RA query into the current query.

    sqlosure 0.2.0
    Compositional relational queries.
    sqlosure.query-comprehension/embedSourceDoc + Usages
    Embed a RA query into the current query.

    plaza 0.2.0-alpha1
    Plaza framework for semantic distributed applications
    plaza.rdf.sparql/parse-sparql-to-querySourceDoc + Usages
    Parses a SPARQL query and builds a query

    plaza 0.2.0-alpha1
    Plaza framework for semantic distributed applications
    plaza.rdf.implementations.jena/parse-sparql-to-query~JenaSparqlFramework~SparqlFrameworkSourceDoc + Usages
    Parses a SPARQL query and builds a query

    Parses a SPARQL query and builds a query

    clj-osf 0.1.2
    Clojure API for Open Semantic Framework web services queries
    clj-osf.core/->postSourceDoc + Usages
    Specify that the query is a HTTP POST query

    squee 0.0.1
    A fresh JDBC library
    squee.jdbc/querySourceDoc + Usages
    Execute an SQL query against a Connection or open transaction.
       params is a function that parameterizes the query, like #'params
    
       Examples:
       (query conn "select * from bar")
    
       (query conn "select * from foo where x = ? and y = ? " (params 4 5))
    
       opts supported:
        :result-type :forward-only | :scroll-insensitive | :scroll-sensitive
        :concurrency :read-only | :updatable
        :cursors
        :fetch-size n
        :max-rows n
        :timeout n
    
        :create-statement!  Providing this function (of a Connection) will override the above arguments
    
        :result-set-fn      By default, this turns the ResultSet into a vector of maps.
    
        Described in #'reducible-result-set:
        :row-strategy
        :name-keys

    pedestal-lacinia 0.1.1
    Pedestal infrastructure supporting Lacinia GraphQL
    com.walmartlabs.lacinia.pedestal/graphql-routesSourceDoc + Usages
    Creates default routes for handling GET and POST requests (at `/graphql`) and
      (optionally) the GraphiQL IDE (at `/`).
    
      Returns a set of route vectors, compatible with
      `io.pedestal.http.route.definition.table/table-routes`.
    
      The standard interceptor stack:
    
      * [[json-response-interceptor]]
      * [[require-graphql-content-interceptor]] (for method POST)
      * [[graphql-data-interceptor]]
      * [[missing-query-interceptor]]
      * [[query-parser-interceptor]]
      * [[status-conversion-interceptor]]
      * [[query-executor-handler]]
    
      Options:
    
      :graphiql (default false)
      : If true, enables routes for the GraphiQL IDE.
    
      :app-context
      : The base application context provided to Lacinia when executing a query.

    potpuri 0.5.1
    Common stuff missing from the clojure.core.
    potpuri.core/build-treeSourceDoc + Usages
    Builds a tree from given items collections.
    
      ID is what is used to match parents and children.
      Root items are those where parent-fn returns nil.
    
      Options:
    
      - :parent-fn (required) Used to create a map from ID => children
      - :id-fn (required) Used to get the ID from an item
      - :assoc-children-fn (required) Attach the children to an item
      - :item-fn (optional) Called for each item, after children has been attached to the item
      - :children-fn (optional) Called for each children collection
    
      Example:
        (build-tree {:id-fn :id, :parent-fn :parent, :assoc-children-fn #(assoc %1 :children %2)}
                    [{:id 1} {:id 2 :parent 1} {:id 3 :parent 1}])
        => [{:id 1 :children [{:id 2} {:id 3}]}]
    
      Check test file for more examples.

    sweatkit 0.1.4
    A Clojure library to work with sports activities data
    sweatkit.core/paceSourceDoc + Usages
    Takes a measured object and an optional reducing fn. When the fn is not
       given, yields the whole Pace track, otherwise it returns a single value.
       rfn can be any fn reducing point-vals or one of these keywords for
       standard behavior: :avg, :max, :min.
    
       If the measured obj doesn't have this metric itself, this fn tries to get
       it via the :speed metric, in case it exists.

    iron 0.4.0
    Front-end utilities and support for ClojureScript and re-frame projects
    iron.core/<atom (cljs)SourceDoc + Usages
    Get a value from an atom. Suitable to use, e.g., as the :value or
      :default-value parameter to a component.
      Atom is the atom to be dereferenced. It will be translated by access-fn.
      If null, default will be supplied instead.

    ganelon 0.9.0
    Microframework bringing instant development of AJAX-enabled web applications to
    ganelon.web.dyna-routes/setroute!SourceDoc + Usages
    Register route in a namespace. When no namespace is provided, use :default namespace.
    
    Routes from a namespace can be referenced later on by route-ns-fn.
    
    Example:
    
    (setroute! :example2
      (compojure.core/GET "/routing/sample2" []
        "Hello world !!!"))

    com.chpill.re-frankenstein 0.0.2
    The deviant fork of re-frame
    re-frame.rum/inject-frank-into-context (cljs)SourceDoc + Usages
    Inject Frank instance into current react context. The Frank instance
      must be provided as argument to the component to which this mixins is applied.
      The `get-frank-fn` will then be used to extract the Frank from the
      arguments.

    clojure-contracts-maps 0.1.0
    Simple map accessors with contracts
    clojure-contracts-maps/compose-map-get-accessorSourceDoc + Usages
    composes the get accessor using a pre-created leaf function
       the generated fn takes a map and, optional default value
       returns the value in the map, the dynamic default or static default

    zifile 0.2.0
    a lib of clojure about file operations.一个关于文件处理的clojure库
    zifile.core/readfileSourceDoc + Usages
    open and read a file,return the obj of BufferedReader,if you pass two args to this fn,you will get a few options of the file,use doc to view more details

    tumalo 0.2.1
    Clojure Elasticsearch Indexing Tools
    tumalo.es/reduce-objects-and-streamsSourceDoc + Usages
    Inputs: [s3-client :- AmazonS3Client processing-fn accum :- [s/Any] s3-object-summary :- S3ObjectSummary]
    
      Reducer: get the S3 object, process it, concat the returned values and streams to the :values and
      :streams sequences in the accumulating map

    mongologic 0.5.6
    Toolkit to develop MongoDB apps with Clojure
    mongologic.core/add-to-callback-queueSourceDoc + Usages
    #IMPORTANT
      Callback queues currently only supported in :after-update and :after-delete
    
      Example:
    
           (swap! (get-in component [:entity :after-update])  ; must be an atom
                  add-to-callback-queue
                  new-callback-fn)

    pipeline 0.2.1
    A pipeline for GraphQL execution, as well as a Ring handler.
    alumbra.pipeline/handlerSourceDoc + Usages
    Generate a Ring Handler for handling GraphQL requests.
    
       - `:parser-fn`: a parser function for GraphQL documents (producing a value
         conforming to either `:alumbra/document` or `:alumbra/parser-errors`),
       - `:validator-fn`: a function taking an `:alumbra/document` and producing either
         `nil` or a value conforming to `:alumbra/validation-errors`,
       - `:canonicalize-fn`: a function taking an `:alumbra/document` and producing
         an `:alumbra/canonical-document`,
       - `:context-fn`: a function taking an HTTP request and returning a value
         representing the context of the GraphQL query,
       - `:executor-fn`: an executor function, taking the request context, as well as
         a map conforming to `:alumbra/canonical-operation` and returning the resolved
         result.
    
       The resulting handler will expect queries to be sent using `POST`,
       represented by a JSON map with the keys `"operationName"`, `"query"`
       and `"variables"`.

    incanter-core 1.9.3
    Incanter-core is the core module of the Incanter project.
    incanter.core/$mapSourceDoc + Usages
      This function returns a sequence resulting from mapping the given function over
      the value(s) for the given column key(s) of the given dataset.
      Like other '$*' functions, it will use $data as the default dataset
      if none is provided, where $data is set using the with-data macro.
    
      Examples:
    
        (use '(incanter core datasets))
        (def cars (get-dataset :cars))
    
        ($map (fn [s] (/ s)) :speed cars)
        ($map (fn [s d] (/ s d)) [:speed :dist] cars)
    
        (with-data (get-dataset :cars)
          (view ($map (fn [s] (/ s)) :speed))
          (view ($map (fn [s d] (/ s d)) [:speed :dist])))
    
        ;; calculate the speed to dist ratio and append as new column to dataset
        (with-data (get-dataset :cars)
          (conj-cols $data ($map (fn [s d] (/ s d)) [:speed :dist])))
      

    Creates standard REST routes for all CRUD operations, taking root path, entity service
       and entity primary key as attributes. Created paths for according http verbs are: 
       1. List   - 'GET path/' (uses sorting parameters from request if present)
       2. Get    - 'GET path/:id'
       3. Query  - 'GET path' (uses querying and sorting parameters from request if present)
       4. Update - 'PUT path/:id'
       5. Create - 'POST path/'
       6. Delete - 'DELETE path/:id'
       Map with post functions for each path (:list :get :query :update :create :delete) can be 
       optionally passed in as fourth argument, corresponding functions will be then called with
       result of entity service call

    pedestal.route 0.5.3
    Pedestal route definition and router construction
    io.pedestal.http.route/parse-query-stringSourceDoc + Usages
    Parses URL query string (not including the leading '?') into a map.
      options are key-value pairs, valid options are:
    
         :key-fn    Function to call on parameter keys (after URL
                    decoding), returns key for the map, default converts
                    to a keyword.
    
         :value-fn  Function to call on the key (after passing through
                    key-fn) and parameter value (after URL decoding),
                    returns value for the map, default does nothing.

    http-kit 2.3.0
    High-performance event-driven HTTP client/server for Clojure
    org.httpkit.client/requestSourceDoc + Usages
    Issues an async HTTP request and returns a promise object to which the value
      of `(callback {:opts _ :status _ :headers _ :body _})` or
         `(callback {:opts _ :error _})` will be delivered.
      The latter will be delivered on client errors only, not on http errors which will be
      contained in the :status of the first.
    
      When unspecified, `callback` is the identity
    
      ;; Asynchronous GET request (returns a promise)
      (request {:url "http://www.cnn.com"})
    
      ;; Asynchronous GET request with callback
      (request {:url "http://www.cnn.com" :method :get}
        (fn [{:keys [opts status body headers error] :as resp}]
          (if error
            (println "Error on" opts)
            (println "Success on" opts))))
    
      ;; Synchronous requests
      @(request ...) or (deref (request ...) timeout-ms timeout-val)
    
      ;; Issue 2 concurrent requests, then wait for results
      (let [resp1 (request ...)
            resp2 (request ...)]
        (println "resp1's status: " (:status @resp1))
        (println "resp2's status: " (:status @resp2)))
    
      Output coercion:
      ;; Return the body as a byte stream
      (request {:url "http://site.com/favicon.ico" :as :stream})
      ;; Coerce as a byte-array
      (request {:url "http://site.com/favicon.ico" :as :byte-array})
      ;; return the body as a string body
      (request {:url "http://site.com/string.txt" :as :text})
      ;; Try to automatically coerce the output based on the content-type header, currently supports :text :stream, (with automatic charset detection)
      (request {:url "http://site.com/string.txt" :as :auto})
    
      Request options:
        :url :method :headers :timeout :connect-timeout :idle-timeout :query-params
        :as :form-params :client :body :basic-auth :user-agent :filter :worker-pool

    macros 0.2.63
    Clojure macros for web and mobile development
    workflo.macros.view/defviewSourceDoc + Usages
    Create a new view with the given name.
    
       Takes an optional query, an optional computed properties "query"
       and an arbitrary number of Om Next component functions (such
       as `ident`, `query`, `query-params`, `initLocalState` or `render`)
       and JavaScript object methods, without requiring their protocols or
       argument bindings (like `[this]` or `[props]`) to be included in
       the definition.
    
       `defview` will wrap the function bodies of all instance functions
       (`ident`, `render`, lifecycle functions, any object methods) so that
       the values in the query result and in computed properties are bound
       to the names appearing in the queries.
    
       Usage:
    
       ```
       (defview User
         [name email address [street city zipcode]]
         [clicked-fn]
         (key name)
         (validate ...)
         (ident [:user/by-name name])
         (render
           (html
             [:div.user {:onClick clicked-fn}
              [:h2 name "(" email ")"]
              [:ul.address
               [:li street]
               [:li city]
               [:li zipcode]]])))
       ```
    
       The above example would define the following:
    
         * an Om Next component called `User`,
         * a component factory called `user`, with a `:keyfn`,
           derived from `(key ...)`, and a `:validator`, derived
           from `(validate ...)`.
    
       If the query includes `[db [id]]`, corresponding to the Om Next
       query attribute `:db/id`, it is assumed that the view represents
       data from DataScript or Datomic. In this case, `defview` will
       automatically infer `(ident ...)` and `(key ...)` functions
       based on the database ID. This behavior can be overriden by
       specifically defining both, `ident` and `key`.

    clarango 0.7.1
    A Clojure client for the HTTP API of ArangoDB
    clarango.query/execute-countSourceDoc + Usages
    Executes a query. Takes also the options 'batch-size' and 'count'.
    
      First argument must be the query string to be executed.
    
      Second argument must be the batch size. This is the amount of documents that will be returned in the first answer of the
      server. In case there are more documents, in the server answer there will be the attribute 'hasMore' set to true.
      In this case you can then use the returned cursor 'id' with the method get-more-results to get the remaining results.
    
      Third argument is 'count', a boolean flag indicating whether or not the number of documents that were found for the query
      should be included in the result of the query as 'count' attribute. This is turned off by default because it might have
      an influence on the performance of the query.
    
      If the query references any bind variables, you must additionally pass these in a map as the fourth argument like this:
      { 'id' 3 } (replace the single quotes with double quotes)
      If you don't use any variables, you can leave this out.
    
      Optionally you can pass a database name as fifth or fourth argument. If omitted, the default db will be used.
    
      The actual result of the query will be contained in the attribute 'result' as a vector.

    clj-apache-https 1.0.18
    Clojure HTTP library using the Apache HttpClient. Based on clj-apache-http, but
    com.twinql.clojure.async-client/build-requestSourceDoc + Usages
    Returns an HttpReqest object. You can make a sequence of requests and
       pass them into execute-batch!
    
       Param options is a map with the following keys. :method and :url are
       required. The rest are optional:
    
       :method             The HTTP request method. This is a symbol, and should be
                           one of :get, :post, :put, :head, :options, :delete.
    
       :url                A string: the url you want to get or post to.
    
       :headers            A map of request headers.
    
       :basic-auth-name    The user/account name to use for a server that requires
                           basic authentication.
    
       :basic-auth-pwd     The password to use for a server that requires basic
                           authentication.
    
       :body               A string. This will become the body of the PUT OR POST.
    
       :query-params       A map of query parameters. These will be URL-encoded
                           and added to the query string for a GET request or
                           to the body of a PUT or POST.

    qualityclj 0.2.3
    Assess Clojure libraries based on a number of different metrics.
    taoensso.sente/make-channel-socket! (cljs)SourceDoc + Usages
    Returns a map with keys:
        :ch-recv ; core.async channel to receive `event-msg`s (internal or from clients).
        :send-fn ; (fn [user-id ev] for server>user push.
        :ajax-post-fn                ; (fn [ring-req]  for Ring CSRF-POST + chsk URL.
        :ajax-get-or-ws-handshake-fn ; (fn [ring-req]) for Ring GET + chsk URL.
        :connected-uids ; Watchable, read-only (atom {:ws #{_} :ajax #{_} :any #{_}}).
    
      Common options:
        :user-id-fn       ; (fn [ring-req]) -> unique user-id for server>user push.
        :csrf-token-fn    ; (fn [ring-req]) -> CSRF token for Ajax POSTs.
        :send-buf-ms-ajax ; [1]
        :send-buf-ms-ws   ; [1]
        :packer           ; :edn (default), or an IPacker implementation (experimental).
    
      [1] Optimization to allow transparent batching of rapidly-triggered
          server>user pushes. This is esp. important for Ajax clients which use a
          (slow) reconnecting poller. Actual event dispatch may occur <= given ms
          after send call (larger values => larger batch windows).

    See [[fn/fn-node]]

    rewrite-cljs 0.4.4
    Comment-/Whitespace-preserving rewriting of EDN documents.
    rewrite-clj.node/fn-node (cljs)SourceDoc + Usages
    See [[fn/fn-node]]

    azip 0.2.0
    Zippers for labeled unordered trees, such as nested maps
    mg.dt.azip/azipperSourceDoc + Usages
    Creates a new associative zipper structure.
    
      branch? is a fn that, given a node, returns true if it can
      have children, even if it currently doesn't.
    
      children is a fn, that, given a branch node, returns a seq
      of keys of its children.
    
      get-child is a fn, that, given a branch node and a key, returns
      a child of node for the key.
    
      set-child is a fn, that, given a branch node, a key and a value,
      returns a new node with a child for the key set to the value.
    
      del-child is a fn, that, given a branch node and a key, returns
      a new node with a child for the key deleted.

    fusion-clj 0.1.3
    Fusing ephemeral kafka queues for dependent distibuted processes
    fusion-clj.reactor/reactorSourceDoc + Usages
    Given a dependency function (deps-fn) and a processing
      function (proc-fn) returns a function which accepts an elements
      map. When invoked, processes messages from a kafka consumer, calls
      deps-fn with each message to get an array of dependent topics,
      processes those deps, and finally calls proc-fn with the original
      message and a seq of messages returned from the dependent services. If
      the original message has a :return-topic key, puts the result of
      proc-fn on that topic and the resulting map gets put on the channel, if
      not, puts the result on the channel returned by the invoked reactor.

    nginx-clojure 0.4.5
    Nginx module for clojure or groovy or java programming
    nginx.clojure.core/co-pcallsSourceDoc + Usages
    Executes the no-arg fns in parallel coroutines, returning a  sequence of their values
       If there's no coroutine support, it will turn to use thread pool to make testing with lein-ring easy.
       e.g. fetch two services in parallel:
       (let [[r1, r2] (co-pcalls (fn[] (client/get "http://page1-url")) (fn[] (client/get "http://page2-url")))]
        ;println bodies of two remote responses
        (println (str (:body r1) "====\n" (:body r2) ))
      

    hara.object 2.8.6
    patterns and utilities
    hara.object.map-like/write-proxy-functionsSourceDoc + Usages
    creates a proxy access through a field in the object
     
       (write-proxy-functions {:school [:name :raw]})
       => '{:name (clojure.core/fn [obj v]
                    (clojure.core/let [proxy (hara.object.access/get obj :school)]
                      (hara.object.access/set proxy :name v))),
            :raw (clojure.core/fn [obj v]
                   (clojure.core/let [proxy (hara.object.access/get obj :school)]
                    (hara.object.access/set proxy :raw v)))}

    aramis 0.1.1
    A library providing a Promise.all()-like capabilities for re-frame.
    re-frame.subs/reg-subSourceDoc + Usages
    Register a given handler function for a given query id.
    
      There's 3 ways this function can be called
    
      1. (reg-sub
           :test-sub
           (fn [db [_]] db))
      The value in app-db is passed to the computation function as the 1st argument.
    
      2. (reg-sub
           :a-b-sub
           (fn [q-vec d-vec]
             [(subs/subscribe [:a-sub])
              (subs/subscribe [:b-sub])])
           (fn [[a b] [_]] {:a a :b b}))
    
      Two functions provided. The 2nd is computation fucntion, as before. The 1st
      is returns what `input signals` should be provided to the computation. The
      `input signals` function is called with two arguments: the query vector
      and the dynamic vector. The return value can be singleton reaction or
      a sequence of reactions.
    
      3. (reg-sub
           :a-b-sub
           :<- [:a-sub]
           :<- [:b-sub]
           (fn [[a b] [_]] {:a a :b b}))```
      This 3rd variation is just syntactic sugar for the 2nd. Pairs are supplied instead
      of an `input signals` functions. `:<-` is supplied followed by the subscription
      vector.
      

    com.chpill.re-frankenstein 0.0.2
    The deviant fork of re-frame
    re-frame.subs/reg-subSourceDoc + Usages
    Associate the given `query id` with a handler function and an optional signal function.
    
      There's 3 ways this function can be called
    
      1. (reg-sub
           :test-sub
           (fn [db [_]] db))
      The value in app-db is passed to the computation function as the 1st argument.
    
      2. (reg-sub
           :a-b-sub
           (fn [q-vec d-vec]
             [(subs/subscribe [:a-sub])
              (subs/subscribe [:b-sub])])
           (fn [[a b] [_]] {:a a :b b}))
    
      Two functions provided. The 2nd is computation function, as before. The 1st
      is returns what `input signals` should be provided to the computation. The
      `input signals` function is called with two arguments: the query vector
      and the dynamic vector. The return value can be singleton reaction or
      a sequence of reactions.
    
      3. (reg-sub
           :a-b-sub
           :<- [:a-sub]
           :<- [:b-sub]
           (fn [[a b] [_]] {:a a :b b}))```
      This 3rd variation is just syntactic sugar for the 2nd. Pairs are supplied instead
      of an `input signals` functions. `:<-` is supplied followed by the subscription
      vector.
      

    district0x 0.1.20
    district0x Frontend Library
    re-frame.subs/reg-subSourceDoc + Usages
    Associate the given `query id` with a handler function and an optional signal function.
    
      There's 3 ways this function can be called
    
      1. (reg-sub
           :test-sub
           (fn [db [_]] db))
      The value in app-db is passed to the computation function as the 1st argument.
    
      2. (reg-sub
           :a-b-sub
           (fn [q-vec d-vec]
             [(subs/subscribe [:a-sub])
              (subs/subscribe [:b-sub])])
           (fn [[a b] [_]] {:a a :b b}))
    
      Two functions provided. The 2nd is computation function, as before. The 1st
      is returns what `input signals` should be provided to the computation. The
      `input signals` function is called with two arguments: the query vector
      and the dynamic vector. The return value can be singleton reaction or
      a sequence of reactions.
    
      3. (reg-sub
           :a-b-sub
           :<- [:a-sub]
           :<- [:b-sub]
           (fn [[a b] [_]] {:a a :b b}))```
      This 3rd variation is just syntactic sugar for the 2nd. Pairs are supplied instead
      of an `input signals` functions. `:<-` is supplied followed by the subscription
      vector.
      

    editable 0.1.4
    lifecycle events for forms using re-frame
    re-frame.subs/reg-subSourceDoc + Usages
    Associate the given `query id` with a handler function and an optional signal function.
    
      There's 3 ways this function can be called
    
      1. (reg-sub
           :test-sub
           (fn [db [_]] db))
      The value in app-db is passed to the computation function as the 1st argument.
    
      2. (reg-sub
           :a-b-sub
           (fn [q-vec d-vec]
             [(subs/subscribe [:a-sub])
              (subs/subscribe [:b-sub])])
           (fn [[a b] [_]] {:a a :b b}))
    
      Two functions provided. The 2nd is computation function, as before. The 1st
      is returns what `input signals` should be provided to the computation. The
      `input signals` function is called with two arguments: the query vector
      and the dynamic vector. The return value can be singleton reaction or
      a sequence of reactions.
    
      3. (reg-sub
           :a-b-sub
           :<- [:a-sub]
           :<- [:b-sub]
           (fn [[a b] [_]] {:a a :b b}))```
      This 3rd variation is just syntactic sugar for the 2nd. Pairs are supplied instead
      of an `input signals` functions. `:<-` is supplied followed by the subscription
      vector.
      

    incanter-core 1.9.3
    Incanter-core is the core module of the Incanter project.
    incanter.core/$fnSourceDoc + Usages
      A simple macro used as syntactic sugar for defining predicate functions to be used
      in the $where function. The supplied arguments should be column names of a dataset.
      This macro performs map destructuring on the arguments.
    
      For instance,
      ($fn [speed] (< speed 10)) => (fn [{:keys [speed]}] (< speed 10))
    
      Examples:
        (use '(incanter core datasets))
        (view ($where ($fn [speed dist] (or (> speed 20) (< dist 10))) (get-dataset :cars)))
    
        (view ($where ($fn [speed dist] (< (/ dist speed) 2)) (get-dataset :cars)))
    
        (use '(incanter core datasets charts))
        (with-data (get-dataset :cars)
          (doto (scatter-plot :speed :dist :data ($where ($fn [speed dist] (< (/ dist speed) 2))))
            (add-points :speed :dist :data ($where ($fn [speed dist] (>= (/ dist speed) 2))))
            (add-lines ($ :speed) (mult 2 ($ :speed)))
            view))
    
    
        (let [passed? ($fn [speed dist] (< (/ dist speed) 2))
              failed? (complement passed?)]
          (with-data (get-dataset :cars)
            (doto (scatter-plot :speed :dist :data ($where passed?))
              (add-points :speed :dist :data ($where failed?))
              (add-lines ($ :speed) (mult 2 ($ :speed)))
              view)))
    
    
        (use '(incanter core stats charts))
        (let [above-sine? ($fn [col-0 col-1] (> col-1 (sin col-0)))
              below-sine? (complement above-sine?)]
          (with-data (conj-cols (sample-uniform 1000 :min -5 :max 5)
                                (sample-uniform 1000 :min -1 :max 1))
            (doto (function-plot sin -5 5)
              (add-points :col-0 :col-1 :data ($where above-sine?))
              (add-points :col-0 :col-1 :data ($where below-sine?))
              view)))
    
    
        (view ($where ($fn [] (> (rand) 0.9)) (get-dataset :cars)))
    
        (view ($where ($fn [Species] ($in Species #{"virginica" "setosa"})) (get-dataset :iris)))
      

    elastisch 3.0.0
    Minimalistic fully featured well documented Clojure Elasticsearch client
    clojurewerkz.elastisch.native.document/multi-getSourceDoc + Usages
    Multi get returns only documents that are found (exist).
    
      Queries can passed as a collection of maps with three keys: `:_index`,
      `:_type` and `:_id`:
    
      ```clojure
      (doc/multi-get conn [{:_index index-name :_type mapping-type :_id "1"}
                           {:_index index-name :_type mapping-type :_id "2"}])
      ```
    
      2-argument version accepts an index name that eliminates the need to include
      `:_index` in every query map:
    
      ```clojure
      (doc/multi-get conn index-name [{:_type mapping-type :_id "1"}
                                      {:_type mapping-type :_id "2"}])
      ```
    
      3-argument version also accepts a mapping type that eliminates the need to include
      `:_type` in every query map:
    
      ```clojure
      (doc/multi-get conn index-name mapping-type [{:_id "1"}
                                                   {:_id "2"}])
      ```

    elastisch 3.0.0
    Minimalistic fully featured well documented Clojure Elasticsearch client
    clojurewerkz.elastisch.rest.document/multi-getSourceDoc + Usages
    Multi get returns only documents that are found (exist).
    
      Queries can passed as a collection of maps with three keys: `:_index`,
      `:_type` and `:_id`:
    
      ```clojure
      (doc/multi-get conn [{:_index index-name :_type mapping-type :_id "1"}
                           {:_index index-name :_type mapping-type :_id "2"}])
      ```
    
      2-argument version accepts an index name that eliminates the need to include
      `:_index` in every query map:
    
      ```clojure
      (doc/multi-get conn index-name [{:_type mapping-type :_id "1"}
                                      {:_type mapping-type :_id "2"}])
      ```
    
      3-argument version also accepts a mapping type that eliminates the need to include
      `:_type` in every query map:
    
      ```clojure
      (doc/multi-get conn index-name mapping-type [{:_id "1"}
                                                   {:_id "2"}])
      ```

    yesql 0.5.3
    A Clojure library for using SQL
    yesql.core/require-sqlSourceDoc + Usages
    Require-like behavior for yesql, to prevent namespace pollution.
       Parameter is a list of [sql-source-file-name [:as alias] [:refer [var1 var2]]]
       At least one of :as or :refer is required
       Usage: (require-sql ["sql/foo.sql" :as foo-sql :refer [some-query-fn])

    fulcro 2.5.9
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    fulcro.client.primitives/merge-alternate-unionsSourceDoc + Usages
    Walks the given query and calls (merge-fn parent-union-component union-child-initial-state) for each non-default element of a union that has initial app state.
      You probably want to use merge-alternate-union-elements[!] on a state map or app.

    pipeline 0.2.1
    A pipeline for GraphQL execution, as well as a Ring handler.
    alumbra.pipeline.steps/run-ring-requestSourceDoc + Usages
    Like [[run]] but uses the given Ring `request` to extract `:query`,
       `:operation-name` and `:variables`.
    
       Additionally, `opts` may contain a `:context-fn` key that will be applied
       to the request to derive the `:context` key.
    
       Note that the request's `:body` has to be a map (i.e. already JSON-decoded).

    uruk 0.3.11
    Clojure wrapper of MarkLogic XML Content Connector For Java (XCC/J)
    uruk.core/convert-typesSourceDoc + Usages
    Return the result of applying type conversion to the given
      MarkLogic query result sequence. Default type mappings can be
      overridden (in part or in whole) with the optional parameter
      `type-mapping`, which should contain a transformation function keyed
      by an XCC type string. See `xml-type-str->conv-fn` above.

    jeesql 0.4.7
    A Clojure library for using SQL
    jeesql.core/require-sqlSourceDoc + Usages
    Require-like behavior for jeesql, to prevent namespace pollution.
       Parameter is a list of [sql-source-file-name [:as alias] [:refer [var1 var2]]]
       At least one of :as or :refer is required
       Usage: (require-sql ["sql/foo.sql" :as foo-sql :refer [some-query-fn])

    korma 0.5.0-RC1
    Tasty SQL for Clojure
    korma.core/with-batchSourceDoc + Usages
    Add a related entity. This behaves like `with`, except that, for has-many
       relationships, it runs a single query to get relations of all fetched rows.
       This is faster than regular `with` but it doesn't support many of the
       additional options (order, limit, offset, group, having)

    http.async.client 1.3.0
    Asynchronous HTTP Client for Clojure
    http.async.client/request-streamSourceDoc + Usages
    Consumes stream from given url.
      method - HTTP method to be used (:get, :post, ...)
      url - URL to set request to
      body-part-callback - callback that takes status (ref {}) of request
                           and received body part as vector of bytes
      options - are optional and can contain :headers, :param, and :query (see prepare-request).

    pedestal.route 0.5.3
    Pedestal route definition and router construction
    io.pedestal.http.route/form-action-for-routesSourceDoc + Usages
    Like 'url-for-routes' but the returned function returns a map with the keys
      :action, the URL string; and :method, the HTTP verb as a lower-case
      string. Also, the :method-param is :_method by default, so HTTP
      verbs other than GET and POST will be converted to POST with the
      actual verb in the query string.

    pedestal.route 0.5.3
    Pedestal route definition and router construction
    io.pedestal.http.route/merge-method-paramSourceDoc + Usages
    If the route's method is other than GET or POST and opts contains
      non-nil :method-param, adds the method name on to the :query-params
      map. Returns updated opts map. If opts does not contain
      :method-param, defaults to :_method.

    clj-spotify 0.1.7
    A client library for the Spotify Web API
    clj-spotify.core/get-audio-features-for-several-tracksSourceDoc + Usages
     Takes two arguments, a map m with query parameters and an optional oauth-token t.
      Compulsory key in m is :ids.
      :ids has to be a comma separated string of spotify track ids.
    
      Example: (get-audio-features-for-several-tracks {:ids "2Dlo9QsN9ohaz9kASYkKmv,6XYvLpqJFebcjnOTolwkGw"} "BQBw-JtC..._7GvA")

    clj-spotify 0.1.7
    A client library for the Spotify Web API
    clj-spotify.core/get-audio-features-for-a-trackSourceDoc + Usages
     Takes two arguments, a map m with query parameters and an optional oauth-token t.
      Compulsory key in m is :id.
      :id has to have the value of an existing track's id.
    
      Example: (get-audio-features-for-a-track {:id "2Dlo9QsN9ohaz9kASYkKmv"} "BQBw-JtC..._7GvA")

    clj-spotify 0.1.7
    A client library for the Spotify Web API
    clj-spotify.core/get-audio-analysis-for-a-trackSourceDoc + Usages
     Takes two arguments, a map m with query parameters and an optional oauth-token t.
      Compulsory key in m is :id.
      :id has to have the value of an existing track's id.
    
      Example: (get-audio-analysis-for-a-track {:id "2Dlo9QsN9ohaz9kASYkKmv"} "BQBw-JtC..._7GvA")

    clj-spotify 0.1.7
    A client library for the Spotify Web API
    clj-spotify.core/get-users-currently-playing-trackSourceDoc + Usages
     Takes two arguments, a map m with query parameters and an oauth-token t.
      There are no compulsary keys in m, optional key is :market.
      :market is an ISO 3166-1 alpha-2 country code.
      Example: (get-users-currently-playing-track {:market "SE"}  "BQBw-JtC..._7GvA")

    clj-spotify 0.1.7
    A client library for the Spotify Web API
    clj-spotify.core/get-info-about-current-users-current-playbackSourceDoc + Usages
     Takes two arguments, a map m with query parameters and an oauth-token t.
      There are no compulsary keys in m, optional key is :market.
      :market is an ISO 3166-1 alpha-2 country code.
      Example: (get-info-about-current-users-current-playback {:market "SE"}  "BQBw-JtC..._7GvA")

    clj-spotify 0.1.7
    A client library for the Spotify Web API
    clj-spotify.core/get-a-users-profileSourceDoc + Usages
     Takes two arguments, a map m with query parameters and an optional oauth-token t.
      Compulsory key in m is :user_id.
      :user_id has to be a spotify user id.
    
      Example: (get-a-users-profile {:user_id "elkalel"} "BQBw-JtC..._7GvA")

    clj-spotify 0.1.7
    A client library for the Spotify Web API
    clj-spotify.core/get-an-artists-related-artistsSourceDoc + Usages
     Takes two arguments, a map m with query parameters and an optional oauth-token t.
      Compulsory key in m is :id.
      :id has to be a spotify artist id.
    
      Example: (get-an-artists-related-artists {:id "4EF5vIcCYKMM61oYOG2Tqa"} "BQBw-JtC..._7GvA")

    clj-spotify 0.1.7
    A client library for the Spotify Web API
    clj-spotify.core/get-several-artistsSourceDoc + Usages
     Takes two arguments, a map m with query parameters and an optional oauth-token t.
      Compulsory key in m is :ids.
      :ids has to be a comma separated string of spotify artist ids.
    
      Example: (get-several-artists {:ids "1kK2LYgoP3raZNngbb1qMT,2RitCPbwEYyYNw5LkbXTGv"} "BQBw-JtC..._7GvA")

    clj-spotify 0.1.7
    A client library for the Spotify Web API
    clj-spotify.core/get-an-artistSourceDoc + Usages
     Takes two arguments, a map m with query parameters and an optional oauth-token t.
      Compulsory key in m is :id.
      :id has to have the value of an existing artist's id.
    
      Example: (get-an-artist {:id "5CE2IfdYZEQGIDsfiRm8SI"} "BQBw-JtC..._7GvA")

    tgkorma 0.4.3
    Tasty SQL for Clojure
    korma.core/with-batchSourceDoc + Usages
    Add a related entity. This behaves like `with`, except that, for has-many
       relationships, it runs a single query to get relations of all fetched rows.
       This is faster than regular `with` but it doesn't support many of the
       additional options (order, limit, offset, group, having)

    restql-core 2.1.8
    Microservice query language
    restql.core.async-runner/do-runSourceDoc + Usages
    it separates all queries in three states, :done :requested and :to-do
       then sends all to-dos to resolve, changing their statuses to :requested.
       As the results get ready, update the query status to :done and send all to-dos again.
       When all queries are :done, the process is complete, and the :done part of the state is returned.

    restql-core 2.1.8
    Microservice query language
    restql.core.async-runner/do-runSourceDoc + Usages
    it separates all queries in three states, :done :requested and :to-do
       then sends all to-dos to resolve, changing their statuses to :requested.
       As the results get ready, update the query status to :done and send all to-dos again.
       When all queries are :done, the process is complete, and the :done part of the state is returned.

    ceterumnet-korma 0.3.1-RC2
    Tasty SQL for Clojure - ceterumnet fork
    korma.core/with-batchSourceDoc + Usages
    Add a related entity. This behaves like `with`, except that, for has-many relationships,
       it runs a single query to get relations of all fetched rows. This is faster than regular `with`
       but it doesn't support many of the additional options (order, limit, offset, group, having)

    fulcro 2.5.9
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    fulcro.client.network/transmit~FulcroHTTPRemote~FulcroRemoteISourceDoc + Usages
    Send the given `request`, which will contain:
         - `:fulcro.client.network/edn` : The actual API tx to send.
         - `:fulcro.client.network/ok-handler` : complete-fn
         - `:fulcro.client.network/error-handler` : error-fn
         - `:fulcro.client.network/progress-handler` : update-fn
    
         It may also optionally include:
         - `:fulcro.client.network/abort-id` : An ID to remember the network request by, to enable user-level API abort
    
         When you implement this protocol, you MUST call the `ok-handler` or `error-handler` exactly once. You *may*
         call the `progress-handler` any number of times (including none).
    
         ok-hander - A (fn [{:keys [transaction body]}] ...) that will merge the edn result using the given transaction (query)
         error-handler - A (fn [{:keys [body]}] ...) that will report an error to Fulcro. The body is EDN that will be placed into the state as the error.
         progress-handler - A (fn [progress] ...) that will run all registered progress mutations, and will include `progress` in the parameters of each progress mutation.
         

    fulcro 2.5.9
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    fulcro.client.network/transmitSourceDoc + Usages
    Send the given `request`, which will contain:
         - `:fulcro.client.network/edn` : The actual API tx to send.
         - `:fulcro.client.network/ok-handler` : complete-fn
         - `:fulcro.client.network/error-handler` : error-fn
         - `:fulcro.client.network/progress-handler` : update-fn
    
         It may also optionally include:
         - `:fulcro.client.network/abort-id` : An ID to remember the network request by, to enable user-level API abort
    
         When you implement this protocol, you MUST call the `ok-handler` or `error-handler` exactly once. You *may*
         call the `progress-handler` any number of times (including none).
    
         ok-hander - A (fn [{:keys [transaction body]}] ...) that will merge the edn result using the given transaction (query)
         error-handler - A (fn [{:keys [body]}] ...) that will report an error to Fulcro. The body is EDN that will be placed into the state as the error.
         progress-handler - A (fn [progress] ...) that will run all registered progress mutations, and will include `progress` in the parameters of each progress mutation.
         

    consul-clojure 0.7.1
    A Consul client for Clojure applications.
    consul.core/kv-getSourceDoc + Usages
    Retrieves key k from consul given the following optional parameters.
    
      Parameters:
    
      :dc        - Optional data center in which to retrieve k, defaults agent's data center.
      :wait      - Used in conjunction with :index to get using a blocking query. e.g. 10s, 1m, etc.
      :index     - The current Consul index, suitable for making subsequent calls to wait for changes since this query was last run.
    
      :raw?      - If true and used with a non-recursive GET, the response is just the raw value of the key, without any encoding.
      :string?    - Converts the value returned for k into a string.  Defaults to true.

    oauth2-client 0.2.0
    OAuth2/OpenID Connect Client Library for Clojure.
    oauth2-client.core/access-token-post-requestSourceDoc + Usages
    Helper to POST an OAuth2 access token request using the
       configuration in the oauth2-config hash-map.
    
      By default, the token-request-query-args function is used to format
      the arguments for posting to the token request url, but can be
      overridden by providing a :token-request-query-args-fn member in the
      oauth2-config map.
    
      You can also toggle debugging of the clj-http.client/post call by
      passing in :debug-http-client? true in the oauth2-config map.

    sente 1.12.0
    Realtime web comms for Clojure/Script
    taoensso.sente/make-channel-socket-server!SourceDoc + Usages
    Takes a web server adapter[1] and returns a map with keys:
        :ch-recv ; core.async channel to receive `event-msg`s (internal or from clients).
        :send-fn ; (fn [user-id ev] for server>user push.
        :ajax-post-fn                ; (fn [ring-req]) for Ring CSRF-POST + chsk URL.
        :ajax-get-or-ws-handshake-fn ; (fn [ring-req]) for Ring GET + chsk URL.
        :connected-uids ; Watchable, read-only (atom {:ws #{_} :ajax #{_} :any #{_}}).
    
      Common options:
        :user-id-fn        ; (fn [ring-req]) -> unique user-id for server>user push.
        :csrf-token-fn     ; (fn [ring-req]) -> CSRF token for Ajax POSTs.
        :handshake-data-fn ; (fn [ring-req]) -> arb user data to append to handshake evs.
        :ws-kalive-ms      ; Ping to keep a WebSocket conn alive if no activity
                           ; w/in given msecs. Should be different to client's :ws-kalive-ms.
        :lp-timeout-ms     ; Timeout (repoll) long-polling Ajax conns after given msecs.
        :send-buf-ms-ajax  ; [2]
        :send-buf-ms-ws    ; [2]
        :packer            ; :edn (default), or an IPacker implementation.
    
      [1] e.g. `(taoensso.sente.server-adapters.http-kit/get-sch-adapter)` or
               `(taoensso.sente.server-adapters.immutant/get-sch-adapter)`.
          You must have the necessary web-server dependency in your project.clj and
          the necessary entry in your namespace's `ns` form.
    
      [2] Optimization to allow transparent batching of rapidly-triggered
          server>user pushes. This is esp. important for Ajax clients which use a
          (slow) reconnecting poller. Actual event dispatch may occur <= given ms
          after send call (larger values => larger batch windows).

    re-view 0.4.15
    ClojureScript React Library
    re-view.core/view* (cljs)SourceDoc + Usages
    Returns a React component factory for supplied lifecycle methods.
       Expects a single map of functions, or any number of key-function pairs,
    
       (component {:render (fn [this] [:div ...])})
    
       -or-
    
       (component
    
         :get-initial-state
         (fn [this] {:apple-state :ripe})
    
         :render
         (fn [this] [:div ...]))
    
       See other functions in this namespace for how to work with props and state.
       Result of :render function is automatically passed through hiccup/element,
       unless it is already a valid React element.
       

    Use `(score-fn class resolvables)` to generate a score for each
       class, selecting the one with the highest score.
    
       For example, to always select the class with the most resolvables:
    
       ```clojure
       (scoring-selector
         (fn [class resolvables]
           (count resolvables)))
       ```
    
       Or, to assign a score based on class, e.g always resolve `FriendsOf` before
       `Person` if applicable:
    
       ```clojure
       (scoring-selector
         (fn [class resolvables]
           (get {Person 2, FriendsOf 1} class 0)))
       ```
       

    re-view-routing 0.1.3
    ClojureScript routing tools
    re-view.core/view* (cljs)SourceDoc + Usages
    Returns a React component factory for supplied lifecycle methods.
       Expects a single map of functions, or any number of key-function pairs,
    
       (component {:render (fn [this] [:div ...])})
    
       -or-
    
       (component
    
         :get-initial-state
         (fn [this] {:apple-state :ripe})
    
         :render
         (fn [this] [:div ...]))
    
       See other functions in this namespace for how to work with props and state.
       Result of :render function is automatically passed through hiccup/element,
       unless it is already a valid React element.
       

    sweatkit 0.1.4
    A Clojure library to work with sports activities data
    sweatkit.core/distanceSourceDoc + Usages
    Takes a measured object and an optional reducing fn. When the fn is not
       given, yields the whole Distance track, otherwise it returns a single value.
       rfn can be any fn reducing point-vals or the :total keyword to get the
       accumulated value.
       N.B: As of now, this metric will not use the geo track to calculate distance.
            Only tracks that provide this metric directly are considered (this might
            change in the future)

    lune 0.2.1
    Collection of dsl
    lune.core/defreqmodSourceDoc + Usages
    A DSL to easily modify header
    
      (defreqmod modder-name
        [:k] (fn  [value] new-value) value-given-if-key-not-exist)
    
       Example:
    
      (defreqmod my-modder
        [:name] (fn [value] (clojure.string/lower-case value) :do-nothing)
        [:age] (fn [value] (inc value)) 22)
    
      First arg is the keys, the second args is the function
      that will get invoked if the key is exists, the last arg
      is a value returned if the key isn't exists. Put :do-nothing
      to leave it untouched.
      

    cassaforte 3.0.0-RC1
    A Clojure client for Apache Cassandra
    clojurewerkz.cassaforte.cql/perform-countSourceDoc + Usages
    Helper function to perform count on a table with given query. Count queries are slow in Cassandra,
      in order to get a rough idea of how many items you have in certain table, use `nodetool cfstats`,
      for more complex cases, you can wither do a full table scan or perform a count with this function,
      please note that it does not have any performance guarantees and is potentially expensive.
    
      Doesn't work as a prepared query.

    context-io-clj 0.1.2
    Context.IO API wrapper for Clojure
    context-io.oauth/oauth-header-stringSourceDoc + Usages
    Creates the string for the 'Authorization' header.
    
       signing-map  - The information to put in the header, as returned by
                      sign-query.
       :url-encode? - Whether to URL-encode the values or not (optional, default true).
    
       Examples
    
         (oauth-header-string
           (sign-query (make-oauth-creds "consumer-key" "consumer-value")
                       :get "https://api.context.io/2.0/accounts")
           :url-encode false)
         ; -> "OAuth foo=bar,baz=foobar"
    
       Returns a string appropriate for putting in the Authorization header of a
         HTTP request.

    context-io-clj 0.1.2
    Context.IO API wrapper for Clojure
    context-io.request/prepare-request-with-multiSourceDoc + Usages
    Prepare a request, allowing multi-part form data
    
       method   - The HTTP method for the request (:get, :post, etc.).
       url      - The URL for the request.
       :headers - The headers for the request (optional).
       :query   - The query parameters for the request (optional).
       :body    - The body for the request (optional).
       :cookies - The cookies for the request (optional).
       :proxy   - The proxy for the request (optional).
       :auth    - The authentication details for the request (optional).
       :timeout - The timeout for the request (optional).
    
       Returns the request with the given information.

    swagger 0.1.4
    swagger integration for ronda.
    ronda.swagger.parameters/collectSourceDoc + Usages
    Inputs: [schema :- common/RequestSchema request-method :- s/Keyword route-params :- [s/Any]]
      Returns: sw/Parameters
    
      Collect all parameters from the given schema.
    
       - if the method is GET/HEAD/OPTIONS, `:params` will be interpreted as
         query parameters,
       - if a body is given, `:params` will be interpreted as query parameters,
       - otherwise, `:params` will be interpreted as form parameter.
    
       `:headers` and `:body` will be used directly.

    two fetches - use the lookup-key to get a stream of uber-keys, then
       map the records from the primary table with individual queries
    
       the lookup query may return multiple records, all of which will be
       dereferenced against the primary table, with nil results from
       dangling lookups being filtered out.
    
       this means that the lookup query may specify a partition-key and
       some clustering column condition (given as a :where option)

    context-io 0.0.3
    Context.IO API wrapper for Clojure
    context-io.oauth/oauth-header-stringSourceDoc + Usages
    Creates the string for the 'Authorization' header.
    
       signing-map  - The information to put in the header, as returned by
                      sign-query.
       :url-encode? - Whether to URL-encode the values or not (optional, default true).
    
       Examples
    
         (oauth-header-string
           (sign-query (make-oauth-creds "consumer-key" "consumer-value")
                       :get "https://api.context.io/2.0/accounts")
           :url-encode false)
         ; -> "OAuth foo=bar,baz=foobar"
    
       Returns a string appropriate for putting in the Authorization header of a
         HTTP request.

    context-io 0.0.3
    Context.IO API wrapper for Clojure
    context-io.request/prepare-request-with-multiSourceDoc + Usages
    Prepare a request, allowing multi-part form data
    
       method   - The HTTP method for the request (:get, :post, etc.).
       url      - The URL for the request.
       :headers - The headers for the request (optional).
       :query   - The query parameters for the request (optional).
       :body    - The body for the request (optional).
       :cookies - The cookies for the request (optional).
       :proxy   - The proxy for the request (optional).
       :auth    - The authentication details for the request (optional).
       :timeout - The timeout for the request (optional).
    
       Returns the request with the given information.

    consul-clojure 0.7.1
    A Consul client for Clojure applications.
    consul.core/kv-recurseSourceDoc + Usages
    Retrieves key k from consul given the following optional parameters.
    
      Parameters:
    
      :dc        - Optional data center in which to retrieve k, defaults agent's data center.
      :wait      - Used in conjunction with :index to get using a blocking query. e.g. 10s, 1m, etc.
      :index     - The current Consul index, suitable for making subsequent calls to wait for changes since this query was last run.
    
      :string?    - Converts the value returned for k into a string.  Defaults to true.

    consul-clojure 0.7.1
    A Consul client for Clojure applications.
    consul.core/kv-keysSourceDoc + Usages
    Retrieves a set of keys using prefix.
    
      Parameters:
    
      :dc        - Optional data center in which to retrieve k, defaults agent's data center.
      :wait      - Used in conjunction with :index to get using a blocking query. e.g. 10s, 1m, etc.
      :index     - The current Consul index, suitable for making subsequent calls to wait for changes since this query was last run.
    
      :separator - List keys up to separator.

    chromex 0.6.1
    A ClojureScript wrapper for writing Chrome Extensions and Apps.
    chromex.app.tabs/querySourceDoc + Usages
    Gets all tabs that have the specified properties, or all tabs if no properties are specified.
    
         |query-info| - https://developer.chrome.com/apps/tabs#property-query-queryInfo.
    
       This function returns a core.async channel of type `promise-chan` which eventually receives a result value.
       Signature of the result value put on the channel is [result] where:
    
         |result| - https://developer.chrome.com/apps/tabs#property-callback-result.
    
       In case of an error the channel closes without receiving any value and relevant error object can be obtained via
       chromex.error/get-last-error.
    
       https://developer.chrome.com/apps/tabs#method-query.

    clj-osf 0.1.2
    Clojure API for Open Semantic Framework web services queries
    clj-osf.ontology.read/readSourceDoc + Usages
    Ontology: Read query.
    
      **Required**
    
      ##### Usage
    
      ```
      ;; Get all loaded ontologies of the OSF instance
      (ontology-r/read
        (ontology-r/get-loaded-ontologies))
    
      ;; Get all the classes of the BIBO ontology
      (ontology-r/read
        (ontology-r/ontology "http://purl.org/ontology/bibo/")
        (ontology-r/get-classes :get-classes-descriptions true))
    
      ;; Get the description of the bibo:Book class
      (ontology-r/read
        (ontology-r/ontology "http://purl.org/ontology/bibo/")
        (ontology-r/get-class "http://purl.org/ontology/bibo/Book"))
    
      ;; Get all the properties of the BIBO ontology
      (ontology-r/read
        (ontology-r/ontology "http://purl.org/ontology/bibo/")
        (ontology-r/get-properties))
    
      ;; Get the ironSchema for the BIBO ontology
      (ontology-r/read
        (ontology-r/ontology "http://purl.org/ontology/bibo/")
        (ontology-r/get-iron-json-schema))
    
      ;; Get the a RDF serialization representation of the ontology
      (ontology-r/read
        (ontology-r/ontology "http://purl.org/ontology/bibo/")
        (ontology-r/get-serialized))
    
      ;; Get all the named individuals of the BIBO ontology
      (ontology-r/read
        (ontology-r/ontology "http://purl.org/ontology/bibo/")
        (ontology-r/get-named-individuals))
    
      ;; Get the description of the bibo:unpublished named individual
      (ontology-r/read
        (ontology-r/ontology "http://purl.org/ontology/bibo/")
        (ontology-r/get-named-individual "http://purl.org/ontology/bibo/status/unpublished"))
    
      ;; Get all the ontologies loaded by a given ontology
      (ontology-r/read                        
        (ontology-r/ontology "http://purl.org/ontology/bibo/")
        (ontology-r/get-ontologies))
    
      ;; Get the description of the bibo:abstract property
      (ontology-r/read                        
        (ontology-r/ontology "http://purl.org/ontology/bibo/")
        (ontology-r/get-property "http://purl.org/ontology/bibo/abstract"))
    
      ;; Get the super classes of the bibo:Book class
      (ontology-r/read                        
        (ontology-r/ontology "http://purl.org/ontology/bibo/")
        (ontology-r/get-super-classes "http://purl.org/ontology/bibo/Book"))
    
      ;; Get the sub classes of the bibo:Book class
      (ontology-r/read                        
        (ontology-r/ontology "http://purl.org/ontology/bibo/")
        (ontology-r/get-sub-classes "http://purl.org/ontology/bibo/Book"))  
      ```

    nanoql 0.3.5
    A lib for declarative schemaless data querying.
    nanoql.core/compileSourceDoc + Usages
    Compiles a query definition to query AST.
      See Query-Def schema.

    themis 0.1.2
    A validation library for Clojure distilled from practice
    themis.core/validationSourceDoc + Usages
    Validate a data structure, `t`,
      against validation query/rule-set.
      The rule-set will be normalized if it is not already.
      Note: By default everything is returned in a map, keyed by
      the coordinate vector.
      Multiple validation results are conj'd together in a vector.
      You can optionally pass in a custom :merge-fn or :validation-seq-fn to process
      the validation and tailor the results

    rip 0.1.3
    REST in Peace, an unopinionated REST framework
    rip.core/defendpointSourceDoc + Usages
    Generate a route with consumer function of arguments [request action-fn] where:
         - request: Original request
         - action-fn: Function with a request as argument
       A producer function with arguments [request result] where:
         - request: Original request
         - result: Last expression from body
       Create a reverse route function of name "route-name->url"
         e.g: (foo->url {:path-params {:id 1} :query-params {:name "bar"}})

    seaquell 0.3.1
    Tame the stormy seas of SQL with sea-quell, another DSL for generating SQL statements
    seaquell.engine/execSourceDoc + Usages
    Executes SQL CRUD operations using clojure.java.jdbc
      Takes a map with two mandatory keys:
        :db - DB spec or connection pool datasource
        :sql-str - SQL string to execute
      And one optional key:
        :params - Parameters to pass to jdbc
      The following are passed directly to jdbc/query or jdbc/execute!, respectively:
        :as-arrays? :identifiers :row-fn :result-set-fn
        :multi? :transaction?

    welle 3.0.0
    Welle is an expressive Clojure client for Riak with batteries included
    clojurewerkz.welle.counters/fetch-counterSourceDoc + Usages
    Fetches Riak counter.
       Available options:
    
       `:basic-quorum` (true or false): whether to return early in some failure cases (eg. when `:r` is 1 and you get 2 errors and a success `:basic-quorum` set to true would return an error)
       `:notfound-ok` (true or false): whether to treat notfounds as successful reads for the purposes of `:r`
       `:if-modified-vclock`: a vclock instance to use for conditional get. Only supported by Protocol Buffers transport.
       `:timeout`: query timeout
      

    clj-spotify 0.1.7
    A client library for the Spotify Web API
    clj-spotify.core/get-users-followed-artistsSourceDoc + Usages
     Takes two arguments, a map m with query parameters and an optional oauth-token t.
      Compulsory key in m is :type, optional keys are :limit and :after.
      :type has to be set to "artist".
      :limit is the maxium number of items to return, default is 20.
      :after the last artist id retrieved from a previous request. Use this to get next set of artists.
    
      Example: (get-users-followed-artists {:type "artist" :limit 50 :offset 50} "BQBw-JtC..._7GvA") 

    bodhi 0.0.3
    Middleware toolkit for building Om parsers and mergers.
    bodhi.query-mapping/read (cljs)SourceDoc + Usages
    Transforms any query expressions for a certain keys using data from the app
      state. This is particularly useful for reading from an entity which is
      selected by route params or something similar. The `data-key` is a key in the
      root of the app state. The `config` is a map of query keys to vector pairs of
      data paths and query-expression-generating functions. The functions take three
      arguments: the data found at `data-key`, the subquery (if any) joined at the
      query key in question, and (optionally) the params given at that query key.
    
      For example, this allows a component to read from the "selected user", where
      the selected user's name is is stored in the app state, perhaps derived from
      the current URL and placed there by the router (such as Secretary). For
      instance, if the `data-key` is `:app/route-params`, given the app state:
    
          {:app/route-params {:username "nipponfarm"}
           ;; ...}
    
      and the config
    
          {:route-params/selected-user
           [[:root/user]
            (fn [{:keys [username]} query params]
              `{(:root/user {:user/name ~username}) ~query})]}
    
      the query
    
          [{:route-params/selected-user [:user/favorite-color]}]
    
      would actually read
    
          [{(:root/user {:user/name "nipponfarm"}) [:user/favorite-color]}]
    
      (Note that you'd want to use bodhi.param-indexing/read to make the params in
      this example useful.)
    
      For local reads, the value returned as `:route-params/selected-user` will be
      the value found at the given path (here, `[:root/user]`) in the result of this
      query. This path is important when mapping to a nested query expression.
    
      For remote reads, the mapped query expression will be the one which appears in
      the remote query.

    rummage 1.1.2
    A Clojure client library for Amazon's SimpleDB (SDB).
    cemerick.rummage/querySourceDoc + Usages
    Issue a query.
    
       If the `client-config` map contains a truthy :consistent-read? value, then the query will
       be performed with SDB's consistent read semantics.
    
       When `q` is a string, it is submitted directly without any interpretation.
    
       When `q` is a map, it is interpreted to generate a corresponding query string,
       using the configuration provided to drive attribute name and value formatting.
    
       The query map has mandatory keys:
    
         :select */id/count/[sequence-of-attrs]
         :from domain-name
    
       and optional keys:
    
         :where sexpr-based query expr supporting
    
            (not expr)
            (and/or/intersection expr expr)
            (=/!=/</<=/>/>=/like/not-like attr-name val)
            (null/not-null attr-name)
            (between attr-name val1 val2)
            (in attr-name #(val-set})
    
         :order-by [attr-name] or [attr-name asc/desc]
         :limit n
    
       The keys in the query map can be keywords or symbols; e.g. these two queries are
       functionally equivalent:
    
         '{select * from foo}
         '{:select * :from foo}
    
       Depending on the semantics of the encoding implemented by the provided configuration,
       attribute names and values in the query map should be specified using the same types as
       they were when those attributes were put into SDB.
    
       When :select is
          count - returns a number
          id - returns a sequence of ids
          * or [sequence-of-attr-names] - returns a sequence of item maps, containing all or specified attrs.
    
       When the return value is a sequence of items, it will have the following slots in its metadata map:
    
         :request-id - the ID of the request submitted to the SDB web service API
         :box-usage - a measure of the resources utilized to process the query; see the SDB documentation
                      for details.
         :next-token - an opaque string token that, when present, indicates that additional query results
                       are available.  This token can be provided as an optional third argument to `query`
                       to obtain the next chunk of results.
                       See `query-all` to get all results of a query in a single lazy seq.
    
       See:
    
          http://docs.amazonwebservices.com/AmazonSimpleDB/latest/DeveloperGuide/index.html?UsingSelect.html
    
       for further details of select semantics.

    secretary 2.0.0.1-d484a1
    A client-side router for ClojureScript.
    secretary.codec/decode-query-params (cljs)SourceDoc + Usages
    Extract a map of query parameters from a query string.

    secretary 2.0.0.1-d484a1
    A client-side router for ClojureScript.
    secretary.query-params/decode-query-params (cljs)SourceDoc + Usages
    Extract a map of query parameters from a query string.

    secretary 2.0.0.1-d484a1
    A client-side router for ClojureScript.
    secretary.codec/decode-query-params (cljs)SourceDoc + Usages
    Extract a map of query parameters from a query string.

    kvlt 0.1.4
    Multi-target Clojure/script HTTP client
    kvlt.middleware.params/short-querySourceDoc + Usages
    Rename request's `:query` key to `:query-params`

    hatti 0.4.0
    A cljs dataview from your friends at Ona.io
    secretary.core/decode-query-params (cljs)SourceDoc + Usages
    Extract a map of query parameters from a query string.

    hatti 0.4.0
    A cljs dataview from your friends at Ona.io
    secretary.core/decode-query-params (cljs)SourceDoc + Usages
    Extract a map of query parameters from a query string.

    macros 0.2.63
    Clojure macros for web and mobile development
    workflo.macros.query.om-next/querySourceDoc + Usages
    Generates an Om Next query from a parsed query.

    macros 0.2.63
    Clojure macros for web and mobile development
    workflo.macros.query.om-next/property-querySourceDoc + Usages
    Generates an Om Next query for a parsed property query

    stardog-clj 5.0.0-RC1
    Stardog-clj: Clojure bindings for Stardog
    stardog.core/configure-querySourceDoc + Usages
    Configures a query is the valid parameters for that type of query

    monte.server 0.0.1
    monte.server is a server with monte library wrapped
    secretary.core/decode-query-params (cljs)SourceDoc + Usages
    Extract a map of query parameters from a query string.

    active-graphql 0.1.0
    A ClojureScript library for programmatically building GraphQL query strings
    active-graphql.core/print-document (cljs)SourceDoc + Usages
    Takes a query document and converts it into a query string.

    restql-core 2.1.8
    Microservice query language
    restql.parser.core/handle-produceSourceDoc + Usages
    Produces the EDN query of a given restQL query

    restql-core 2.1.8
    Microservice query language
    restql.parser.core/handle-produceSourceDoc + Usages
    Produces the EDN query of a given restQL query

    yz 0.0.1-alpha18
    YZ[ˈiːzi] is simple (easy), laconic, string-based, object query language.
    ru.petrsu.nest.yz.yz/-createSourceDoc + Usages
    Creates object Query for specified string query.

    Update a component's query and query parameters with a function.

    Update a component's query and query parameters with a function.

    ona-viewer 1.1.30
    Ona viewer that connects to the Ona API.
    secretary.core/decode-query-params (cljs)SourceDoc + Usages
    Extract a map of query parameters from a query string.

    ona-viewer 1.1.30
    Ona viewer that connects to the Ona API.
    secretary.core/decode-query-params (cljs)SourceDoc + Usages
    Extract a map of query parameters from a query string.

    cellophane 0.3.5
    Server-side rendering for Om Next components
    cellophane.next/update-query!SourceDoc + Usages
    Update a component's query and query parameters with a function.

    yetibot 1.0.0-RC7
    A command line in your chat, where chat ∈ {irc,slack}.
    yetibot.commands.giphy/translate-cmdSourceDoc + Usages
    giphy <query> # find a gif for <query> on giphy.com

    yetibot 1.0.0-RC7
    A command line in your chat, where chat ∈ {irc,slack}.
    yetibot.commands.rhyme/rhyme-cmdSourceDoc + Usages
    rhyme <query> # find words rhyming with <query>

    yetibot 1.0.0-RC7
    A command line in your chat, where chat ∈ {irc,slack}.
    yetibot.commands.urban-dictionary/search-cmdSourceDoc + Usages
    urban <query> # search for <query> on Urban Dictionary

    yetibot 1.0.0-RC7
    A command line in your chat, where chat ∈ {irc,slack}.
    yetibot.commands.wolfram/search-wolframSourceDoc + Usages
    wolfram <query> # search for <query> on Wolfram Alpha

    sqlosure 0.2.0
    Compositional relational queries.
    sqlosure.relational-algebra/query-schemeSourceDoc + Usages
    Return the query scheme of query `q` as a `rel-scheme`.

    muicljs 0.1.01
    Mui cljs test
    om.next/update-query!SourceDoc + Usages
    Update a component's query and query parameters with a function.

    rp-query-clj 0.1.4
    RentPath query abstractions in Clojure
    rp.query/querySourceDoc + Usages
    Issues a (read-only) query to query engine.

    plaza 0.2.0-alpha1
    Plaza framework for semantic distributed applications
    plaza.rdf.sparql/build-querySourceDoc + Usages
    Transforms a query reprsentation into a query Java object

    plaza 0.2.0-alpha1
    Plaza framework for semantic distributed applications
    plaza.rdf.implementations.jena/build-query~JenaSparqlFramework~SparqlFrameworkSourceDoc + Usages
    Transforms a query reprsentation into a query Java object

    plaza 0.2.0-alpha1
    Plaza framework for semantic distributed applications
    plaza.rdf.implementations.common/build-query-fnSourceDoc + Usages
    Transforms a query representation into a Jena Query object

    plaza 0.2.0-alpha1
    Plaza framework for semantic distributed applications
    plaza.rdf.implementations.common/parse-sparql-to-query-fnSourceDoc + Usages
    Parses a SPARQL query and builds a whole query dictionary

    plaza 0.2.0-alpha1
    Plaza framework for semantic distributed applications
    plaza.rdf.implementations.sesame/build-query~SesameSparqlFramework~SparqlFrameworkSourceDoc + Usages
    Transforms a query reprsentation into a query Java object

    couchbase-clj 0.2.0
    A Clojure client for Couchbase Server 2.x.
    couchbase-clj.query/str~CouchbaseCljQuery~ICouchbaseCljQuerySourceDoc + Usages
    Print the query created, in the form of url query parameters.

    couchbase-clj 0.2.0
    A Clojure client for Couchbase Server 2.x.
    couchbase-clj.query/strSourceDoc + Usages
    Print the query created, in the form of url query parameters.

    midje-cascalog 0.4.0
    Cascalog functions for Midje.
    midje.cascalog/wrap-checkerSourceDoc + Usages
    Accepts up to three arguments:
    
      `checker-fn`: a midje collection checker (just or contains, for
      example). This checker-fn will be primed with the expected set of
      tuples for the query being tested.
    
      `opt-map` (optional): map of some set of allowed keyword arguments
      for the checker we're generating to the corresponding arguments to
      the supplied `checker-fn`.
    
      `valid-set` (optional): set of options that should be allowed to
      pass on through to the wrapper checker.
    
      Returns a function that accepts a sequence of result tuples and
     optional arguments and returns a chatty checker tuned for said
     arguments. See `produces` and `produces-some` for usage examples.

    carmine 2.18.1
    Clojure Redis client & message queue
    taoensso.carmine.commands/skip-fnsSourceDoc + Usages
    #{<fn-name>}

    zprint 0.4.9
    Pretty print zippers and s-expressions
    zprint.sutil/sfn?SourceDoc + Usages
    Is this an anonymous fn?

    zprint 0.4.9
    Pretty print zippers and s-expressions
    zprint.zutil/zanonfn?SourceDoc + Usages
    Is this an anonymous fn?

    lib-grenada 1.0.0-rc.4
    A library for processing Clojure metadata
    grenada.schemas/FnSourceDoc + Usages
    A Clojure fn.

    datomic as-of fn

    onyx-datomic 0.13.0.0
    Onyx plugin for Datomic
    onyx.datomic.peer/as-of~DatomicPeer~DatomicFnsSourceDoc + Usages
    datomic as-of fn

    onyx-datomic 0.13.0.0
    Onyx plugin for Datomic
    onyx.datomic.protocols/as-ofSourceDoc + Usages
    datomic as-of fn

    cljtang 0.1.6
    Itang's Clojure utility 糖
    cljtang.core/wfn?SourceDoc + Usages
    fn? or keyword?

    sweet-tooth-endpoint 0.2.2
    Utilities for working with liberator-based endpoints
    sweet-tooth.endpoint.page/desc~nil~PageSortFnSourceDoc + Usages
    Descending fn

    sweet-tooth-endpoint 0.2.2
    Utilities for working with liberator-based endpoints
    sweet-tooth.endpoint.page/asc~nil~PageSortFnSourceDoc + Usages
    Ascending fn

    sweet-tooth-endpoint 0.2.2
    Utilities for working with liberator-based endpoints
    sweet-tooth.endpoint.page/desc~Object~PageSortFnSourceDoc + Usages
    Descending fn

    sweet-tooth-endpoint 0.2.2
    Utilities for working with liberator-based endpoints
    sweet-tooth.endpoint.page/asc~Object~PageSortFnSourceDoc + Usages
    Ascending fn

    sweet-tooth-endpoint 0.2.2
    Utilities for working with liberator-based endpoints
    sweet-tooth.endpoint.page/desc~Date~PageSortFnSourceDoc + Usages
    Descending fn

    sweet-tooth-endpoint 0.2.2
    Utilities for working with liberator-based endpoints
    sweet-tooth.endpoint.page/asc~Date~PageSortFnSourceDoc + Usages
    Ascending fn

    sweet-tooth-endpoint 0.2.2
    Utilities for working with liberator-based endpoints
    sweet-tooth.endpoint.page/descSourceDoc + Usages
    Descending fn

    sweet-tooth-endpoint 0.2.2
    Utilities for working with liberator-based endpoints
    sweet-tooth.endpoint.page/ascSourceDoc + Usages
    Ascending fn

    elements 0.1.0
    Reusable elements for component-based Clojure applications
    pointslope.elements.pedestal/service-fn (cljs)SourceDoc + Usages
    The service fn

    clojure 1.10.0-alpha4
    Core language
    clojure.core/accessorSourceDoc + Usages
    Returns a fn that, given an instance of a structmap with the basis,
      returns the value at the key.  The key must be in the basis. The
      returned function should be (slightly) more efficient than using
      get, but such use of accessors should be limited to known
      performance-critical areas.

    rebel-readline 0.1.3
    Terminal readline library for Clojure dialects
    rebel-readline.clojure.service.simple/createSourceDoc + Usages
    A very simple service that you can use to get rebel readline
      working without any introspecting functionality (doc, source, appropos,
      completion, eval).
    
      It's best overide the :prompt option with a fn returns a proper
      prompt with the current namespace.