CrossClj
full-text documentation search

Project count:
9764

Last update
May 26, 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 4570 results in 215 projects. Show the first 500.
    clucie 0.4.0
    Clojure for the Lucene
    clucie.query/walkSourceDoc + Usages
    Traverses query. inner and outer are functions. Applies inner to each
      sub-query of query, building up a query of the same type, then applies outer
      to the result.

    cartodb-clj 1.5.5
    CartoDB client.
    cartodb.playground/big-insertSourceDoc + Usages
    Insert a large number of rows by partitioning the rows and thus the
      query into smaller sub-queries. Supply a `partition-size` to
      indicate the number of rows for each query.

    clucie 0.4.0
    Clojure for the Lucene
    clucie.query/postwalkSourceDoc + Usages
    Performs a depth-first, post-order traversal of query. Calls f on each
      sub-query, uses f's return value in place of the original.

    lacinia 0.26.0
    A GraphQL server implementation in Clojure
    com.walmartlabs.lacinia.validation.scalar-leafs/scalar-leafsSourceDoc + Usages
    A GraphQL query is valid only if all leaf nodes (fields without
      sub selections) are of scalar or enum types.

    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.
      

    elastica 1.0.1
    An idiomatic clojure interface to native Elasticsearch
    elastica.query/dis-maxSourceDoc + Usages
    Generates the union of documents produced by its subqueries, and scores each
      document with the maximum score for that document as produced by any sub query,
      plus a tie breaking increment for any additional matching sub queries
    
      https://www.elastic.co/guide/en/elasticsearch/reference/2.4/query-dsl-dis-max-query.html

    hyjinks 0.0.3
    Hyjinks - An HTML generation/templating library
    hyjinks.core/subSourceDoc + Usages
    The <sub></sub> tag.

    dendrite 0.5.11
    A Dremel-like columnar storage format for Clojure.
    dendrite.core/readSourceDoc + Usages
    Returns a view of all the records in the reader. This view is seqable (lazy), reducible, and foldable (per
      clojure.core.reducers, in which case the folding is done as part of record assembly).
    
      If provided, the options map supports the following keys:
    
      :missing-fields-as-nil?  Set to true (default) or false. If true, then fields that are specified in the
                               query but are not present in this reader's schema will be read as nil values. If
                               false, querying for fields not present in the schema will throw an exception.
    
      :query                   The query. Default: '_. See docs for full explanation.
    
      :sub-schema-in           Path to the desired sub-schema. The value should be a sequence of keys that cannot
                               contain any keys to repeated elements. If both :sub-schema-in and :query are
                               defined, the query applies to the specified sub-schema. See docs for full
                               explanation.
    
      :readers                 A map of query tag symbol to tag function. Default: nil. See docs for full
                               explanation.

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

    sicmutils 0.10.0
    A port of the Scmutils computer algebra/mechanics system to Clojure
    sicmutils.generic/subSourceDoc + Usages
    generic sub

    cspbox-trading 0.1.3
    Part of cspbox trading system for build standalone daemon
    cspbox.trading.ind.dsl/-SourceDoc + Usages
    `-` sub vectors

    korma-enhanced 0.3.1
    Tasty SQL for Clojure
    korma.core/relation-switchSourceDoc + Usages
    Implements switch for relation types, takes function to be called for each relation type
       and variable number of arguments after. Each function will be called with relation query,
       sub-entity and optional other arguments if those are provided.

    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
      

    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
      

    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
      

    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
      

    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
      

    sodium 0.12.0
    A wrapper around soda-ash and semantic-ui-react
    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
      

    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.

    comporoute 0.2.0
    Composable request handling.
    comporoute.core/url-forSourceDoc + Usages
    Reconstruct url for route at ident based on parameters in params
      (optional). opts may specify the following settings in a hash-map
    
      :no-query When set to logical true, don't append a query-string like
      ?unmatched-param=its-val for params that could not be used to name
      sub-dirs in the route.

    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.

    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]]
         ...)
      

    schema-tools 0.10.3
    Common utilities for Prismatic Schema
    schema-tools.core/schema-valueSourceDoc + Usages
    Returns the sub-schema or sub-schemas of given schema.

    re-frame 0.10.5
    A Clojurescript MVC-like Framework For Writing SPAs Using Reagent.
    re-frame.subs/subscribeSourceDoc + Usages
    Given a `query`, returns a Reagent `reaction` which, over
      time, reactively delivers a stream of values. So in FRP-ish terms,
      it returns a Signal.
    
      To obtain the returned Signal/Stream's current value, it must be `deref`ed.
    
      `query` is a vector of at least one element. The first element is the
      `query-id`, typically a namespaced keyword. The rest of the vector's
      elements are optional, additional values which parameterise the query
      performed.
    
      `dynv` is an optional 3rd argument, `which is a vector of further input
      signals (atoms, reactions, etc), NOT values. This argument exists for
      historical reasons and is borderline deprecated these days.
    
      Example Usage:
      --------------
    
        (subscribe [:items])
        (subscribe [:items "blue" :small])
        (subscribe [:items {:colour "blue"  :size :small}])
    
      Note: for any given call to `subscribe` there must have been a previous call
      to `reg-sub`, registering the query handler (function) for the `query-id` given.
    
      Hint
      ----
    
      When used in a view function BE SURE to `deref` the returned value.
      In fact, to avoid any mistakes, some prefer to define:
    
         (def <sub  (comp deref re-frame.core/subscribe))
    
      And then, within their views, they call  `(<sub [:items :small])` rather
      than using `subscribe` directly.
    
      De-duplication
      --------------
    
      XXX
      

    re-frame-10x 0.3.3
    Become 10x more productive when developing and debugging re-frame applications.
    mranderson048.re-frame.v0v10v2.re-frame.subs/subscribeSourceDoc + Usages
    Given a `query`, returns a Reagent `reaction` which, over
      time, reactively delivers a stream of values. So in FRP-ish terms,
      it returns a Signal.
    
      To obtain the returned Signal/Stream's current value, it must be `deref`ed.
    
      `query` is a vector of at least one element. The first element is the
      `query-id`, typically a namespaced keyword. The rest of the vector's
      elements are optional, additional values which parameterise the query
      performed.
    
      `dynv` is an optional 3rd argument, `which is a vector of further input
      signals (atoms, reactions, etc), NOT values. This argument exists for
      historical reasons and is borderline deprecated these days.
    
      Example Usage:
      --------------
    
        (subscribe [:items])
        (subscribe [:items "blue" :small])
        (subscribe [:items {:colour "blue"  :size :small}])
    
      Note: for any given call to `subscribe` there must have been a previous call
      to `reg-sub`, registering the query handler (function) for the `query-id` given.
    
      Hint
      ----
    
      When used in a view function BE SURE to `deref` the returned value.
      In fact, to avoid any mistakes, some prefer to define:
    
         (def <sub  (comp deref mranderson048.re-frame.v0v10v2.re-frame.core/subscribe))
    
      And then, within their views, they call  `(<sub [:items :small])` rather
      than using `subscribe` directly.
    
      De-duplication
      --------------
    
      XXX
      

    iron 0.4.0
    Front-end utilities and support for ClojureScript and re-frame projects
    re-frame.subs/subscribeSourceDoc + Usages
    Given a `query`, returns a Reagent `reaction` which, over
      time, reactively delivers a stream of values. So in FRP-ish terms,
      it returns a Signal.
    
      To obtain the returned Signal/Stream's current value, it must be `deref`ed.
    
      `query` is a vector of at least one element. The first element is the
      `query-id`, typically a namespaced keyword. The rest of the vector's
      elements are optional, additional values which parameterise the query
      performed.
    
      `dynv` is an optional 3rd argument, `which is a vector of further input
      signals (atoms, reactions, etc), NOT values. This argument exists for
      historical reasons and is borderline deprecated these days.
    
      Example Usage:
      --------------
    
        (subscribe [:items])
        (subscribe [:items "blue" :small])
        (subscribe [:items {:colour "blue"  :size :small}])
    
      Note: for any given call to `subscribe` there must have been a previous call
      to `reg-sub`, registering the query handler (function) for the `query-id` given.
    
      Hint
      ----
    
      When used in a view function BE SURE to `deref` the returned value.
      In fact, to avoid any mistakes, some prefer to define:
    
         (def <sub  (comp deref re-frame.core/subscribe))
    
      And then, within their views, they call  `(<sub [:items :small])` rather
      than using `subscribe` directly.
    
      De-duplication
      --------------
    
      XXX
      

    trace 0.1.22
    Tracing and developer tools for re-frame apps
    mranderson047.re-frame.v0v10v2.re-frame.subs/subscribeSourceDoc + Usages
    Given a `query`, returns a Reagent `reaction` which, over
      time, reactively delivers a stream of values. So in FRP-ish terms,
      it returns a Signal.
    
      To obtain the returned Signal/Stream's current value, it must be `deref`ed.
    
      `query` is a vector of at least one element. The first element is the
      `query-id`, typically a namespaced keyword. The rest of the vector's
      elements are optional, additional values which parameterise the query
      performed.
    
      `dynv` is an optional 3rd argument, `which is a vector of further input
      signals (atoms, reactions, etc), NOT values. This argument exists for
      historical reasons and is borderline deprecated these days.
    
      Example Usage:
      --------------
    
        (subscribe [:items])
        (subscribe [:items "blue" :small])
        (subscribe [:items {:colour "blue"  :size :small}])
    
      Note: for any given call to `subscribe` there must have been a previous call
      to `reg-sub`, registering the query handler (function) for the `query-id` given.
    
      Hint
      ----
    
      When used in a view function BE SURE to `deref` the returned value.
      In fact, to avoid any mistakes, some prefer to define:
    
         (def <sub  (comp deref mranderson047.re-frame.v0v10v2.re-frame.core/subscribe))
    
      And then, within their views, they call  `(<sub [:items :small])` rather
      than using `subscribe` directly.
    
      De-duplication
      --------------
    
      XXX
      

    re-frame-ipfs-fx 0.0.2
    IPFS Re-Frame handlers.
    re-frame.subs/subscribeSourceDoc + Usages
    Given a `query`, returns a Reagent `reaction` which, over
      time, reactively delivers a stream of values. So in FRP-ish terms,
      it returns a Signal.
    
      To obtain the returned Signal/Stream's current value, it must be `deref`ed.
    
      `query` is a vector of at least one element. The first element is the
      `query-id`, typically a namespaced keyword. The rest of the vector's
      elements are optional, additional values which parameterise the query
      performed.
    
      `dynv` is an optional 3rd argument, `which is a vector of further input
      signals (atoms, reactions, etc), NOT values. This argument exists for
      historical reasons and is borderline deprecated these days.
    
      Example Usage:
      --------------
    
        (subscribe [:items])
        (subscribe [:items "blue" :small])
        (subscribe [:items {:colour "blue"  :size :small}])
    
      Note: for any given call to `subscribe` there must have been a previous call
      to `reg-sub`, registering the query handler (function) for the `query-id` given.
    
      Hint
      ----
    
      When used in a view function BE SURE to `deref` the returned value.
      In fact, to avoid any mistakes, some prefer to define:
    
         (def <sub  (comp deref re-frame.core/subscribe))
    
      And then, within their views, they call  `(<sub [:items :small])` rather
      than using `subscribe` directly.
    
      De-duplication
      --------------
    
      XXX
      

    rejax 0.1.0
    A library that creates nicer API for usage of cljs-ajax in Re-frame
    re-frame.subs/subscribeSourceDoc + Usages
    Given a `query`, returns a Reagent `reaction` which, over
      time, reactively delivers a stream of values. So in FRP-ish terms,
      it returns a Signal.
    
      To obtain the returned Signal/Stream's current value, it must be `deref`ed.
    
      `query` is a vector of at least one element. The first element is the
      `query-id`, typically a namespaced keyword. The rest of the vector's
      elements are optional, additional values which parameterise the query
      performed.
    
      `dynv` is an optional 3rd argument, `which is a vector of further input
      signals (atoms, reactions, etc), NOT values. This argument exists for
      historical reasons and is borderline deprecated these days.
    
      Example Usage:
      --------------
    
        (subscribe [:items])
        (subscribe [:items "blue" :small])
        (subscribe [:items {:colour "blue"  :size :small}])
    
      Note: for any given call to `subscribe` there must have been a previous call
      to `reg-sub`, registering the query handler (function) for the `query-id` given.
    
      Hint
      ----
    
      When used in a view function BE SURE to `deref` the returned value.
      In fact, to avoid any mistakes, some prefer to define:
    
         (def <sub  (comp deref re-frame.core/subscribe))
    
      And then, within their views, they call  `(<sub [:items :small])` rather
      than using `subscribe` directly.
    
      De-duplication
      --------------
    
      XXX
      

    pine 0.1.6
    A Clojure/ClojureScript router designed for universal applications.
    re-frame.subs/subscribeSourceDoc + Usages
    Given a `query`, returns a Reagent `reaction` which, over
      time, reactively delivers a stream of values. So in FRP-ish terms,
      it returns a Signal.
    
      To obtain the returned Signal/Stream's current value, it must be `deref`ed.
    
      `query` is a vector of at least one element. The first element is the
      `query-id`, typically a namespaced keyword. The rest of the vector's
      elements are optional, additional values which parameterise the query
      performed.
    
      `dynv` is an optional 3rd argument, `which is a vector of further input
      signals (atoms, reactions, etc), NOT values. This argument exists for
      historical reasons and is borderline deprecated these days.
    
      Example Usage:
      --------------
    
        (subscribe [:items])
        (subscribe [:items "blue" :small])
        (subscribe [:items {:colour "blue"  :size :small}])
    
      Note: for any given call to `subscribe` there must have been a previous call
      to `reg-sub`, registering the query handler (function) for the `query-id` given.
    
      Hint
      ----
    
      When used in a view function BE SURE to `deref` the returned value.
      In fact, to avoid any mistakes, some prefer to define:
    
         (def <sub  (comp deref re-frame.core/subscribe))
    
      And then, within their views, they call  `(<sub [:items :small])` rather
      than using `subscribe` directly.
    
      De-duplication
      --------------
    
      XXX
      

    rui 0.3.0
    UI components based on Reagent and Re-frame
    re-frame.subs/subscribeSourceDoc + Usages
    Given a `query`, returns a Reagent `reaction` which, over
      time, reactively delivers a stream of values. So in FRP-ish terms,
      it returns a Signal.
    
      To obtain the returned Signal/Stream's current value, it must be `deref`ed.
    
      `query` is a vector of at least one element. The first element is the
      `query-id`, typically a namespaced keyword. The rest of the vector's
      elements are optional, additional values which parameterise the query
      performed.
    
      `dynv` is an optional 3rd argument, `which is a vector of further input
      signals (atoms, reactions, etc), NOT values. This argument exists for
      historical reasons and is borderline deprecated these days.
    
      Example Usage:
      --------------
    
        (subscribe [:items])
        (subscribe [:items "blue" :small])
        (subscribe [:items {:colour "blue"  :size :small}])
    
      Note: for any given call to `subscribe` there must have been a previous call
      to `reg-sub`, registering the query handler (function) for the `query-id` given.
    
      Hint
      ----
    
      When used in a view function BE SURE to `deref` the returned value.
      In fact, to avoid any mistakes, some prefer to define:
    
         (def <sub  (comp deref re-frame.core/subscribe))
    
      And then, within their views, they call  `(<sub [:items :small])` rather
      than using `subscribe` directly.
    
      De-duplication
      --------------
    
      XXX
      

    rui 0.3.0
    UI components based on Reagent and Re-frame
    re-frame.subs/subscribeSourceDoc + Usages
    Given a `query`, returns a Reagent `reaction` which, over
      time, reactively delivers a stream of values. So in FRP-ish terms,
      it returns a Signal.
    
      To obtain the returned Signal/Stream's current value, it must be `deref`ed.
    
      `query` is a vector of at least one element. The first element is the
      `query-id`, typically a namespaced keyword. The rest of the vector's
      elements are optional, additional values which parameterise the query
      performed.
    
      `dynv` is an optional 3rd argument, `which is a vector of further input
      signals (atoms, reactions, etc), NOT values. This argument exists for
      historical reasons and is borderline deprecated these days.
    
      Example Usage:
      --------------
    
        (subscribe [:items])
        (subscribe [:items "blue" :small])
        (subscribe [:items {:colour "blue"  :size :small}])
    
      Note: for any given call to `subscribe` there must have been a previous call
      to `reg-sub`, registering the query handler (function) for the `query-id` given.
    
      Hint
      ----
    
      When used in a view function BE SURE to `deref` the returned value.
      In fact, to avoid any mistakes, some prefer to define:
    
         (def <sub  (comp deref re-frame.core/subscribe))
    
      And then, within their views, they call  `(<sub [:items :small])` rather
      than using `subscribe` directly.
    
      De-duplication
      --------------
    
      XXX
      

    re-frame-fork 0.10.2-1
    A Clojurescript MVC-like Framework For Writing SPAs Using Reagent.
    re-frame.subs/subscribeSourceDoc + Usages
    Given a `query`, returns a Reagent `reaction` which, over
      time, reactively delivers a stream of values. So in FRP-ish terms,
      it returns a Signal.
    
      To obtain the returned Signal/Stream's current value, it must be `deref`ed.
    
      `query` is a vector of at least one element. The first element is the
      `query-id`, typically a namespaced keyword. The rest of the vector's
      elements are optional, additional values which parameterise the query
      performed.
    
      `dynv` is an optional 3rd argument, `which is a vector of further input
      signals (atoms, reactions, etc), NOT values. This argument exists for
      historical reasons and is borderline deprecated these days.
    
      Example Usage:
      --------------
    
        (subscribe [:items])
        (subscribe [:items "blue" :small])
        (subscribe [:items {:colour "blue"  :size :small}])
    
      Note: for any given call to `subscribe` there must have been a previous call
      to `reg-sub`, registering the query handler (function) for the `query-id` given.
    
      Hint
      ----
    
      When used in a view function BE SURE to `deref` the returned value.
      In fact, to avoid any mistakes, some prefer to define:
    
         (def <sub  (comp deref re-frame.core/subscribe))
    
      And then, within their views, they call  `(<sub [:items :small])` rather
      than using `subscribe` directly.
    
      De-duplication
      --------------
    
      XXX
      

    sodium 0.12.0
    A wrapper around soda-ash and semantic-ui-react
    re-frame.subs/subscribeSourceDoc + Usages
    Given a `query`, returns a Reagent `reaction` which, over
      time, reactively delivers a stream of values. So in FRP-ish terms,
      it returns a Signal.
    
      To obtain the returned Signal/Stream's current value, it must be `deref`ed.
    
      `query` is a vector of at least one element. The first element is the
      `query-id`, typically a namespaced keyword. The rest of the vector's
      elements are optional, additional values which parameterise the query
      performed.
    
      `dynv` is an optional 3rd argument, `which is a vector of further input
      signals (atoms, reactions, etc), NOT values. This argument exists for
      historical reasons and is borderline deprecated these days.
    
      Example Usage:
      --------------
    
        (subscribe [:items])
        (subscribe [:items "blue" :small])
        (subscribe [:items {:colour "blue"  :size :small}])
    
      Note: for any given call to `subscribe` there must have been a previous call
      to `reg-sub`, registering the query handler (function) for the `query-id` given.
    
      Hint
      ----
    
      When used in a view function BE SURE to `deref` the returned value.
      In fact, to avoid any mistakes, some prefer to define:
    
         (def <sub  (comp deref re-frame.core/subscribe))
    
      And then, within their views, they call  `(<sub [:items :small])` rather
      than using `subscribe` directly.
    
      De-duplication
      --------------
    
      XXX
      

    re-frame-utils 0.1.0
    Fxs and CoFxs for re-frame
    re-frame.subs/subscribeSourceDoc + Usages
    Given a `query`, returns a Reagent `reaction` which, over
      time, reactively delivers a stream of values. So in FRP-ish terms,
      it returns a Signal.
    
      To obtain the returned Signal/Stream's current value, it must be `deref`ed.
    
      `query` is a vector of at least one element. The first element is the
      `query-id`, typically a namespaced keyword. The rest of the vector's
      elements are optional, additional values which parameterise the query
      performed.
    
      `dynv` is an optional 3rd argument, `which is a vector of further input
      signals (atoms, reactions, etc), NOT values. This argument exists for
      historical reasons and is borderline deprecated these days.
    
      Example Usage:
      --------------
    
        (subscribe [:items])
        (subscribe [:items "blue" :small])
        (subscribe [:items {:colour "blue"  :size :small}])
    
      Note: for any given call to `subscribe` there must have been a previous call
      to `reg-sub`, registering the query handler (function) for the `query-id` given.
    
      Hint
      ----
    
      When used in a view function BE SURE to `deref` the returned value.
      In fact, to avoid any mistakes, some prefer to define:
    
         (def <sub  (comp deref re-frame.core/subscribe))
    
      And then, within their views, they call  `(<sub [:items :small])` rather
      than using `subscribe` directly.
    
      De-duplication
      --------------
    
      XXX
      

    pathom 2.0.2
    A Clojure library designed to provide a collection of helper functions to support
    com.wsscode.pathom.core/joinSourceDoc + Usages
    Runs a parser with current sub-query. When run with an `entity` argument, that entity is set as the new environment
       value of `::entity`, and the subquery is parsered with that new environment. When run without an `entity` it
       parses the current subquery in the context of whatever entity was already in `::entity` of the env.

    clojure-hbase 0.92.4
    A convenient Clojure interface to HBase.
    clojure-hbase.internal/partition-querySourceDoc + Usages
    Given a query sequence and a command argnum map (each keyword in map
       mapped to how many arguments that item expects), this function returns
       a sequence of sequences; each sub-sequence is just a single command,
       command keyword followed by args.

    serio 0.1.4
    Serio is a time series database solution built on top of Apache Kudu.
    serio/find-entities-in-parallelSourceDoc + Usages
    Find all entities matching the supplied tags.
    
      tags is a map of the form {:key "value"}
    
      An entity is deemed to match if it has all [key value] pairs in the supplied tags map
      (i.e. it's an intersection of the tags, not union).
      The query will be performed in parallel, with 1 sub-query per KV-pair, followed by the
      intersection of results from the sub-queries. This does not allow the caller to narrow down
      the search space using domain knowledge, hence use with caution to avoid massive scans for
      any key-value pairs with a lot of entries.
    
      Returns a deferred set of entity1 .. entityN (or empty set if no matching entities.)

    lein-ancient 0.6.15
    Check your Projects for outdated Dependencies.
    leiningen.ancient.collect/profiles-directory-filesSourceDoc + Usages
    Get the sub-profiles directory.

    clojure-mail 0.1.6
    Clojure Email Library
    clojure-mail.core/sub-folder?SourceDoc + Usages
    Check if a folder is a sub folder

    brevis 0.10.5
    A Functional Scientific and Artificial Life Simulator
    brevis.vector/sub-vec4SourceDoc + Usages
    Wrap's Vector3f sub.

    brevis 0.10.5
    A Functional Scientific and Artificial Life Simulator
    brevis.vector/subSourceDoc + Usages
    Wrap's Vector3f sub.

    wilson 0.33.1
    Opinionated Reagent bindings for Bootstrap components.
    wilson.utils/substr?SourceDoc + Usages
    Is sub a substring of super?

    reason 0.9.0
    Library for producing predicates from textual user input.
    reason.core/prefix? (cljs)SourceDoc + Usages
    Does super start with sub?

    inspectable 0.2.2
    Tools for clojure.spec
    inspectable.core/sub-path?SourceDoc + Usages
    Is p1 a sub-path of p2

    editscript 0.3.1
    A diffing library for Clojure data structures
    editscript.diff.a-star/set-size~Node~INodeSourceDoc + Usages
    Set the size of sub-tree

    editscript 0.3.1
    A diffing library for Clojure data structures
    editscript.diff.a-star/set-sizeSourceDoc + Usages
    Set the size of sub-tree

    mr-edda 0.1.0
    For querying edda
    mr-edda.core/querySourceDoc + Usages
    Runs a query against the given resource
    
      e.g (query client images {:fields [:name, :imageId]})
      => returns a sequence of maps describing aws images currently cached by edda.
    
      valid query options are:
      :id -> a resource identity, this is a shortcut for filters on identity
      :filters -> a map that will restrict the result set e.g {:name "some-string"}
      :fields -> a vector describing the fields to select out
                 e.g [:a, :b, {:c [:x :d]}] maps are used to describe sub fields.
      :limit -> limits the result set by n
      :expand? -> fully expand resultset, otherwise sometimes only the id will be returned.
                  note: if you select fields via :fields, :expand will always be true

    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?

    brevis 0.10.5
    A Functional Scientific and Artificial Life Simulator
    brevis.vector/sub-vec3SourceDoc + Usages
    Wrap's Vector3f sub. Should be a little faster than normal sub

    clj-tree-zipper 1.0.0
    FIXME: write description
    clj-tree-zipper.core/find-pathSourceDoc + Usages
    path is a list of the form '('/' 'tmp' 'sub'), would find '/tmp/sub'

    clojure-contrib 1.2.0
    Clojure user contributions library.
    clojure.contrib.pprint.examples.xml/*prxml-indent*SourceDoc + Usages
    The number of spaces to indent sub-tags.

    encore 2.96.0
    Core utils library for Clojure/Script
    taoensso.encore/subvec*SourceDoc + Usages
    Like `subvec` but uses `sub-indexes`.

    encore 2.96.0
    Core utils library for Clojure/Script
    taoensso.encore/subvec* (cljs)SourceDoc + Usages
    Like `subvec` but uses `sub-indexes`.

    schema-tools 0.10.3
    Common utilities for Prismatic Schema
    schema-tools.impl/schema-value~nil~SchemaValueSourceDoc + Usages
    Returns the sub-schema for given schema.

    schema-tools 0.10.3
    Common utilities for Prismatic Schema
    schema-tools.impl/schema-value~Object~SchemaValueSourceDoc + Usages
    Returns the sub-schema for given schema.

    schema-tools 0.10.3
    Common utilities for Prismatic Schema
    schema-tools.impl/schema-value~schema.core.EnumSchema~SchemaValueSourceDoc + Usages
    Returns the sub-schema for given schema.

    schema-tools 0.10.3
    Common utilities for Prismatic Schema
    schema-tools.impl/schema-value~schema.core.Constrained~SchemaValueSourceDoc + Usages
    Returns the sub-schema for given schema.

    schema-tools 0.10.3
    Common utilities for Prismatic Schema
    schema-tools.impl/schema-value~schema.core.CondPre~SchemaValueSourceDoc + Usages
    Returns the sub-schema for given schema.

    Returns the sub-schema for given schema.

    schema-tools 0.10.3
    Common utilities for Prismatic Schema
    schema-tools.impl/schema-value~schema.core.NamedSchema~SchemaValueSourceDoc + Usages
    Returns the sub-schema for given schema.

    schema-tools 0.10.3
    Common utilities for Prismatic Schema
    schema-tools.impl/schema-value~schema.core.Recursive~SchemaValueSourceDoc + Usages
    Returns the sub-schema for given schema.

    schema-tools 0.10.3
    Common utilities for Prismatic Schema
    schema-tools.impl/schema-value~schema.core.Either~SchemaValueSourceDoc + Usages
    Returns the sub-schema for given schema.

    schema-tools 0.10.3
    Common utilities for Prismatic Schema
    schema-tools.impl/schema-value~schema.core.Both~SchemaValueSourceDoc + Usages
    Returns the sub-schema for given schema.

    schema-tools 0.10.3
    Common utilities for Prismatic Schema
    schema-tools.impl/schema-value~schema.core.Maybe~SchemaValueSourceDoc + Usages
    Returns the sub-schema for given schema.

    schema-tools 0.10.3
    Common utilities for Prismatic Schema
    schema-tools.impl/schema-value~schema.core.One~SchemaValueSourceDoc + Usages
    Returns the sub-schema for given schema.

    schema-tools 0.10.3
    Common utilities for Prismatic Schema
    schema-tools.impl/schema-valueSourceDoc + Usages
    Returns the sub-schema for given schema.

    yetibot.core 1.0.0
    Core yetibot utilities, extracted for shared use among yetibot and
    yetibot.core.hooks/cmd-unhookSourceDoc + Usages
    Removes the sub-commands for a prefix / topic.

    celtuce-core 0.3.1
    An idiomatic Clojure Redis client wrapping the Java client Lettuce
    celtuce.commands/PubSubListenerSourceDoc + Usages
    Protocol for redis pub/sub listeners

    jerks-whistling-tunes 0.3.2
    Clojure library for creating/verifying JWT
    jerks-whistling-tunes.core/subSourceDoc + Usages
    Returns a predicate that validates the sub of a JWT

    autodoc 1.1.2
    A tool to build HTML documentation from your Clojure source
    autodoc.build-html/flatten-namespacesSourceDoc + Usages
    Build a list of namespaces and sub-namespaces

    stylefy 1.5.1
    Library for styling UI components
    stylefy.core/sub-style (cljs)SourceDoc + Usages
    Returns sub-style for a given style.

    aot-match 0.2.0-alpha10-aot
    Optimized pattern matching and predicate dispatch for Clojure
    clojure.core.match.pred/subsumesSourceDoc + Usages
    Declares super as a strict superset of sub

    gyptis 0.2.2
    A library for generating and viewing vega.js plots
    taoensso.encore/subvec* (cljs)SourceDoc + Usages
    Like `subvec` but uses `sub-indexes`.

    zmqchans 0.3.4
    Thread-safe Clojure core.async interface to ZeroMQ
    zmqchans.utils/subscribe!SourceDoc + Usages
    Subscribe to a topic.
    
      Only for SUB sockets.

    buddy-pkcs15-sha1 0.2.0b3
    Forked security library buddy for Clojure with PKCS v1.5 for SHA1. Original library:
    taoensso.encore/subvec*SourceDoc + Usages
    Like `subvec` but uses `sub-indexes`.

    buddy-pkcs15-sha1 0.2.0b3
    Forked security library buddy for Clojure with PKCS v1.5 for SHA1. Original library:
    taoensso.encore/subvec* (cljs)SourceDoc + Usages
    Like `subvec` but uses `sub-indexes`.

    ona-viewer 1.1.30
    Ona viewer that connects to the Ona API.
    taoensso.encore/subvec* (cljs)SourceDoc + Usages
    Like `subvec` but uses `sub-indexes`.

    ona-viewer 1.1.30
    Ona viewer that connects to the Ona API.
    taoensso.encore/subvec* (cljs)SourceDoc + Usages
    Like `subvec` but uses `sub-indexes`.

    timbre-datomic-handler 0.1.3
    A simple Datomic handler that logs via Timbre
    taoensso.encore/subvec*SourceDoc + Usages
    Like `subvec` but uses `sub-indexes`.

    timbre-datomic-handler 0.1.3
    A simple Datomic handler that logs via Timbre
    taoensso.encore/subvec* (cljs)SourceDoc + Usages
    Like `subvec` but uses `sub-indexes`.

    cleancr 1.0-beta3
    Finds and optionally removes carriage return characters from your project text files
    clojure.contrib.pprint.examples.xml/*prxml-indent*SourceDoc + Usages
    The number of spaces to indent sub-tags.

    expresso 0.2.2
    a general Algebraic Expression manipulation library in clojure
    numeric.expresso.utils/set-in-expressionSourceDoc + Usages
    assocs sub in the position posv in the expression

    expresso 0.2.2
    a general Algebraic Expression manipulation library in clojure
    numeric.expresso.utils/set-in-expressionSourceDoc + Usages
    assocs sub in the position posv in the expression

    pink 0.4.1
    A library for music research, composition, and performance.
    pink.live-code/sub-beatSourceDoc + Usages
    Returns current sub-beat time.

    group-redis 0.6.3
    Group management api that supports locks, empheral data and membership join and
    group-redis.core/remove-sub-groupSourceDoc + Usages
    Removes a sub group to the current connection

    group-redis 0.6.3
    Group management api that supports locks, empheral data and membership join and
    group-redis.core/add-sub-groupSourceDoc + Usages
    Adds a sub group to the current connection

    Creates a sub graph for the given condition.

    predicat 0.2.2
    A Clojure library to compose predicate/validation functions
    predicat.core/f->fsSourceDoc + Usages
    Return the vector of sub failures, if any.

    cantor 0.3.0
    primitive math for clojure
    cantor/subSourceDoc + Usages
    Subtract scalars or vectors of equal dimension.
    
       (sub a b c) is equivalent to (sub (sub a b) c)

    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.

    sqlingvo 0.9.24
    A Clojure DSL to create SQL statements
    sqlingvo.core/fromSourceDoc + Usages
    Add a FROM clause to an SQL statement. The `from` forms can be one
      or more tables, :stdin, a filename or an other sub query.
    
      Examples:
    
      (select db [:*]
        (from :continents))
    
      (select db [:*]
        (from :continents :countries)
        (where '(= :continents.id :continent-id)))
    
      (select db [:*]
        (from (as (select [1 2 3]) :x)))
    
      (copy db :country []
        (from :stdin))
    
      (copy db :country []
        (from "/usr1/proj/bray/sql/country_data"))

    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

    fook 0.3.0
    Small utilities for datomic
    fook.query/assoc-querySourceDoc + Usages
    Assoc into 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.

    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.

    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

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

    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.

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

    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

    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

    predicat 0.2.2
    A Clojure library to compose predicate/validation functions
    predicat.core/q->qfSourceDoc + Usages
    Return the query function of a query Q.

    wire 0.4.1
    A routing lib for Clojure and Ring
    wire.routing/route-pathSourceDoc + Usages
    Creates a param populated path suitable for use in an URL.
       Example:
       (route-path route [:sub-of-root :sub-of-sub] {:param 100})

    core.matrix 0.62.0
    N-dimensional array programming API for Clojure
    clojure.core.matrix.operators/-SourceDoc + Usages
    Array subtraction operator. Equivalent to clojure.core.matrix/sub.

    core.matrix 0.62.0
    N-dimensional array programming API for Clojure
    clojure.core.matrix.operators/-SourceDoc + Usages
    Array subtraction operator. Equivalent to clojure.core.matrix/sub.

    lein-modules 0.3.11
    Similar to Maven multi-module projects, but less sucky
    lein-modules.compression/substituteSourceDoc + Usages
    If found, replace a sub-sequence of a collection with v

    parkour 0.6.4-alpha1
    Hadoop MapReduce in idiomatic Clojure.
    parkour.io.dux/get-subconfsSourceDoc + Usages
    Get map of `job` demultiplex sub-configuration diffs.

    parkour 0.6.4-alpha1
    Hadoop MapReduce in idiomatic Clojure.
    parkour.io.dux/dux-emptySourceDoc + Usages
    Clone of `job` with empty demultiplex sub-configurations map.

    parkour 0.6.4-alpha1
    Hadoop MapReduce in idiomatic Clojure.
    parkour.io.mux/get-subconfsSourceDoc + Usages
    Get sequence of `job` multiplex sub-configuration diffs.

    parkour 0.6.4-alpha1
    Hadoop MapReduce in idiomatic Clojure.
    parkour.io.mux/mux-emptySourceDoc + Usages
    Clone of `job` with empty multiplex sub-configurations vector.

    re-frame-10x 0.3.3
    Become 10x more productive when developing and debugging re-frame applications.
    day8.re-frame-10x.subs/prepare-pod-info (cljs)SourceDoc + Usages
    Returns sub info prepared for rendering in pods

    funnyqt 1.1.5
    A model querying and transformation library for TGraphs and EMF models developed
    funnyqt.emf/esubclassesSourceDoc + Usages
    Returns the direct sub-EClasses of the given EClass `ec`.

    think.image 0.4.16
    Image manipulation library
    think.image.patch/random-sub-rectSourceDoc + Usages
    Create a square sub-rect inside the outer-rect

    think.image 0.4.16
    Image manipulation library
    think.image.image/sub-imageSourceDoc + Usages
    Create a new sub-image from an existing image

    misaki 0.2.6.2-beta
    Jekyll inspired static site generator in Clojure
    misaki.util.string/str-contains?SourceDoc + Usages
    Check whether specified string contains sub string or not.

    imagez 0.12.0
    Image processing library for Clojure
    mikera.image.core/sub-imageSourceDoc + Usages
    Gets a sub-image area from an image.

    kerodon 0.9.0
    Acceptance test framework for web applications
    kerodon.test/submap?SourceDoc + Usages
    Checks whether m contains all entries in sub.

    iron 0.4.0
    Front-end utilities and support for ClojureScript and re-frame projects
    iron.re-utils/sub2 (cljs)SourceDoc + Usages
    Shorthand for simple 'layer 2` usage of re-sub

    iron 0.4.0
    Front-end utilities and support for ClojureScript and re-frame projects
    iron.re-utils/sub2 (cljs)SourceDoc + Usages
    Shorthand for simple 'layer 2` usage of re-sub

    trace 0.1.22
    Tracing and developer tools for re-frame apps
    day8.re-frame.trace.subs/prepare-pod-info (cljs)SourceDoc + Usages
    Returns sub info prepared for rendering in pods

    inet.data 0.5.7
    Represent and manipulate various Internet entities as data.
    inet.data.dns/domain-parentSourceDoc + Usages
    Return the domain for which `dom` is an immediate sub-domain.

    byplay 0.4.0
    Clojure background job queue on top of PostgreSQL 9.5.
    unit.utils/-submap?SourceDoc + Usages
    Checks whether m contains all entries in sub.

    pdf-stamper 0.4.1
    Combine template descriptions and template PDFs with data to produce PDFs.
    pdf-stamper.template-utils/sub-rootsSourceDoc + Usages
    Computes the roots of all sub trees of tree.

    indice 0.1.0
    A wrapper for Lucene
    indice.core/none-ofSourceDoc + Usages
    Accept docs that satisfy none of the sub-queries

    indice 0.1.0
    A wrapper for Lucene
    indice.core/one-ofSourceDoc + Usages
    Accept docs that satisfy at least one of the sub-queries

    indice 0.1.0
    A wrapper for Lucene
    indice.core/all-ofSourceDoc + Usages
    Accept docs that satisfy all the sub-queries

    indice 0.1.0
    A wrapper for Lucene
    indice.core/all-ofSourceDoc + Usages
    Accept docs that satisfy all the sub-queries

    zmqchans 0.3.4
    Thread-safe Clojure core.async interface to ZeroMQ
    zmqchans.utils/unsubscribe!SourceDoc + Usages
    Unsubscribe from a topic.
    
      Only for SUB sockets.

    george-application 2018.4
    George - Application
    george.turtle/cloneSourceDoc + Usages
    Clones certain JavaFX Node sub-classes

    lein-modules-bpk 0.3.12.bpk
    Similar to Maven multi-module projects, but less sucky
    lein-modules.compression/substituteSourceDoc + Usages
    If found, replace a sub-sequence of a collection with v

    reframe-utils 0.2.1-1
    Utility/helper functions for use with re-frame
    reframe-utils.core/reg-basic-sub (cljs)SourceDoc + Usages
    Registers a 'get' subscription from the re-frame db.
    
       (reg-basic-sub :sub-name :kw-to-get)
       (reg-basic-sub :sub-name [:kw-to-get1 :kw-to-get2])
    
       Using the one-arity version of this function will append 'get'
       as a prefix to the keyword for the name of the sub. For example
       (reg-basic-sub :best-ns/my-sub) registers a subscription named
       :best-ns/get-my-sub and returns :best-ns/my-sub from the db

    clodash 0.43.0
    FIXME: write description
    clodash.map/submap?SourceDoc + Usages
    Determine whether sub-map is a submap of m.

    expresso 0.2.2
    a general Algebraic Expression manipulation library in clojure
    numeric.expresso.optimize/constant-foldingSourceDoc + Usages
    folds constants and constant (sub-) expressions in expr

    expresso 0.2.2
    a general Algebraic Expression manipulation library in clojure
    numeric.expresso.optimize/constant-foldingSourceDoc + Usages
    folds constants and constant (sub-) expressions in expr

    eciton 0.1
    Apache Ant wrapper for Clojure.
    eciton.core/subprojectSourceDoc + Usages
    Create Ant sub project with new base directory.

    comporoute 0.2.0
    Composable request handling.
    comporoute.core/compile-specsSourceDoc + Usages
    Generate full sub-paths and compile Clout routes.

    org.eag.clie 0.1.2
    CLI-Ext: Extensions to tools.cli to make commandline argument creation and parsing
    org.eag.clie.config/file-sub-commandsSourceDoc + Usages
    define a map of sub commands, their options and a usage function.

    treajure 1.0.12
    A treasure trove of Clojure goodness.
    com.unbounce.treajure.either/run-eitherSourceDoc + Usages
    Evaluates a monadic sub-routine of type Either

    kits 1.38.5
    Staples SparX core libraries.
    kits.map/submap?SourceDoc + Usages
    Determine whether sub-map is a submap of m.

    reason 0.9.0
    Library for producing predicates from textual user input.
    reason.core/parsed-subrule->pred (cljs)SourceDoc + Usages
    Given a parsed sub-rule, create a predicate for that rule.

    google-maps 0.5.0
    Google Maps Clojure Library
    google.maps.geocoder/sub-localitySourceDoc + Usages
    Returns the sub locality from address components.

    cssgen 0.3.0-alpha1
    Generate CSS from clojure code. Like an embedded sass.
    cssgen/cssSourceDoc + Usages
    Generate CSS string for the rules and their sub-rules

    cssgen 0.3.0-alpha1
    Generate CSS from clojure code. Like an embedded sass.
    cssgen/compile-ruleSourceDoc + Usages
    Generate CSS string for a rule and its sub-rules

    crud 0.2.0
    Create, Read, Update, Delete. Done!
    crud.db.datomic/branch?SourceDoc + Usages
    Return true if `v` has sub-elements

    sodium 0.12.0
    A wrapper around soda-ash and semantic-ui-react
    iron.re-utils/sub2 (cljs)SourceDoc + Usages
    Shorthand for simple 'layer 2` usage of re-sub

    Returns number of nodes in given (sub)tree.

    Returns the max depth of the given (sub)tree

    editscript 0.3.1
    A diffing library for Clojure data structures
    editscript.diff.a-star/get-size~Node~INodeSourceDoc + Usages
    Get the size of sub-tree, used to estimate cost

    editscript 0.3.1
    A diffing library for Clojure data structures
    editscript.diff.a-star/get-sizeSourceDoc + Usages
    Get the size of sub-tree, used to estimate cost

    creates a vector [sub]type for another Push type

    stylefy 1.5.1
    Library for styling UI components
    stylefy.core/use-style (cljs)SourceDoc + Usages
    Defines a style for a component by converting the given style map in to an unique CSS class,
       and returning a pointer (a map with :class keyword) to it so that the component can use it.
    
       Calling use-style does not immediately add the generated CSS class to DOM, because doing this
       in a single render would slow everything down if use-style is called multiple times.
       If the style has not been added into the DOM yet, it also returns the given props as inline style, so that
       the component looks good even if CSS class has not been generated yet.
    
       Important exception: if the style contains specific modes or media query definitions,
       {:style {:visibility "hidden"}} is returned until the DOM is ready.
       This is done because these definitions cannot be present as inline style.
       If this is a problem, see prepare-styles function.
    
       The given 'style' parameter is a map which contains CSS style properties
       (as supported by Garden library). There can also be special namespaced keywords
       along with the style definitions:
    
       ::sub-styles        Makes it possible to define a named style map inside of the main style map.
                           The contents of ::sub-styles should be a map,
                           in which keys define the name of the sub-style and
                           values contain the style properties.
                           Sub-styles are nothing special, they are supposed to contain the same contents
                           as the main style map. ::sub-styles helps you to define styles that are closely
                           related to the main style map but do not deserve their own 'def'.
       ::mode              A map in which keys are mode names and values are style properties.
                           Internally all modes are converted to CSS pseudoclasses. You can use any mode name
                           that is a valid CSS speudoclass.
       ::media             A map in which keys are maps presenting CSS media query definitions, and values
                           are style maps which are used when the media query is active.
       ::vendors           A vector of vendor prefixes that are used with ::auto-prefix.
       ::auto-prefix       A set of style properties that should be prefixed with ::vendors.
       ::with-classes      A collection of additional class names that should always be used with
                           this style definition.
    
       Options is an optional map, which contains HTML attributes (:class, :href, :src etc.).
       It can also contain the the following features:
    
       ::with-classes       DEPRECATED. A vector of additional class names used with the current style.
                            Deprecated since version 1.3.0: The options map can now contain
                            any HTML attributes. Thus, you can just use :class instead of ::with-classes.

    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.

    lein-ancient 0.6.15
    Check your Projects for outdated Dependencies.
    ancient.rewrite-clj.v0v4v13.rewrite-clj.zip.subedit/subedit-nodeSourceDoc + Usages
    Apply the given function to the current sub-tree. The resulting
       zipper will be located on the root of the modified sub-tree.

    Apply the given function to the current sub-tree. The resulting
       zipper will be located on the root of the modified sub-tree.

    rewrite-clj 0.6.0
    Comment-/Whitespace-preserving rewriting of EDN documents.
    rewrite-clj.zip.subedit/subedit-nodeSourceDoc + Usages
    Apply the given function to the current sub-tree. The resulting
       zipper will be located on the root of the modified sub-tree.

    refactor-nrepl 2.3.1
    nREPL middleware to support editor-agnostic refactoring
    mranderson047.rewrite-clj.v0v4v13-20150917v134033-1.rewrite-clj.zip.subedit/subedit-nodeSourceDoc + Usages
    Apply the given function to the current sub-tree. The resulting
       zipper will be located on the root of the modified sub-tree.

    Returns the sub-tree of a given tree at index. The index is the index of the root of the sub-tree
       in a depth-first walk of the original tree.

    probe 0.9.5
    A library for interacting with dynamic program state
    probe.core/policy-uniqueSourceDoc + Usages
    Deduplicates transformed states. returns
       a seq of maps of :sub (subscriber ) and
       :new-state (state transformed by (:transform sub))

    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`

    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

    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.

    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.

    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.

    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

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

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

    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.

    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.

    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

    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.

    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

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

    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

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

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

    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.

    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.

    comporoute 0.2.0
    Composable request handling.
    comporoute.util/compose-pathSourceDoc + Usages
    Multi-purpose path-builder:
    
      Split sub-paths into more sub-paths if they contain slashes, replace
      batched slashes with a single slash, concat all sub-paths with
      slashes between them.
    
      If no sub-paths could be composed, return the empty-string.
    
      Sub-paths must be strings and may not be nil.

    data.sub 0.1.4
    Clojure test helper for testing subtrees of data structures
    nl.zeekat.data.sub/sub?SourceDoc + Usages
    true if `sub` is either `nil`, equal to `x`, or a recursive
      subcollection of `x`.
    
      If sub is a sequential collection of size N the first N elements of
      `x` are tested. If sub is a map every value in sub is tested with
      the corresponding value in `x`. If `sub` is a set every *key* in sub
      should exist in `x`.
    
      **Examples:**
    
          (sub? nil
                {:anything :at-all})
          (sub? [:a :b]
                [:a :b :c])
          (not (sub? [:a :b :c]
                     [:a :b]))
          (sub? {:a [1 2 3]}
                {:a [1 2 3 4] :b 2})
          (sub? {:a [1 nil 3]}
                {:a [1 2 3 4] :b 2})
          (not (sub? {:a [1 2 3 4]}
                     {:a [1 2 3] :b 2}))
          (sub? #{:a}
                {:a 1 :b 2})
          (sub? #{:a}
                #{:a :b})
          (not (sub? #{:a :c}
                     #{:a :b}))
          (sub? :something
                :something)
          (sub? [:1 :2 :3]
                (list :1 :2 :3))
          (sub? [:1 :2]
                (list :1 :2 :3))
          (sub? (list :1 :2 :3)
                [:1 :2 :3])
          (not (sub? (list nil 2)
                     [:1 :2 :3]))
      

    clojure-contrib 1.2.0
    Clojure user contributions library.
    clojure.contrib.datalog.rules/?-SourceDoc + Usages
    Define a datalog query

    clojure-contrib 1.2.0
    Clojure user contributions library.
    clojure.contrib.datalog.rules/display-querySourceDoc + Usages
    Return a query in a readable format.

    garden 1.3.5
    Generate CSS from Clojure(Script) data structures.
    garden.compiler/*media-query-context*SourceDoc + Usages
    The current media query context.

    korma 0.5.0-RC1
    Tasty SQL for Clojure
    korma.core/intersect*SourceDoc + Usages
    Create an empty intersect query.

    korma 0.5.0-RC1
    Tasty SQL for Clojure
    korma.core/union*SourceDoc + Usages
    Create an empty union query.

    twitter-api 1.8.0
    Async interface to Twitter's REST and Streaming APIs
    twitter.request/add-query-parametersSourceDoc + Usages
    adds the query parameters to the requestbuilder

    re-view 0.4.15
    ClojureScript React Library
    re-view.routing/query (cljs)SourceDoc + Usages
    Returns query parameters as map.

    analytics 2.0.0
    ClanHR specific analytics
    clanhr.analytics.metrics/postgres-requestSourceDoc + Usages
    Tracks a postgres query

    re-frame-10x 0.3.3
    Become 10x more productive when developing and debugging re-frame applications.
    mranderson048.garden.v1v3v3.garden.compiler/*media-query-context*SourceDoc + Usages
    The current media query context.

    datumbazo 0.13.21
    Clojure Database Kung-Foo
    datumbazo.pagination/querySourceDoc + Usages
    Returns the query for `target`.

    datumbazo 0.13.21
    Clojure Database Kung-Foo
    datumbazo.core/print-explainSourceDoc + Usages
    Print the execution plan of `query`.

    datumbazo 0.13.21
    Clojure Database Kung-Foo
    datumbazo.driver.core/execute-sql-querySourceDoc + Usages
    Execute a SQL query.

    fulcro 2.5.5
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    fulcro.ui.form-state/form-config-joinSourceDoc + Usages
    A query join to ::form-config.

    fulcro 2.5.5
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    fulcro.client.impl.protocols/index-rootSourceDoc + Usages
    Index the entire root query

    fulcro 2.5.5
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    fulcro.client.primitives/index-root~Indexer~IIndexerSourceDoc + Usages
    Index the entire root query

    fulcro 2.5.5
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    fulcro.client.primitives/query-zipSourceDoc + Usages
    Return a zipper on a query expression.

    elastisch 3.0.0
    Minimalistic fully featured well documented Clojure Elasticsearch client
    clojurewerkz.elastisch.native.conversion/attach-suggestion-contextSourceDoc + Usages
    attach context for suggestion query.

    elastisch 3.0.0
    Minimalistic fully featured well documented Clojure Elasticsearch client
    clojurewerkz.elastisch.query/sortSourceDoc + Usages
    Sort query results.

    clj-webdriver 0.7.2
    Clojure API for Selenium-WebDriver
    clj-webdriver.cache/delete~Driver~IElementCacheSourceDoc + Usages
    Delete the cached value at `query`

    clj-webdriver 0.7.2
    Clojure API for Selenium-WebDriver
    clj-webdriver.cache/deleteSourceDoc + Usages
    Delete the cached value at `query`

    pathom 2.0.2
    A Clojure library designed to provide a collection of helper functions to support
    com.wsscode.pathom.connect.test/diff-data-shapesSourceDoc + Usages
    Return the query shape differece.

    datalog 0.1.1
    contrib.datalog brought back to life
    datalog.rules/?-SourceDoc + Usages
    Define a datalog query

    datalog 0.1.1
    contrib.datalog brought back to life
    datalog.rules/display-querySourceDoc + Usages
    Return a query in a readable format.

    shared 0.11.27
    This is an echo lambda function. It's mainly used for debugging purposes.
    shared.models.query.index/create (cljs)SourceDoc + Usages
    creates a new query

    Query the connection bindings.

    Query the break context

    Query the debug context

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

    clj-firmata 2.1.1
    A Standard Firmata (http://firmata.org/) client.
    firmata.core/query-versionSourceDoc + Usages
    Query the firmware version of the board.

    clj-firmata 2.1.1
    A Standard Firmata (http://firmata.org/) client.
    firmata.core/query-capabilitiesSourceDoc + Usages
    Query the capabilities of the board.

    clj-firmata 2.1.1
    A Standard Firmata (http://firmata.org/) client.
    firmata.core/query-firmwareSourceDoc + Usages
    Query the firmware of the board.

    clj-firmata 2.1.1
    A Standard Firmata (http://firmata.org/) client.
    firmata.core/query-version (cljs)SourceDoc + Usages
    Query the firmware version of the board.

    clj-firmata 2.1.1
    A Standard Firmata (http://firmata.org/) client.
    firmata.core/query-capabilities (cljs)SourceDoc + Usages
    Query the capabilities of the board.

    clj-firmata 2.1.1
    A Standard Firmata (http://firmata.org/) client.
    firmata.core/query-firmware (cljs)SourceDoc + Usages
    Query the firmware of the board.

    clj-pg 0.0.3
    Collection of helpers to work with pg from clj
    clj-pg.honey/querySourceDoc + Usages
    query honey SQL

    trace 0.1.22
    Tracing and developer tools for re-frame apps
    mranderson047.garden.v1v3v3.garden.compiler/*media-query-context*SourceDoc + Usages
    The current media query context.

    re-view-routing 0.1.3
    ClojureScript routing tools
    re-view-routing.core/query (cljs)SourceDoc + Usages
    Returns query parameters as map.

    lib-onyx 0.13.0.0
    A library to support additional functionality in Onyx
    lib-onyx.replica-query-server/stop-replica-query-serverSourceDoc + Usages
    Stops the replica query server.

    lib-onyx 0.13.0.0
    A library to support additional functionality in Onyx
    lib-onyx.replica-query-server/start-replica-query-serverSourceDoc + Usages
    Starts the replica query server.

    cljam 0.5.1
    A DNA Sequence Alignment/Map (SAM) library for Clojure
    cljam.algo.sorter/sort-by-qnameSourceDoc + Usages
    Sort alignments by query name.

    welle 3.0.0
    Welle is an expressive Clojure client for Riak with batteries included
    clojurewerkz.welle.conversion/to-value-query~Long~IndexQueryConversionSourceDoc + Usages
    Builds a value 2i query

    welle 3.0.0
    Welle is an expressive Clojure client for Riak with batteries included
    clojurewerkz.welle.conversion/to-range-query~Long~IndexQueryConversionSourceDoc + Usages
    Builds a range 2i query

    welle 3.0.0
    Welle is an expressive Clojure client for Riak with batteries included
    clojurewerkz.welle.conversion/to-value-query~Integer~IndexQueryConversionSourceDoc + Usages
    Builds a value 2i query

    welle 3.0.0
    Welle is an expressive Clojure client for Riak with batteries included
    clojurewerkz.welle.conversion/to-range-query~Integer~IndexQueryConversionSourceDoc + Usages
    Builds a range 2i query

    welle 3.0.0
    Welle is an expressive Clojure client for Riak with batteries included
    clojurewerkz.welle.conversion/to-value-query~String~IndexQueryConversionSourceDoc + Usages
    Builds a value 2i query

    welle 3.0.0
    Welle is an expressive Clojure client for Riak with batteries included
    clojurewerkz.welle.conversion/to-range-query~String~IndexQueryConversionSourceDoc + Usages
    Builds a range 2i query

    welle 3.0.0
    Welle is an expressive Clojure client for Riak with batteries included
    clojurewerkz.welle.conversion/to-value-querySourceDoc + Usages
    Builds a value 2i query

    welle 3.0.0
    Welle is an expressive Clojure client for Riak with batteries included
    clojurewerkz.welle.conversion/to-range-querySourceDoc + Usages
    Builds a range 2i query

    welle 3.0.0
    Welle is an expressive Clojure client for Riak with batteries included
    clojurewerkz.welle.mr/map-reduceSourceDoc + Usages
    Runs a map/reduce query

    postgres-gateway 1.12.1
    ClanHR postgres-gateway
    clanhr.postgres-gateway.core/querySourceDoc + Usages
    Runs a query on the database

    asosio.utils 0.0.4
    The Asosio Utils is a collection of utilities that makes development of clojure
    asosio.utils.middleware/wrap-keywordize-qparamsSourceDoc + Usages
    Keywordize query parameters.

    receipt 1.0.1
    FIXME: write description
    garden.compiler/*media-query-context*SourceDoc + Usages
    The current media query context.

    The current media query context.

    ez-database 0.6.0
    Handling database queries with ease
    ez-database.query/optionalSourceDoc + Usages
    Optional query arguments

    Save the results of a query to a list

    Save the results of a query to a list

    Save the results of a query to a list

    Save the results of a query to a list

    paprika 0.0.4
    A Clojure library for the App.net API.
    paprika.core/find-postsSourceDoc + Usages
    Search for posts matching a query.

    azql 0.2.0
    DSL for SQL generation
    azql.core/having*SourceDoc + Usages
    Adds 'having' condition to query.

    azql 0.2.0
    DSL for SQL generation
    azql.core/offsetSourceDoc + Usages
    Adds an offset to query.

    azql 0.2.0
    DSL for SQL generation
    azql.core/groupSourceDoc + Usages
    Adds 'group by' section to query.

    azql 0.2.0
    DSL for SQL generation
    azql.core/orderSourceDoc + Usages
    Adds 'order by' section to query.

    azql 0.2.0
    DSL for SQL generation
    azql.core/order*SourceDoc + Usages
    Adds 'order by' section to query.

    azql 0.2.0
    DSL for SQL generation
    azql.core/where*SourceDoc + Usages
    Adds 'where' condition to query

    azql 0.2.0
    DSL for SQL generation
    azql.core/fields*SourceDoc + Usages
    Adds field list to query.

    azql 0.2.0
    DSL for SQL generation
    azql.core/join*SourceDoc + Usages
    Adds join section to query.

    azql 0.2.0
    DSL for SQL generation
    azql.core/fields*SourceDoc + Usages
    Adds field list to query.

    azql 0.2.0
    DSL for SQL generation
    azql.expression/attach-fieldSourceDoc + Usages
    Add fieldlist to query.

    basex 1.0.0
    A Clojure-ified wrapper around the BaseX Java Client
    basex.query/closeSourceDoc + Usages
    Closes and unregisters the query

    Query a range of 2i indexes

    reek 0.1.0
    Simple Riak k/v library
    reek.impl.client/query-rangeSourceDoc + Usages
    Query a range of 2i indexes

    tgkorma 0.4.3
    Tasty SQL for Clojure
    korma.core/intersect*SourceDoc + Usages
    Create an empty intersect query.

    tgkorma 0.4.3
    Tasty SQL for Clojure
    korma.core/union*SourceDoc + Usages
    Create an empty union query.

    yz 0.0.1-alpha18
    YZ[ˈiːzi] is simple (easy), laconic, string-based, object query language.
    ru.petrsu.nest.yz.parsing/funcqSourceDoc + Usages
    Defines rule for query as function.

    yz 0.0.1-alpha18
    YZ[ˈiːzi] is simple (easy), laconic, string-based, object query language.
    ru.petrsu.nest.yz.parsing/param-querySourceDoc + Usages
    Defines parameter as query.

    yz 0.0.1-alpha18
    YZ[ˈiːzi] is simple (easy), laconic, string-based, object query language.
    ru.petrsu.nest.yz.parsing/param-querySourceDoc + Usages
    Defines parameter as query.

    yz 0.0.1-alpha18
    YZ[ˈiːzi] is simple (easy), laconic, string-based, object query language.
    ru.petrsu.nest.yz.parsing/nest-querySourceDoc + Usages
    Defines nested query

    yz 0.0.1-alpha18
    YZ[ˈiːzi] is simple (easy), laconic, string-based, object query language.
    ru.petrsu.nest.yz.query/-getResultSourceDoc + Usages
    Returns a map of the result query.

    revise 0.0.6
    RethinkDB client for Clojure
    bitemyapp.revise.query/nowSourceDoc + Usages
    The time the query was received by the server

    restql-core 2.1.8
    Microservice query language
    restql.parser.core/parse-querySourceDoc + Usages
    Parses the restQL query

    restql-core 2.1.8
    Microservice query language
    restql.parser.core/parse-querySourceDoc + Usages
    Parses the restQL query

    ceterumnet-korma 0.3.1-RC2
    Tasty SQL for Clojure - ceterumnet fork
    korma.core/intersect*SourceDoc + Usages
    Create an empty intersect query.

    ceterumnet-korma 0.3.1-RC2
    Tasty SQL for Clojure - ceterumnet fork
    korma.core/union*SourceDoc + Usages
    Create an empty union query.

    clj-sql-builder 0.0.3
    FIXME: write description
    sql.parser/parse-querySourceDoc + Usages
    Parse a SQL query

    pani 0.0.3
    Convenience library for using Firebase with Clojure and Clojurescript
    pani.cljs.geofire/query (cljs)SourceDoc + Usages
    Setup a geofire query

    pithos 0.7.4
    cassandra-backed object storage
    io.pithos.bucket/fetch-bucket-qSourceDoc + Usages
    Cassandra query for bucket by name

    pithos 0.7.4
    cassandra-backed object storage
    io.pithos.bucket/bucket-by-tenant-qSourceDoc + Usages
    Cassandra query for bucket by tenant

    pithos 0.7.4
    cassandra-backed object storage
    io.pithos.request/knownSourceDoc + Usages
    known query args

    Return the query params for a component.

    Return the unbound query for a component.

    Return a zipper on a query expression.

    Return the query params for a component.

    Return the unbound query for a component.

    Return a zipper on a query expression.

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

    cantata 0.1.17
    SQL and database abstraction
    cantata.jdbc/querySourceDoc + Usages
    Implementation of cantata.core/query

    cantata 0.1.17
    SQL and database abstraction
    cantata.query.prepare/prepare-querySourceDoc + Usages
    See cantata.core/prepare-query

    cantata 0.1.17
    SQL and database abstraction
    cantata.query.strategy/multi-querySourceDoc + Usages
    Implementation of :multiple query strategy

    cljmb 0.2.0
    MusicBrainz API client
    cljmb.core/searchSourceDoc + Usages
    Search for entities matching a query.

    social-wallet-api 0.9.3.1
    Freecoin web API for wallet operations
    social-wallet-api.schema/QuerySourceDoc + Usages
    POST Wallet query validator

    sqlrat 0.2
    SQLRat is a Clojure (v1.2 or later) library to access relational databases using
    org.bituf.sqlrat.clause/>>SourceDoc + Usages
    Alias for the 'query' function

    sqlrat 0.2
    SQLRat is a Clojure (v1.2 or later) library to access relational databases using
    org.bituf.sqlrat.entity.internal/assert-criteriaSourceDoc + Usages
    Assert query criteria

    mew-twitter-api 0.7.6
    full twitter api async interface
    twitter.request/add-query-parametersSourceDoc + Usages
    adds the query parameters to the requestbuilder

    elastics 0.1.1
    Data driven clojure client for Elasticsearch.
    elastics.core/paramsSourceDoc + Usages
    Adds query-params to map.

    elastics 0.1.1
    Data driven clojure client for Elasticsearch.
    elastics.search/querySourceDoc + Usages
    Executes a search query.

    tophat 0.1.5
    Tophat is a Clojure library for handling HTTP request and response documents/maps.
    tophat.core/parse-query-stringSourceDoc + Usages
    Parse an HTTP query string.

    digitalocean 1.2
    Clojure Digital Ocean Client
    digitalocean.v1.core/make-query-paramsSourceDoc + Usages
    Build query params

    clj-apache-http 2.3.2
    Clojure HTTP library using the Apache HttpClient.
    com.twinql.clojure.http/combine-querySourceDoc + Usages
    Combine two query strings.

    paneer 0.1.3
    A small library for managing SQL tables intended to be used alongside Korma, or
    paneer.core/with-connectionSourceDoc + Usages
    Executes a query with a given connection

    fulcro-sql 0.3.2
    A library for using SQL databases as components, writing integration tests, and
    fulcro-sql.util/query-zipSourceDoc + Usages
    Return a zipper on a query expression.

    turntable 0.3.2
    A service for running SQL queries every n minutes.
    flatland.turntable.service/get-querySourceDoc + Usages
    Fetch the currently running query.

    qu-core 1.1.7
    qu is a data platform created by the CFPB to serve their public data sets.
    qu.query.validation/validateSourceDoc + Usages
    Check the query for any errors.

    qu-core 1.1.7
    qu is a data platform created by the CFPB to serve their public data sets.
    qu.query/prepareSourceDoc + Usages
    Prepare the query for execution.

    qu-core 1.1.7
    qu is a data platform created by the CFPB to serve their public data sets.
    qu.resources/slice-querySourceDoc + Usages
    Resource for a query on an individual slice.

    clj-webdriver-vonrosen 0.7.3
    Clojure API for Selenium-WebDriver
    clj-webdriver.cache/delete~Driver~IElementCacheSourceDoc + Usages
    Delete the cached value at `query`

    clj-webdriver-vonrosen 0.7.3
    Clojure API for Selenium-WebDriver
    clj-webdriver.cache/deleteSourceDoc + Usages
    Delete the cached value at `query`

    cljs-css-modules 0.2.1
    cljs-css-modules: css modules in clojurescript
    garden.compiler/*media-query-context*SourceDoc + Usages
    The current media query context.

    cljs-css-modules 0.2.1
    cljs-css-modules: css modules in clojurescript
    garden.compiler/*media-query-context*SourceDoc + Usages
    The current media query context.

    clj-uri 0.1.0
    Parse URI strings into URI components. (wraps java.net.URI)
    clj-uri.core/querySourceDoc + Usages
    Returns query component.

    influxdb-clojure 0.2.0
    Minimalistic InfluxDB client for Clojure, implemented as a wrapper
    influxdb-clojure.core/querySourceDoc + Usages
    Executes a database query

    jiralog 0.0.1
    search jira, why would you want to?
    com.thelastcitadel.query/queriesSourceDoc + Usages
    last 10 query strings

    x-vec 0.1.1
    X-Expressions in Clojure
    x-vec.graphql/*query-deps* (cljs)SourceDoc + Usages
    Track fragments for a query.

    Sends an answer to an callback query

    morse 0.4.0
    Telegram Bot API
    morse.api/answer-inlineSourceDoc + Usages
    Sends an answer to an inline query

    cayenne 0.1.0
    Index and serve CrossRef metadata
    cayenne.data.funder/parse-query-termsSourceDoc + Usages
    Split query terms.

    clj-apache-https 1.0.18
    Clojure HTTP library using the Apache HttpClient. Based on clj-apache-http, but
    com.twinql.clojure.http/combine-querySourceDoc + Usages
    Combine two query strings.

    query-engine 0.1.30
    Execute Om Next queries against various data layers
    workflo.query-engine.query.process/process-query-rootSourceDoc + Usages
    Processes a query root expression.

    query-engine 0.1.30
    Execute Om Next queries against various data layers
    workflo.query-engine.query.process/process-plain-query-exprSourceDoc + Usages
    Processes a plain query expression.

    query-engine 0.1.30
    Execute Om Next queries against various data layers
    workflo.query-engine.query.process/process-keywordSourceDoc + Usages
    Processes a query keyword.

    query-engine 0.1.30
    Execute Om Next queries against various data layers
    workflo.query-engine.query.process/process-query-rootSourceDoc + Usages
    Processes a query root expression.

    query-engine 0.1.30
    Execute Om Next queries against various data layers
    workflo.query-engine.query/resolve-identSourceDoc + Usages
    Resolves an ident query into data.

    Execute a query for a Druid DB.

    Run the query itself.

    Process and run an MBQL query.

    metabase 0.1.0
    Metabase Community Edition
    metabase.pulse/execute-cardSourceDoc + Usages
    Execute the query for a single card.

    Does QUERY have an aggregation?

    metabase 0.1.0
    Metabase Community Edition
    metabase.query-processor.interface/QuerySourceDoc + Usages
    Schema for an MBQL query.

    capacitor 0.6.0
    A Clojure client for InfluxDB
    capacitor.core/db-querySourceDoc + Usages
    Perform arbitrary query string

    cleancr 1.0-beta3
    Finds and optionally removes carriage return characters from your project text files
    clojure.contrib.datalog.rules/?-SourceDoc + Usages
    Define a datalog query

    cleancr 1.0-beta3
    Finds and optionally removes carriage return characters from your project text files
    clojure.contrib.datalog.rules/display-querySourceDoc + Usages
    Return a query in a readable format.

    instagram-api 0.2.0
    Clojure Instagram interface
    instagram.core/encode-paramsSourceDoc + Usages
    Encode params for a query string

    instagram-api 0.2.0
    Clojure Instagram interface
    instagram.request/add-query-parametersSourceDoc + Usages
    Adds the query parameters to the requestbuilder

    fook 0.3.0
    Small utilities for datomic
    fook.query/update-querySourceDoc + Usages
    Dissoc from a query

    fook 0.3.0
    Small utilities for datomic
    fook.query/dissoc-querySourceDoc + Usages
    Dissoc from a query

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

    jopbox 0.2.3
    A Clojure Library to work with Dropbox API
    jopbox.client/searchSourceDoc + Usages
    Searches for a given query.

    engine 0.1.1
    A workflow engine that implements query -> logic -> updates.
    engine.queryable/querySourceDoc + Usages
    Run the query and return the result.

    engine 0.1.1
    A workflow engine that implements query -> logic -> updates.
    engine.data.memory/query~Map~QueryableSourceDoc + Usages
    Run the query and return the result.

    engine 0.1.1
    A workflow engine that implements query -> logic -> updates.
    engine.data.memory/query~IPersistentSet~QueryableSourceDoc + Usages
    Run the query and return the result.

    engine 0.1.1
    A workflow engine that implements query -> logic -> updates.
    engine.data.memory/query~ILookup~QueryableSourceDoc + Usages
    Run the query and return the result.

    engine 0.1.1
    A workflow engine that implements query -> logic -> updates.
    engine.data.memory/query~InMemoryDataStore~QueryableSourceDoc + Usages
    Run the query and return the result.

    engine 0.1.1
    A workflow engine that implements query -> logic -> updates.
    engine.core/querySourceDoc + Usages
    Adapter for 2-arity -query.

    engine 0.1.1
    A workflow engine that implements query -> logic -> updates.
    engine.core/-query~Engine~EngineFlowSourceDoc + Usages
    Run a query and yield that value.

    engine 0.1.1
    A workflow engine that implements query -> logic -> updates.
    engine.core/-querySourceDoc + Usages
    Run a query and yield that value.

    muicljs 0.1.01
    Mui cljs test
    om.next/get-paramsSourceDoc + Usages
    Return the query params for a component.

    Return the unbound query for a component.

    muicljs 0.1.01
    Mui cljs test
    om.next/querySourceDoc + Usages
    Return the component's unbound query

    Return the query parameters

    muicljs 0.1.01
    Mui cljs test
    om.next/paramsSourceDoc + Usages
    Return the query parameters

    muicljs 0.1.01
    Mui cljs test
    om.next/query-zipSourceDoc + Usages
    Return a zipper on a query expression.

    plaza 0.2.0-alpha1
    Plaza framework for semantic distributed applications
    plaza.rdf.sparql/query-to-stringSourceDoc + Usages
    Returns the string representation of a query

    plaza 0.2.0-alpha1
    Plaza framework for semantic distributed applications
    plaza.rdf.sparql/query-set-order-bySourceDoc + Usages
    Sets the pattern for the query

    plaza 0.2.0-alpha1
    Plaza framework for semantic distributed applications
    plaza.rdf.sparql/query-set-patternSourceDoc + Usages
    Sets the pattern for the query

    plaza 0.2.0-alpha1
    Plaza framework for semantic distributed applications
    plaza.rdf.sparql/query-set-filtersSourceDoc + Usages
    Set a collection of filters for the query

    plaza 0.2.0-alpha1
    Plaza framework for semantic distributed applications
    plaza.rdf.sparql/query-set-varsSourceDoc + Usages
    Set a collection of vars for the query

    plaza 0.2.0-alpha1
    Plaza framework for semantic distributed applications
    plaza.rdf.sparql/query-set-typeSourceDoc + Usages
    Sets the type of a query

    plaza 0.2.0-alpha1
    Plaza framework for semantic distributed applications
    plaza.rdf.predicates/not?SourceDoc + Usages
    Negates a clause query

    clj-jargon 2.8.9
    Clojure API on top of iRODS's jargon-core.
    clj-jargon.spec-query/delete-querySourceDoc + Usages
    Deletes a specific query in iRODS.

    persephone 0.1.1
    Clojure DSL that generates [Neo4J] Cypher queries
    clojurewerkz.persephone.compiler/compile-querySourceDoc + Usages
    Render a full Cypher query.

    persephone 0.1.1
    Clojure DSL that generates [Neo4J] Cypher queries
    clojurewerkz.persephone/render-querySourceDoc + Usages
    Render a full Cypher query.

    persephone 0.1.1
    Clojure DSL that generates [Neo4J] Cypher queries
    clojurewerkz.persephone/startSourceDoc + Usages
    Construct and render a Cypher query.

    persephone 0.1.1
    Clojure DSL that generates [Neo4J] Cypher queries
    clojurewerkz.persephone/render-querySourceDoc + Usages
    Render a full Cypher query.

    clj-orchestrate 0.2.2
    Clojure Orchestrate.io client
    clj-orchestrate.kv/searchSourceDoc + Usages
    Execute a Lucene query in a collection

    List users report by query

    List users report by query

    asosio-utils 0.0.1
    The Asosio Utils is a collection of utilities that makes development of clojure
    asosio_utils.middleware/wrap-keywordize-qparamsSourceDoc + Usages
    Keywordize query parameters.

    anglican 1.0.0
    Anglican, a probabilistic programming system
    anglican.trap/query-cpsSourceDoc + Usages
    transforms nested query into CPS

    anglican 1.0.0
    Anglican, a probabilistic programming system
    anglican.trap/query-cpsSourceDoc + Usages
    transforms nested query into CPS

    qseq 0.6.3
    qseq: a lazy sequence for simply and efficiently consuming Korma
    qseq.korma/q-limitedSourceDoc + Usages
    returns a query with limit

    gardendb 0.2.0
    GardenDB is an embedded, file-backed document store specifically for Clojure, influenced
    gardendb.core/qSourceDoc + Usages
    Convenience function that wraps query.

    sqlosure 0.2.0
    Compositional relational queries.
    sqlosure.relational-algebra/query?SourceDoc + Usages
    Returns true if the `obj` is a query.

    sqlosure 0.2.0
    Compositional relational queries.
    sqlosure.relational-algebra/make-groupSourceDoc + Usages
    Make a grouped query from a basic query.
    
      - `columns` is a seq of columns to be grouped by
      - `query` is the underlying query

    sqlosure 0.2.0
    Compositional relational queries.
    sqlosure.relational-algebra/make-empty-querySourceDoc + Usages
    Construct a `empty-query` record.
    

    sqlosure 0.2.0
    Compositional relational queries.
    sqlosure.relational-algebra/attach-rel-scheme-cacheSourceDoc + Usages
    Attach a rel-scheme cache to query.
    
      - `query` is the query
      - `fun` is a function accepting an environment, yielding the scheme of the query

    rage-db 1.0
    Lightweight disk based json database
    rage-db.core/db-?SourceDoc + Usages
    query a keyspace by function

    twfy 0.3.2
    Clojure bindings for the [TheyWorkForYou](http://www.theyworkforyou.com/) [API](http://www.theyworkforyou.com/api/)
    twfy.core/map2querySourceDoc + Usages
    Translates a map into a query string.

    monglorious 0.7.0
    Query MongoDB using strings!
    monglorious.parser/parse-querySourceDoc + Usages
    Parses a MongoDB query and simplifies

    sunog 0.0.4
    Convenience library for using Firebase with Clojure and Clojurescript
    sunog.cljs.geofire/query (cljs)SourceDoc + Usages
    Setup a geofire query

    dorali 0.1.0
    Transitive SQL + Elasticsearch queries
    dorali.es.core/percolate>SourceDoc + Usages
    Returns an ES percolate query.

    bacwn 0.1.0
    Deep studies in Clojure.
    bacwn.datalog.impl.rules/?-SourceDoc + Usages
    Define a datalog query

    Return a query in a readable format.

    schemonger 0.2.0
    Schema-vased validations for mongodb
    schemonger.models/find-recordsSourceDoc + Usages
    Find records by query

    cellophane 0.3.5
    Server-side rendering for Om Next components
    cellophane.next/get-paramsSourceDoc + Usages
    Return the query params for a component.

    cellophane 0.3.5
    Server-side rendering for Om Next components
    cellophane.next/get-unbound-querySourceDoc + Usages
    Return the unbound query for a component.

    cellophane 0.3.5
    Server-side rendering for Om Next components
    cellophane.next/querySourceDoc + Usages
    Return the component's unbound query

    cellophane 0.3.5
    Server-side rendering for Om Next components
    cellophane.next/params~Object~IQueryParamsSourceDoc + Usages
    Return the query parameters

    cellophane 0.3.5
    Server-side rendering for Om Next components
    cellophane.next/paramsSourceDoc + Usages
    Return the query parameters

    cellophane 0.3.5
    Server-side rendering for Om Next components
    cellophane.next/query-zipSourceDoc + Usages
    Return a zipper on a query expression.

    clopp 0.2.0
    clopp : appliation components in clojure
    clopp.dataset/query*SourceDoc + Usages
    run the query with id <query-id>, with (apply query this args). use query instead

    clj-trakt 1.0.2
    Trakt API in Clojure
    clj-trakt.search/textSourceDoc + Usages
    Perform a text 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.

    uri-handler 1.1.0
    A Library which will search the classpath to load URI handlers
    uri-handler.uri/query~String~URILikeSourceDoc + Usages
    Return the query portion of the URI.

    uri-handler 1.1.0
    A Library which will search the classpath to load URI handlers
    uri-handler.uri/query~IPersistentMap~URILikeSourceDoc + Usages
    Return the query portion of the URI.

    uri-handler 1.1.0
    A Library which will search the classpath to load URI handlers
    uri-handler.uri/query~java.net.URI~URILikeSourceDoc + Usages
    Return the query portion of the URI.

    uri-handler 1.1.0
    A Library which will search the classpath to load URI handlers
    uri-handler.uri/querySourceDoc + Usages
    Return the query portion of the URI.

    service-hub 1.0.3
    Service hub framework
    servicehub.korma-util/limit-helperSourceDoc + Usages
    Adds limit attribute to query

    service-hub 1.0.3
    Service hub framework
    servicehub.korma-util/offset-helperSourceDoc + Usages
    Adds offset attribute to query

    service-hub 1.0.3
    Service hub framework
    servicehub.korma-util/sorting-helperSourceDoc + Usages
    Adds sorting attributes to query

    suricatta 0.2.2
    High level sql toolkit for clojure (backed by jooq library)
    suricatta.format/get-sqlSourceDoc + Usages
    Renders a query sql into string.

    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-sql~suricatta.types.Deferred~IRendererSourceDoc + Usages
    Render a query sql into a string.

    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.format/get-sql~org.jooq.Query~IRendererSourceDoc + Usages
    Render a query sql into a string.

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

    suricatta 0.2.2
    High level sql toolkit for clojure (backed by jooq library)
    suricatta.proto/get-sqlSourceDoc + Usages
    Render a query sql into a string.

    clj-neo4j-data 0.0.0-alfa-140202c
    This is program which offers basic API for eDocu
    sk.selmeci.clj-neo4j-data.core/tquerySourceDoc + Usages
    Execute query in database

    clj-neo4j-data 0.0.0-alfa-140202c
    This is program which offers basic API for eDocu
    sk.selmeci.clj-neo4j-data.labeled-node/query-properties~LabeledNode~QueryPropertiesSourceDoc + Usages
    Return properties as string for query

    clj-neo4j-data 0.0.0-alfa-140202c
    This is program which offers basic API for eDocu
    sk.selmeci.clj-neo4j-data.labeled-node/query-properties~NodeRelationship~QueryPropertiesSourceDoc + Usages
    Return properties as string for query

    clj-neo4j-data 0.0.0-alfa-140202c
    This is program which offers basic API for eDocu
    sk.selmeci.clj-neo4j-data.labeled-node/query-propertiesSourceDoc + Usages
    Return properties as string for query

    calabash-jvm 0.0.7
    JVM client for calabash-ios-server for automated iOS functional testing
    calabash-jvm/indexSourceDoc + Usages
    construct an index query

    clj-dropbox-oauth2 0.1.2
    Simple Clojure bindings for Dropbox API with OAuth2.
    clj-dropbox-oauth2.dropbox/searchSourceDoc + Usages
    Searches for a given query.

    gin 0.3.5
    All the generators you need and/or want.
    gin.internet/querySourceDoc + Usages
    Generates a URI query segment.

    clj-druid 0.2.18
    Clojure library for Druid.io
    clj-druid.client/querySourceDoc + Usages
    Issue a druid query

    clj-druid 0.2.18
    Clojure library for Druid.io
    clj-druid.schemas.query/querySourceDoc + Usages
    druid query router

    clj-druid 0.2.18
    Clojure library for Druid.io
    clj-druid.validations/validate-topNSourceDoc + Usages
    Validate a druid topN query

    clj-druid 0.2.18
    Clojure library for Druid.io
    clj-druid.validations/validate-timeseriesSourceDoc + Usages
    Validate a druid timeseries query

    clj-druid 0.2.18
    Clojure library for Druid.io
    clj-druid.validations/validate-searchSourceDoc + Usages
    Validate a druid search query

    clj-druid 0.2.18
    Clojure library for Druid.io
    clj-druid.validations/validate-groupbySourceDoc + Usages
    Validate a druid groupBy query

    stylefy 1.5.1
    Library for styling UI components
    stylefy.core/use-sub-style (cljs)SourceDoc + Usages
    Defines style for a component using sub-style.
    
       The style and options are the same as you would use with use-style.
       sub-style is the name of the sub-stale in the given style map.
    
       If you have a deeper sub-style nesting, ie. you want to get a sub-style from sub-style,
       take a look at sub-style function.

    monotony 0.0.6
    Time utilities for humans.
    monotony.core/cycles-inSourceDoc + Usages
    Break a period down by a cycle into multiple sub-periods wholly
      contained in that period. The first sub-period will be inclusive of
      the start of the period. The last sub-period will be exclusive of
      the end of the period. Returns a lazy-seq of the periods.

    clojure-contrib 1.2.0
    Clojure user contributions library.
    clojure.contrib.prxml/*prxml-indent*SourceDoc + Usages
    The number of spaces to indent sub-tags.  nil for no indent
      and no extra line-breaks.

    encore 2.96.0
    Core utils library for Clojure/Script
    taoensso.encore/substrSourceDoc + Usages
    Gives a consistent, flexible, cross-platform substring API built on
      `sub-indexes`.

    encore 2.96.0
    Core utils library for Clojure/Script
    taoensso.encore/substr (cljs)SourceDoc + Usages
    Gives a consistent, flexible, cross-platform substring API built on
      `sub-indexes`.

    core.matrix 0.62.0
    N-dimensional array programming API for Clojure
    clojure.core.matrix.impl.defaults/subvector~Object~PSubVectorSourceDoc + Usages
    Gets a sub-vector of a vector. Must return a view if the vector is mutable.

    core.matrix 0.62.0
    N-dimensional array programming API for Clojure
    clojure.core.matrix.impl.defaults/subvector~Number~PSubVectorSourceDoc + Usages
    Gets a sub-vector of a vector. Must return a view if the vector is mutable.

    core.matrix 0.62.0
    N-dimensional array programming API for Clojure
    clojure.core.matrix.impl.defaults/subvector~nil~PSubVectorSourceDoc + Usages
    Gets a sub-vector of a vector. Must return a view if the vector is mutable.

    core.matrix 0.62.0
    N-dimensional array programming API for Clojure
    clojure.core.matrix.impl.double-array/subvector~array~PSubVector (cljs)SourceDoc + Usages
    Gets a sub-vector of a vector. Must return a view if the vector is mutable.

    core.matrix 0.62.0
    N-dimensional array programming API for Clojure
    clojure.core.matrix.impl.wrappers/subvector~NDWrapper~PSubVectorSourceDoc + Usages
    Gets a sub-vector of a vector. Must return a view if the vector is mutable.

    core.matrix 0.62.0
    N-dimensional array programming API for Clojure
    clojure.core.matrix.impl.object-array/object-array-coerceSourceDoc + Usages
    Coerce to object array format, avoids copying Object[] sub-arrays if possible.

    core.matrix 0.62.0
    N-dimensional array programming API for Clojure
    clojure.core.matrix.impl.persistent-vector/subvector~IPersistentVector~PSubVectorSourceDoc + Usages
    Gets a sub-vector of a vector. Must return a view if the vector is mutable.

    core.matrix 0.62.0
    N-dimensional array programming API for Clojure
    clojure.core.matrix.protocols/subvectorSourceDoc + Usages
    Gets a sub-vector of a vector. Must return a view if the vector is mutable.

    Applys normalize-spec-fn-form to any fn* sub form.

    vectorz-clj 0.47.0
    Fast matrix and vector maths library for Clojure - as a pure JVM core.matrix implementation
    mikera.vectorz.matrix-api/subvector~AVector~PSubVectorSourceDoc + Usages
    Gets a sub-vector of a vector. Must return a view if the vector is mutable.

    vectorz-clj 0.47.0
    Fast matrix and vector maths library for Clojure - as a pure JVM core.matrix implementation
    mikera.vectorz.matrix-api/subvector~INDArray~PSubVectorSourceDoc + Usages
    Gets a sub-vector of a vector. Must return a view if the vector is mutable.

    parkour 0.6.4-alpha1
    Hadoop MapReduce in idiomatic Clojure.
    parkour.io.dux/add-substepSourceDoc + Usages
    Add configuration changes produced by `step` as a demultiplex
    sub-configuration of `job`.

    parkour 0.6.4-alpha1
    Hadoop MapReduce in idiomatic Clojure.
    parkour.io.mux/add-substepSourceDoc + Usages
    Add configuration changes produced by `step` as a multiplex
    sub-configuration of `job`.

    The number of spaces to indent sub-tags.  nil for no indent
      and no extra line-breaks.

    clojure-mail 0.1.6
    Clojure Email Library
    clojure-mail.core/foldersSourceDoc + Usages
    Returns a seq of all IMAP folders inlcuding sub folders

    clojurecuda 0.4.0
    ClojureCUDA is a Clojure library for parallel computations with Nvidia's CUDA.
    uncomplicate.clojurecuda.core/mem-sub-regionSourceDoc + Usages
    Creates a [[CULinearMemory]] that references a sub-region of `mem` from origin to len.

    funnyqt 1.1.5
    A model querying and transformation library for TGraphs and EMF models developed
    funnyqt.emf/eallsubclassesSourceDoc + Usages
    Returns the direct and indirect sub-EClasses of the given EClass `ec`.

    funnyqt 1.1.5
    A model querying and transformation library for TGraphs and EMF models developed
    funnyqt.coevo.tg/create-specialization!SourceDoc + Usages
    Creates a specialization between Vertex- or EdgeClasses `super` and `sub`.
      Returns `super` again.

    cortex 0.9.22
    A neural network toolkit for Clojure.
    cortex.compute.driver/sub-buffer-implSourceDoc + Usages
    Create a sub buffer that shares the backing store with the main buffer.

    cortex 0.9.22
    A neural network toolkit for Clojure.
    cortex.compute.driver/PBufferSourceDoc + Usages
    Interface to create sub-buffers out of larger contiguous buffers.

    cortex 0.9.22
    A neural network toolkit for Clojure.
    cortex.compute.cuda.driver/sub-buffer-impl~Pointer~PBufferSourceDoc + Usages
    Create a sub buffer that shares the backing store with the main buffer.

    Create a sub buffer that shares the backing store with the main buffer.

    Create a sub buffer that shares the backing store with the main buffer.

    lein-sub 0.3.0
    Leiningen Subprojects plugin
    leiningen.sub/resolve-subprojectsSourceDoc + Usages
    Parse `args` and return [sub-projects task-name args]

    hara.string.case 2.8.3
    patterns and utilities
    hara.string.case/re-subSourceDoc + Usages
    substitute a pattern by applying a function
     
       (re-sub "aTa" hump-pattern (fn [_] "$"))
       => "$a"

    systems-toolbox-redis 0.6.4
    Redis communication components for systems-toolbox
    matthiasn.systems-toolbox-redis.receiver/msg-handler-fnSourceDoc + Usages
    Create handler function for messages from Redis Pub/Sub

    locos 0.1.3
    Logic based Configuration Functions
    palletops.locos/recursive-partial-mapSourceDoc + Usages
    Return a value that will use partial-map unification on sub-maps

    cljss-core 0.3.0
    DSL to write css rules in clojure.
    cljss.precompilation/default-visitorSourceDoc + Usages
    The visitor used to precompile an AST, representation
      of a rule and its sub rules.

    compute 0.5.0
    Compute abstraction and cpu implementation. Meant to abstract things like openCL
    think.compute.driver/sub-buffer-implSourceDoc + Usages
    Create a sub buffer that shares the backing store with the main buffer.

    compute 0.5.0
    Compute abstraction and cpu implementation. Meant to abstract things like openCL
    think.compute.cpu-driver/sub-buffer-impl~CPUDriver~PDriverSourceDoc + Usages
    Create a sub buffer that shares the backing store with the main buffer.

    iron 0.4.0
    Front-end utilities and support for ClojureScript and re-frame projects
    iron.re-utils/sub->fn (cljs)SourceDoc + Usages
    Accept either a re-frame sub or a function, for contexts that demand
      a function.

    iron 0.4.0
    Front-end utilities and support for ClojureScript and re-frame projects
    iron.re-utils/sub->fn (cljs)SourceDoc + Usages
    Accept either a re-frame sub or a function, for contexts that demand
      a function.

    precept 0.4.0-alpha
    A declarative programming framework
    precept.core/subscribeSourceDoc + Usages
    Returns lens that points to a path in the store. Sub is handled by a rule.

    bartok-x 0.1
    a set of primitives for musical programming
    bartok.primitives/equiv-sub-type? (cljs)SourceDoc + Usages
    same as sub-type? but equality is tested via the t-equiv? function