CrossClj
full-text documentation search

Project count:
9877

Last update
Jun 16, 2018

How to be listed

Artifact list

Clojurescript

Feedback

RECENT
    Less more depended upon.
    Full-text search for function, var, namespace, project documentation and descriptions for Clojure open-source projects.
    Query syntax supports boolean modifiers (+word, -word), wildcards (* and ?, except for the first character of a word), and phrases ("word1 word2").
    To search for identifiers, use the name search.
    Found 20746 results in 224 projects. Show the first 500.
    cspbox-runtime 0.1.2
    runtime lib for cspbox system
    cspbox.runtime.sys.utils.util/filter-valsSourceDoc + Usages
    filter a map with pred on value only

    Inputs: [config-value :- (schema/pred map? "map?")]

    rp-util-clj 1.0.15
    Common utilities
    rp.util.map/select-vals-bySourceDoc + Usages
    Returns a map where the vals satisfy pred.

    rp-util-clj 1.0.15
    Common utilities
    rp.util.map/select-keys-bySourceDoc + Usages
    Returns a map where the keys satisfy pred.

    rp-util-clj 1.0.15
    Common utilities
    rp.util.map/select-bySourceDoc + Usages
    Returns a map where the entries satisfy pred.

    utilis 1.1.0
    Library of common utilities used in 7theta projects
    utilis.map/assoc-ifSourceDoc + Usages
    Conditionally assoc `val` into `map` at `key` if `val` passes the test
      specified by the optional `pred`. If `pred` is not specified, the val is
      tested for truthiness.

    useful 0.11.5
    A collection of generally-useful Clojure utility functions
    flatland.useful.map/remove-keysSourceDoc + Usages
    Returns a map that only contains keys where (pred key) returns false.

    useful 0.11.5
    A collection of generally-useful Clojure utility functions
    flatland.useful.map/filter-keysSourceDoc + Usages
    Returns a map that only contains keys where (pred key) returns true.

    useful 0.11.5
    A collection of generally-useful Clojure utility functions
    flatland.useful.map/remove-valsSourceDoc + Usages
    Returns a map that only contains values where (pred value) returns false.

    useful 0.11.5
    A collection of generally-useful Clojure utility functions
    flatland.useful.map/filter-valsSourceDoc + Usages
    Returns a map that only contains values where (pred value) returns true.

    useful 0.11.5
    A collection of generally-useful Clojure utility functions
    flatland.useful.map/remove-keys-by-valSourceDoc + Usages
    Returns all keys of map for which (pred value) returns false.

    useful 0.11.5
    A collection of generally-useful Clojure utility functions
    flatland.useful.map/filter-keys-by-valSourceDoc + Usages
    Returns all keys in map for which (pred value) returns true.

    utilize 0.2.3
    Compilation of Clojure functions from around the community
    utilize.map/remove-keysSourceDoc + Usages
    Returns a map that only contains keys where (pred key) returns false.

    utilize 0.2.3
    Compilation of Clojure functions from around the community
    utilize.map/filter-keysSourceDoc + Usages
    Returns a map that only contains keys where (pred key) returns true.

    utilize 0.2.3
    Compilation of Clojure functions from around the community
    utilize.map/remove-valsSourceDoc + Usages
    Returns a map that only contains values where (pred value) returns false.

    utilize 0.2.3
    Compilation of Clojure functions from around the community
    utilize.map/filter-valsSourceDoc + Usages
    Returns a map that only contains values where (pred value) returns true.

    utilize 0.2.3
    Compilation of Clojure functions from around the community
    utilize.map/remove-keys-by-valSourceDoc + Usages
    Returns all keys of map for which (pred value) returns false.

    utilize 0.2.3
    Compilation of Clojure functions from around the community
    utilize.map/filter-keys-by-valSourceDoc + Usages
    Returns all keys in map for which (pred value) returns true.

    clojure-common-utils 0.0.24
    This is a library location for me to plunk a lot of common utilities I want to keep
    roxxi.utils.collections/filter-mapSourceDoc + Usages
    Like `filter` but kv-pred is assumed to operate on a keyval,
    and yields a map

    utility-belt 1.8
    Provisdom utility-belt
    provisdom.utility-belt.maps/filter-mapSourceDoc + Usages
    Returns map with keys that meet `pred`, which takes a key and value as
      inputs.

    strict-config 0.1.0
    Less tolerant Clojure service configuration.
    strict-config.map/restrictionSourceDoc + Usages
    Throws an Exception if the map contains values for which (pred item) returns true

    strict-config 0.1.0
    Less tolerant Clojure service configuration.
    strict-config.map/strictSourceDoc + Usages
    Convert an ordinary map into one that throws an Exception when
       - an unknown key is requested
       - a value returns true for (pred value)
       - map contains values for which (pred item) returns true.
       If not passed, pred is nil?

    incanter-core 1.9.3
    Incanter-core is the core module of the Incanter project.
    incanter.core/query-to-predSourceDoc + Usages
      Given a query-map, it returns a function that accepts a hash-map and returns true if it
      satisfies the conditions specified in the provided query-map.
    
      Examples:
    
        (use 'incanter.core)
        (def pred (query-to-pred {:x 5 :y 7}))
        (pred {:x 5 :y 7 :z :d})
    
        (def pred (query-to-pred {:x 5 :y {:$gt 5 :$lt 10}}))
        (pred {:x 5 :y 7 :z :d})
    
        (def pred (query-to-pred {:z {:$in #{:a :b}}}))
        (pred {:x 5 :y 7 :z :d})
      

    funnyqt 1.1.5
    A model querying and transformation library for TGraphs and EMF models developed
    funnyqt.visualization/*edge-attrs*SourceDoc + Usages
    A map of the form {pred edge-attrs}.  If (pred e) returns true,
      edge-attrs is appended to its edge definition.  Useful for colorizing etc.

    funnyqt 1.1.5
    A model querying and transformation library for TGraphs and EMF models developed
    funnyqt.visualization/*node-attrs*SourceDoc + Usages
    A map of the form {pred node-attrs}.  If (pred el) returns true,
      node-attrs is appended to its node definition.  Useful for colorizing etc.

    dataset-tools 0.1.12
    Easy to use library for working with core.matrix datasets in Clojure.
    dataset-tools.core/whereSourceDoc + Usages
    Returns the dataset ds filtered on predicate pred. Pred is expected
       to be a unitary function which expects a map representation of each
       row as an input and returns true/false.

    clojure-tools 1.1.3
    Clojure tools is a set of clojure utilities pulled out of Conjure.
    clojure.tools.map-utils/filter-mapSourceDoc + Usages
    Returns a new map only including keys from the given map where pred
    returns true. Pred must be a function which takes a key and value from map.

    Inputs: [inner-query :- (s/pred map?)]
      Returns: i/Query
    
      Expand an inner query map.

    anansi-site 0.0.10
    basic compojure/ring based web framework
    anansi.validation/validationSourceDoc + Usages
    Convinience function to perform a series of validations on a map of params.
      Takes a set of params and a collection of argument vectors for the validate
      function:
      e.g. (validation params
             [name pred message]
             [pred message])
      Is the same as:
           (merge-errors
             (validate params name pred message)
             (validate params pred message))

    arbol 0.2.1
    Arbol is a mixed data type tree transformer using simple selectors available in
    arbol.internal/read-selectorSourceDoc + Usages
    Read selector parses one step of the selector and
       returns a map with :axis :pred :rest keys
       Axis: first function or keyword in the selector.
       Pred: an ever-pred on all predicates available for that axis.
       A nil predicate indicates no tests are to be run on this path element.
       Rest: the remainder of the everything else besides the current axis/pred.

    arbol 0.2.1
    Arbol is a mixed data type tree transformer using simple selectors available in
    arbol.internal/read-selector (cljs)SourceDoc + Usages
    Read selector parses one step of the selector and
       returns a map with :axis :pred :rest keys
       Axis: first function or keyword in the selector.
       Pred: an ever-pred on all predicates available for that axis.
       A nil predicate indicates no tests are to be run on this path element.
       Rest: the remainder of the everything else besides the current axis/pred.

    jp 1.3.0
    An ode to jutils.
    jp.core/ensure-withSourceDoc + Usages
    Ensures `pred?` is true of `arg` by calling `xform` on `arg` if
       `(pred? arg)` is not already true.
    
       eg.
          (ensure-with map? #(-> {:val %}) {:val 7})  ;; => {:val 7}
          (ensure-with map? #(-> {:val %}) 5)         ;; => {:val 5}
      

    kurosawa.core 2.0.1
    The root Kurosawa library.
    org.purefn.kurosawa.transform/filter-valsSourceDoc + Usages
    Takes a predicate and a map, and returns a map containing only the
       keys for which (pred val) returns true. Returns a transducer when
       no input map is provided.

    refactor-nrepl 2.3.1
    nREPL middleware to support editor-agnostic refactoring
    refactor-nrepl.util/filter-mapSourceDoc + Usages
    Return a new map where (pred [k v]) is true for every key-value pair.

    utilis 1.1.0
    Library of common utilities used in 7theta projects
    utilis.map/remove-valsSourceDoc + Usages
    Returns a map with the keys and values from 'm' with the keys and
      values for which 'pred' returned a truthy result removed.

    utilis 1.1.0
    Library of common utilities used in 7theta projects
    utilis.map/filter-valsSourceDoc + Usages
    Return a map with the keys and values from 'm' for which 'pred'
      returned a truthy result for the value.

    bartok-x 0.1
    a set of primitives for musical programming
    utils.utils/filt-h (cljs)SourceDoc + Usages
    like filter but takes and return hash-map
         if pred fail on a keyval it is dissoc from h

    bartok-x 0.1
    a set of primitives for musical programming
    utils.utils/filt-hSourceDoc + Usages
    like filter but takes and return hash-map
         if pred fail on a keyval it is dissoc from h

    rp-util-clj 1.0.15
    Common utilities
    rp.util.map/relocate-vals-bySourceDoc + Usages
    Returns a map where the keys of the vals satisfying pred are associated to
       the path of the relocation-ks key sequence.

    rp-util-clj 1.0.15
    Common utilities
    rp.util.map/relocate-keys-bySourceDoc + Usages
    Returns a map where the keys satisfying pred are associated to the path of the
       relocation-ks key sequence.

    filters values of a map that fits the predicate
       (filter-pred string? {:a "valid" :b 0})
       => {:a "valid"}

    hydrox 0.1.17
    dive deeper into your code
    hydrox.common.util/filter-predSourceDoc + Usages
    filters values of a map that fits the predicate
       (filter-pred string? {:a "valid" :b 0})
       => {:a "valid"}

    schema 1.1.9
    Clojure(Script) library for declarative data description and validation
    schema.experimental.abstract-map/open-abstract-map-schema (cljs)SourceDoc + Usages
    Inputs: [dispatch-key :- s/Keyword schema :- (s/pred map?)]
    
      Like abstract-map-schema, but allows unknown types to validate (for, e.g. forward
       compatibility).

    schema 1.1.9
    Clojure(Script) library for declarative data description and validation
    schema.experimental.abstract-map/open-abstract-map-schemaSourceDoc + Usages
    Inputs: [dispatch-key :- s/Keyword schema :- (s/pred map?)]
    
      Like abstract-map-schema, but allows unknown types to validate (for, e.g. forward
       compatibility).

    tupelo 0.9.76
    Tupelo: Clojure With A Spoonful of Honey
    tupelo.impl/contains-key?SourceDoc + Usages
    Inputs: [map-or-set :- (s/pred (fn* [p1__49954#] (or (map? p1__49954#) (set? p1__49954#)))) elem :- s/Any]
      Returns: s/Bool

    Takes key+pred pairs, e.g.
    
      (s/cat :e even? :o odd?)
    
      Returns a regex op that matches (all) values in sequence, returning a map
      containing the keys of each pred and the corresponding value.

    spec.alpha 0.1.143
    Specification of data and functions
    clojure.spec.alpha/catSourceDoc + Usages
    Takes key+pred pairs, e.g.
    
      (s/cat :e even? :o odd?)
    
      Returns a regex op that matches (all) values in sequence, returning a map
      containing the keys of each pred and the corresponding value.

    clojure-future-spec 1.9.0-alpha9-1
    Backport of clojure.spec for Clojure 1.8
    clojure.spec/catSourceDoc + Usages
    Takes key+pred pairs, e.g.
    
      (s/cat :e even? :o odd?)
    
      Returns a regex op that matches (all) values in sequence, returning a map
      containing the keys of each pred and the corresponding value.

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

    strictly-specking-standalone 0.1.1
    A Clojure library to help validate edn configuration data, and hopefully more
    strictly-specking-standalone.spec/catSourceDoc + Usages
    Takes key+pred pairs, e.g.
    
      (s/cat :e even? :o odd?)
    
      Returns a regex op that matches (all) values in sequence, returning a map
      containing the keys of each pred and the corresponding value.

    unscrew 0.2.1
    A toolkit for processing jar files
    irresponsible.unscrew/slurp-jar-matchingSourceDoc + Usages
    Opens a jar at the given path, filters filenames by predicate and reads them,
       closing the jar afterwards. returns data as map of filename to content
       args: [jar-path pred binary?]
         pred: boolean predicate
         binary?: should we return a bytebuffer (true) or a string (false)?
       returns map of filename to content

    eat-static 0.1.0
    Eat Static, a library for type checking and validation of Clojure maps and functions.
    eat-static.validations/epm>SourceDoc + Usages
    Like epcoll> but tests specifically for a map type of collection. This is likely to be used the least, since the other pred* functions are better for dealing with maps.

    bouncer 1.0.1
    A validation library for Clojure apps
    bouncer.core/wrapSourceDoc + Usages
    Wraps pred in the context of validating a single value
    
      - `acc`  is the map being validated
    
      - `pred` is a validator
    
      - `k`    the path to the value to be validated in the associative structure `acc`
    
      - `args` any extra args to pred
    
      It only runs pred if:
    
      - the validator contains a pre-condition *and* it is met or;
      - the validator is optional  *and* there is a non-nil value to be validated (this information is read from pred's metadata) or;
      - there are no previous errors for the given path
    
      Returns `acc` augmented with a namespace qualified ::errors keyword
    

    Registers a handler to be dispatched based on a request method and a
      predicate.
    
      pred should be a function that accepts an options map, a connection,
      and a request map and returns a boolean value based on whether or not
      that request should be dispatched to the related handler.

    receipt 1.0.1
    FIXME: write description
    cljs.repl.server/dispatch-onSourceDoc + Usages
    Registers a handler to be dispatched based on a request method and a
      predicate.
    
      pred should be a function that accepts an options map, a connection,
      and a request map and returns a boolean value based on whether or not
      that request should be dispatched to the related handler.

    torus-pong 0.1.0
    A multiplayer take on the classic Game of Pong. Entry for Clojure Cup 2013.
    cljs.repl.server/dispatch-onSourceDoc + Usages
    Registers a handler to be dispatched based on a request method and a
      predicate.
    
      pred should be a function that accepts an options map, a connection,
      and a request map and returns a boolean value based on whether or not
      that request should be dispatched to the related handler.

    Takes key+pred pairs, e.g.
    
      (s/alt :even even? :small #(< % 42))
    
      Returns a regex op that returns a map entry containing the key of the
      first matching pred and the corresponding value. Thus the
      'key' and 'val' functions can be used to refer generically to the
      components of the tagged return.

    Takes key+pred pairs, e.g.
    
      (s/or :even even? :small #(< % 42))
    
      Returns a destructuring spec that returns a map entry containing the
      key of the first matching pred and the corresponding value. Thus the
      'key' and 'val' functions can be used to refer generically to the
      components of the tagged return.

    spec.alpha 0.1.143
    Specification of data and functions
    clojure.spec.alpha/altSourceDoc + Usages
    Takes key+pred pairs, e.g.
    
      (s/alt :even even? :small #(< % 42))
    
      Returns a regex op that returns a map entry containing the key of the
      first matching pred and the corresponding value. Thus the
      'key' and 'val' functions can be used to refer generically to the
      components of the tagged return

    spec.alpha 0.1.143
    Specification of data and functions
    clojure.spec.alpha/orSourceDoc + Usages
    Takes key+pred pairs, e.g.
    
      (s/or :even even? :small #(< % 42))
    
      Returns a destructuring spec that returns a map entry containing the
      key of the first matching pred and the corresponding value. Thus the
      'key' and 'val' functions can be used to refer generically to the
      components of the tagged return.

    clojure-future-spec 1.9.0-alpha9-1
    Backport of clojure.spec for Clojure 1.8
    clojure.spec/altSourceDoc + Usages
    Takes key+pred pairs, e.g.
    
      (s/alt :even even? :small #(< % 42))
    
      Returns a regex op that returns a map entry containing the key of the
      first matching pred and the corresponding value. Thus the
      'key' and 'val' functions can be used to refer generically to the
      components of the tagged return

    clojure-future-spec 1.9.0-alpha9-1
    Backport of clojure.spec for Clojure 1.8
    clojure.spec/orSourceDoc + Usages
    Takes key+pred pairs, e.g.
    
      (s/or :even even? :small #(< % 42))
    
      Returns a destructuring spec that returns a map entry containing the
      key of the first matching pred and the corresponding value. Thus the
      'key' and 'val' functions can be used to refer generically to the
      components of the tagged return.

    strictly-specking-standalone 0.1.1
    A Clojure library to help validate edn configuration data, and hopefully more
    strictly-specking-standalone.spec/altSourceDoc + Usages
    Takes key+pred pairs, e.g.
    
      (s/alt :even even? :small #(< % 42))
    
      Returns a regex op that returns a map entry containing the key of the
      first matching pred and the corresponding value. Thus the
      'key' and 'val' functions can be used to refer generically to the
      components of the tagged return

    strictly-specking-standalone 0.1.1
    A Clojure library to help validate edn configuration data, and hopefully more
    strictly-specking-standalone.spec/orSourceDoc + Usages
    Takes key+pred pairs, e.g.
    
      (s/or :even even? :small #(< % 42))
    
      Returns a destructuring spec that returns a map entry containing the
      key of the first matching pred and the corresponding value. Thus the
      'key' and 'val' functions can be used to refer generically to the
      components of the tagged return.

    comidi 0.3.2
    Puppet Labs utility functions and compojure-like wrappers for use with the bidi
    puppetlabs.comidi/wrap-with-route-metadataSourceDoc + Usages
    Inputs: [app :- (schema/pred fn?) routes :- bidi-schema/RoutePair]
      Returns: (schema/pred fn?)
    
      Ring middleware; adds the comidi route-metadata to the request map, as well
      as a :route-info key that can be used to determine which route a given request
      matches.

    bartok-x 0.1
    a set of primitives for musical programming
    utils.utils/satisfies-all? (cljs)SourceDoc + Usages
    return true if for each pred (pred v) is true

    bartok-x 0.1
    a set of primitives for musical programming
    utils.utils/satisfies-all?SourceDoc + Usages
    return true if for each pred (pred v) is true

    structural-typing 2.0.5
    Define types by giving descriptions (perhaps incomplete) of how they're built.
    structural-typing.assist.testutil/lift-and-runSourceDoc + Usages
    [[lift-pred]] the `pred` and run it against the [[exval]].

    skm-ice-utils 1.0.3
    Utility library developed by the ICE project within the danish ministry of taxation
    cljs.spec/explain-data (cljs)SourceDoc + Usages
    Given a spec and a value x which ought to conform, returns nil if x
      conforms, else a map with at least the key ::problems whose value is
      a path->problem-map, where problem-map has at least :pred and :val
      keys describing the predicate and the value that failed at that
      path.

    aramis 0.1.1
    A library providing a Promise.all()-like capabilities for re-frame.
    cljs.spec/explain-data (cljs)SourceDoc + Usages
    Given a spec and a value x which ought to conform, returns nil if x
      conforms, else a map with at least the key ::problems whose value is
      a path->problem-map, where problem-map has at least :pred and :val
      keys describing the predicate and the value that failed at that
      path.

    skm-ice-gui 1.0.0
    GUI library developed by the ICE project within the danish ministry of taxation
    cljs.spec/explain-data (cljs)SourceDoc + Usages
    Given a spec and a value x which ought to conform, returns nil if x
      conforms, else a map with at least the key ::problems whose value is
      a path->problem-map, where problem-map has at least :pred and :val
      keys describing the predicate and the value that failed at that
      path.

    editable 0.1.4
    lifecycle events for forms using re-frame
    cljs.spec/explain-data (cljs)SourceDoc + Usages
    Given a spec and a value x which ought to conform, returns nil if x
      conforms, else a map with at least the key ::problems whose value is
      a path->problem-map, where problem-map has at least :pred and :val
      keys describing the predicate and the value that failed at that
      path.

    trapperkeeper 1.5.6
    A framework for configuring, composing, and running Clojure services.
    puppetlabs.trapperkeeper.services-internal/transform-deps-mapSourceDoc + Usages
    Inputs: [deps :- DependencyMap]
      Returns: (schema/pred vector?)
    
      Given a map of required and optional dependencies, return a vector that
      adheres to Prismatic Graph's binding syntax. Specifically, optional
      dependencies are transformed into {ServiceName nil}.

    dbwalk 0.2.1
    Clojure library for getting your data from a db as nested maps.
    dbwalk.crawler/advance-query-treeSourceDoc + Usages
    Inputs: [config :- Configuration query-tree :- QueryTree graph :- (s/atom (s/protocol loom.graph/Digraph)) nodes-to-advance :- [(s/pred map?)]]
    
      Walks the query tree and builds the query result graph.

    clojureql 1.0.4c
    Superior SQL integration for Clojure
    clojureql.core/update!~RTable~RelationSourceDoc + Usages
    Updates a record where pred is true. Record
         is a map from strings or keywords (identifying columns)
         to updated values.
    
         Ex. (update! (table :one) (where (= :id 5))
                {:age 22})

    clojureql 1.0.4c
    Superior SQL integration for Clojure
    clojureql.core/update-in!~RTable~RelationSourceDoc + Usages
    Inserts or updates a record where pred is true. Record
         is a map from strings or keywords (identifying columns)
         to updated values.
    
         Ex. (update-in! (table :one) (where (= :id 5))
                {:age 22})

    clojureql 1.0.4c
    Superior SQL integration for Clojure
    clojureql.core/update-in!SourceDoc + Usages
    Inserts or updates a record where pred is true. Record
         is a map from strings or keywords (identifying columns)
         to updated values.
    
         Ex. (update-in! (table :one) (where (= :id 5))
                {:age 22})

    clojureql 1.0.4c
    Superior SQL integration for Clojure
    clojureql.core/update!SourceDoc + Usages
    Updates a record where pred is true. Record
         is a map from strings or keywords (identifying columns)
         to updated values.
    
         Ex. (update! (table :one) (where (= :id 5))
                {:age 22})

    trapperkeeper 1.5.6
    A framework for configuring, composing, and running Clojure services.
    puppetlabs.trapperkeeper.services-internal/parse-service-forms!SourceDoc + Usages
    Inputs: [lifecycle-fn-names :- [(schema/pred symbol?)] forms :- (schema/pred seq?)]
      Returns: InternalServiceMap
    
      Parse the forms provided to the `service` macro.  Return a map
      containing all of the data necessary to implement the macro:
    
      :service-protocol-sym - the service protocol symbol (or nil if there is no protocol)
      :service-id           - a unique identifier (keyword) for the service
      :service-fn-map       - a map of symbols for the names of the functions provided by the protocol
      :dependencies         - a vector (using fnk binding syntax) of deps or a map of :required and :optional deps.
      :fns-map              - a map of all of the fn definition forms in the service

    refactor-nrepl 2.3.1
    nREPL middleware to support editor-agnostic refactoring
    mranderson047.fs.v1v4v6.me.raynes.fs/find-files*SourceDoc + Usages
    Find files in path by pred.

    mranderson 0.4.8
    Leiningen plugin to download and use some dependencies as source.
    mranderson048.fs.v1v4v6.me.raynes.fs/find-files*SourceDoc + Usages
    Find files in path by pred.

    duckling 0.4.24
    Date & Number parser
    duckling.time.pred/take-the-last-ofSourceDoc + Usages
    Takes the *last* occurence of cyclic-pred *within* base-pred.
      For example, cyclic-pred is 'Monday' and base-pred 'October'

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

    clj-duckling 0.4.24
    A Clojure library that parses text into structured data
    duckling.time.pred/take-the-last-ofSourceDoc + Usages
    Takes the *last* occurence of cyclic-pred *within* base-pred.
      For example, cyclic-pred is 'Monday' and base-pred 'October'

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

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

    schema 1.1.9
    Clojure(Script) library for declarative data description and validation
    schema.experimental.abstract-map/abstract-map-schema (cljs)SourceDoc + Usages
    Inputs: [dispatch-key :- s/Keyword schema :- (s/pred map?)]
    
      A schema representing an 'abstract class' map that must match at least one concrete
       subtype (indicated by the value of dispatch-key, a keyword).  Add subtypes by calling
       `extend-schema`.

    schema 1.1.9
    Clojure(Script) library for declarative data description and validation
    schema.experimental.abstract-map/abstract-map-schemaSourceDoc + Usages
    Inputs: [dispatch-key :- s/Keyword schema :- (s/pred map?)]
    
      A schema representing an 'abstract class' map that must match at least one concrete
       subtype (indicated by the value of dispatch-key, a keyword).  Add subtypes by calling
       `extend-schema`.

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

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

    trapperkeeper 1.5.6
    A framework for configuring, composing, and running Clojure services.
    puppetlabs.trapperkeeper.services-internal/fn-defsSourceDoc + Usages
    Inputs: [fns-map :- FnsMap fn-names :- [Symbol]]
      Returns: [(schema/pred seq?)]
    
      Given a map of all of the function forms from a service definition, and a list
      of function names, return a sequence of all of the forms (including multi-arity forms)
      for the given function names.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    trapperkeeper 1.5.6
    A framework for configuring, composing, and running Clojure services.
    puppetlabs.trapperkeeper.services-internal/build-fns-map!SourceDoc + Usages
    Inputs: [service-protocol-sym :- (schema/maybe Symbol) service-fn-names :- (schema/maybe (schema/pred coll?)) lifecycle-fn-names :- [Symbol] fns :- [(schema/pred seq?)]]
      Returns: FnsMap
    
      Given the list of fn forms from the service body, build up a map of
      service fn forms.  The keys of the map will be keyword representations
      of the function names, and the values will be the fn forms.  The final
      map will include default implementations of any lifecycle functions that
      aren't overridden in the service body.  Throws `IllegalArgumentException`
      if the fn forms do not match the protocol.

    suchwow 6.0.2
    Such functions! Such doc strings! Much utility!
    such.shorthand/find-firstSourceDoc + Usages
    Returns the first item of `coll` where `(pred item)` returns a truthy value, `nil` otherwise.
       `coll` is evaluated lazily.
       
            (find-first even? [1 2 3]) => 2
       
       You can apply `find-first` to a map, even though which
       element matches "first" is undefined. Note that the item passed to `pred` will
       be a key-value pair:
    
            (find-first #(even? (second %)) {:a 2, :b 22, :c 222}) => [:c 222]
    

    Returns a vector of [(take-while pred coll) (drop-while pred coll)]

    clojure 1.10.0-alpha4
    Core language
    clojure.core/split-withSourceDoc + Usages
    Returns a vector of [(take-while pred coll) (drop-while pred coll)]

    garden 1.3.5
    Generate CSS from Clojure(Script) data structures.
    garden.compiler/divide-vecSourceDoc + Usages
    Return a vector of [(filter pred coll) (remove pred coll)].

    re-frame-10x 0.3.3
    Become 10x more productive when developing and debugging re-frame applications.
    mranderson048.garden.v1v3v3.garden.compiler/divide-vecSourceDoc + Usages
    Return a vector of [(filter pred coll) (remove pred coll)].

    jackknife 0.1.7
    Useful clojure utilities.
    jackknife.seq/separateSourceDoc + Usages
    Accepts a predicate and a sequence, and returns:
    
       [(filter pred xs) (remove pred xs)]

    trace 0.1.22
    Tracing and developer tools for re-frame apps
    mranderson047.garden.v1v3v3.garden.compiler/divide-vecSourceDoc + Usages
    Return a vector of [(filter pred coll) (remove pred coll)].

    if-let 0.3.0
    Implementation of `if-let`, `let-pred`, `when-let`, `if-some`, `when-some` macros
    if-let.core/let-predSourceDoc + Usages
    bindings => binding-form test
      If pred fails - the return the input to the pred.

    receipt 1.0.1
    FIXME: write description
    garden.compiler/divide-vecSourceDoc + Usages
    Return a vector of [(filter pred coll) (remove pred coll)].

    receipt 1.0.1
    FIXME: write description
    garden.compiler/divide-vec (cljs)SourceDoc + Usages
    Return a vector of [(filter pred coll) (remove pred coll)].

    mcmc 1.0.1
    Markov Chain Monte Carlo library and related tools.
    mcmc.stats/divide-bySourceDoc + Usages
    Returns [satisfies-pred not-satisfies-pred] from the given
      collection and predicate.

    cljs-css-modules 0.2.1
    cljs-css-modules: css modules in clojurescript
    garden.compiler/divide-vecSourceDoc + Usages
    Return a vector of [(filter pred coll) (remove pred coll)].

    cljs-css-modules 0.2.1
    cljs-css-modules: css modules in clojurescript
    garden.compiler/divide-vecSourceDoc + Usages
    Return a vector of [(filter pred coll) (remove pred coll)].

    clojure 1.10.0-alpha4
    Core language
    clojure.core/throw-ifSourceDoc + Usages
    Throws a CompilerException with a message if pred is true

    adjunct 0.1.4
    Extensions to Clojure
    adjunct.zip/filterSourceDoc + Usages
    A sequence of all locs that satisfy pred

    honeybadger 0.4.0
    Clojure library for reporting errors to honeybadger.io
    honeybadger.filter/exceptSourceDoc + Usages
    Inputs: [pred :- EventPredicate]
      Returns: EventFilter

    honeybadger 0.4.0
    Clojure library for reporting errors to honeybadger.io
    honeybadger.filter/onlySourceDoc + Usages
    Inputs: [pred :- EventPredicate]
      Returns: EventFilter

    brukbart 0.1.1
    Some useful stuff
    brukbart.core/ffilterSourceDoc + Usages
    Like (first (filter pred coll))

    closeout 0.1.0
    closeout - clojure templates inspired by knockoutjs
    closeout.state.update/filter-i (cljs)SourceDoc + Usages
    filter by pred? - reporting indices removed

    closeout 0.1.0
    closeout - clojure templates inspired by knockoutjs
    closeout.state.update/filter-iSourceDoc + Usages
    filter by pred? - reporting indices removed

    spectrum 0.1.4
    Static 'type' checking for clojure.spec
    spectrum.conform/or-disjSourceDoc + Usages
    Remove pred from the set of preds

    Returns a spec for a collection of items satisfying pred. Unlike
      generator will fill an empty init-coll.
    
      Same options as 'every'. conform will produce a collection
      corresponding to :into if supplied, else will match the input collection,
      avoiding rebuilding when possible.
    
      Same options as 'every'.
    
      See also - every, map-of

    spec.alpha 0.1.143
    Specification of data and functions
    clojure.spec.alpha/coll-ofSourceDoc + Usages
    Returns a spec for a collection of items satisfying pred. Unlike
      'every', coll-of will exhaustively conform every value.
    
      Same options as 'every'. conform will produce a collection
      corresponding to :into if supplied, else will match the input collection,
      avoiding rebuilding when possible.
    
      See also - every, map-of

    clojure-future-spec 1.9.0-alpha9-1
    Backport of clojure.spec for Clojure 1.8
    clojure.spec/coll-ofSourceDoc + Usages
    Returns a spec for a collection of items satisfying pred. Unlike
      'every', coll-of will exhaustively conform every value.
    
      Same options as 'every'. conform will produce a collection
      corresponding to :into if supplied, else will match the input collection,
      avoiding rebuilding when possible.
    
      See also - every, map-of

    trapperkeeper 1.5.6
    A framework for configuring, composing, and running Clojure services.
    puppetlabs.trapperkeeper.services-internal/build-output-schemaSourceDoc + Usages
    Inputs: [service-fn-names :- (schema/maybe [schema/Keyword])]
      Returns: {schema/Keyword (schema/pred (partial = IFn))}
    
      Given a list of service protocol function names (keywords), build up the
      prismatic output schema for the service (a map from keywords to `IFn`).

    trapperkeeper 1.5.6
    A framework for configuring, composing, and running Clojure services.
    puppetlabs.trapperkeeper.services-internal/find-prot-and-deps-forms!SourceDoc + Usages
    Inputs: [forms :- (schema/pred seq?)]
      Returns: ProtocolandDependenciesMap
    
      Given the forms passed to the service macro, find the service protocol
      (if one is provided), the dependency list, and the function definitions.
      Throws `IllegalArgumentException` if the forms do not represent a valid service.
      Returns a map containing the protocol, dependency list, and fn forms.

    strictly-specking-standalone 0.1.1
    A Clojure library to help validate edn configuration data, and hopefully more
    strictly-specking-standalone.spec/coll-ofSourceDoc + Usages
    Returns a spec for a collection of items satisfying pred. Unlike
      'every', coll-of will exhaustively conform every value.
    
      Same options as 'every'. conform will produce a collection
      corresponding to :into if supplied, else will match the input collection,
      avoiding rebuilding when possible.
    
      See also - every, map-of

    clj-lib 0.9.1
    Util libraries for common tasks
    clj-lib.core/maybe?SourceDoc + Usages
    Returns true if either `val` is nil or `(pred? val)` returns truthful.
    
      Useful for situations where `nil` is acceptable, but when non-nil `val` is
      expected to meet some criterion.
    
      Examples:
    
          (maybe? map? m)
          (maybe? string? s)
      

    earthworm 0.2.4
    Common components and utils for server side development
    earthworm.util.bean/rm-defaultsSourceDoc + Usages
    将 m 中是默认值(由 pred 函数确定)的项目去掉. 如果整个 map 都是
       默认值, 则返回 nil

    oolong 0.2.2
    A config-based loader for stuartsierra's `component` library
    oolong.util/expectsSourceDoc + Usages
    If a predicate fails, make and throw an exception
       Args: [pred got exp in extra?]
         exp: what you expected. Will be stringified into error message
         in: the container you found the unexpected thing in
         extra: optional map of extra args to merge (per `expected` docstring)

    dbwalk 0.2.1
    Clojure library for getting your data from a db as nested maps.
    dbwalk.crawler/distribute-childrenSourceDoc + Usages
    Inputs: [parents :- [en/EntityNode] children :- [(s/pred map?)] relations :- [(s/protocol relations/Relation)]]
      Returns: (s/maybe {en/EntityNode [en/EntityNode]})
    
      Relate the new items to their parents.
       Essentially the same as a JOIN between the parent and children tables, but with maps.

    boot-figreload 0.5.14
    Boot task to automatically reload page resources in the browser (featuring Figwheel).
    powerlaces.boot-figreload.messages/assign-cljs-optsSourceDoc + Usages
    Assign the correct cljs options to the file-map based on pred.
    
      The (fn [data compile-opts] ...) predicate decides what "correct"
      means, returning true or false according to the input data and the
      candidate compile-opts.
    
      The correct options will be assigned under the :cljs-opts key.

    Convenient syntax for constructing arbitraries.
    
    This is usually used implicitly via the property macro.
    
    The argument form can be one of the following:
    
    - boolean, integer, natural, rational, float, char, ascii-char,
      printable-ascii-char, string, ascii-string, printable-ascii-string,
      symbol, keyword
    - (one-of <equality> <expr> ...)
    - (tuple <arb> ...)
    - (list <arb>)
    - (vector <arb>)
    - (set <arb>)
    - (record <constructor> [<accessor> <arb> ...])
    - (mixed <pred> <arb> <pred> <arb> ...)
    - (map <arb1> <arb2>) ; map with keys from <arb1>, values from <arb2>
    - ~<expr>, which evaluates <expr> as a regular expression
    
    The syntax is extensible via the expand-arbitrary multimethod.

    test.check 0.10.0-alpha3
    A QuickCheck inspired property-based testing library
    clojure.test.check.generators/such-thatSourceDoc + Usages
    Create a generator that generates values from `gen` that satisfy predicate
      `pred`. Care is needed to ensure there is a high chance `gen` will satisfy
      `pred`. By default, `such-that` will try 10 times to generate a value that
      satisfies the predicate. If no value passes this predicate after this number
      of iterations, a runtime exception will be thrown. Note also that each
      time such-that retries, it will increase the size parameter.
    
      Examples:
    
          ;; generate non-empty vectors of integers
          ;; (note, gen/not-empty does exactly this)
          (gen/such-that not-empty (gen/vector gen/int))
    
      You can customize `such-that` by passing an optional third argument, which can
      either be an integer representing the maximum number of times test.check
      will try to generate a value matching the predicate, or a map:
    
          :max-tries  positive integer, the maximum number of tries (default 10)
          :ex-fn      a function of one arg that will be called if test.check cannot
                      generate a matching value; it will be passed a map with `:gen`,
                      `:pred`, and `:max-tries` and should return an exception

    pine 0.1.6
    A Clojure/ClojureScript router designed for universal applications.
    clojure.test.check.generators/such-thatSourceDoc + Usages
    Create a generator that generates values from `gen` that satisfy predicate
      `pred`. Care is needed to ensure there is a high chance `gen` will satisfy
      `pred`. By default, `such-that` will try 10 times to generate a value that
      satisfies the predicate. If no value passes this predicate after this number
      of iterations, a runtime exception will be thrown. Note also that each
      time such-that retries, it will increase the size parameter.
    
      Examples:
    
          ;; generate non-empty vectors of integers
          ;; (note, gen/not-empty does exactly this)
          (gen/such-that not-empty (gen/vector gen/int))
    
      You can customize `such-that` by passing an optional third argument, which can
      either be an integer representing the maximum number of times test.check
      will try to generate a value matching the predicate, or a map:
    
          :max-tries  positive integer, the maximum number of tries (default 10)
          :ex-fn      a function of one arg that will be called if test.check cannot
                      generate a matching value; it will be passed a map with `:gen`,
                      `:pred`, and `:max-tries` and should return an exception

    gadjett 0.5.2
    Inspector tools for clojure[script]
    gadjett.collections/split-by-predicate-positionsSourceDoc + Usages
      Optimized version of `split-by-predicate` where we assume that the data is from a signal that we can sample.
    
      Instead of checking each element, we check 1 over `n` elements.
    
     We return the positions where the data splits.
    
    ~~~klipse
      (let [data (map Math/sin (range 0 6.28 0.001))]
        (split-by-predicate-positions data #(<= -0.01 % 0.01) 2 10))
    ~~~
    
      The following assertion holds:
    
    ~~~clojure
      (= (split-by-predicate coll pred n)
         (map #(apply subsequence data %) (split-by-predicate-positions coll pred n 1)))
    ~~~
    
      Here is an example:
    
    ~~~klipse
      (let [data (map Math/sin (range 0 6.28 0.01))]
        (= (split-by-predicate data #(<= -0.01 % 0.01) 2)
           (map #(apply subsequence data %) (split-by-predicate-positions data #(<= -0.01 % 0.01) 2 1))))
    ~~~
      

    gadjett 0.5.2
    Inspector tools for clojure[script]
    gadjett.collections/split-by-predicate-positionsSourceDoc + Usages
      Optimized version of `split-by-predicate` where we assume that the data is from a signal that we can sample.
    
      Instead of checking each element, we check 1 over `n` elements.
    
     We return the positions where the data splits.
    
    ~~~klipse
      (let [data (map Math/sin (range 0 6.28 0.001))]
        (split-by-predicate-positions data #(<= -0.01 % 0.01) 2 10))
    ~~~
    
      The following assertion holds:
    
    ~~~clojure
      (= (split-by-predicate coll pred n)
         (map #(apply subsequence data %) (split-by-predicate-positions coll pred n 1)))
    ~~~
    
      Here is an example:
    
    ~~~klipse
      (let [data (map Math/sin (range 0 6.28 0.01))]
        (= (split-by-predicate data #(<= -0.01 % 0.01) 2)
           (map #(apply subsequence data %) (split-by-predicate-positions data #(<= -0.01 % 0.01) 2 1))))
    ~~~
      

    funnyqt 1.1.5
    A model querying and transformation library for TGraphs and EMF models developed
    funnyqt.in-place/create-state-spaceSourceDoc + Usages
    Takes the `model` as initial state and applies all `rules` to it generating
      a state space graph.
    
      An optional map of options may be given.  For a description of arguments and
      options except for :recur-pred, see `funnyqt.in-place/state-space-step-fn`.
    
      If the map of options contains a :recur-pred entry, its value must be a
      function of five arguments which determines if the state space generation
      should be resumed.  It's signature should be:
    
        (fn [ssg state2model-map
             invalid-states invalid-transitions failed-state-space-preds]
          ...)
    
      If the recur-pred returns logical true, the state space generation is
      resumed.  By default, i.e., when there is no :recur-pred entry in the map of
      options, `create-state-space` returns as soon as at least one predicate of
      `state-preds`, `transition-preds`, or `state-space-preds` fails.
    
      The return value has the form
    
        [state-space-graph state2model-map step-fn-retval]
    
      where state-space-graph is the final state space graph, state2model-map is
      the final map from SSG states to corresponding models, and step-fn-retval
      is the return value of the underlying `state-space-step-fn`.
    
      This vector also has :state-space-step-fn metadata which is the state space
      step function used internally by create-state-space.  This allows for driving
      the state space generation further after create-state-space has returned
      because of a failed predicate or a user-defined recur-pred.

    cantata 0.1.17
    SQL and database abstraction
    cantata.core/make-data-modelSourceDoc + Usages
    Transforms an entity specification into a DataModel record.
    
      `name` is an optional keyword name of the data model.
    
      `entity-specs` can be map, with entity names as keys and maps describing
      the entity as values; or a collection of maps describing the entities.
    
      Example (map format):
    
        {:film       {:fields [:id :title]
                      :shortcuts {:actor :film-actor.actor}}
         :actor      {:fields [:id :name]}
         :film-actor {:fields [:film-id :actor-id]
                      :pk [:film-id :actor-id]
                      :rels [:film :actor]}}
    
      The entity map will be transformed into an Entity record using the
      following keys:
    
             :name - entity name, a keyword (optional for map format)
               :pk - name(s) of primary key field(s); default: name of first field
           :fields - collection of field specs; see below for format
             :rels - optional collection of rel specs; see below for format
        :shortcuts - optional map of shortcuts; see below for format
         :validate - optional function to validate a entity values map; called
                     prior to inserting or updating; expected to return problem
                     map(s) on validation failure; see `problem`
            :hooks - optional map of hooks; see below for format
          :db-name - string name of corresponding table in SQL database;
                     default: entity name with dashes converted to underscores
        :db-schema - optional string name of table schema in SQL database
    
      Field specs can be keywords or maps. A keyword is equivalent to a map with
      only the :name key set. The following map keys are accepted:
    
             :name - field name, a keyword
             :type - optional data type; built-in types:
    
                       :int :str :boolean :double :decimal :bytes
                       :datetime :date :time
    
          :db-name - string name of corresponding column in SQL database;
                     default: field name with dashes converted to underscores
          :db-type - optional string type of corresponding column in SQL database
    
      Relationship (rel) specs can be keywords or maps. A keyword is equivalent to
      a map with only the :name key set. The following map keys are accepted:
    
             :name - rel name, a keyword
            :ename - name of related entity; default: rel name
              :key - name of foreign key field; default: rel name + "-id" suffix
        :other-key - name of referenced key on related entity; default: primary
                     key of related entity
          :reverse - boolean indicating that the foreign key column is on the other
                     table; default: false
              :one - boolean indicating whether the relationship is one-to-one;
                     default: false for reverse rels, true otherwise
    
      Reverse relationships will be automatically added to related entities
      referenced in rel specs, using the name of the former entity as the rel name.
      If there is more than one reverse relationship created with the same name,
      each will be prefixed with an underscore and the name of the relationship
      to ensure uniqueness, like so: :_rel-name.entity-name.
    
      Shortcuts take the form of a map of shortcut path to target path. Target
      paths can point to rels or fields.
    
      Hooks are experimental and may change in future versions. They take the form
      of a map from hook name to hook function. Available hooks and their
      corresponding arguments and expected return values:
    
        :before-query  [ent expanded-q env added-paths] -> [expanded-q env added-paths]
        :after-query   [ent results] -> results
        :validate      [ent map] -> problems
        :before-save   [ent map] -> map
        :after-save    [ent map ret] -> ret
        :before-insert [ent maps] -> maps
        :after-insert  [ent maps ret] -> ret
        :before-update [ent map pred] -> [map pred]
        :after-update  [ent map pred ret] -> ret
        :before-delete [ent pred] -> pred
        :after-delete  [ent pred ret] -> ret

    structural-typing 2.0.5
    Define types by giving descriptions (perhaps incomplete) of how they're built.
    structural-typing.preds/kvsSourceDoc + Usages
    A variant of [[exactly]] that ignores the difference between records and maps.
    
       In Clojure, compound values are usually equal if their contents are equal. For example:
    
           (= (vector 1 2) (list 1 2)) ;=> true
    
       That is not true when comparing records to maps. Therefore, the following will *always*
       be false if `structure` is a record.
    
           (built-like (pred/exactly {:a 1, :b 2}) structure)
    
       However, the following will be true, given `(defrecord R [a b])`:
    
           (built-like (pred/kvs {:a 1, :b 2}) (R. 1 2))
    
       Note: `kvs` is false when given anything other than a map or record.

    phrase 0.3-alpha3
    Clojure(Script) library for phrasing spec problems.
    phrase.alpha/phrase*SourceDoc + Usages
    Phrases the given problem for human consumption.
    
      Dispatches on normalized pred and optional via of problem.
    
      Dispatches in this order:
    
      * [normalized-pred via]
      * [normalized-pred]

    domiscuity 0.2.0
    HTML Parsing and Dom manipulation for clj/cljs
    irresponsible.domiscuity.dom/find-where-attrSourceDoc + Usages
    Finds deeply all elements where an attribute passes pred
       args: [elem pred]
         pred: function of attribute object -> truthy
       returns: vector of elements

    domiscuity 0.2.0
    HTML Parsing and Dom manipulation for clj/cljs
    irresponsible.domiscuity.dom/find-attrSourceDoc + Usages
    Finds attributes on the given element passing pred
       args: [elem pred]
         pred: function of attribute object -> truthy
       returns: vector of elem

    Returns an JavaScript compatible comparator based upon pred.

    returns a spec that accepts nil and values satisfiying pred

    Returns a set of the elements for which pred is true

    core.typed 0.5.2
    An optional type system for Clojure — full system for annotating and type-checking.
    clojure.core.typed.test.set/selectSourceDoc + Usages
    Returns a set of the elements for which pred is true

    clojure-contrib 1.2.0
    Clojure user contributions library.
    clojure.contrib.zip-filter/fixup-applySourceDoc + Usages
    Calls (pred loc), and then converts the result to the 'appropriate'
      sequence.

    clojure 1.10.0-alpha4
    Core language
    clojure.set/selectSourceDoc + Usages
    Returns a set of the elements for which pred is true

    clojure 1.10.0-alpha4
    Core language
    clojure.core/comparatorSourceDoc + Usages
    Returns an implementation of java.util.Comparator based upon pred.

    spec.alpha 0.1.143
    Specification of data and functions
    clojure.spec.alpha/nilableSourceDoc + Usages
    returns a spec that accepts nil and values satisfying pred

    plumbing 0.5.5
    Prismatic's Clojure utility belt.
    plumbing.core/count-when (cljs)SourceDoc + Usages
    Returns # of elements of xs where pred holds

    plumbing 0.5.5
    Prismatic's Clojure utility belt.
    plumbing.core/count-whenSourceDoc + Usages
    Returns # of elements of xs where pred holds

    Calls (pred loc), and then converts the result to the 'appropriate'
      sequence.

    Calls (pred loc), and then converts the result to the 'appropriate'
      sequence.

    Navigates to every continuous subsequence of elements matching `pred`

    hasch 0.3.5
    Cryptographic hashing of EDN datastructures.
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    leiningen 2.8.1
    Automate Clojure projects without setting your hair on fire.
    leiningen.do/pop-if-lastSourceDoc + Usages
    Pops the collection if (pred (peek coll)) is truthy.

    clojure-future-spec 1.9.0-alpha9-1
    Backport of clojure.spec for Clojure 1.8
    clojure.spec/nilableSourceDoc + Usages
    returns a spec that accepts nil and values satisfiying pred

    superv.async 0.2.9
    Supervised channel management for core.async.
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    dynadoc 1.4.7
    A dynamic documentation generator
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    zetta-parser 0.1.0
    Powerful monadic parser combinator in Clojure (Haskell attoparsec's port)
    zetta.parser.seq/skip-whileSourceDoc + Usages
    Parser that skips input for as long as `pred` returns `true`.

    hoplon-elem-lib 0.2.0
    Tiny element library for Hoplon.
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    ez-form 0.8.0
    Forms for the web
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    misaki 0.2.6.2-beta
    Jekyll inspired static site generator in Clojure
    misaki.util.sequence/find-firstSourceDoc + Usages
    Returns the first matched entry for pred, or nil if not matched.

    refactor-nrepl 2.3.1
    nREPL middleware to support editor-agnostic refactoring
    refactor-nrepl.core/find-in-projectSourceDoc + Usages
    Return the files in the project satisfying (pred ^File file).

    strictly-specking-standalone 0.1.1
    A Clojure library to help validate edn configuration data, and hopefully more
    strictly-specking-standalone.spec/nilableSourceDoc + Usages
    returns a spec that accepts nil and values satisfiying pred

    lambdacd 0.14.1
    A library to create a continous delivery pipeline in code.
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    lambdacd 0.14.1
    A library to create a continous delivery pipeline in code.
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    zprint 0.4.9
    Pretty print zippers and s-expressions
    zprint.zprint/interpose-eitherSourceDoc + Usages
    Do the same as interpose, but different seps depending on pred?.

    milia 0.3.37
    The ona.io Clojure Web API Client.
    chimera.seq/positionsSourceDoc + Usages
    Returns the position of at which pred is true for items in coll.

    milia 0.3.37
    The ona.io Clojure Web API Client.
    chimera.seq/fn-collectionSourceDoc + Usages
    Apply func to pred matching k value to v.

    milia 0.3.37
    The ona.io Clojure Web API Client.
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    chimera 0.0.6
    Collection of useful Clojure(Script) functions.
    chimera.seq/positionsSourceDoc + Usages
    Returns the position of at which pred is true for items in coll.

    chimera 0.0.6
    Collection of useful Clojure(Script) functions.
    chimera.seq/fn-collectionSourceDoc + Usages
    Apply func to pred matching k value to v.

    xml-in 0.1.0
    your friendly XML navigator
    xml-in.core/filter-allSourceDoc + Usages
    filters all keys 'k' with value matching 'pred'

    pretty-spec 0.1.3
    A pretty printer for clojure.spec forms.
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    Returns a set of the elements for which pred is true

    route-ccrs 3.6.0
    A library for calculating part/routing end dates and CCRs
    route-ccrs.part-zipper/take-untilSourceDoc + Usages
    Like `take-while` but includes the item that matches `pred`.

    re-view-routing 0.1.3
    ClojureScript routing tools
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    hatti 0.4.0
    A cljs dataview from your friends at Ona.io
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    hatti 0.4.0
    A cljs dataview from your friends at Ona.io
    chimera.seq/positionsSourceDoc + Usages
    Returns the position of at which pred is true for items in coll.

    hatti 0.4.0
    A cljs dataview from your friends at Ona.io
    chimera.seq/fn-collectionSourceDoc + Usages
    Apply func to pred matching k value to v.

    hatti 0.4.0
    A cljs dataview from your friends at Ona.io
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    modelo 0.1.0
    Relational database abstraction for Clojure
    modelo.util/expand-predicateSourceDoc + Usages
    Expands any wildcards present in pred to :or clauses of fields

    adjunct 0.1.4
    Extensions to Clojure
    adjunct.zip/find-parentSourceDoc + Usages
    Ancestor traversal for loc that satisfies (pred node), or nil

    clojure-objc 1.7.0-RC1
    Clojure core environment and runtime library.
    clojure.set/selectSourceDoc + Usages
    Returns a set of the elements for which pred is true

    chu.graph 0.2.2
    a graph library
    chu.graph/remove-linkSourceDoc + Usages
    Make a graph without links verifying pred.

    chu.graph 0.2.2
    a graph library
    chu.graph/remove-nodeSourceDoc + Usages
    Make a graph without nodes verifying pred.

    remove indexes for which (pred? i) is true

    filter (include) indexes for which (pred? i) is true

    dsann-clj-utils 0.1.0
    general utilities
    dsann.utils.seq/remove-by-index-predSourceDoc + Usages
    remove indexes for which (pred? i) is true

    dsann-clj-utils 0.1.0
    general utilities
    dsann.utils.seq/filter-by-index-predSourceDoc + Usages
    filter (include) indexes for which (pred? i) is true

    jutsu 0.1.2
    Data visualization tool built for the web
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    hitchhiker-tree 0.1.2
    A Hitchhiker Tree Library
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    skm-ice-utils 1.0.3
    Utility library developed by the ICE project within the danish ministry of taxation
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    iron 0.4.0
    Front-end utilities and support for ClojureScript and re-frame projects
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    receipt 1.0.1
    FIXME: write description
    clojure.set/selectSourceDoc + Usages
    Returns a set of the elements for which pred is true

    inky 0.1.7
    FIXME: write description
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    derive 0.2.1
    Clojurescript library to support efficient computation of up to date values derived
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    derive 0.2.1
    Clojurescript library to support efficient computation of up to date values derived
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    clj-odbp 0.2.2
    A Clojure driver for OrientDB binary protocol
    clj-odbp.binary.deserialize.buffer/buffer-take-while!SourceDoc + Usages
    Returns a vector of n elements while pred is true.

    clj-rpe 1.2.0
    Regular path expressions for Java object networks and Clojure structures.
    clj-rpe.core/rpe-restrSourceDoc + Usages
    Regular path restriction filtering `objs' by `pred'.

    buddy-pkcs15-sha1 0.2.0b3
    Forked security library buddy for Clojure with PKCS v1.5 for SHA1. Original library:
    clojure.set/selectSourceDoc + Usages
    Returns a set of the elements for which pred is true

    nativestore 0.2.2
    A client-side, in-memory, indexed data store.
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    reagent-slider 0.1.2
    Reagent wrapper around react-components/slider
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    Returns a set of the elements for which pred is true

    fsmviz 0.1.3
    Generate Graphviz diagrams from FSM data.
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    foam 0.1.6
    Om form on steroids
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    Returns # of elements of xs where pred holds

    yfinance 0.2.0
    Clojure code to access Yahoo! Finance
    clojure.set/selectSourceDoc + Usages
    Returns a set of the elements for which pred is true

    budb 0.0.1
    A CRDT Database for Clojure(script)
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    budb 0.0.1
    A CRDT Database for Clojure(script)
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    re-frame-ipfs-fx 0.0.2
    IPFS Re-Frame handlers.
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    spigot-repl 0.1.0
    Clojure REPL plugin for Spigot
    clojure.set/selectSourceDoc + Usages
    Returns a set of the elements for which pred is true

    clj-thamil 0.2.0
    A project encompassing various Thamil language-specific computing ideas
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    dali 0.7.4
    A Clojure library for 2D graphics.
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    pcp-broker 1.5.0
    PCP fabric messaging broker
    puppetlabs.pcp.broker.util/update-condSourceDoc + Usages
    Works like update, but only if pred is satisfied

    live-components 1.2.0
    Don't duplicate server state on the client and get realtime collaboration for free
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    validat 0.2.2
    Simple custom validation framework.
    validat.core/checkSourceDoc + Usages
    Create a check from a pred with a fixed error.

    aramis 0.1.1
    A library providing a Promise.all()-like capabilities for re-frame.
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    fsrun 0.1.2
    High Order Plugin to run some tasks on fs change
    leiningen.fschange/pop-if-lastSourceDoc + Usages
    Pops the collection if (pred (peek coll)) is truthy.

    riemann-jmx-clj 0.1.1
    A JMX connector to riemann
    clojure.set/selectSourceDoc + Usages
    Returns a set of the elements for which pred is true

    lemonade 0.3.0
    High level language for graphical and UI programming. No markup.
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    lemonade 0.3.0
    High level language for graphical and UI programming. No markup.
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    clojarr 1.9.0-4f80cfd4
    arrdem flavored Clojure
    clojure.set/selectSourceDoc + Usages
    Returns a set of the elements for which pred is true

    vee 0.2.4
    Native Mobile Tooling for Clojure
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    ventas 0.0.6
    The Ventas eCommerce platform
    com.rpl.specter/continuous-subseqsSourceDoc + Usages
    Navigates to every continuous subsequence of elements matching `pred`

    ventas 0.0.6
    The Ventas eCommerce platform
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    ventas 0.0.6
    The Ventas eCommerce platform
    com.rpl.specter/continuous-subseqsSourceDoc + Usages
    Navigates to every continuous subsequence of elements matching `pred`

    ventas 0.0.6
    The Ventas eCommerce platform
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    skm-ice-gui 1.0.0
    GUI library developed by the ICE project within the danish ministry of taxation
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    clojure-android 1.7.0-alpha5-r2
    Fork of Clojure for leaner code compilation.
    clojure.set/selectSourceDoc + Usages
    Returns a set of the elements for which pred is true

    timbre-datomic-handler 0.1.3
    A simple Datomic handler that logs via Timbre
    clojure.set/selectSourceDoc + Usages
    Returns a set of the elements for which pred is true

    curiosity.utils 0.9.3
    Misc clojure functions
    curiosity.utils/update-in-ifSourceDoc + Usages
    Updates obj[path] with f if pred(obj[path])

    anki-cljs 0.1.1
    CLJS interface for interacting with Anki
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    rejax 0.1.0
    A library that creates nicer API for usage of cljs-ajax in Re-frame
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    clodash 0.43.0
    FIXME: write description
    clodash.seq/any?SourceDoc + Usages
    Returns true if some element in coll matches the pred

    cleancr 1.0-beta3
    Finds and optionally removes carriage return characters from your project text files
    clojure.set/selectSourceDoc + Usages
    Returns a set of the elements for which pred is true

    cleancr 1.0-beta3
    Finds and optionally removes carriage return characters from your project text files
    clojure.contrib.zip-filter/fixup-applySourceDoc + Usages
    Calls (pred loc), and then converts the result to the 'appropriate'
      sequence.

    hellonico-alchemy 0.1.0
    clojure.set/selectSourceDoc + Usages
    Returns a set of the elements for which pred is true

    ui.navigate 0.2.0
    A small library to help automated tests navigate a hierarchical user interface
    ui.navigate/find-nodeSourceDoc + Usages
    Finds first node in z that matches pred.

    torus-pong 0.1.0
    A multiplayer take on the classic Game of Pong. Entry for Clojure Cup 2013.
    clojure.set/selectSourceDoc + Usages
    Returns a set of the elements for which pred is true

    torus-pong 0.1.0
    A multiplayer take on the classic Game of Pong. Entry for Clojure Cup 2013.
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    mixfix-clj 0.2.0
    mixfix operators syntax for clojure
    mixfix.clj.parser/guardSourceDoc + Usages
    filters out values where `pred` returns false

    clojure-ccw 1.7.0
    Clojure core environment and runtime library.
    clojure.set/selectSourceDoc + Usages
    Returns a set of the elements for which pred is true

    reepl 1.0.1
    A configurable in-browser clojurescript REPL
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    yz 0.0.1-alpha18
    YZ[ˈiːzi] is simple (easy), laconic, string-based, object query language.
    ru.petrsu.nest.yz.parsing/get-idsSourceDoc + Usages
    Returns new value of the :ids key of the pred structure.

    om-image-grid 0.3.1
    That justified image grid thingie
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    fif 1.0.2
    Stack-based Programming in Clojure(script)
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    paredit-cm 0.1.1
    paredit for codemirror
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    react-bootstrap-wrapper 0.1.1
    A wrapper of react-bootstrap for reagent
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    gershwin 0.2.0
    Gershwin: Stack-based, Concatenative Clojure
    clojure.set/selectSourceDoc + Usages
    Returns a set of the elements for which pred is true

    pldb-cache 0.1.0-webstorage
    Clientside caching for pldb
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    cloth 0.3.1
    Clojure(Script) tools for Ethereum
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    gyptis 0.2.2
    A library for generating and viewing vega.js plots
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    Returns a set of the elements for which pred is true

    Returns a set of the elements for which pred is true

    Returns a set of the elements for which pred is true

    qualityclj 0.2.3
    Assess Clojure libraries based on a number of different metrics.
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    cantata 0.1.17
    SQL and database abstraction
    cantata.query.util/expand-predicate-wildcardsSourceDoc + Usages
    Expands any wildcards present in pred to :or clauses of fields

    Returns a set of the elements for which pred is true

    ona-viewer 1.1.30
    Ona viewer that connects to the Ona API.
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    ona-viewer 1.1.30
    Ona viewer that connects to the Ona API.
    ona.utils.collections/positionsSourceDoc + Usages
    Returns the position of at which pred is true for items in coll.

    ona-viewer 1.1.30
    Ona viewer that connects to the Ona API.
    ona.utils.collections/fn-collectionSourceDoc + Usages
    Apply func to pred matching k value to v.

    ona-viewer 1.1.30
    Ona viewer that connects to the Ona API.
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    ona-viewer 1.1.30
    Ona viewer that connects to the Ona API.
    ona.utils.collections/positionsSourceDoc + Usages
    Returns the position of at which pred is true for items in coll.

    ona-viewer 1.1.30
    Ona viewer that connects to the Ona API.
    ona.utils.collections/fn-collectionSourceDoc + Usages
    Apply func to pred matching k value to v.

    core.storage 20170421.162221
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    bocko-android 0.1.3-1
    Render Bocko on Android surface
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    eat-static 0.1.0
    Eat Static, a library for type checking and validation of Clojure maps and functions.
    eat-static.validations/get-predSourceDoc + Usages
    Returns the pred-fn for a symbol previously defined with desc

    Returns a set of the elements for which pred is true

    Returns a set of the elements for which pred is true

    reagent-quill 0.1.1
    Reagent wrapper around react-quill
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    cljs-bach 0.3.0
    A Clojurescript wrapper for the Web Audio API.
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    engine 0.1.1
    A workflow engine that implements query -> logic -> updates.
    engine.core/condp->SourceDoc + Usages
    Cascading ifp-> with pred-x true-x pairs.

    district0x 0.1.20
    district0x Frontend Library
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    comportex 0.0.14
    Functionally composable cortex, an implementation of Hierarchical Temporal Memory
    org.nfrac.comportex.util/count-filterSourceDoc + Usages
    Same as `(count (filter pred coll))`, but faster.

    kits 1.38.5
    Staples SparX core libraries.
    kits.seq/any?SourceDoc + Usages
    Returns true if some element in coll matches the pred

    posh-async 0.5.5
    Luxuriously easy and powerful Reagant / Datascript front-end framework
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    Returns a set of the elements for which pred is true

    clojars-test 1.3.0
    clojars test
    clojure.set/selectSourceDoc + Usages
    Returns a set of the elements for which pred is true

    pine 0.1.6
    A Clojure/ClojureScript router designed for universal applications.
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    rerenderer 0.2.0
    Simple platform agnostic react-like library for drawing on canvas, handling events
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    clojr 0.3.0
    Run single file clojure apps
    clojure.set/selectSourceDoc + Usages
    Returns a set of the elements for which pred is true

    jaunt 1.9.0-RC4
    arrdem flavored Clojure
    clojure.set/selectSourceDoc + Usages
    Returns a set of the elements for which pred is true

    cljlangdetect 0.1.0
    Language detection for text. Wrapper of http://code.google.com/p/language-detection/
    clojure.set/selectSourceDoc + Usages
    Returns a set of the elements for which pred is true

    gadjett 0.5.2
    Inspector tools for clojure[script]
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    gadjett 0.5.2
    Inspector tools for clojure[script]
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    spectrum 0.1.4
    Static 'type' checking for clojure.spec
    spectrum.conform/or-someSourceDoc + Usages
    clojure.core/some, called on each pred in the orspec

    rui 0.3.0
    UI components based on Reagent and Re-frame
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    rui 0.3.0
    UI components based on Reagent and Re-frame
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    replify 0.4.1
    A minimalist Clojurescript repl and minimalist build tool
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    skm-ice-stateviewer 1.0.0
    Clojurescript library developed by the ICE project within the danish ministry of
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    phalanges 0.1.6
    ClojureScript library providing utilities for working with JavaScript KeyboardEvents.
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    pumpet 1.7.0-RC1-r4
    Fork of Clojure for leaner code compilation.
    clojure.set/selectSourceDoc + Usages
    Returns a set of the elements for which pred is true

    kern 1.1.0
    A Parser Combinators Library
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    inspectable 0.2.2
    Tools for clojure.spec
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    bootstrap-cljs 0.28.1-0
    ClojureScript wrapper around React Bootstrap
    plumbing.core/count-when (cljs)SourceDoc + Usages
    Returns # of elements of xs where pred holds

    bootstrap-cljs 0.28.1-0
    ClojureScript wrapper around React Bootstrap
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    editable 0.1.4
    lifecycle events for forms using re-frame
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    re-frame-utils 0.1.0
    Fxs and CoFxs for re-frame
    clojure.set/select (cljs)SourceDoc + Usages
    Returns a set of the elements for which pred is true

    active-quickcheck 0.3.0
    QuickCheck clone for Clojure
    active.quickcheck/arbitrarySourceDoc + Usages
    Convenient syntax for constructing arbitraries.
    
    This is usually used implicitly via the property macro.
    
    The argument form can be one of the following:
    
    - boolean, integer, byte, short, int, long, 
      unsigned byte, unsigned-short, unsigned-int, unsigned-long
      natural, rational, float, char, ascii-char,
      printable-ascii-char, string, ascii-string, printable-ascii-string,
      byte-array, symbol, keyword
    - (one-of <equality> <expr> ...)
    - (tuple <arb> ...)
    - (list <arb>)
    - (vector <arb>)
    - (set <arb>)
    - (record <constructor> [<accessor> <arb> ...])
    - (mixed <pred> <arb> <pred> <arb> ...)
    - (map <arb1> <arb2>) ; map with keys from <arb1>, values from <arb2>
    - ~<expr>, which evaluates <expr> as a regular expression
    
    The syntax is extensible via the expand-arbitrary multimethod.

    Returns a vector of the items in coll for which
      (pred item) returns true. pred must be free of side-effects.

    clojure-contrib 1.2.0
    Clojure user contributions library.
    clojure.contrib.probabilities.finite-distributions/probSourceDoc + Usages
    Return the probability that the predicate pred is satisfied in the
       distribution dist, i.e. the sum of the probabilities of the values
       that satisfy pred.

    clojure 1.10.0-alpha4
    Core language
    clojure.core/filtervSourceDoc + Usages
    Returns a vector of the items in coll for which
      (pred item) returns logical true. pred must be free of side-effects.

    structural-typing 2.0.5
    Define types by giving descriptions (perhaps incomplete) of how they're built.
    structural-typing.assist.lifting/mark-as-liftedSourceDoc + Usages
    A pred so marked is not lifted again. You can call [[lift-pred]] safely many times.

    structural-typing 2.0.5
    Define types by giving descriptions (perhaps incomplete) of how they're built.
    structural-typing.guts.preds.wrap/mark-as-liftedSourceDoc + Usages
    A pred so marked is not lifted again. You can call [[lift-pred]] safely many times.

    tcp-driver 0.1.0
    Java/Clojure TCP Connections done right
    tcp-driver.routing.retry/with-retrySourceDoc + Usages
    Inputs: [retry-policy :- (s/pred (fn* [p1__50057#] (satisfies? IRetry p1__50057#))) f :- (s/pred fn?)]

    clj-jclouds 0.1.1
    A clojure wrapper for jclouds
    com.palletops.jclouds.compute2/reboot-nodes-matchingSourceDoc + Usages
    Reboot all the nodes in the fn pred.
      pred should be a fn of one argument that takes a ComputeMetadata and returns true or false.

    clj-jclouds 0.1.1
    A clojure wrapper for jclouds
    com.palletops.jclouds.compute2/resume-nodes-matchingSourceDoc + Usages
    Suspend all the nodes in the fn pred.
      pred should be a fn of one argument that takes a ComputeMetadata and returns true or false.

    Suspend all nodes matching the fn pred.
      pred should be a fn of one argument that takes a ComputeMetadata and returns true or false.

    webdriver-logic 0.0.2
    Library of goals (relational functions) that can be used with core.logic to expose
    webdriver-logic.test/s?SourceDoc + Usages
    Assert that a run returns values that, when passed as a seq of values to `pred`, makes `pred` return a truthy value.

    unscrew 0.2.1
    A toolkit for processing jar files
    irresponsible.unscrew/paths-matchingSourceDoc + Usages
    Returns a sorted-set of filepaths in the jar for which (pred %) returns truthy
       args: [jar pred]
       returns: set of string

    dragonmark-util 0.1.0
    A bunch of useful functions
    dragonmark.util.core/split-bySourceDoc + Usages
    Splits the incoming collection by the predicate. 
    Returns [(filter pred coll) (remove pred coll)]

    dragonmark-util 0.1.0
    A bunch of useful functions
    dragonmark.util.core/split-by (cljs)SourceDoc + Usages
    Splits the incoming collection by the predicate. 
    Returns [(filter pred coll) (remove pred coll)]

    cleancr 1.0-beta3
    Finds and optionally removes carriage return characters from your project text files
    clojure.contrib.probabilities.finite-distributions/probSourceDoc + Usages
    Return the probability that the predicate pred is satisfied in the
       distribution dist, i.e. the sum of the probabilities of the values
       that satisfy pred.

    circle-util 0.1.1
    FIXME: write description
    circle-util.seq/move-to-firstSourceDoc + Usages
    returns a seq with the first item in coll for which pred is true at the front
    
      returns coll unchanged if no items match pred

    circle-util 0.1.1
    FIXME: write description
    circle-util.seq/separateSourceDoc + Usages
    Returns a vector of two seqs, the seq of elements where (pred x) is true, and the seq where (pred x) is false

    basil 0.4.1
    A general purpose template library for Clojure
    basil.util-macro/verifySourceDoc + Usages
    Assert that (pred x) returns logical true, then returns x. `pred` may be a
      fn, or something that can be invoked with one argument.

    duckling 0.4.24
    Date & Number parser
    duckling.time.prod/duration-afterSourceDoc + Usages
    Shifts the pred to pred+duration and changes the grain, typically to
      the one just below the duration grain. See pred.clj for conversion.

    djui 1.10
    Library of helper functions as extension to clojure and clojure.contrib.
    clojure.contrib.djui.coll/any?SourceDoc + Usages
    Returns a boolean representing if any value in coll is true. If pred is
      given, return if any value in coll satisfies pred.

    clj-duckling 0.4.24
    A Clojure library that parses text into structured data
    duckling.time.prod/duration-afterSourceDoc + Usages
    Shifts the pred to pred+duration and changes the grain, typically to
      the one just below the duration grain. See pred.clj for conversion.

    clj-foundation 0.10.0
    Guiding opinions: Enhance the core language in resonable, useful, and conservative
    clj-foundation.errors/seq<-SourceDoc + Usages
    Inputs: [failure :- (s/pred failure? "(failure? failure) is truthy")]
      Returns: [Throwable]
    
      Converts failures into seqs of exceptions.  If the failure is already an exception (the common case),
      it returns a seq starting with the root exception, and recursively including (.getCause e)
      until there are no more causes.
    
      If the failure is a seq, ensures that the result is a seq of excetions.
    
      If the failure isn't already an exception or a seq, it is converted into one first using ex-info.  In this case,
      the :cause in the ex-info map will be the original failure object.

    jdt 0.1.2
    These are not the tools you're looking for.
    jdt.core/assoc-ifSourceDoc + Usages
    Like assoc only the k/v pair is added only if the supplied predicate returns
      logical true for the k/v pair to be added. Otherwise the unaltered map is returned.
    
      If pred is nil, uses #(logically-true? val) as a predicate which will filter
      false as well as nil valued pairs.
      You might specify (fn [k v] (not (nil? v))) if you want to filter only nil valued k/v pairs.

    structural-typing 2.0.5
    Define types by giving descriptions (perhaps incomplete) of how they're built.
    structural-typing.guts.type-descriptions/requires-mentioned-pathsSourceDoc + Usages
    Canonicalizes the type descriptions into a single path->pred map and adds 
       [[required-path]] to each path's predicates.
       
            (type! :X (requires-mentioned-paths (includes :Point)
                                                {:color rgb-string?}))
      
       Note: It can't require paths you don't mention. The easiest way to mention a
       path is to name it in a `requires` - which may be either an argument to this function
       or outside it:
       
            (type! :X (requires-mentioned-paths (requires :name)
                                                (includes :Point)))
            (type! :X (requires :name)
                      (requires-mentioned-paths (includes :Point)))
    

    etaoin 0.2.8
    Pure Clojure Webdriver protocol implementation.
    etaoin.api/wait-predicateSourceDoc + Usages
    Sleeps continuously calling a predicate until it returns true.
      Rises a slingshot exception when timeout is reached.
    
      Arguments:
    
      - `pred`: a zero-argument predicate to call;
      - `opt`: a map of optional parameters:
      -- `:timeout` wait limit in seconds, 20 by default;
      -- `:interval` how long to wait b/w calls, 0.33 by default;
      -- `:message` a message that becomes a part of exception when timeout is reached.

    clojure 1.10.0-alpha4
    Core language
    clojure.parallel/parSourceDoc + Usages
    Creates a parallel array from coll. ops, if supplied, perform
      on-the-fly filtering or transformations during parallel realization
      or calculation. ops form a chain, and bounds must precede filters,
      must precede maps. ops must be a set of keyword value pairs of the
      following forms:
    
         :bound [start end] 
    
      Only elements from start (inclusive) to end (exclusive) will be
      processed when the array is realized.
    
         :filter pred 
    
      Filter preds remove elements from processing when the array is realized. pred
      must be a function of one argument whose return will be processed
      via boolean.
    
         :filter-index pred2 
    
      pred2 must be a function of two arguments, which will be an element
      of the collection and the corresponding index, whose return will be
      processed via boolean.
    
         :filter-with [pred2 coll2] 
    
      pred2 must be a function of two arguments, which will be
      corresponding elements of the 2 collections.
    
         :map f 
    
      Map fns will be used to transform elements when the array is
      realized. f must be a function of one argument.
    
         :map-index f2 
    
      f2 must be a function of two arguments, which will be an element of
      the collection and the corresponding index.
    
         :map-with [f2 coll2]
    
      f2 must be a function of two arguments, which will be corresponding
      elements of the 2 collections.

    clojure-objc 1.7.0-RC1
    Clojure core environment and runtime library.
    clojure.parallel/parSourceDoc + Usages
    Creates a parallel array from coll. ops, if supplied, perform
      on-the-fly filtering or transformations during parallel realization
      or calculation. ops form a chain, and bounds must precede filters,
      must precede maps. ops must be a set of keyword value pairs of the
      following forms:
    
         :bound [start end] 
    
      Only elements from start (inclusive) to end (exclusive) will be
      processed when the array is realized.
    
         :filter pred 
    
      Filter preds remove elements from processing when the array is realized. pred
      must be a function of one argument whose return will be processed
      via boolean.
    
         :filter-index pred2 
    
      pred2 must be a function of two arguments, which will be an element
      of the collection and the corresponding index, whose return will be
      processed via boolean.
    
         :filter-with [pred2 coll2] 
    
      pred2 must be a function of two arguments, which will be
      corresponding elements of the 2 collections.
    
         :map f 
    
      Map fns will be used to transform elements when the array is
      realized. f must be a function of one argument.
    
         :map-index f2 
    
      f2 must be a function of two arguments, which will be an element of
      the collection and the corresponding index.
    
         :map-with [f2 coll2]
    
      f2 must be a function of two arguments, which will be corresponding
      elements of the 2 collections.

    receipt 1.0.1
    FIXME: write description
    clojure.parallel/parSourceDoc + Usages
    Creates a parallel array from coll. ops, if supplied, perform
      on-the-fly filtering or transformations during parallel realization
      or calculation. ops form a chain, and bounds must precede filters,
      must precede maps. ops must be a set of keyword value pairs of the
      following forms:
    
         :bound [start end] 
    
      Only elements from start (inclusive) to end (exclusive) will be
      processed when the array is realized.
    
         :filter pred 
    
      Filter preds remove elements from processing when the array is realized. pred
      must be a function of one argument whose return will be processed
      via boolean.
    
         :filter-index pred2 
    
      pred2 must be a function of two arguments, which will be an element
      of the collection and the corresponding index, whose return will be
      processed via boolean.
    
         :filter-with [pred2 coll2] 
    
      pred2 must be a function of two arguments, which will be
      corresponding elements of the 2 collections.
    
         :map f 
    
      Map fns will be used to transform elements when the array is
      realized. f must be a function of one argument.
    
         :map-index f2 
    
      f2 must be a function of two arguments, which will be an element of
      the collection and the corresponding index.
    
         :map-with [f2 coll2]
    
      f2 must be a function of two arguments, which will be corresponding
      elements of the 2 collections.

    buddy-pkcs15-sha1 0.2.0b3
    Forked security library buddy for Clojure with PKCS v1.5 for SHA1. Original library:
    clojure.parallel/parSourceDoc + Usages
    Creates a parallel array from coll. ops, if supplied, perform
      on-the-fly filtering or transformations during parallel realization
      or calculation. ops form a chain, and bounds must precede filters,
      must precede maps. ops must be a set of keyword value pairs of the
      following forms:
    
         :bound [start end] 
    
      Only elements from start (inclusive) to end (exclusive) will be
      processed when the array is realized.
    
         :filter pred 
    
      Filter preds remove elements from processing when the array is realized. pred
      must be a function of one argument whose return will be processed
      via boolean.
    
         :filter-index pred2 
    
      pred2 must be a function of two arguments, which will be an element
      of the collection and the corresponding index, whose return will be
      processed via boolean.
    
         :filter-with [pred2 coll2] 
    
      pred2 must be a function of two arguments, which will be
      corresponding elements of the 2 collections.
    
         :map f 
    
      Map fns will be used to transform elements when the array is
      realized. f must be a function of one argument.
    
         :map-index f2 
    
      f2 must be a function of two arguments, which will be an element of
      the collection and the corresponding index.
    
         :map-with [f2 coll2]
    
      f2 must be a function of two arguments, which will be corresponding
      elements of the 2 collections.

    yfinance 0.2.0
    Clojure code to access Yahoo! Finance
    clojure.parallel/parSourceDoc + Usages
    Creates a parallel array from coll. ops, if supplied, perform
      on-the-fly filtering or transformations during parallel realization
      or calculation. ops form a chain, and bounds must precede filters,
      must precede maps. ops must be a set of keyword value pairs of the
      following forms:
    
         :bound [start end] 
    
      Only elements from start (inclusive) to end (exclusive) will be
      processed when the array is realized.
    
         :filter pred 
    
      Filter preds remove elements from processing when the array is realized. pred
      must be a function of one argument whose return will be processed
      via boolean.
    
         :filter-index pred2 
    
      pred2 must be a function of two arguments, which will be an element
      of the collection and the corresponding index, whose return will be
      processed via boolean.
    
         :filter-with [pred2 coll2] 
    
      pred2 must be a function of two arguments, which will be
      corresponding elements of the 2 collections.
    
         :map f 
    
      Map fns will be used to transform elements when the array is
      realized. f must be a function of one argument.
    
         :map-index f2 
    
      f2 must be a function of two arguments, which will be an element of
      the collection and the corresponding index.
    
         :map-with [f2 coll2]
    
      f2 must be a function of two arguments, which will be corresponding
      elements of the 2 collections.

    spigot-repl 0.1.0
    Clojure REPL plugin for Spigot
    clojure.parallel/parSourceDoc + Usages
    Creates a parallel array from coll. ops, if supplied, perform
      on-the-fly filtering or transformations during parallel realization
      or calculation. ops form a chain, and bounds must precede filters,
      must precede maps. ops must be a set of keyword value pairs of the
      following forms:
    
         :bound [start end] 
    
      Only elements from start (inclusive) to end (exclusive) will be
      processed when the array is realized.
    
         :filter pred 
    
      Filter preds remove elements from processing when the array is realized. pred
      must be a function of one argument whose return will be processed
      via boolean.
    
         :filter-index pred2 
    
      pred2 must be a function of two arguments, which will be an element
      of the collection and the corresponding index, whose return will be
      processed via boolean.
    
         :filter-with [pred2 coll2] 
    
      pred2 must be a function of two arguments, which will be
      corresponding elements of the 2 collections.
    
         :map f 
    
      Map fns will be used to transform elements when the array is
      realized. f must be a function of one argument.
    
         :map-index f2 
    
      f2 must be a function of two arguments, which will be an element of
      the collection and the corresponding index.
    
         :map-with [f2 coll2]
    
      f2 must be a function of two arguments, which will be corresponding
      elements of the 2 collections.

    riemann-jmx-clj 0.1.1
    A JMX connector to riemann
    clojure.parallel/parSourceDoc + Usages
    Creates a parallel array from coll. ops, if supplied, perform
      on-the-fly filtering or transformations during parallel realization
      or calculation. ops form a chain, and bounds must precede filters,
      must precede maps. ops must be a set of keyword value pairs of the
      following forms:
    
         :bound [start end] 
    
      Only elements from start (inclusive) to end (exclusive) will be
      processed when the array is realized.
    
         :filter pred 
    
      Filter preds remove elements from processing when the array is realized. pred
      must be a function of one argument whose return will be processed
      via boolean.
    
         :filter-index pred2 
    
      pred2 must be a function of two arguments, which will be an element
      of the collection and the corresponding index, whose return will be
      processed via boolean.
    
         :filter-with [pred2 coll2] 
    
      pred2 must be a function of two arguments, which will be
      corresponding elements of the 2 collections.
    
         :map f 
    
      Map fns will be used to transform elements when the array is
      realized. f must be a function of one argument.
    
         :map-index f2 
    
      f2 must be a function of two arguments, which will be an element of
      the collection and the corresponding index.
    
         :map-with [f2 coll2]
    
      f2 must be a function of two arguments, which will be corresponding
      elements of the 2 collections.

    clojarr 1.9.0-4f80cfd4
    arrdem flavored Clojure
    clojure.parallel/parSourceDoc + Usages
    Creates a parallel array from coll. ops, if supplied, perform
      on-the-fly filtering or transformations during parallel realization
      or calculation. ops form a chain, and bounds must precede filters,
      must precede maps. ops must be a set of keyword value pairs of the
      following forms:
    
         :bound [start end] 
    
      Only elements from start (inclusive) to end (exclusive) will be
      processed when the array is realized.
    
         :filter pred 
    
      Filter preds remove elements from processing when the array is realized. pred
      must be a function of one argument whose return will be processed
      via boolean.
    
         :filter-index pred2 
    
      pred2 must be a function of two arguments, which will be an element
      of the collection and the corresponding index, whose return will be
      processed via boolean.
    
         :filter-with [pred2 coll2] 
    
      pred2 must be a function of two arguments, which will be
      corresponding elements of the 2 collections.
    
         :map f 
    
      Map fns will be used to transform elements when the array is
      realized. f must be a function of one argument.
    
         :map-index f2 
    
      f2 must be a function of two arguments, which will be an element of
      the collection and the corresponding index.
    
         :map-with [f2 coll2]
    
      f2 must be a function of two arguments, which will be corresponding
      elements of the 2 collections.

    clojure-android 1.7.0-alpha5-r2
    Fork of Clojure for leaner code compilation.
    clojure.parallel/parSourceDoc + Usages
    Creates a parallel array from coll. ops, if supplied, perform
      on-the-fly filtering or transformations during parallel realization
      or calculation. ops form a chain, and bounds must precede filters,
      must precede maps. ops must be a set of keyword value pairs of the
      following forms:
    
         :bound [start end] 
    
      Only elements from start (inclusive) to end (exclusive) will be
      processed when the array is realized.
    
         :filter pred 
    
      Filter preds remove elements from processing when the array is realized. pred
      must be a function of one argument whose return will be processed
      via boolean.
    
         :filter-index pred2 
    
      pred2 must be a function of two arguments, which will be an element
      of the collection and the corresponding index, whose return will be
      processed via boolean.
    
         :filter-with [pred2 coll2] 
    
      pred2 must be a function of two arguments, which will be
      corresponding elements of the 2 collections.
    
         :map f 
    
      Map fns will be used to transform elements when the array is
      realized. f must be a function of one argument.
    
         :map-index f2 
    
      f2 must be a function of two arguments, which will be an element of
      the collection and the corresponding index.
    
         :map-with [f2 coll2]
    
      f2 must be a function of two arguments, which will be corresponding
      elements of the 2 collections.

    timbre-datomic-handler 0.1.3
    A simple Datomic handler that logs via Timbre
    clojure.parallel/parSourceDoc + Usages
    Creates a parallel array from coll. ops, if supplied, perform
      on-the-fly filtering or transformations during parallel realization
      or calculation. ops form a chain, and bounds must precede filters,
      must precede maps. ops must be a set of keyword value pairs of the
      following forms:
    
         :bound [start end] 
    
      Only elements from start (inclusive) to end (exclusive) will be
      processed when the array is realized.
    
         :filter pred 
    
      Filter preds remove elements from processing when the array is realized. pred
      must be a function of one argument whose return will be processed
      via boolean.
    
         :filter-index pred2 
    
      pred2 must be a function of two arguments, which will be an element
      of the collection and the corresponding index, whose return will be
      processed via boolean.
    
         :filter-with [pred2 coll2] 
    
      pred2 must be a function of two arguments, which will be
      corresponding elements of the 2 collections.
    
         :map f 
    
      Map fns will be used to transform elements when the array is
      realized. f must be a function of one argument.
    
         :map-index f2 
    
      f2 must be a function of two arguments, which will be an element of
      the collection and the corresponding index.
    
         :map-with [f2 coll2]
    
      f2 must be a function of two arguments, which will be corresponding
      elements of the 2 collections.

    cleancr 1.0-beta3
    Finds and optionally removes carriage return characters from your project text files
    clojure.parallel/parSourceDoc + Usages
    Creates a parallel array from coll. ops, if supplied, perform
      on-the-fly filtering or transformations during parallel realization
      or calculation. ops form a chain, and bounds must precede filters,
      must precede maps. ops must be a set of keyword value pairs of the
      following forms:
    
         :bound [start end] 
    
      Only elements from start (inclusive) to end (exclusive) will be
      processed when the array is realized.
    
         :filter pred 
    
      Filter preds remove elements from processing when the array is realized. pred
      must be a function of one argument whose return will be processed
      via boolean.
    
         :filter-index pred2 
    
      pred2 must be a function of two arguments, which will be an element
      of the collection and the corresponding index, whose return will be
      processed via boolean.
    
         :filter-with [pred2 coll2] 
    
      pred2 must be a function of two arguments, which will be
      corresponding elements of the 2 collections.
    
         :map f 
    
      Map fns will be used to transform elements when the array is
      realized. f must be a function of one argument.
    
         :map-index f2 
    
      f2 must be a function of two arguments, which will be an element of
      the collection and the corresponding index.
    
         :map-with [f2 coll2]
    
      f2 must be a function of two arguments, which will be corresponding
      elements of the 2 collections.

    Creates a parallel array from coll. ops, if supplied, perform
      on-the-fly filtering or transformations during parallel realization
      or calculation. ops form a chain, and bounds must precede filters,
      must precede maps. ops must be a set of keyword value pairs of the
      following forms:
    
         :bound [start end] 
    
      Only elements from start (inclusive) to end (exclusive) will be
      processed when the array is realized.
    
         :filter pred 
    
      Filter preds remove elements from processing when the array is realized. pred
      must be a function of one argument whose return will be processed
      via boolean.
    
         :filter-index pred2 
    
      pred2 must be a function of two arguments, which will be an element
      of the collection and the corresponding index, whose return will be
      processed via boolean.
    
         :filter-with [pred2 coll2] 
    
      pred2 must be a function of two arguments, which will be
      corresponding elements of the 2 collections.
    
         :map f 
    
      Map fns will be used to transform elements when the array is
      realized. f must be a function of one argument.
    
         :map-index f2 
    
      f2 must be a function of two arguments, which will be an element of
      the collection and the corresponding index.
    
         :map-with [f2 coll2]
    
      f2 must be a function of two arguments, which will be corresponding
      elements of the 2 collections.

    torus-pong 0.1.0
    A multiplayer take on the classic Game of Pong. Entry for Clojure Cup 2013.
    clojure.parallel/parSourceDoc + Usages
    Creates a parallel array from coll. ops, if supplied, perform
      on-the-fly filtering or transformations during parallel realization
      or calculation. ops form a chain, and bounds must precede filters,
      must precede maps. ops must be a set of keyword value pairs of the
      following forms:
    
         :bound [start end] 
    
      Only elements from start (inclusive) to end (exclusive) will be
      processed when the array is realized.
    
         :filter pred 
    
      Filter preds remove elements from processing when the array is realized. pred
      must be a function of one argument whose return will be processed
      via boolean.
    
         :filter-index pred2 
    
      pred2 must be a function of two arguments, which will be an element
      of the collection and the corresponding index, whose return will be
      processed via boolean.
    
         :filter-with [pred2 coll2] 
    
      pred2 must be a function of two arguments, which will be
      corresponding elements of the 2 collections.
    
         :map f 
    
      Map fns will be used to transform elements when the array is
      realized. f must be a function of one argument.
    
         :map-index f2 
    
      f2 must be a function of two arguments, which will be an element of
      the collection and the corresponding index.
    
         :map-with [f2 coll2]
    
      f2 must be a function of two arguments, which will be corresponding
      elements of the 2 collections.

    clojure-ccw 1.7.0
    Clojure core environment and runtime library.
    clojure.parallel/parSourceDoc + Usages
    Creates a parallel array from coll. ops, if supplied, perform
      on-the-fly filtering or transformations during parallel realization
      or calculation. ops form a chain, and bounds must precede filters,
      must precede maps. ops must be a set of keyword value pairs of the
      following forms:
    
         :bound [start end] 
    
      Only elements from start (inclusive) to end (exclusive) will be
      processed when the array is realized.
    
         :filter pred 
    
      Filter preds remove elements from processing when the array is realized. pred
      must be a function of one argument whose return will be processed
      via boolean.
    
         :filter-index pred2 
    
      pred2 must be a function of two arguments, which will be an element
      of the collection and the corresponding index, whose return will be
      processed via boolean.
    
         :filter-with [pred2 coll2] 
    
      pred2 must be a function of two arguments, which will be
      corresponding elements of the 2 collections.
    
         :map f 
    
      Map fns will be used to transform elements when the array is
      realized. f must be a function of one argument.
    
         :map-index f2 
    
      f2 must be a function of two arguments, which will be an element of
      the collection and the corresponding index.
    
         :map-with [f2 coll2]
    
      f2 must be a function of two arguments, which will be corresponding
      elements of the 2 collections.

    gershwin 0.2.0
    Gershwin: Stack-based, Concatenative Clojure
    clojure.parallel/parSourceDoc + Usages
    Creates a parallel array from coll. ops, if supplied, perform
      on-the-fly filtering or transformations during parallel realization
      or calculation. ops form a chain, and bounds must precede filters,
      must precede maps. ops must be a set of keyword value pairs of the
      following forms:
    
         :bound [start end] 
    
      Only elements from start (inclusive) to end (exclusive) will be
      processed when the array is realized.
    
         :filter pred 
    
      Filter preds remove elements from processing when the array is realized. pred
      must be a function of one argument whose return will be processed
      via boolean.
    
         :filter-index pred2 
    
      pred2 must be a function of two arguments, which will be an element
      of the collection and the corresponding index, whose return will be
      processed via boolean.
    
         :filter-with [pred2 coll2] 
    
      pred2 must be a function of two arguments, which will be
      corresponding elements of the 2 collections.
    
         :map f 
    
      Map fns will be used to transform elements when the array is
      realized. f must be a function of one argument.
    
         :map-index f2 
    
      f2 must be a function of two arguments, which will be an element of
      the collection and the corresponding index.
    
         :map-with [f2 coll2]
    
      f2 must be a function of two arguments, which will be corresponding
      elements of the 2 collections.

    Creates a parallel array from coll. ops, if supplied, perform
      on-the-fly filtering or transformations during parallel realization
      or calculation. ops form a chain, and bounds must precede filters,
      must precede maps. ops must be a set of keyword value pairs of the
      following forms:
    
         :bound [start end] 
    
      Only elements from start (inclusive) to end (exclusive) will be
      processed when the array is realized.
    
         :filter pred 
    
      Filter preds remove elements from processing when the array is realized. pred
      must be a function of one argument whose return will be processed
      via boolean.
    
         :filter-index pred2 
    
      pred2 must be a function of two arguments, which will be an element
      of the collection and the corresponding index, whose return will be
      processed via boolean.
    
         :filter-with [pred2 coll2] 
    
      pred2 must be a function of two arguments, which will be
      corresponding elements of the 2 collections.
    
         :map f 
    
      Map fns will be used to transform elements when the array is
      realized. f must be a function of one argument.
    
         :map-index f2 
    
      f2 must be a function of two arguments, which will be an element of
      the collection and the corresponding index.
    
         :map-with [f2 coll2]
    
      f2 must be a function of two arguments, which will be corresponding
      elements of the 2 collections.

    Creates a parallel array from coll. ops, if supplied, perform
      on-the-fly filtering or transformations during parallel realization
      or calculation. ops form a chain, and bounds must precede filters,
      must precede maps. ops must be a set of keyword value pairs of the
      following forms:
    
         :bound [start end] 
    
      Only elements from start (inclusive) to end (exclusive) will be
      processed when the array is realized.
    
         :filter pred 
    
      Filter preds remove elements from processing when the array is realized. pred
      must be a function of one argument whose return will be processed
      via boolean.
    
         :filter-index pred2 
    
      pred2 must be a function of two arguments, which will be an element
      of the collection and the corresponding index, whose return will be
      processed via boolean.
    
         :filter-with [pred2 coll2] 
    
      pred2 must be a function of two arguments, which will be
      corresponding elements of the 2 collections.
    
         :map f 
    
      Map fns will be used to transform elements when the array is
      realized. f must be a function of one argument.
    
         :map-index f2 
    
      f2 must be a function of two arguments, which will be an element of
      the collection and the corresponding index.
    
         :map-with [f2 coll2]
    
      f2 must be a function of two arguments, which will be corresponding
      elements of the 2 collections.

    clojars-test 1.3.0
    clojars test
    clojure.parallel/parSourceDoc + Usages
    Creates a parallel array from coll. ops, if supplied, perform
      on-the-fly filtering or transformations during parallel realization
      or calculation. ops form a chain, and bounds must precede filters,
      must precede maps. ops must be a set of keyword value pairs of the
      following forms:
    
         :bound [start end] 
    
      Only elements from start (inclusive) to end (exclusive) will be
      processed when the array is realized.
    
         :filter pred 
    
      Filter preds remove elements from processing when the array is realized. pred
      must be a function of one argument whose return will be processed
      via boolean.
    
         :filter-index pred2 
    
      pred2 must be a function of two arguments, which will be an element
      of the collection and the corresponding index, whose return will be
      processed via boolean.
    
         :filter-with [pred2 coll2] 
    
      pred2 must be a function of two arguments, which will be
      corresponding elements of the 2 collections.
    
         :map f 
    
      Map fns will be used to transform elements when the array is
      realized. f must be a function of one argument.
    
         :map-index f2 
    
      f2 must be a function of two arguments, which will be an element of
      the collection and the corresponding index.
    
         :map-with [f2 coll2]
    
      f2 must be a function of two arguments, which will be corresponding
      elements of the 2 collections.

    clojr 0.3.0
    Run single file clojure apps
    clojure.parallel/parSourceDoc + Usages
    Creates a parallel array from coll. ops, if supplied, perform
      on-the-fly filtering or transformations during parallel realization
      or calculation. ops form a chain, and bounds must precede filters,
      must precede maps. ops must be a set of keyword value pairs of the
      following forms:
    
         :bound [start end] 
    
      Only elements from start (inclusive) to end (exclusive) will be
      processed when the array is realized.
    
         :filter pred 
    
      Filter preds remove elements from processing when the array is realized. pred
      must be a function of one argument whose return will be processed
      via boolean.
    
         :filter-index pred2 
    
      pred2 must be a function of two arguments, which will be an element
      of the collection and the corresponding index, whose return will be
      processed via boolean.
    
         :filter-with [pred2 coll2] 
    
      pred2 must be a function of two arguments, which will be
      corresponding elements of the 2 collections.
    
         :map f 
    
      Map fns will be used to transform elements when the array is
      realized. f must be a function of one argument.
    
         :map-index f2 
    
      f2 must be a function of two arguments, which will be an element of
      the collection and the corresponding index.
    
         :map-with [f2 coll2]
    
      f2 must be a function of two arguments, which will be corresponding
      elements of the 2 collections.

    jaunt 1.9.0-RC4
    arrdem flavored Clojure
    clojure.parallel/parSourceDoc + Usages
    Creates a parallel array from coll. ops, if supplied, perform
      on-the-fly filtering or transformations during parallel realization
      or calculation. ops form a chain, and bounds must precede filters,
      must precede maps. ops must be a set of keyword value pairs of the
      following forms:
    
         :bound [start end] 
    
      Only elements from start (inclusive) to end (exclusive) will be
      processed when the array is realized.
    
         :filter pred 
    
      Filter preds remove elements from processing when the array is realized. pred
      must be a function of one argument whose return will be processed
      via boolean.
    
         :filter-index pred2 
    
      pred2 must be a function of two arguments, which will be an element
      of the collection and the corresponding index, whose return will be
      processed via boolean.
    
         :filter-with [pred2 coll2] 
    
      pred2 must be a function of two arguments, which will be
      corresponding elements of the 2 collections.
    
         :map f 
    
      Map fns will be used to transform elements when the array is
      realized. f must be a function of one argument.
    
         :map-index f2 
    
      f2 must be a function of two arguments, which will be an element of
      the collection and the corresponding index.
    
         :map-with [f2 coll2]
    
      f2 must be a function of two arguments, which will be corresponding
      elements of the 2 collections.

    cljlangdetect 0.1.0
    Language detection for text. Wrapper of http://code.google.com/p/language-detection/
    clojure.parallel/parSourceDoc + Usages
    Creates a parallel array from coll. ops, if supplied, perform
      on-the-fly filtering or transformations during parallel realization
      or calculation. ops form a chain, and bounds must precede filters,
      must precede maps. ops must be a set of keyword value pairs of the
      following forms:
    
         :bound [start end] 
    
      Only elements from start (inclusive) to end (exclusive) will be
      processed when the array is realized.
    
         :filter pred 
    
      Filter preds remove elements from processing when the array is realized. pred
      must be a function of one argument whose return will be processed
      via boolean.
    
         :filter-index pred2 
    
      pred2 must be a function of two arguments, which will be an element
      of the collection and the corresponding index, whose return will be
      processed via boolean.
    
         :filter-with [pred2 coll2] 
    
      pred2 must be a function of two arguments, which will be
      corresponding elements of the 2 collections.
    
         :map f 
    
      Map fns will be used to transform elements when the array is
      realized. f must be a function of one argument.
    
         :map-index f2 
    
      f2 must be a function of two arguments, which will be an element of
      the collection and the corresponding index.
    
         :map-with [f2 coll2]
    
      f2 must be a function of two arguments, which will be corresponding
      elements of the 2 collections.

    pumpet 1.7.0-RC1-r4
    Fork of Clojure for leaner code compilation.
    clojure.parallel/parSourceDoc + Usages
    Creates a parallel array from coll. ops, if supplied, perform
      on-the-fly filtering or transformations during parallel realization
      or calculation. ops form a chain, and bounds must precede filters,
      must precede maps. ops must be a set of keyword value pairs of the
      following forms:
    
         :bound [start end] 
    
      Only elements from start (inclusive) to end (exclusive) will be
      processed when the array is realized.
    
         :filter pred 
    
      Filter preds remove elements from processing when the array is realized. pred
      must be a function of one argument whose return will be processed
      via boolean.
    
         :filter-index pred2 
    
      pred2 must be a function of two arguments, which will be an element
      of the collection and the corresponding index, whose return will be
      processed via boolean.
    
         :filter-with [pred2 coll2] 
    
      pred2 must be a function of two arguments, which will be
      corresponding elements of the 2 collections.
    
         :map f 
    
      Map fns will be used to transform elements when the array is
      realized. f must be a function of one argument.
    
         :map-index f2 
    
      f2 must be a function of two arguments, which will be an element of
      the collection and the corresponding index.
    
         :map-with [f2 coll2]
    
      f2 must be a function of two arguments, which will be corresponding
      elements of the 2 collections.

    ebenbild 0.1.1
    tiny library to create predicates from different data that match on "look-a-likes"
    ebenbild.core/likeSourceDoc + Usages
    Creates a predicate from different objects.
       Uses the EbenbildPred Protocol.
       Default Options are:
    Fn -> just assumes its already a pred,
    String -> matches if the string is included,
    Pattern -> matches the exact pattern,
    Number -> matches the number
    Keyword -> matches other keywords with equal (if given no namespace will match only on name).
    Map -> calls like on all keys and matches if all vals of the map are matching.
    Vector -> calls like on all elements, matches all seqs of the same size whose elements match the given vector.
    ANY -> matches everything.

    core.matrix 0.62.0
    N-dimensional array programming API for Clojure
    clojure.core.matrix.impl.ndarray-macro/unroll-predicateSourceDoc + Usages
    Generates code for unrolling a binary predicate over a list of provided
       symbols. For example, `(unroll-predicate 'pred ['a 'b 'c])` will return
       `'(and (pred a b) (pred b c))`

    pedestal.interceptor 0.5.3
    Pedestal interceptor chain and execution utilities
    io.pedestal.interceptor.chain/terminate-whenSourceDoc + Usages
    Adds pred as a terminating condition of the context. pred is a
      function that takes a context as its argument. It will be invoked
      after every Interceptor's :enter function. If pred returns logical
      true, execution will stop at that Interceptor.

    tripod 0.2.0
    Pedestal routing for Ring and ClojureScript
    tripod.context/terminate-whenSourceDoc + Usages
    Adds pred as a terminating condition of the context. pred is a
      function that takes a context as its argument. It will be invoked
      after every Interceptor's :enter function. If pred returns logical
      true, execution will stop at that Interceptor.

    duckling 0.4.24
    Date & Number parser
    duckling.time.pred/shift-durationSourceDoc + Usages
    Shifts base-pred forward or backward ('two days after pred')
      Duration can be negative ('three hours before pred').
      The resulting grain is the one just below the duration's grain
      Shifted slots' width is exactly their grain

    Like take-the-nth, but takes the nth cyclic-pred *after base-pred*
      (or before if n is negative.
      Since pred generates sequences, it also generates sequences.
      
      Options: :not-immediate works as usual

    ykk 1.1.0
    Some utilities for clojure zippers.
    ykk.core/find*SourceDoc + Usages
    This is the underlying implementation of find-{leaf, branch}. The first loc
      satisfying either one of or both loc-pred and node-pred, depending on the
      value of the or kwarg, is returned. Note the implicit call to clojure.zip/node
      that precedes node-pred.

    synthread 1.3.0
    Syntax Threading library
    lonocloud.synthread.core/>if-letSourceDoc + Usages
    Thread x through then or else depending on the value of pred. If
      pred is true, bind local to pred.
      (-> {}
        (>if-let [x :bar]
          (assoc :foo x)
          (assoc :was-bar false)))
      ;; returns {:foo :bar}

    clj-duckling 0.4.24
    A Clojure library that parses text into structured data
    duckling.time.pred/shift-durationSourceDoc + Usages
    Shifts base-pred forward or backward ('two days after pred')
      Duration can be negative ('three hours before pred').
      The resulting grain is the one just below the duration's grain
      Shifted slots' width is exactly their grain

    clj-duckling 0.4.24
    A Clojure library that parses text into structured data
    duckling.time.pred/take-the-nth-afterSourceDoc + Usages
    Like take-the-nth, but takes the nth cyclic-pred *after base-pred*
      (or before if n is negative.
      Since pred generates sequences, it also generates sequences.
      
      Options: :not-immediate works as usual

    datasplash 0.6.1
    Clojure API for a more dynamic Google Cloud Dataflow and (hopefully) Apache BEAM
    datasplash.core/dfilterSourceDoc + Usages
    Returns a PCollection that only contains the items for which (pred item)
    returns true.
    
      Example:
    ```
        (ds/filter even? foo)
    (ds/filter (fn [x] (even? (* x x))) foo)
    ```
    
    Available options:
    
      - :checkpoint => Given a path, will store the resulting pcoll at this path in edn to facilitate dev/debug.
      - :coder => Uses a specific Coder for the results of this transform. Usually defaults to some form of nippy-coder.
      - :name => Adds a name to the Transform.
      - :side-inputs => Adds a map of PCollectionViews as side inputs to the underlying ParDo Transform. They can be accessed there by key in the return of side-inputs fn.
      - :side-outputs => Defines as a seq of keywords the output tags for the underlying ParDo Transform. The map fn should return a map with keys set to the same set of keywords.
      - :without-coercion-to-clj => Avoids coercing Dataflow types to Clojure, like KV. Coercion will happen by default
    

    Ends the reduction of coll when (pred val) returns logical false.

    clojure-contrib 1.2.0
    Clojure user contributions library.
    clojure.contrib.seq/positionsSourceDoc + Usages
    Returns a lazy sequence containing the positions at which pred
       is true for items in coll.

    clojure-contrib 1.2.0
    Clojure user contributions library.
    clojure.contrib.seq-utils/positionsSourceDoc + Usages
    Returns a lazy sequence containing the positions at which pred
       is true for items in coll.

    clojure 1.10.0-alpha4
    Core language
    clojure.core.reducers/take-whileSourceDoc + Usages
    Ends the reduction of coll when (pred val) returns logical false.

    tools.reader 1.3.0-alpha3
    A Clojure reader in Clojure
    cljs.tools.reader.impl.commons/read-past (cljs)SourceDoc + Usages
    Read until first character that doesn't match pred, returning
       char.

    tools.reader 1.3.0-alpha3
    A Clojure reader in Clojure
    clojure.tools.reader.impl.commons/read-pastSourceDoc + Usages
    Read until first character that doesn't match pred, returning
       char.

    schema 1.1.9
    Clojure(Script) library for declarative data description and validation
    schema.core/Str (cljs)SourceDoc + Usages
    Satisfied only by String.
       Is (pred string?) and not js/String in cljs because of keywords.

    schema 1.1.9
    Clojure(Script) library for declarative data description and validation
    schema.core/StrSourceDoc + Usages
    Satisfied only by String.
       Is (pred string?) and not js/String in cljs because of keywords.

    truss 1.5.0
    Assertions API for Clojure/Script
    taoensso.truss.impl/-xpredSourceDoc + Usages
    Expands any special predicate forms and returns [<expanded-pred> <non-throwing?>].

    truss 1.5.0
    Assertions API for Clojure/Script
    taoensso.truss.impl/-xpred (cljs)SourceDoc + Usages
    Expands any special predicate forms and returns [<expanded-pred> <non-throwing?>].

    useful 0.11.5
    A collection of generally-useful Clojure utility functions
    flatland.useful.seq/take-untilSourceDoc + Usages
    Take from coll up to and including the first item that satisfies pred.

    useful 0.11.5
    A collection of generally-useful Clojure utility functions
    flatland.useful.seq/find-withSourceDoc + Usages
    Returns the val corresponding to the first key where (pred key) returns true.

    useful 0.11.5
    A collection of generally-useful Clojure utility functions
    flatland.useful.seq/find-firstSourceDoc + Usages
    Returns the first item of coll where (pred item) returns logical true.

    Read until first character that doesn't match pred, returning
       char.

    lein-ancient 0.6.15
    Check your Projects for outdated Dependencies.
    ancient.toolsreader.v0v10v0.cljs.tools.reader.impl.commons/read-past (cljs)SourceDoc + Usages
    Read until first character that doesn't match pred, returning
       char.

    lein-ancient 0.6.15
    Check your Projects for outdated Dependencies.
    ancient.toolsreader.v0v10v0.clojure.tools.reader.impl.commons/read-pastSourceDoc + Usages
    Read until first character that doesn't match pred, returning
       char.

    Read until first character that doesn't match pred, returning
       char.

    Read until first character that doesn't match pred, returning
       char.

    utilize 0.2.3
    Compilation of Clojure functions from around the community
    utilize.seq/find-withSourceDoc + Usages
    Returns the val corresponding to the first key where (pred key) returns true.

    utilize 0.2.3
    Compilation of Clojure functions from around the community
    utilize.seq/find-firstSourceDoc + Usages
    Returns the first item of coll where (pred item) returns logical true.

    core.typed.rt 0.5.2
    An optional type system for Clojure — zero-dependency artifact for annotations only.
    clojure.core.typed/PredSourceDoc + Usages
    A predicate for the given type.
                
                eg. Type for integer?: (Pred Int)

    hasch 0.3.5
    Cryptographic hashing of EDN datastructures.
    cljs.reader/read-past (cljs)SourceDoc + Usages
    Read until first character that doesn't match pred, returning
       char.

    hasch 0.3.5
    Cryptographic hashing of EDN datastructures.
    cljs.reader/read-past (cljs)SourceDoc + Usages
    Read until first character that doesn't match pred, returning
       char.

    secretary 2.0.0.1-d484a1
    A client-side router for ClojureScript.
    cljs.reader/read-past (cljs)SourceDoc + Usages
    Read until first character that doesn't match pred, returning
       char.

    parkour 0.6.4-alpha1
    Hadoop MapReduce in idiomatic Clojure.
    parkour.reducers/ffilterSourceDoc + Usages
    Returns the first item in `coll` for which `(pred item)` is true.

    failjure 1.3.0
    Simple helpers for treating failures as values
    failjure.core/assert-withSourceDoc + Usages
    If (pred v) is true, return v
       otherwise, return (f/fail msg)

    superv.async 0.2.9
    Supervised channel management for core.async.
    cljs.reader/read-past (cljs)SourceDoc + Usages
    Read until first character that doesn't match pred, returning
       char.

    toolbelt-core 0.5.0
    Generic utility functions for Clojure/Script.
    toolbelt.core/find-bySourceDoc + Usages
    Return the first element in `coll` matching `pred`; otherwise nil.

    toolbelt-core 0.5.0
    Generic utility functions for Clojure/Script.
    toolbelt.core/find-by (cljs)SourceDoc + Usages
    Return the first element in `coll` matching `pred`; otherwise nil.

    dynadoc 1.4.7
    A dynamic documentation generator
    oakcljs.tools.reader.impl.commons/read-past (cljs)SourceDoc + Usages
    Read until first character that doesn't match pred, returning
       char.

    dynadoc 1.4.7
    A dynamic documentation generator
    cljs.tools.reader.impl.commons/read-past (cljs)SourceDoc + Usages
    Read until first character that doesn't match pred, returning
       char.

    zetta-parser 0.1.0
    Powerful monadic parser combinator in Clojure (Haskell attoparsec's port)
    zetta.parser.seq/skipSourceDoc + Usages
    Parser that succeeds for any item for which the predicate `pred`, returns
      `nil`.

    hoplon-elem-lib 0.2.0
    Tiny element library for Hoplon.
    cljs.tools.reader.impl.commons/read-past (cljs)SourceDoc + Usages
    Read until first character that doesn't match pred, returning
       char.

    funnyqt 1.1.5
    A model querying and transformation library for TGraphs and EMF models developed
    funnyqt.query/exist-n?SourceDoc + Usages
    Returns logical true iff `pred` holds for exactly `n` elements in `coll`.

    funnyqt 1.1.5
    A model querying and transformation library for TGraphs and EMF models developed
    funnyqt.query/exists?SourceDoc + Usages
    Returns logical true iff `pred` holds at least for one element in `coll`.

    funnyqt 1.1.5
    A model querying and transformation library for TGraphs and EMF models developed
    funnyqt.query/forall?SourceDoc + Usages
    Returns logical true, iff `pred` holds forall elements in `coll`.

    ez-form 0.8.0
    Forms for the web
    cljs.reader/read-past (cljs)SourceDoc + Usages
    Read until first character that doesn't match pred, returning
       char.

    refactor-nrepl 2.3.1
    nREPL middleware to support editor-agnostic refactoring
    mranderson047.toolsreader.v1v0v0-beta4.cljs.tools.reader.impl.commons/read-past (cljs)SourceDoc + Usages
    Read until first character that doesn't match pred, returning
       char.

    refactor-nrepl 2.3.1
    nREPL middleware to support editor-agnostic refactoring
    mranderson047.toolsreader.v1v0v0-beta4.clojure.tools.reader.impl.commons/read-pastSourceDoc + Usages
    Read until first character that doesn't match pred, returning
       char.

    refactor-nrepl 2.3.1
    nREPL middleware to support editor-agnostic refactoring
    refactor-nrepl.util/dissoc-whenSourceDoc + Usages
    Remove the enumerated keys from m on which pred is truthy.

    pedestal.route 0.5.3
    Pedestal route definition and router construction
    io.pedestal.http.route.definition.terse/dissoc-whenSourceDoc + Usages
    Dissoc those keys from m whose values in m satisfy pred.

    ssl-utils 1.0.0
    SSL certificate management on the JVM.
    puppetlabs.ssl-utils.core/create-ca-extensionsSourceDoc + Usages
    Inputs: [ca-name :- (schema/pred valid-x500-name?) ca-serial :- (schema/pred number?) ca-public-key :- (schema/pred public-key?)]
      Returns: (schema/pred extension-list?)
    
      Create a list of extensions to be added to the CA certificate.

    re-com 2.1.0
    Reusable UI components for Reagent
    re-com.datepicker/previous (cljs)SourceDoc + Usages
    If date fails pred, subtract period until true, otherwise answer date

    autodoc 1.1.2
    A tool to build HTML documentation from your Clojure source
    autodoc.build-html/key-pred*SourceDoc + Usages
    A function for pretty-printing specs that take key-pred-forms

    zprint 0.4.9
    Pretty print zippers and s-expressions
    zprint.spec/numbers-or-number-pred?SourceDoc + Usages
    If they are both numbers and are equal, or the first is a number 
      and the second one is a pred.

    Read until first character that doesn't match pred, returning
       char.

    Read until first character that doesn't match pred, returning
       char.

    milia 0.3.37
    The ona.io Clojure Web API Client.
    cljs.reader/read-past (cljs)SourceDoc + Usages
    Read until first character that doesn't match pred, returning
       char.

    clairvoyant v0.0-23-gd6225fd
    ClojureScript tracing library
    cljs.reader/read-past (cljs)SourceDoc + Usages
    Read until first character that doesn't match pred, returning
       char.

    xml-in 0.1.0
    your friendly XML navigator
    xml-in.core/filter-firstSourceDoc + Usages
    finds the first value at the key 'k' matching 'pred'
       and shortcuts transducing

    riemann 0.3.1
    A network event stream processor. Intended for analytics, metrics, and alerting;
    riemann.streams/dualSourceDoc + Usages
    A stream which splits events into two mirror-images streams, based on
      (pred e).
    
      If (pred e) is true, calls (true-stream e) and (false-stream (expire e)).
    
      If (pred e) is false, does the opposite. Expired events are forwarded to both
      streams.
    
      (pred e) is always called once per incoming event.

    riemann 0.3.1
    A network event stream processor. Intended for analytics, metrics, and alerting;
    riemann.streams/dualSourceDoc + Usages
    A stream which splits events into two mirror-images streams, based on
      (pred e).
    
      If (pred e) is true, calls (true-stream e) and (false-stream (expire e)).
    
      If (pred e) is false, does the opposite. Expired events are forwarded to both
      streams.
    
      (pred e) is always called once per incoming event.

    pretty-spec 0.1.3
    A pretty printer for clojure.spec forms.
    cljs.reader/read-past (cljs)SourceDoc + Usages
    Read until first character that doesn't match pred, returning
       char.

    sanity 1.12.0
    Fixes a number of problems with Clojure semantics and syntax and fills in some missing
    sanity.core/find-ifSourceDoc + Usages
    Return a value from collection coll where predicate pred is true.

    Read until first character that doesn't match pred, returning
       char.

    catnip 0.5.1
    The irresistible Clojure IDE-in-a-plugin
    cljs.reader/read-past (cljs)SourceDoc + Usages
    Read until first character that doesn't match pred, returning
       char.

    zengarden 0.1.8
    Zengarden is a library for rendering CSS in Clojure.
    zengarden.process/process-importSourceDoc + Usages
    Inputs: [node :- (s/pred url-or-uri-predicate)]
      Returns: s/Str

    hatti 0.4.0
    A cljs dataview from your friends at Ona.io
    cljs.reader/read-past (cljs)SourceDoc + Usages
    Read until first character that doesn't match pred, returning
       char.

    hatti 0.4.0
    A cljs dataview from your friends at Ona.io
    cljs.reader/read-past (cljs)SourceDoc + Usages
    Read until first character that doesn't match pred, returning
       char.

    ff-om-draggable 0.0.18
    FIXME: write description
    cljs.reader/read-past (cljs)SourceDoc + Usages
    Read until first character that doesn't match pred, returning
       char.

    modelo 0.1.0
    Relational database abstraction for Clojure
    modelo.util/valid-predicate?SourceDoc + Usages
    Returns true if pred contains only fields from allowed-fields

    adjunct 0.1.4
    Extensions to Clojure
    adjunct.zip/findSourceDoc + Usages
    Depth first search for loc that satisfies (pred node), or nil.

    clojure-objc 1.7.0-RC1
    Clojure core environment and runtime library.
    clojure.core.reducers/take-whileSourceDoc + Usages
    Ends the reduction of coll when (pred val) returns logical false.

    cljs-ipfs-native 1.0.0
    Native ClojureScript js-ipfs-api implementation.
    cljs.tools.reader.impl.commons/read-past (cljs)SourceDoc + Usages
    Read until first character that doesn't match pred, returning
       char.

    bartok-x 0.1
    a set of primitives for musical programming
    utils.utils/iterate-while (cljs)SourceDoc + Usages
    like (last (take-while pred (iterate f init))) 

    bartok-x 0.1
    a set of primitives for musical programming
    utils.utils/iterate-whileSourceDoc + Usages
    like (last (take-while pred (iterate f init))) 

    chu.graph 0.2.2
    a graph library
    chu.graph/filter-linkSourceDoc + Usages
    Make a graph where you only keep links verifying pred.

    chu.graph 0.2.2
    a graph library
    chu.graph/filter-linkSourceDoc + Usages
    Make a graph where you only keep links verifying pred.

    chu.graph 0.2.2
    a graph library
    chu.graph/filter-nodeSourceDoc + Usages
    Make a graph where you keep only nodes verifying pred.

    chu.graph 0.2.2
    a graph library
    chu.graph/filter-nodeSourceDoc + Usages
    Make a graph where you keep only nodes verifying pred.

    Make a graph where you only keep links verifying pred.

    Make a graph where you keep only nodes verifying pred.

    Make a graph where you only keep links verifying pred.

    Make a graph where you keep only nodes verifying pred.

    Make a graph where you only keep links verifying pred.

    Make a graph where you keep only nodes verifying pred.

    Make a graph where you only keep links verifying pred.

    Make a graph where you keep only nodes verifying pred.

    Make a graph where you only keep links verifying pred.

    Make a graph where you keep only nodes verifying pred.

    dsann-clj-utils 0.1.0
    general utilities
    dsann.utils.seq/find-first (cljs)SourceDoc + Usages
    find first element, e, for which (pred? e) is true

    dsann-clj-utils 0.1.0
    general utilities
    dsann.utils.seq/find-firstSourceDoc + Usages
    find first element, e, for which (pred? e) is true

    Returns a lazy sequence containing the positions at which pred
       is true for items in coll.

    jutsu 0.1.2
    Data visualization tool built for the web
    cljs.reader/read-past (cljs)SourceDoc + Usages
    Read until first character that doesn't match pred, returning
       char.

    hitchhiker-tree 0.1.2
    A Hitchhiker Tree Library
    cljs.reader/read-past (cljs)SourceDoc + Usages
    Read until first character that doesn't match pred, returning
       char.

    skm-ice-utils 1.0.3
    Utility library developed by the ICE project within the danish ministry of taxation
    cljs.spec/coll-checker (cljs)SourceDoc + Usages
    returns a predicate function that checks *coll-check-limit* items in a collection with pred

    skm-ice-utils 1.0.3
    Utility library developed by the ICE project within the danish ministry of taxation
    schema.core/Str (cljs)SourceDoc + Usages
    Satisfied only by String.
       Is (pred string?) and not js/String in cljs because of keywords.

    Read until first character that doesn't match pred, returning
       char.

    receipt 1.0.1
    FIXME: write description
    clojure.core.reducers/take-whileSourceDoc + Usages
    Ends the reduction of coll when (pred val) returns logical false.

    pseudoace 0.5.7
    WormBase database migration library and CLI.
    pseudoace.utils/filter-by-dateSourceDoc + Usages
    Filter `coll` by date object `dt` using predicate `pred`.

    derive 0.2.1
    Clojurescript library to support efficient computation of up to date values derived
    cljs.reader/read-past (cljs)SourceDoc + Usages
    Read until first character that doesn't match pred, returning
       char.

    derive 0.2.1
    Clojurescript library to support efficient computation of up to date values derived
    clojure.core.reducers/take-while (cljs)SourceDoc + Usages
    Ends the reduction of coll when (pred val) returns logical false.

    clj-odbp 0.2.2
    A Clojure driver for OrientDB binary protocol
    clj-odbp.binary.deserialize.buffer/buffer-take-upto!SourceDoc + Usages
    Returns a vector of n elements while pred is
       true including the first false.

    blind 0.5.0
    A clojure reader written in clojure
    blind.reader/read-pastSourceDoc + Usages
    Read until first character that doesn't match pred, returning
       char.

    buddy-pkcs15-sha1 0.2.0b3
    Forked security library buddy for Clojure with PKCS v1.5 for SHA1. Original library:
    clojure.tools.reader.impl.commons/read-pastSourceDoc + Usages
    Read until first character that doesn't match pred, returning
       char.

    buddy-pkcs15-sha1 0.2.0b3
    Forked security library buddy for Clojure with PKCS v1.5 for SHA1. Original library:
    clojure.core.reducers/take-whileSourceDoc + Usages
    Ends the reduction of coll when (pred val) returns logical false.

    nativestore 0.2.2
    A client-side, in-memory, indexed data store.
    clojure.core.reducers/take-while (cljs)SourceDoc + Usages
    Ends the reduction of coll when (pred val) returns logical false.

    reagent-slider 0.1.2
    Reagent wrapper around react-components/slider
    cljs.reader/read-past (cljs)SourceDoc + Usages
    Read until first character that doesn't match pred, returning
       char.

    Read until first character that doesn't match pred, returning
       char.

    If date fails pred, subtract period until true, otherwise answer date

    tupelo 0.9.76
    Tupelo: Clojure With A Spoonful of Honey
    tupelo.impl/has-none?SourceDoc + Usages
    Inputs: [pred :- s/Any coll :- [s/Any]]
      Returns: s/Bool

    tupelo 0.9.76
    Tupelo: Clojure With A Spoonful of Honey
    tupelo.impl/has-some?SourceDoc + Usages
    Inputs: [pred :- s/Any coll :- [s/Any]]
      Returns: s/Bool

    foam 0.1.6
    Om form on steroids
    schema.core/Str (cljs)SourceDoc + Usages
    Satisfied only by String.
       Is (pred string?) and not js/String in cljs because of keywords.

    Read until first character that doesn't match pred, returning
       char.

    budb 0.0.1
    A CRDT Database for Clojure(script)
    cljs.reader/read-past (cljs)SourceDoc + Usages
    Read until first character that doesn't match pred, returning
       char.

    budb 0.0.1
    A CRDT Database for Clojure(script)
    cljs.tools.reader.impl.commons/read-past (cljs)SourceDoc + Usages
    Read until first character that doesn't match pred, returning
       char.

    budb 0.0.1
    A CRDT Database for Clojure(script)
    taoensso.truss.impl/-xpred (cljs)SourceDoc + Usages
    Expands any special predicate forms and returns [<expanded-pred> <non-throwing?>]

    budb 0.0.1
    A CRDT Database for Clojure(script)
    cljs.reader/read-past (cljs)SourceDoc + Usages
    Read until first character that doesn't match pred, returning
       char.

    budb 0.0.1
    A CRDT Database for Clojure(script)
    cljs.tools.reader.impl.commons/read-past (cljs)SourceDoc + Usages
    Read until first character that doesn't match pred, returning
       char.

    budb 0.0.1
    A CRDT Database for Clojure(script)
    taoensso.truss.impl/-xpred (cljs)SourceDoc + Usages
    Expands any special predicate forms and returns [<expanded-pred> <non-throwing?>]

    re-frame-ipfs-fx 0.0.2
    IPFS Re-Frame handlers.
    taoensso.truss.impl/-xpred (cljs)SourceDoc + Usages
    Expands any special predicate forms and returns [<expanded-pred> <non-throwing?>].

    re-frame-ipfs-fx 0.0.2
    IPFS Re-Frame handlers.
    cljs.tools.reader.impl.commons/read-past (cljs)SourceDoc + Usages
    Read until first character that doesn't match pred, returning
       char.

    spigot-repl 0.1.0
    Clojure REPL plugin for Spigot
    clojure.core.reducers/take-whileSourceDoc + Usages
    Ends the reduction of coll when (pred val) returns logical false.