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 409 results in 131 projects.
    metrics-clojure 2.10.0
    A Clojure façade for Coda Hale's metrics library.
    metrics.core/remove-all-metricsSourceDoc + Usages
    Remove all the metrics in the given registry, or the default
      registry if no registry given.

    immutant-common 1.1.4
    Common utilities and functions used by all the Immutant namespaces.
    immutant.registry/keysSourceDoc + Usages
    Return all the keys in the registry

    immutant-common 1.1.4
    Common utilities and functions used by all the Immutant namespaces.
    immutant.registry/getSourceDoc + Usages
    Retrieve a value from the registry.

    immutant-common 1.1.4
    Common utilities and functions used by all the Immutant namespaces.
    immutant.registry/putSourceDoc + Usages
    Store a value in the registry.

    Retrieve the registry name (for exporting).

    Retrieve the registry name (for exporting).

    iapetos 0.1.8
    A Clojure Prometheus Client
    iapetos.registry/nameSourceDoc + Usages
    Retrieve the registry name (for exporting).

    iapetos 0.1.8
    A Clojure Prometheus Client
    iapetos.registry/RegistrySourceDoc + Usages
    Protocol for the iapetos collector registry.

    re-view 0.4.15
    ClojureScript React Library
    re-view.view-spec/spec-registry (cljs)SourceDoc + Usages
    Global registry for view specs

    boot.core 2.5.1
    A script interpreter for Clojure. Also a build tool.
    tailrecursion.boot.tmpregistry/-init!~TmpRegistry~ITmpRegistrySourceDoc + Usages
    Initialize temp registry.

    boot.core 2.5.1
    A script interpreter for Clojure. Also a build tool.
    tailrecursion.boot.tmpregistry/-init!SourceDoc + Usages
    Initialize temp registry.

    conskit 1.0.0-rc1
    Toolkit for building applications
    conskit.core/registry-containerSourceDoc + Usages
    Temporary container for the Registry

    conskit 1.0.0-rc1
    Toolkit for building applications
    conskit.protocols/get-actionSourceDoc + Usages
    Retrieve an action from the registry

    cryogen-core 0.1.61
    Cryogen's compiler
    cryogen-core.markup/clear-registrySourceDoc + Usages
    Reset the Markup registry.

    cryogen-core 0.1.61
    Cryogen's compiler
    cryogen-core.markup/register-markupSourceDoc + Usages
    Add a Markup implementation to the registry.

    macros 0.2.63
    Clojure macros for web and mobile development
    workflo.macros.registry/throw-registry-errorSourceDoc + Usages
    Throws an error generated by a registry.

    macros 0.2.63
    Clojure macros for web and mobile development
    workflo.macros.registry/throw-registry-error (cljs)SourceDoc + Usages
    Throws an error generated by a registry.

    skm-ice-utils 1.0.3
    Utility library developed by the ICE project within the danish ministry of taxation
    cljs.spec/registry (cljs)SourceDoc + Usages
    returns the registry map

    hbase-admin 0.1.18
    A library to administer hbase
    hbase.admin.core/init-hbase-connectionSourceDoc + Usages
    Make a connection and store it into registry

    pneumatic-tubes 0.3.0
    WebSocket based transport of events between re-frame app and server
    pneumatic-tubes.core/rm-tube!SourceDoc + Usages
    Removes tube from the registry

    skm-ice-gui 1.0.0
    GUI library developed by the ICE project within the danish ministry of taxation
    cljs.spec/registry (cljs)SourceDoc + Usages
    returns the registry map

    twilio-rest 1.0.0
    Adapter library for the Twilio web service.
    twilio.messages/sync-twilioSourceDoc + Usages
    Synchronize the registry with the server

    twilio-rest 1.0.0
    Adapter library for the Twilio web service.
    twilio.messages/sync-twilioSourceDoc + Usages
    Synchronize the registry with the server

    jmh-clojure 0.2.1
    Benchmarking with JMH, the Java Microbenchmark Harness, from Clojure.
    jmh.exec/profiler-aliasesSourceDoc + Usages
    A registry map of aliases to profilers.

    Clears the symbol registry

    Adds a symbol to the symbol registry

    Adds a symbol to the symbol registry

    com.vitalreactor.twilio-rest 0.9.0
    Adapter library for the Twilio web service.
    twilio.messages/sync-twilioSourceDoc + Usages
    Synchronize the registry with the server

    com.vitalreactor.twilio-rest 0.9.0
    Adapter library for the Twilio web service.
    twilio.messages/sync-twilioSourceDoc + Usages
    Synchronize the registry with the server

    Initialize temp registry.

    Initialize temp registry.

    onto 0.0.0-alpha3
    <!> Developer is too lazy to write a description
    onto.core/|$SourceDoc + Usages
    Alias for clojure.spec/registry

    schmetrics 0.3.0
    Clojure Bindings for metrics
    schmetrics.health-check/registerSourceDoc + Usages
    Register a health check in the registry.

    bad-advice 0.0.4
    This is probably a bad idea, but...
    biiwide.bad-advice.alpha/unregister-advice-macro!SourceDoc + Usages
    Removes advice from the registry.

    editable 0.1.4
    lifecycle events for forms using re-frame
    cljs.spec/registry (cljs)SourceDoc + Usages
    returns the registry map

    hara.concurrent.procedure 2.8.6
    patterns and utilities
    hara.concurrent.procedure.data/registrySourceDoc + Usages
    creates a registry for running threads
     
       (into {} (registry))
       => (contains {:store clojure.lang.Atom})

    funnyqt 1.1.5
    A model querying and transformation library for TGraphs and EMF models developed
    funnyqt.emf/with-epackage-registrySourceDoc + Usages
    Evaluate `body` with the current value of *epackage-registry* set to
      `registry`.

    leiningen-core 2.8.1
    Library for core functionality of Leiningen.
    leiningen.core.ssl/map->registrySourceDoc + Usages
    Creates a Registry based of the given map.

    leiningen 2.8.1
    Automate Clojure projects without setting your hair on fire.
    leiningen.core.ssl/map->registrySourceDoc + Usages
    Creates a Registry based of the given map.

    iapetos 0.1.8
    A Clojure Prometheus Client
    iapetos.collector/CollectorSourceDoc + Usages
    Protocol for Collectors to be registered with a iapetos registry.

    iapetos 0.1.8
    A Clojure Prometheus Client
    iapetos.core/collector-registrySourceDoc + Usages
    Create a fresh iapetos collector registry.

    Push all metrics of the given registry.

    iapetos 0.1.8
    A Clojure Prometheus Client
    iapetos.export/push!SourceDoc + Usages
    Push all metrics of the given registry.

    hara.concurrent.procedure 2.8.6
    patterns and utilities
    hara.concurrent.procedure.middleware/wrap-registrySourceDoc + Usages
    updates the registry of the procedure
     
       (->> ((wrap-registry (fn [inst _] inst))
             {:registry (data/registry) :name "hello" :id :1}
             [])
            (into {}))
       => (contains {:store clojure.lang.Atom})

    aether 2.7.2
    Boot aether module–performs maven dependency resolution.
    boot.ssl/map->registrySourceDoc + Usages
    Creates a Registry based of the given map.

    Package level connection info registry.

    rektify 0.0.6
    ClojureScript library to manipulate any JS object model in a declarative way.
    rektify.core/unregister-generator-obj! (cljs)SourceDoc + Usages
    Remove an object from the generator registry

    ezmq 0.0.1
    Yet another Clojure ZMQ wrapper for JZMQ.
    ezmq.core/with-serialization-registrySourceDoc + Usages
    Use a custom Kyro/Carbonite registry.

    zookareg 1.0.1-3
    Embedded ZOokeeper KAfka and Confluent's Schema REGistry
    zookareg.schema-registry/halt!SourceDoc + Usages
    Stops a Confluent Schema Registry server.

    zookareg 1.0.1-3
    Embedded ZOokeeper KAfka and Confluent's Schema REGistry
    zookareg.schema-registry/->schema-registrySourceDoc + Usages
    Starts a Confluent Schema Registry server.

    schmetrics 0.3.0
    Clojure Bindings for metrics
    schmetrics.counter/get-counterSourceDoc + Usages
    Get the counter object from the registry.

    schmetrics 0.3.0
    Clojure Bindings for metrics
    schmetrics.gauge/get-gaugeSourceDoc + Usages
    Get the gauge object from the registry.

    schmetrics 0.3.0
    Clojure Bindings for metrics
    schmetrics.meter/get-meterSourceDoc + Usages
    Get the meter object from the registry.

    register/lookup a timer from the registry

    register/lookup a counter from the registry

    register/lookup a meter from the registry

    register/lookup a gauge from the registry

    register/lookup a histogram from the registry

    schmetrics 0.3.0
    Clojure Bindings for metrics
    schmetrics.registry/timerSourceDoc + Usages
    register/lookup a timer from the registry

    schmetrics 0.3.0
    Clojure Bindings for metrics
    schmetrics.registry/histogramSourceDoc + Usages
    register/lookup a histogram from the registry

    schmetrics 0.3.0
    Clojure Bindings for metrics
    schmetrics.registry/meterSourceDoc + Usages
    register/lookup a meter from the registry

    schmetrics 0.3.0
    Clojure Bindings for metrics
    schmetrics.registry/gaugeSourceDoc + Usages
    register/lookup a gauge from the registry

    schmetrics 0.3.0
    Clojure Bindings for metrics
    schmetrics.registry/counterSourceDoc + Usages
    register/lookup a counter from the registry

    schmetrics 0.3.0
    Clojure Bindings for metrics
    schmetrics.timer/get-timerSourceDoc + Usages
    Get the timer object from the registry.

    plaza 0.2.0-alpha1
    Plaza framework for semantic distributed applications
    plaza.rdf.core/register-rdf-nsSourceDoc + Usages
    Add a registered namespace to the registry of namespaces

    uri-handler 1.1.0
    A Library which will search the classpath to load URI handlers
    uri-handler.core/find-uri-handlersSourceDoc + Usages
    Looks for a handler for uri in the handler registry

    borg 0.0.2
    Sane Machine Management
    borg.registry.core/set-registry!SourceDoc + Usages
    Creates a new registry and sets it to be the global registry.
       Takes a map of config options that is passed to the registry init function.

    leiningen-core 2.8.1
    Library for core functionality of Leiningen.
    leiningen.core.ssl/https-registrySourceDoc + Usages
    Constructs a registry map that uses a given SSLContext for https.

    metrics-clojure 2.10.0
    A Clojure façade for Coda Hale's metrics library.
    metrics.core/countersSourceDoc + Usages
    Returns a map of all the counters in the registry and their names.

    metrics-clojure 2.10.0
    A Clojure façade for Coda Hale's metrics library.
    metrics.core/gaugesSourceDoc + Usages
    Returns a map of all the gauges in the registry and their names.

    metrics-clojure 2.10.0
    A Clojure façade for Coda Hale's metrics library.
    metrics.core/timersSourceDoc + Usages
    Returns a map of all the timers in the registry and their names.

    metrics-clojure 2.10.0
    A Clojure façade for Coda Hale's metrics library.
    metrics.core/histogramsSourceDoc + Usages
    Returns a map of all the histograms in the registry and their names.

    metrics-clojure 2.10.0
    A Clojure façade for Coda Hale's metrics library.
    metrics.core/metersSourceDoc + Usages
    Returns a map of all the meters in the registry and their names.

    leiningen 2.8.1
    Automate Clojure projects without setting your hair on fire.
    leiningen.core.ssl/https-registrySourceDoc + Usages
    Constructs a registry map that uses a given SSLContext for https.

    iapetos 0.1.8
    A Clojure Prometheus Client
    iapetos.collector.jvm/initializeSourceDoc + Usages
    Attach all available JVM collectors to the given registry.

    Create a new registry that is bound to the given subsystem.

    Clear the registry, removing all collectors from it.

    Unregister the collector under the given name from the registry.

    Create a new registry that is bound to the given subsystem.

    Clear the registry, removing all collectors from it.

    Unregister the collector under the given name from the registry.

    iapetos 0.1.8
    A Clojure Prometheus Client
    iapetos.registry/clearSourceDoc + Usages
    Clear the registry, removing all collectors from it.

    iapetos 0.1.8
    A Clojure Prometheus Client
    iapetos.registry/unregisterSourceDoc + Usages
    Unregister the collector under the given name from the registry.

    iapetos 0.1.8
    A Clojure Prometheus Client
    iapetos.registry/subsystemSourceDoc + Usages
    Create a new registry that is bound to the given subsystem.

    funnyqt 1.1.5
    A model querying and transformation library for TGraphs and EMF models developed
    funnyqt.emf/*epackage-registry*SourceDoc + Usages
    The current EPackage Registry which is used for EClassifier registration and
      lookup.  The default value is the global registry.  Use
    
        (with-epackage-registry (.getPackageRegistry my-resource-set)
          ...)
    
      to use a ResourceSet's local registry instead.

    carbonite 1.5.0
    Write Clojure data to and from bytes using Kryo.
    carbonite.api/register-serializersSourceDoc + Usages
    Register a map of Class to Kryo Serializer with a Kryo registry.

    carbonite 1.5.0
    Write Clojure data to and from bytes using Kryo.
    carbonite.buffer/read-bytesSourceDoc + Usages
    Read obj from byte[] using the registry.

    carbonite 1.5.0
    Write Clojure data to and from bytes using Kryo.
    carbonite.buffer/write-bytesSourceDoc + Usages
    Write obj using registry and return a byte[].

    boot.core 2.5.1
    A script interpreter for Clojure. Also a build tool.
    tailrecursion.boot.core/tmpregSourceDoc + Usages
    Get the tempfile registry object for the current boot environment.

    spec-tools 0.7.0
    Clojure(Script) tools for clojure.spec
    spec-tools.core/get-specSourceDoc + Usages
    Finds recursively a spec implementation from the registry

    conskit 1.0.0-rc1
    Toolkit for building applications
    conskit.core/build-registrySourceDoc + Usages
    Builds the state for the registry (i.e map of actions)

    clj-debug 0.7.6
    Library for debugging Clojure programms with support for tracing, timing and inspection.
    debug.intercept.registry/get-intercept-fnSourceDoc + Usages
    Get the interception function for the given key from the registry.

    clj-debug 0.7.6
    Library for debugging Clojure programms with support for tracing, timing and inspection.
    debug.intercept.registry/create-registrySourceDoc + Usages
    Create a registry for interception information (function and type interception).

    structgen 0.2.1
    Interop library for working with native C structs and binary formats in general.
    thi.ng.structgen.core/lookupSourceDoc + Usages
    Returns the type for given id from the `*registry*`.

    hara.io.scheduler 2.8.6
    patterns and utilities
    hara.io.scheduler.array/initialiseSourceDoc + Usages
    initialise the array with the ticker function as well and the registry and cache

    clomponents 0.5.2
    component configuration for clojure
    clomponents.core/swap-registrySourceDoc + Usages
    given an atom containing a current registry, and config for a new registry, first
       destroy all clomponents in the current registry, then swap the atom for a new
       registry initialised from the config

    immutant-wildfly 3.0.0-alpha1
    Utility functions only useful within a WildFly container.
    immutant.wildfly/get-from-service-registrySourceDoc + Usages
    Looks up a service in the WildFly internal service registry.

    future-spec-tools 0.3.3
    Clojure(Script) tools for clojure-spec-tools
    spec-tools.core/get-specSourceDoc + Usages
    Finds recursively a spec implementation from the registry

    discord.clj 1.1.0
    A library for creating Discord bots in Clojure.
    discord.bot/get-registered-extensionsSourceDoc + Usages
    Returns the current extension-registry as a list of Extensions.

    clj-apache-https 1.0.18
    Clojure HTTP library using the Apache HttpClient. Based on clj-apache-http, but
    com.twinql.clojure.http/thread-safe-connection-managerSourceDoc + Usages
    Produce a new ThreadSafeClientConnManager with http and https, or
       the provided registry.

    clj-apache-https 1.0.18
    Clojure HTTP library using the Apache HttpClient. Based on clj-apache-http, but
    com.twinql.clojure.http/single-client-connection-managerSourceDoc + Usages
    Produce a new SingleClientConnManager with http and https, or
       the provided registry.

    clj-apache-http 2.3.2
    Clojure HTTP library using the Apache HttpClient.
    com.twinql.clojure.http/thread-safe-connection-managerSourceDoc + Usages
    Produce a new ThreadSafeClientConnManager with http and https, or
       the provided registry.

    clj-apache-http 2.3.2
    Clojure HTTP library using the Apache HttpClient.
    com.twinql.clojure.http/single-client-connection-managerSourceDoc + Usages
    Produce a new SingleClientConnManager with http and https, or
       the provided registry.

    hara.benchmark 2.8.4
    patterns and utilities
    hara.benchmark/clear-benchmarksSourceDoc + Usages
    cleans all benchmarks in the registry
     
       (clear-benchmarks)

    hara.benchmark 2.8.4
    patterns and utilities
    hara.benchmark/list-benchmarksSourceDoc + Usages
    lists all benchmarks in the registry
     
       (list-benchmarks)

    george-application 2018.4
    George - Application
    george.turtle/register-turtleSourceDoc + Usages
    Appends turtle to the global registry if it is not already registered.

    george-application 2018.4
    George - Application
    george.turtle/register-turtleSourceDoc + Usages
    Appends turtle to the global registry if it is not already registered.

    lcmap-rest 0.5.0
    LCMAP REST Service API
    lcmap.rest.system/get-metrics-timersSourceDoc + Usages
    Returns a map of all the timers in the registry and their names.

    lcmap-rest 0.5.0
    LCMAP REST Service API
    lcmap.rest.system/get-metrics-metersSourceDoc + Usages
    Returns a map of all the meters in the registry and their names.

    lcmap-rest 0.5.0
    LCMAP REST Service API
    lcmap.rest.system/get-metrics-histogramsSourceDoc + Usages
    Returns a map of all the histograms in the registry and their names.

    lcmap-rest 0.5.0
    LCMAP REST Service API
    lcmap.rest.system/get-metrics-gaugesSourceDoc + Usages
    Returns a map of all the gauges in the registry and their names.

    lcmap-rest 0.5.0
    LCMAP REST Service API
    lcmap.rest.system/get-metrics-countersSourceDoc + Usages
    Returns a map of all the counters in the registry and their names.

    lcmap-rest 0.5.0
    LCMAP REST Service API
    lcmap.rest.system/get-metrics-namesSourceDoc + Usages
    Returns a set of the names of all the metrics in the default registry.

    wildfly 2.1.10
    Utility functions only useful within a WildFly container.
    immutant.wildfly/get-from-service-registrySourceDoc + Usages
    Looks up a service in the WildFly internal service registry.

    action-lists 1.0.1
    Clojure port of LispWorks Action Lists.
    action-lists.core/print-action-listsSourceDoc + Usages
    Prints a list of all the action lists in the global registry.

    kafkakit 0.5.0
    A go-to kit for working with Confluent Kafka in componentized Clojure projects.
    kafkakit.schema-registry/cached-clientSourceDoc + Usages
    Creates a new cached schema registry client.

    specql 20180312
    PostgreSQL spec query language
    specql.impl.registry/enum-typeSourceDoc + Usages
    Find an enum type from registry by name.

    leiningen-core 2.8.1
    Library for core functionality of Leiningen.
    leiningen.core.ssl/register-schemeSourceDoc + Usages
    Override the registry scheme used by the HTTP Wagon's Connection
      manager (used for Aether).
    
      DEPRECATED: Use override-wagon-registry! instead.

    leiningen-core 2.8.1
    Library for core functionality of Leiningen.
    leiningen.core.ssl/https-schemeSourceDoc + Usages
    Constructs a registry map that uses a given SSLContext for https.
    
      DEPRECATED: Use https-registry instead.

    metrics-clojure 2.10.0
    A Clojure façade for Coda Hale's metrics library.
    metrics.core/default-registrySourceDoc + Usages
    Default registry used by public API functions when no explicit registry argument is given

    metrics-clojure 2.10.0
    A Clojure façade for Coda Hale's metrics library.
    metrics.gauges/gaugeSourceDoc + Usages
    Retrieve an existing gauge from the provided registry (or the
      default registry) from its name. Returns nil when not found.

    leiningen 2.8.1
    Automate Clojure projects without setting your hair on fire.
    leiningen.core.ssl/register-schemeSourceDoc + Usages
    Override the registry scheme used by the HTTP Wagon's Connection
      manager (used for Aether).
    
      DEPRECATED: Use override-wagon-registry! instead.

    leiningen 2.8.1
    Automate Clojure projects without setting your hair on fire.
    leiningen.core.ssl/https-schemeSourceDoc + Usages
    Constructs a registry map that uses a given SSLContext for https.
    
      DEPRECATED: Use https-registry instead.

    hara.concurrent.procedure 2.8.6
    patterns and utilities
    hara.concurrent.procedure.registry/add-instanceSourceDoc + Usages
    adds something to the registry
     
       (->> (add-instance (data/registry) "hello" :1 {:a 1})
            (into {})
            :store
            deref)
       => {"hello" {:1 {:a 1}}}

    funnyqt 1.1.5
    A model querying and transformation library for TGraphs and EMF models developed
    funnyqt.emf/eclassesSourceDoc + Usages
    Returns the lazy seq of EClasses known by *epackage-registry*.
      Also see: `with-ns-uris` and `with-epackage-registry`

    funnyqt 1.1.5
    A model querying and transformation library for TGraphs and EMF models developed
    funnyqt.emf/eclassifiersSourceDoc + Usages
    Returns the lazy seq of EClassifiers known by *epackage-registry*.
      Also see: `with-ns-uris` and `with-epackage-registry`.

    pedestal.log 0.5.3
    Pedestal logging and metrics facilities
    io.pedestal.log/metric-registrySourceDoc + Usages
    Create a metric-registry.
      Optionally pass in single-arg functions, which when passed a registry,
      create, start, and return a reporter.

    carbonite 1.5.0
    Write Clojure data to and from bytes using Kryo.
    carbonite.api/default-registrySourceDoc + Usages
    Create or install a set of default serializers in an existing
       registry.  Modifies and returns the registry instance.

    metrics-clojure-health 2.10.0
    Gluing together metrics-clojure and healthchecks.
    metrics.health.core/default-healthcheck-registrySourceDoc + Usages
    Default health check registry used by public API functions when no explicit registry argument is given

    iapetos 0.1.8
    A Clojure Prometheus Client
    iapetos.core/valueSourceDoc + Usages
    Read the current value of a metric. This can be either called using a
       registry and a metric name or directly on a collector:
    
       ```
       (-> registry (value :app/duration-seconds))
       (-> registry :app/duration-seconds (value))
       ```
    
       The return value depends on the type of collector.

    iapetos 0.1.8
    A Clojure Prometheus Client
    iapetos.export/push-registry!SourceDoc + Usages
    Directly push all metrics of the given registry to the given push gateway.
       This can be used if you don't have control over registry creation, otherwise
       [[pushable-collector-registry]] and [[push!]] are recommended.

    iapetos 0.1.8
    A Clojure Prometheus Client
    iapetos.export/pushable-collector-registrySourceDoc + Usages
    Create a fresh iapetos collector registry whose metrics can be pushed to the
       specified gateway using [[push!]].
    
       Alternatively, by supplying `:registry`, an existing one can be wrapped to be
       pushable, e.g. the [[default-registry]].

    measure 0.1.7
    Say things about your application with authority, using Coda Hale's Metrics.
    measure.core/registrySourceDoc + Usages
    The core construct of measure is the registry.  To be useful, all
       metrics are registered with a registry, which is typically a singleton.
    
       The registry is a collection of named metrics.  Registries are useful both
       to group related sets of measurements, and as the vehicle through which
       measurements are reported.

    returns the registry map, prefer 'get-spec' to lookup a spec by name

    spec.alpha 0.1.143
    Specification of data and functions
    clojure.spec.alpha/registrySourceDoc + Usages
    returns the registry map, prefer 'get-spec' to lookup a spec by name

    hasch 0.3.5
    Cryptographic hashing of EDN datastructures.
    cljs.spec/registry (cljs)SourceDoc + Usages
    returns the registry map, prefer 'get-spec' to lookup a spec by name

    clojure-future-spec 1.9.0-alpha9-1
    Backport of clojure.spec for Clojure 1.8
    clojure.spec/registrySourceDoc + Usages
    returns the registry map, prefer 'get-spec' to lookup a spec by name

    superv.async 0.2.9
    Supervised channel management for core.async.
    cljs.spec/registry (cljs)SourceDoc + Usages
    returns the registry map, prefer 'get-spec' to lookup a spec by name

    iapetos 0.1.8
    A Clojure Prometheus Client
    iapetos.collector/make-simple-collectorSourceDoc + Usages
    Create a new simple collector representation to be instantiated and
       registered with a iapetos registry.

    iapetos 0.1.8
    A Clojure Prometheus Client
    iapetos.core/set-to-current-timeSourceDoc + Usages
    Set the given metric to the current timestamp. This can be either called
       using a registry and metric name or directly on a collector:
    
       ```
       (-> registry (set-to-current-time :app/last-success-unixtime))
       (-> registry :app/last-success-unixtime set-to-current-time)
       ```
    
       The return value of this operation is either the collector or registry that
       was passed in.

    iapetos 0.1.8
    A Clojure Prometheus Client
    iapetos.core/setSourceDoc + Usages
    Set the given metric to the given value. This can be either called
       using a registry and metric name or directly on a collector:
    
       ```
       (-> registry (set :app/active-users-total 10.0))
       (-> registry :app/active-users-total (set 10.0))
       ```
    
       The return value of this operation is either the collector or registry that
       was passed in.

    iapetos 0.1.8
    A Clojure Prometheus Client
    iapetos.core/decSourceDoc + Usages
    Decrement the given metric by the given amount. This can be either called
       using a registry and metric name or directly on a collector:
    
       ```
       (-> registry (inc :app/active-users-total))
       (-> registry :app/active-users-total (inc))
       ```
    
       The return value of this operation is either the collector or registry that
       was passed in.

    iapetos 0.1.8
    A Clojure Prometheus Client
    iapetos.core/incSourceDoc + Usages
    Increment the given metric by the given amount. This can be either called
       using a registry and metric name or directly on a collector:
    
       ```
       (-> registry (inc :app/active-users-total))
       (-> registry :app/active-users-total (inc))
       ```
    
       The return value of this operation is either the collector or registry that
       was passed in.

    iapetos 0.1.8
    A Clojure Prometheus Client
    iapetos.core/observeSourceDoc + Usages
    Observe the given amount for the desired metric. This can be either called
       using a registry and metric name or directly on a collector:
    
       ```
       (-> registry (observe :app/active-users-total 10.0))
       (-> registry :app/active-users-total (observe 10.0))
       ```
    
       The return value of this operation is either the collector or registry that
       was passed in.

    Add the given `iapetos.collector/Collector` to the registry using the
         given name.

    iapetos 0.1.8
    A Clojure Prometheus Client
    iapetos.export/text-formatSourceDoc + Usages
    Dump the given registry using the Prometheus text format (version 0.0.4).

    Add the given `iapetos.collector/Collector` to the registry using the
         given name.

    iapetos 0.1.8
    A Clojure Prometheus Client
    iapetos.registry/registerSourceDoc + Usages
    Add the given `iapetos.collector/Collector` to the registry using the
         given name.

    dynadoc 1.4.7
    A dynamic documentation generator
    cljs.spec.alpha/registry (cljs)SourceDoc + Usages
    returns the registry map, prefer 'get-spec' to lookup a spec by name

    spec-inspec 1.0.0-alpha2
    FIXME: write description
    com.wsscode.spec-inspec/registry-lookupSourceDoc + Usages
    Look for the key in registry, if not found try key spec parent recursively.

    hoplon-elem-lib 0.2.0
    Tiny element library for Hoplon.
    cljs.spec.alpha/registry (cljs)SourceDoc + Usages
    returns the registry map, prefer 'get-spec' to lookup a spec by name

    funnyqt 1.1.5
    A model querying and transformation library for TGraphs and EMF models developed
    funnyqt.emf/register-epackagesSourceDoc + Usages
    Registeres the given packages at the EPackage$Registry by their nsURI.
      Skips packages that are already registered.

    returns the registry map, prefer 'get-spec' to lookup a spec by name

    ez-form 0.8.0
    Forms for the web
    cljs.spec/registry (cljs)SourceDoc + Usages
    returns the registry map, prefer 'get-spec' to lookup a spec by name

    strictly-specking-standalone 0.1.1
    A Clojure library to help validate edn configuration data, and hopefully more
    strictly-specking-standalone.spec/registrySourceDoc + Usages
    returns the registry map, prefer 'get-spec' to lookup a spec by name

    carbonite 1.5.0
    Write Clojure data to and from bytes using Kryo.
    carbonite.api/read-bufferSourceDoc + Usages
    Read serialized object from byte-buffer using registry.

    carbonite 1.5.0
    Write Clojure data to and from bytes using Kryo.
    carbonite.buffer/ensure-bufferSourceDoc + Usages
    Create or return a Thread-specific scratch buffer for a kryo registry

    hara.io.file 2.8.6
    patterns and utilities
    hara.io.file.attribute/lookup-groupSourceDoc + Usages
    lookup the user registry for the name
     
       (lookup-group "WRONG")
       => (throws)

    hara.io.file 2.8.6
    patterns and utilities
    hara.io.file.attribute/lookup-ownerSourceDoc + Usages
    lookup the user registry for the name
     
       (lookup-owner "WRONG")
       => (throws)

    clj-debug 0.7.6
    Library for debugging Clojure programms with support for tracing, timing and inspection.
    debug.intercept/create-type-keySourceDoc + Usages
    Create a key for the given namespace and symbol of the type that is used in the registry.

    clj-debug 0.7.6
    Library for debugging Clojure programms with support for tracing, timing and inspection.
    debug.intercept/create-function-keySourceDoc + Usages
    Create a key for the given namespace and symbol of the function that is used in the registry.

    re-view-hiccup 0.1.15
    Hiccup parser for re-view
    cljs.spec.alpha/registry (cljs)SourceDoc + Usages
    returns the registry map, prefer 'get-spec' to lookup a spec by name

    trapperkeeper-metrics 1.1.0
    Trapperkeeper Metrics Service
    puppetlabs.trapperkeeper.services.metrics.metrics-core/jmx-reporterSourceDoc + Usages
    Inputs: [registry :- MetricRegistry domain :- (schema/maybe schema/Keyword)]
      Returns: JmxReporter

    pretty-spec 0.1.3
    A pretty printer for clojure.spec forms.
    cljs.spec.alpha/registry (cljs)SourceDoc + Usages
    returns the registry map, prefer 'get-spec' to lookup a spec by name

    farmhand 0.9.1
    Simple and powerful background jobs
    farmhand.queue/scheduled-cleanupSourceDoc + Usages
    Function for handling jobs that have expired from the schedule registry.

    farmhand 0.9.1
    Simple and powerful background jobs
    farmhand.queue/in-flight-cleanupSourceDoc + Usages
    Function for handling jobs that have expired from the in flight registry.

    farmhand 0.9.1
    Simple and powerful background jobs
    farmhand.registry/fetch-ready-idSourceDoc + Usages
    Fetches the next job-id that is ready to be popped off the registry.

    macros 0.2.63
    Clojure macros for web and mobile development
    workflo.macros.registry/defregistrySourceDoc + Usages
    Defines a registry with the given name. See defregistry* for
       more information.

    iron 0.4.0
    Front-end utilities and support for ClojureScript and re-frame projects
    cljs.spec.alpha/registry (cljs)SourceDoc + Usages
    returns the registry map, prefer 'get-spec' to lookup a spec by name

    reagent-slider 0.1.2
    Reagent wrapper around react-components/slider
    cljs.spec/registry (cljs)SourceDoc + Usages
    returns the registry map, prefer 'get-spec' to lookup a spec by name

    returns the registry map, prefer 'get-spec' to lookup a spec by name

    fsmviz 0.1.3
    Generate Graphviz diagrams from FSM data.
    cljs.spec.alpha/registry (cljs)SourceDoc + Usages
    returns the registry map, prefer 'get-spec' to lookup a spec by name

    swot-clj 1.1.2
    Clojure port of the 'swot' Ruby gem to validate academic email addresses and domains
    swot-clj.core/blacklistSourceDoc + Usages
    Returns a vector of blacklisted domains, such as those that snuck into the
      .edu registry.

    budb 0.0.1
    A CRDT Database for Clojure(script)
    cljs.spec/registry (cljs)SourceDoc + Usages
    returns the registry map, prefer 'get-spec' to lookup a spec by name

    budb 0.0.1
    A CRDT Database for Clojure(script)
    cljs.spec/registry (cljs)SourceDoc + Usages
    returns the registry map, prefer 'get-spec' to lookup a spec by name

    discord.clj 1.1.0
    A library for creating Discord bots in Clojure.
    discord.bot/register-extension-docs!SourceDoc + Usages
    Add the documentation for this particular extension to the global extension documentation
       registry.

    aramis 0.1.1
    A library providing a Promise.all()-like capabilities for re-frame.
    cljs.spec/registry (cljs)SourceDoc + Usages
    returns the registry map, prefer 'get-spec' to lookup a spec by name

    lemonade 0.3.0
    High level language for graphical and UI programming. No markup.
    cljs.spec.alpha/registry (cljs)SourceDoc + Usages
    returns the registry map, prefer 'get-spec' to lookup a spec by name

    lemonade 0.3.0
    High level language for graphical and UI programming. No markup.
    cljs.spec.alpha/registry (cljs)SourceDoc + Usages
    returns the registry map, prefer 'get-spec' to lookup a spec by name

    prom-metrics 0.3-alpha1
    Clojure Wrappers for the Prometheus Java Client.
    prometheus.alpha/dump-metricsSourceDoc + Usages
    Dumps metrics of the default registry using simple client's text format.

    ventas 0.0.6
    The Ventas eCommerce platform
    cljs.spec.alpha/registry (cljs)SourceDoc + Usages
    returns the registry map, prefer 'get-spec' to lookup a spec by name

    ventas 0.0.6
    The Ventas eCommerce platform
    cljs.spec.alpha/registry (cljs)SourceDoc + Usages
    returns the registry map, prefer 'get-spec' to lookup a spec by name

    anki-cljs 0.1.1
    CLJS interface for interacting with Anki
    cljs.spec.alpha/registry (cljs)SourceDoc + Usages
    returns the registry map, prefer 'get-spec' to lookup a spec by name

    rejax 0.1.0
    A library that creates nicer API for usage of cljs-ajax in Re-frame
    cljs.spec.alpha/registry (cljs)SourceDoc + Usages
    returns the registry map, prefer 'get-spec' to lookup a spec by name

    com.wsscode.spec-inspec 0.1.0
    FIXME: write description
    com.wsscode.spec-inspec/registry-lookupSourceDoc + Usages
    Look for the key in registry, if not found try key spec parent recursively.

    cmr-client 0.1.0
    A Clojure(Script) Client for NASA's Common Metadata Repository
    cljs.spec.alpha/registry (cljs)SourceDoc + Usages
    returns the registry map, prefer 'get-spec' to lookup a spec by name

    nudge 0.1.0
    A Clojure(Script) library for returning user friendly messages from spec explanations.
    nudge.core/registrySourceDoc + Usages
    returns the registry map, prefer 'get-msg' to lookup a message by name

    fastmath 0.1.1
    Fast and primitive math library
    fastmath.core/smoothstepSourceDoc + Usages
    GL [smoothstep](https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/smoothstep.xhtml).

    hara.benchmark 2.8.4
    patterns and utilities
    hara.benchmark/remove-benchmarkSourceDoc + Usages
    remove benchmark from the registry
     
       (remove-benchmark (:id bench))

    cloth 0.3.1
    Clojure(Script) tools for Ethereum
    cljs.spec/registry (cljs)SourceDoc + Usages
    returns the registry map, prefer 'get-spec' to lookup a spec by name

    returns the registry map, prefer 'get-spec' to lookup a spec by name

    core.storage 20170421.162221
    cljs.spec/registry (cljs)SourceDoc + Usages
    returns the registry map, prefer 'get-spec' to lookup a spec by name

    tyan-a-bumfit yan.tan.tethera
    Implementation of the Yan Tan Tethera sheep-counting system
    cljs.spec/registry (cljs)SourceDoc + Usages
    returns the registry map, prefer 'get-spec' to lookup a spec by name

    returns the registry map, prefer 'get-spec' to lookup a spec by name

    reagent-quill 0.1.1
    Reagent wrapper around react-quill
    cljs.spec/registry (cljs)SourceDoc + Usages
    returns the registry map, prefer 'get-spec' to lookup a spec by name

    docker 0.2.0
    A work in progress docket API client
    docker.image/pushSourceDoc + Usages
    Push the image on the registry
      Arguments:
        client  -  the initialized client for docker api
        image   -  the name of the image
      Optional arguments:
        :registry - the url of your registry
      Response:
        a lazy-seq of a parsed json stream
      Usage:
        (push client "lapax/tiny-haproxy")
        (push client "lapax/tiny-haproxy" :registry "http://url")

    district0x 0.1.20
    district0x Frontend Library
    cljs.spec.alpha/registry (cljs)SourceDoc + Usages
    returns the registry map, prefer 'get-spec' to lookup a spec by name

    conwip.modules 0.1.0
    Library for dynamically loading ClojureScript modules
    cljs.spec/registry (cljs)SourceDoc + Usages
    returns the registry map, prefer 'get-spec' to lookup a spec by name

    conwip.modules 0.1.0
    Library for dynamically loading ClojureScript modules
    cljs.spec/registry (cljs)SourceDoc + Usages
    returns the registry map, prefer 'get-spec' to lookup a spec by name

    schmetrics 0.3.0
    Clojure Bindings for metrics
    schmetrics.registry/remove-metricSourceDoc + Usages
    Removes the metric from the registry. Returns true if the metric was removed, false otherwise.

    pine 0.1.6
    A Clojure/ClojureScript router designed for universal applications.
    cljs.spec.alpha/registry (cljs)SourceDoc + Usages
    returns the registry map, prefer 'get-spec' to lookup a spec by name

    gadjett 0.5.2
    Inspector tools for clojure[script]
    cljs.spec/registry (cljs)SourceDoc + Usages
    returns the registry map, prefer 'get-spec' to lookup a spec by name

    plaza 0.2.0-alpha1
    Plaza framework for semantic distributed applications
    plaza.rdf.core/find-ns-registry-by-uriSourceDoc + Usages
    Checks if a provided namespace has an associated uri in the registry of namespaces

    plaza 0.2.0-alpha1
    Plaza framework for semantic distributed applications
    plaza.rdf.core/find-ns-registrySourceDoc + Usages
    Checks if a provided namespace has an associated uri in the registry of namespaces

    rui 0.3.0
    UI components based on Reagent and Re-frame
    cljs.spec.alpha/registry (cljs)SourceDoc + Usages
    returns the registry map, prefer 'get-spec' to lookup a spec by name

    sponge-clj v0.2.10
    Clojure DSL for Sponge
    sponge-clj.sponge/get-catalog-typeSourceDoc + Usages
    Returns catalog type from sponge registry or nil if it is absent

    kern 1.1.0
    A Parser Combinators Library
    cljs.spec.alpha/registry (cljs)SourceDoc + Usages
    returns the registry map, prefer 'get-spec' to lookup a spec by name

    uri-handler 1.1.0
    A Library which will search the classpath to load URI handlers
    uri-handler.core/uri-handlersSourceDoc + Usages
    Returns the registry of uri handlers, optionally limited by scope and scheme

    inspectable 0.2.2
    Tools for clojure.spec
    cljs.spec.alpha/registry (cljs)SourceDoc + Usages
    returns the registry map, prefer 'get-spec' to lookup a spec by name

    kurosawa.core 2.0.1
    The root Kurosawa library.
    org.purefn.kurosawa.spec/registrySourceDoc + Usages
    Returns the registry map, keyed by spec name, with documentation metadata
       on each spec.

    specql 20180312
    PostgreSQL spec query language
    specql.impl.registry/composite-typeSourceDoc + Usages
    Find user defined composite type from registry by name.

    metrics-clojure 2.10.0
    A Clojure façade for Coda Hale's metrics library.
    metrics.core/remove-metricsSourceDoc + Usages
    Remove all the metrics matching the given predicate in the given
      repository, or the default registry if no registry given. The
      predicate takes one argument, the name of the metric.

    hara.concurrent.procedure 2.8.6
    patterns and utilities
    hara.concurrent.procedure.registry/killSourceDoc + Usages
    kills the running instance in the registry
     
       (-> (data/registry)
           (add-instance "hello" :1 {:thread (future (Thread/sleep 100000))})
           (kill "hello" :1))
       => true

    hara.concurrent.procedure 2.8.6
    patterns and utilities
    hara.concurrent.procedure.registry/remove-instanceSourceDoc + Usages
    removes something from the registry
     
       (-> (data/registry)
           (add-instance "hello" :1 {:a 1})
           (remove-instance "hello" :1)
           (into {})
           :store
           deref)
      => {}

    Inputs: [metric-registry :- MetricRegistry]
      Returns: (schema/maybe common/AllMetrics)
    
      Returns the http client-specific metrics from the metric registry.

    trapperkeeper-metrics 1.1.0
    Trapperkeeper Metrics Service
    puppetlabs.metrics/registerSourceDoc + Usages
    Inputs: [registry :- MetricRegistry metric-name :- schema/Str metric :- Metric]
      Returns: Metric
    
      Register a metric with a metrics registry, using the given metric name.

    clomponents 0.5.2
    component configuration for clojure
    clomponents.core/create-registrySourceDoc + Usages
    create a registry of clomponents from a hash of configuration. clomponent
       objects will be registered against the same keys in the registry that their
       config is registered against in the config

    clj-apache-https 1.0.18
    Clojure HTTP library using the Apache HttpClient. Based on clj-apache-http, but
    com.twinql.clojure.async-libs/scheme-registrySourceDoc + Usages
    Creates a scheme registry using the given socket factory to connect
       on the port you specify. This scheme registry is suitable for the async
       http client.

    clj-apache-https 1.0.18
    Clojure HTTP library using the Apache HttpClient. Based on clj-apache-http, but
    com.twinql.clojure.sync-libs/scheme-registrySourceDoc + Usages
    Creates a scheme registry using the given socket factory to connect
       on the port you specify. This scheme registry is suitable for the normal
       (synchronous) connection manager and client.

    kafkakit 0.5.0
    A go-to kit for working with Confluent Kafka in componentized Clojure projects.
    kafkakit.component.schema-registry/latest-schema~SchemaRegistry~SchemaRegistryAvroFetcherSourceDoc + Usages
    Reads the latest Avro schema with the given subject name from the schema
        registry.
    
        Params:
          component: The component.
          subject: The Schema Registry topic for which the schema will be fetched.

    kafkakit 0.5.0
    A go-to kit for working with Confluent Kafka in componentized Clojure projects.
    kafkakit.component.schema-registry/latest-schemaSourceDoc + Usages
    Reads the latest Avro schema with the given subject name from the schema
        registry.
    
        Params:
          component: The component.
          subject: The Schema Registry topic for which the schema will be fetched.

    hara.concurrent.procedure 2.8.6
    patterns and utilities
    hara.concurrent.procedure.middleware/wrap-interruptSourceDoc + Usages
    interrupts the existing procedure
     
       (do ((procedure {:name "hello"
                        :id :1
                        :handler (fn [] (Thread/sleep 1000000000))} []))
     
           (map :id (registry/list-instances
                     registry/*default-registry*
                     "hello")))
       => '(:1)
     
       (do ((procedure {:name "hello"
                        :id :1
                        :interrupt true
                        :handler (fn [] :FAST)} []))
           (map :id (registry/list-instances
                    registry/*default-registry*
                     "hello")))
       => ()

    Inputs: [metrics-config :- MetricsConfig registry-settings :- {schema/Any DefaultRegistrySettings} domain :- schema/Keyword]
      Returns: #{schema/Str}
    
      Get the metrics allowed for the registry. Looks at the metrics-allowed registered for the
      registry in the registry settings atom using the `update-registry-settings` function as well
      as the metrics-allowed listed in the config file under the `:metrics-allowed` key. Merges these
      lists together and then adds the metrics prefix to them, returning a set of prefixed allowed
      metrics.

    Use the given [[exception-counter]] to collect any Exceptions thrown within
       the given piece of code.
    
       ```
       (defonce registry
         (-> (prometheus/collector-registry)
             (prometheus/register
               (exeception-counter :app/exceptions-total))))
    
       (with-exceptions (registry :app/exceptions-total)
         ...)
       ```
    
       The exception class will be stored in the counter's `exceptionClass` label.

    iapetos 0.1.8
    A Clojure Prometheus Client
    iapetos.core/start-timerSourceDoc + Usages
    Start a timer that, when stopped, will store the duration in the given
       metric. This can be either called using a registry and metric name or a
       collector:
    
       ```
       (-> registry (start-timer :app/duration-seconds))
       (-> registry :app/duration-seconds (start-timer))
       ```
    
       The return value will be a _function_ that should be called once the
       operation to time has run.

    funnyqt 1.1.5
    A model querying and transformation library for TGraphs and EMF models developed
    funnyqt.emf/load-ecore-resourceSourceDoc + Usages
    Loads an Ecore model from the ecore file `f`.
      All EPackages are registered at the *epackage-registry* which defaults to the
      global registry.  The Ecore model is returned as a Resource.  `f` may be a
      file name given as string, a java.io.File, an URI, or a java.net.URL.  Also
      see `with-epackage-registry`.

    structgen 0.2.1
    Interop library for working with native C structs and binary formats in general.
    thi.ng.structgen.core/with-registrySourceDoc + Usages
    Binds the type `*registry*` to the supplied map and executes body
      in a `do` form. The given registry value is automatically wrapped
      in or converted to a ref (if not already).
      If the custom registry is supposed to be used outside the macro
      scope at a later time, it **must** already be wrapped in a ref.

    Inputs: [{:keys [registries metrics-config]} :- MetricsServiceContext domain :- schema/Keyword]
      Returns: RegistryContext
    
      If a registry exists within the service context for a given domain
      already, return it.
      Otherwise initialize a new registry for that domain and return it.
      Modifies the registries atom in the service context to add the new registry

    docker 0.2.0
    A work in progress docket API client
    docker.image/createSourceDoc + Usages
    Creates an new image by pulling source from index.
      Arguments:
        client - initialized docker client
        image - name of docker image
      Optional arguments:
        :repo - name of repository
        :tag - image's tag
        :registry - to specify url
      Usage:
        (create client "registry")
        (create client "registry" :tag "latest")

    iapetos 0.1.8
    A Clojure Prometheus Client
    iapetos.export/with-push-gatewaySourceDoc + Usages
    Create a [[pushable-collector-registry]], run the given block of code, then
       push all collected metrics.
    
       ```
       (with-push-gateway [registry {:job "my-job", :push-gateway "0:8080"}]
         ...)
       ```

    hara.concurrent.procedure 2.8.6
    patterns and utilities
    hara.concurrent.procedure.registry/get-instanceSourceDoc + Usages
    lists all items in the registry
     
       (-> (data/registry)
           (add-instance  "hello" :1 {:a 1})
           (add-instance "hello" :2 {:b 1})
           (get-instance "hello" :2))
       => {:b 1}

    hara.concurrent.procedure 2.8.6
    patterns and utilities
    hara.concurrent.procedure.registry/list-instancesSourceDoc + Usages
    lists all items in the registry
     
       (-> (data/registry)
           (add-instance  "hello" :1 {:a 1})
           (add-instance  "hello" :2 {:b 1})
           (list-instances "hello"))
       => [{:a 1} {:b 1}]

    Inputs: [context :- MetricsServiceContext]
      Returns: MetricsServiceContext
    
      Switch the `can-update-registry-settings?` boolean to false to show that it is after the `init`
      phase and registry settings can no longer be set.

    Inputs: [registry :- MetricRegistry metrics-allowed :- #{schema/Str} graphite-sender :- GraphiteSender]
      Returns: GraphiteReporter
    
      Constructs a GraphiteReporter instance for the given registry, with the given allowed metrics,
      and using the given graphite-sender

    Allows for specifying settings for a metric registry reporter that don't
       go into a config file. Must be called during the 'init' phase of a
       service's lifecycle. Will error if called more than once per metric
       registry.

    kafka-avro-confluent 0.1.0
    An Avro Kafka De/Serializer lib that works with Confluent's Schema Registry
    kafka-avro-confluent.deserializers/->avro-deserializerSourceDoc + Usages
    Avro deserializer for Apache Kafka using Confluent's Schema Registry.
      Use for deserializing Kafka keys and values.
       See https://avro.apache.org/
       See http://docs.confluent.io/current/schema-registry/docs
       See https://github.com/damballa/abracad

    objection 0.1.1
    Manages global resources.
    objection.core/stop!SourceDoc + Usages
    Runs the stopfn of `x` or the type specific AutoStoppable impl. e.g on AutoCloseable objects .close will be called.
    
      Removes the object from the registry.
    
      If an exception is thrown when stopping the object, it will remain in the registry, use the :force? option to unregister
      on error.

    Given a string like "clojure.core/let" or ":user/email" returns
      the associated spec in the registry, if there is one.

    Retrieves a list of all specs in the registry, sorted by ns/name.
      If filter-regex is not empty, keep only the specs with that prefix.

    iapetos 0.1.8
    A Clojure Prometheus Client
    iapetos.collector.fn/wrap-instrumentationSourceDoc + Usages
    Wrap the given function to write a series of execution metrics to the given
       registry. See [[initialize]].

    iapetos 0.1.8
    A Clojure Prometheus Client
    iapetos.export/with-pushSourceDoc + Usages
    Use the given [[pushable-collector-registry]] to push metrics after the given
       block of code has run successfully.

    Add the given `iapetos.collector/Collector` to the registry using the
         given name, but only actually register it on first use.

    iapetos 0.1.8
    A Clojure Prometheus Client
    iapetos.export/write-text-format!SourceDoc + Usages
    Dump the given registry to the given writer using the Prometheus text format
       (version 0.0.4).

    Add the given `iapetos.collector/Collector` to the registry using the
         given name, but only actually register it on first use.

    iapetos 0.1.8
    A Clojure Prometheus Client
    iapetos.registry/register-lazySourceDoc + Usages
    Add the given `iapetos.collector/Collector` to the registry using the
         given name, but only actually register it on first use.

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.constants/cl-device-svm-capabilitiesSourceDoc + Usages
    Context properties defined in OpenCL standard.
    See http://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clGetDeviceInfo.html

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.constants/cl-context-propertiesSourceDoc + Usages
    Context properties defined in OpenCL standard.
    See http://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clGetDeviceInfo.html

    trackit-core 0.7.1
    TRACKit! A Clojure developer friendly wrapper for Yammer's Metrics library.
    samsara.trackit.reporter/start-reportingSourceDoc + Usages
    Starts the reporting with the given configuration for the `registry`.
       It returns a function which when called it stops the reporter.

    trackit-core 0.7.1
    TRACKit! A Clojure developer friendly wrapper for Yammer's Metrics library.
    samsara.trackit/remove-metricSourceDoc + Usages
    Removes the given metric from the registry causing.
       After this call the given metric won't be reported any longer.

    carbonite 1.5.0
    Write Clojure data to and from bytes using Kryo.
    carbonite.api/write-bufferSourceDoc + Usages
    Write serialized obj into ByteBuffer using registry.  If the buffer
      is not big enough, a SerializationException will be thrown.

    carbonite 1.5.0
    Write Clojure data to and from bytes using Kryo.
    carbonite.api/new-registrySourceDoc + Usages
    Create a new Kryo registry that supports unregistered classes and defers to the
       kryo-extend multimethod if an unhandled Class serializer is requested.

    spec-tools 0.7.0
    Clojure(Script) tools for clojure.spec
    spec-tools.core/deserializeSourceDoc + Usages
    Reads specs from a string.
      TODO: Should optionally read the realated Registry entries.

    spec-tools 0.7.0
    Clojure(Script) tools for clojure.spec
    spec-tools.core/serializeSourceDoc + Usages
    Writes specs into a string that can be read by the reader.
      TODO: Should optionally write the realated Registry entries.

    clj-debug 0.7.6
    Library for debugging Clojure programms with support for tracing, timing and inspection.
    debug.intercept.registry/update-registrySourceDoc + Usages
    Update the interception registry by adding another interception function for the given key.
      The info-prefix is used in the interception notification. 
      

    structgen 0.2.1
    Interop library for working with native C structs and binary formats in general.
    thi.ng.structgen.core/make-registrySourceDoc + Usages
    Builds a vanilla type registry populated only with standard C
      and OpenCL primitive types.

    riemann 0.3.1
    A network event stream processor. Intended for analytics, metrics, and alerting;
    riemann.pubsub/pubsub-registrySourceDoc + Usages
    Returns a new pubsub registry, which tracks which subscribers are
      listening to which channels.

    riemann 0.3.1
    A network event stream processor. Intended for analytics, metrics, and alerting;
    riemann.config/publishSourceDoc + Usages
    Returns a stream which publishes events to the given channel. Uses this
      core's pubsub registry.

    riemann 0.3.1
    A network event stream processor. Intended for analytics, metrics, and alerting;
    riemann.pubsub/pubsub-registrySourceDoc + Usages
    Returns a new pubsub registry, which tracks which subscribers are
      listening to which channels.

    riemann 0.3.1
    A network event stream processor. Intended for analytics, metrics, and alerting;
    riemann.config/publishSourceDoc + Usages
    Returns a stream which publishes events to the given channel. Uses this
      core's pubsub registry.

    precept 0.5.0-alpha
    A declarative programming framework
    precept.core/register-ruleSourceDoc + Usages
    Returns rule name if found in registry, else registers new rule and returns name

    precept 0.5.0-alpha
    A declarative programming framework
    precept.macros/existing-session-defSourceDoc + Usages
    Returns session definition hash-map matching session-name from registry in compiler-env or nil
      if no match found

    macros 0.2.63
    Clojure macros for web and mobile development
    workflo.macros.screen.om-next/reload-active-screen! (cljs)SourceDoc + Usages
    Reloads the implementation of the active screen by replacing
       it with a freshly resolved instance from the screen registry.

    redirects 0.2.0
    Canonical redirects for your URL.
    invetica.redirects/canonical-redirectSourceDoc + Usages
    Given a registry (i.e. hash-map) of hosts, returns a Ring-compatible redirect
      if there's a canonical URL that should be used instead.

    cynomys 0.2.0
    A middleware library
    cynomys.core/deregister-channelSourceDoc + Usages
    This removes a channel from the channel registry.
    It also closes it and removes any bindings so it can be collected by the gc.

    future-spec-tools 0.3.3
    Clojure(Script) tools for clojure-spec-tools
    spec-tools.core/deserializeSourceDoc + Usages
    Reads specs from a string.
      TODO: Should optionally read the realated Registry entries.

    future-spec-tools 0.3.3
    Clojure(Script) tools for clojure-spec-tools
    spec-tools.core/serializeSourceDoc + Usages
    Writes specs into a string that can be read by the reader.
      TODO: Should optionally write the realated Registry entries.

    discord.clj 1.1.0
    A library for creating Discord bots in Clojure.
    discord.bot/register-extension!SourceDoc + Usages
    Creates a mapping between the supplied extension name and the handler function in the global
       extension registry.

    nudge 0.1.0
    A Clojure(Script) library for returning user friendly messages from spec explanations.
    nudge.core/defSourceDoc + Usages
    Given a namespace-qualified keyword or resolvable symbol k, and a string message msg
      makes an entry in the registry mapping k to the msg

    pedestal.vase 0.9.3
    Vase: Pedestal API Container
    com.cognitect.vase/specsSourceDoc + Usages
    Given a app-spec or collection of app-specs,
      extract all defined clojure.specs and evaluate them,
      placing them in clojure.spec's registry.

    plaza 0.2.0-alpha1
    Plaza framework for semantic distributed applications
    plaza.rdf.core/expand-nsSourceDoc + Usages
    Provided a pair [ns local] tries to expand the ns with the information in the rdf-ns registry

    objection 0.1.1
    Manages global resources.
    objection.core/alter-data!SourceDoc + Usages
    Applies `f` to the data for the object (i.e supplied under :data key on registry/construct).
      Saves and returns the new data.

    objection 0.1.1
    Manages global resources.
    objection.core/IAutoStoppableSourceDoc + Usages
    A protocol that can be extended to types in order to tell objection how to stop! them if a :stopfn is not provided
      on registry.

    inspectable 0.2.2
    Tools for clojure.spec
    inspectable.spec-utils/spec-listSourceDoc + Usages
    Retrieves a list of all specs in the registry, sorted by ns/name.
      If filter-regex is not empty, keep only the specs with that prefix.

    inspectable 0.2.2
    Tools for clojure.spec
    inspectable.spec-utils/spec-listSourceDoc + Usages
    Retrieves a list of all specs in the registry, sorted by ns/name.
      If filter-regex is not empty, keep only the specs with that prefix.

    kurosawa.core 2.0.1
    The root Kurosawa library.
    org.purefn.kurosawa.spec/defSourceDoc + Usages
    Registers a spec with optional given docstring. Also calls out
       clojure's spec registry to register the spec, if name is
       registerable.

    Inputs: [metrics-config :- MetricsConfig]
      Returns: {schema/Any RegistryContext}
    
      Read through the config and create a MetricsRegistry (+ JMX reporter if configured) for every
      registry mentioned in it. Also create the default registry if not mentioned in the config. Should
      be called from `init` of the metrics-service.

    Inputs: [registry-context :- RegistryContext graphite-config :- (schema/maybe GraphiteReporterConfig) metrics-allowed :- #{schema/Str} domain :- schema/Keyword]
      Returns: RegistryContext
    
      Adds a graphite reporter to the given registry context if graphite
      is enabled in the configuration. Starts up a thread which reports the metrics
      to graphite on the interval specified in :update-interval-seconds

    trapperkeeper-comidi-metrics 0.1.2
    Comidi/HTTP Metrics for Trapperkeeper
    puppetlabs.metrics.http/register-metrics-for-endpointSourceDoc + Usages
    Inputs: [registry :- MetricRegistry total-requests :- Timer metric-name-fn :- (schema/pred ifn?) acc :- TimersMap endpoint :- schema/Str]
      Returns: TimersMap
    
      Initialize metrics for an http endpoint and add them to the registry.  This
      includes a Timer for the endpoint itself, and a Ratio to track the percentage
      of total requests that were directed to this endpoint.

    kafka-avro-confluent 0.1.0
    An Avro Kafka De/Serializer lib that works with Confluent's Schema Registry
    kafka-avro-confluent.serializers/->avro-serializerSourceDoc + Usages
    Avro serializer for Apache Kafka using Confluent's Schema Registry.
      Use for serializing Kafka keys values.
      Values will be serialized according to the provided schema.
       See https://avro.apache.org/
       See http://docs.confluent.io/current/schema-registry/docs
       See https://github.com/damballa/abracad

    Given a namespace-qualified keyword or resolveable symbol k, and a spec,
       spec-name, predicate or regex-op makes an entry in the registry mapping k to
       the spec

    spec.alpha 0.1.143
    Specification of data and functions
    clojure.spec.alpha/defSourceDoc + Usages
    Given a namespace-qualified keyword or resolvable symbol k, and a
      spec, spec-name, predicate or regex-op makes an entry in the
      registry mapping k to the spec

    clojure-future-spec 1.9.0-alpha9-1
    Backport of clojure.spec for Clojure 1.8
    clojure.spec/defSourceDoc + Usages
    Given a namespace-qualified keyword or resolvable symbol k, and a
      spec, spec-name, predicate or regex-op makes an entry in the
      registry mapping k to the spec

    charset 1.2.1
    Clojure wrappers around java.nio.charset.Charset
    charset.core/registered?SourceDoc + Usages
    Tells whether or not this Charset is registered in the IANA Charset Registry.
       See for details:
       http://docs.oracle.com/javase/7/docs/api/java/nio/charset/Charset.html#isRegistered()

    iapetos 0.1.8
    A Clojure Prometheus Client
    iapetos.standalone/metrics-serverSourceDoc + Usages
    Expose the metrics contained within the given collector registry using
       the given port and path.
    
       Returns a handle on the standalone server, implementing `java.io.Closeable`.

    funnyqt 1.1.5
    A model querying and transformation library for TGraphs and EMF models developed
    funnyqt.emf/with-ns-urisSourceDoc + Usages
    Restricts the EClassifier lookup in the dynamic scope of `body` to those
      contained in top-level EPackages registered with the given namespace `uris`
      at the EPackage registry and subpackages thereof.

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.constants/cl-command-execution-statusSourceDoc + Usages
    Execution statuses of commands, defined in OpenCL standard.
    See http://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clGetEventInfo.html

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.constants/dec-command-execution-statusSourceDoc + Usages
    Converts `cl_event_command_execution_status` code from number to keyword.
      See http://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clGetEventInfo.html

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.constants/dec-command-typeSourceDoc + Usages
    Converts `cl_event_command_type` code from number to keyword.
      See http://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clGetEventInfo.html

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.constants/cl-kernel-arg-type-qualifierSourceDoc + Usages
    Type quilifiers specified for the argument, defined in OpenCL standard.
    See http://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clGetKernelArgInfo.html

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.constants/dec-kernel-arg-access-qualifierSourceDoc + Usages
    Converts `cl_kernel_arg_access_qualifier` code from number to keyword.
      See http://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clGetKernelArgInfo.html

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.constants/dec-kernel-arg-address-qualifierSourceDoc + Usages
    Converts `cl_kernel_arg_address_qualifier` code from number to keyword.
      See http://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clGetKernelArgInfo.html

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.constants/dec-build-statusSourceDoc + Usages
    Converts `cl_program_build_status` code from number to keyword.
      See https://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clGetProgramBuildInfo.html

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.constants/dec-program-binary-typeSourceDoc + Usages
    Converts `cl_program_binary_type` code from number to keyword.
      See https://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clGetProgramBuildInfo.html

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.constants/cl-map-flagsSourceDoc + Usages
    Map flags used in enqueuing buffer mapping defined in OpenCL standard.
    See http://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clEnqueueMapBuffer.html

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.constants/dec-mem-object-typeSourceDoc + Usages
    Converts `cl_mem_object_type` code from number to keyword.
      See http://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clGetMemObjectInfo.html

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.constants/cl-svm-mem-flagsSourceDoc + Usages
    Memory allocation and usage information defined in OpenCL standard.
    See http://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clSVMAlloc.html

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.constants/cl-mem-flagsSourceDoc + Usages
    Memory allocation and usage information defined in OpenCL standard.
    See http://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clCreateBuffer.html

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.constants/cl-device-affinity-domainSourceDoc + Usages
    Affinity domains for partitioning the device defined in OpenCL standard.
    See http://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clGetDeviceInfo.html

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.constants/dec-device-partition-propertySourceDoc + Usages
    Converts `cl_device_partition_property` code from number to keyword.
    See http://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clGetDeviceInfo.html

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.constants/dec-context-propertiesSourceDoc + Usages
    Converts `cl_context_properties` code from number to keyword.
    See http://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clGetDeviceInfo.html

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.constants/cl-command-queue-propertiesSourceDoc + Usages
    On device command-queue properties defined in OpenCL standard.
    See http://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clGetDeviceInfo.html

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.constants/cl-device-exec-capabilitiesSourceDoc + Usages
    The execution capabilities of the device defined in OpenCL standard.
    See http://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clGetDeviceInfo.html

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.constants/cl-local-mem-typeSourceDoc + Usages
    Types of local memory defined in OpenCL standard.
    See http://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clGetDeviceInfo.html

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.constants/cl-device-mem-cache-typeSourceDoc + Usages
    Types of global memory cache defined in OpenCL standard.
    See http://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clGetDeviceInfo.html

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.constants/cl-device-fp-configSourceDoc + Usages
    Floating point capabilities of the device defined in OpenCL standard.
    See http://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clGetDeviceInfo.html

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.constants/cl-device-typeSourceDoc + Usages
    Types of OpenCL devices defined in OpenCL standard.
    See http://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clGetDeviceIDs.html

    strictly-specking-standalone 0.1.1
    A Clojure library to help validate edn configuration data, and hopefully more
    strictly-specking-standalone.spec/defSourceDoc + Usages
    Given a namespace-qualified keyword or resolvable symbol k, and a
      spec, spec-name, predicate or regex-op makes an entry in the
      registry mapping k to the spec

    Inputs: [metric-registry :- MetricRegistry url :- schema/Str]
      Returns: [common/UrlMetricData]
    
      Returns a summary of the metric data for all http client timers filtered by
      url.

    Inputs: [metric-registry :- MetricRegistry]
      Returns: common/AllMetricsData
    
      Returns a summary of the metric data for all http client timers, organized
      in a map by category.

    Inputs: [metric-registry :- MetricRegistry metric-id :- common/MetricId]
      Returns: common/Metrics
    
      Returns the http client-specific url metrics matching the specified url.

    Inputs: [metric-registry :- MetricRegistry url :- schema/Str]
      Returns: common/Metrics
    
      Returns the http client-specific url metrics matching the specified url.

    Inputs: [config :- MetricsConfig domain :- schema/Keyword]
      Returns: (schema/maybe GraphiteReporterConfig)
    
      Merge together the graphite config for the registry with the global graphite config.

    Inputs: [config :- (schema/maybe RegistryConfig) domain :- schema/Keyword]
      Returns: RegistryContext
    
      Create initial registry context. This will include a MetricsRegistry and a
      JMX reporter, but not a Graphite reporter.

    pneumatic-tubes 0.3.0
    WebSocket based transport of events between re-frame app and server
    pneumatic-tubes.core/add-tube!SourceDoc + Usages
    Registers a new tube in a global registry,
      the send-fn is a function which sends a message via implementation-specific channel like a WebSocket

    clj-terminal 0.1.0-beta
    Wrapper for Java Lanterna lib
    clj-terminal.gui/load-themeSourceDoc + Usages
    load theme from properties file and register it with new name in registry.
      to set loaded theme for components use named-theme fn and new name.

    grape 0.1.7
    The opinionated, data-first, REST, GraphQL and Falcor enabled API Clojure library
    grape.query/validate-querySourceDoc + Usages
    Inputs: [{:keys [hooks resources-registry], :as deps} :- s/Any resource :- s/Any request :- s/Any query :- Query {:keys [recur?]}]

    macros 0.2.63
    Clojure macros for web and mobile development
    workflo.macros.registry/defregistry*SourceDoc + Usages
    Defines a registry with the given name. The resulting registry
       maps names (e.g. screen, view or command names) to definitions
       (e.g. the definition of a screen, a command or a view).
    
       Definitions in the registry can be looked up using one of the
       utility functions that are defined implicitly.
    
       (defregistry* 'command)
       (defregistry* 'command
                     (fn [event entity-name]
                       ...))
    
       will result in the following functions to be defined:
    
       (defn register-command! [name def] ...)
       (defn unregister-command! [name] ...)
       (defn registered-commands [] ...)
       (defn reset-registered-commands! [] ...)
       (defn resolve-command [name] ...).

    iapetos 0.1.8
    A Clojure Prometheus Client
    iapetos.collector.ring/wrap-metrics-exposeSourceDoc + Usages
    Expose Prometheus metrics at the given constant URI using the text format.
    
       If `:on-request` is given, it will be called with the collector registry
       whenever a request comes in (the result will be ignored). This lets you use
       the Prometheus scraper as a trigger for metrics collection.

    iapetos 0.1.8
    A Clojure Prometheus Client
    iapetos.core/subsystemSourceDoc + Usages
    Create a new registry bound to the given subsystem. The resulting value will
       not have access to any of the original registry's collectors.
    
       Subsystems can be nested, resulting in joining the subsystem names with
       underscores.

    re-view 0.4.15
    ClojureScript React Library
    re-view.view-spec/resolve-spec (cljs)SourceDoc + Usages
    Resolves a spec. Keywords are looked up in the spec registry recursively until a function or set is found.
      If a map's :spec is a namespaced keyword, it is resolved and merged (without overriding existing keys)

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.core/num-platformsSourceDoc + Usages
    The number of available OpenCL platforms.
    
      See http://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clGetPlatformIDs.html
      and http://www.jocl.org/doc/org/jocl/CL.html#clGetPlatformIDs-int-org.jocl.cl_platform_id:A-int:A-
      

    Inputs: [metric-registry :- MetricRegistry metric-id :- common/MetricId]
      Returns: [common/MetricIdMetricData]
    
      Returns a summary of the metric data for all http client timers filtered by
      metric-id.

    Inputs: [metric-registry :- MetricRegistry url :- schema/Str method :- common/HTTPMethod]
      Returns: [common/UrlAndMethodMetricData]
    
      Returns a summary of the metric data for all http client timers filtered by
      url and method.

    Inputs: [metric-registry :- MetricRegistry url :- schema/Str method :- common/HTTPMethod]
      Returns: common/Metrics
    
      Returns the http client-specific url metrics matching the specified url.

    Provides access to a MetricsRegistry where `domain` is the string used to
         look up the registry. Specifing no `domain` will return the default
         MetricsRegistry. The `domain` is the name that will appear at the front of
         the JMX metric. For example in `foo:name=my-metric`, `foo` is the
         `domain`.

    trapperkeeper-comidi-metrics 0.1.2
    Comidi/HTTP Metrics for Trapperkeeper
    puppetlabs.metrics.http/register-http-metricsSourceDoc + Usages
    Inputs: [registry :- MetricRegistry total-requests :- Timer metric-name-fn :- (schema/pred ifn?) route-names :- [schema/Str]]
      Returns: TimersMap
    
      Initialize metrics for a list of http endpoints.

    clj-service-locator 0.3.0
    Clojure Service Locator library.
    clj-service-locator.core/missing-functionsSourceDoc + Usages
    Returns a list of missing functions (not defined in the registered namespace) of the
      registered service-key parameters.  Returns nil is the service-key doesn't exist in the
      registry and/or if the service-key namespace has complete coverage of the service functions.

    cynomys 0.2.0
    A middleware library
    cynomys.core/register-channelSourceDoc + Usages
    This registers a new channel in the channel registry.
    This also adds a link point for middleware, usable as :ch-chname, e.g. :ch-toserver
    chname: A keyword which is used as the name of this channel.
    channel: The channel itself.

    com.chpill.re-frankenstein 0.0.2
    The deviant fork of re-frame
    re-frame.frank/swap-stateful-interceptors! (cljs)SourceDoc + Usages
    Modifies the registry value by replacing the handlers that refer refer to the
      global app-db with very similar handlers that refer to the local-db provided
      as argument. Then swap registered stateful interceptors to use new local ones

    docker 0.2.0
    A work in progress docket API client
    docker.image/deleteSourceDoc + Usages
    Remove image from filesystem
      Arguments:
        client - initialized docker client
        image-name - name of image
      Optional arguments:
        :force - ignore possible errors while removing it, default false.
      Usage:
        (delete client "registry")

    clj-ioc 0.2.0
    Clojure Inversion-of-Control (IOC) library.
    clj-ioc.core/missing-functionsSourceDoc + Usages
    Returns a list of missing functions (not defined in the registered namespace) of the
       registered ioc-key parameters.  Returns nil is the ioc-key doesn't exist in the
      registry and/or if the ioc-key'd namespace has complete coverage of the IOC functions.

    riemann 0.3.1
    A network event stream processor. Intended for analytics, metrics, and alerting;
    riemann.config/subscribeSourceDoc + Usages
    Subscribes to the given channel with f, which will receive events. Uses the
      current core's pubsub registry always, because the next core's registry will
      be discarded by core/transition.
    
      Returns a single-arity function that does nothing with its inputs and, when
      invoked, returns the subscription you created. Why do this weird thing? So
      you can pretend (subscribe ...) is a stream, and use it in the same context
      as your other streams, like (publish).

    riemann 0.3.1
    A network event stream processor. Intended for analytics, metrics, and alerting;
    riemann.config/subscribeSourceDoc + Usages
    Subscribes to the given channel with f, which will receive events. Uses the
      current core's pubsub registry always, because the next core's registry will
      be discarded by core/transition.
    
      Returns a single-arity function that does nothing with its inputs and, when
      invoked, returns the subscription you created. Why do this weird thing? So
      you can pretend (subscribe ...) is a stream, and use it in the same context
      as your other streams, like (publish).

    funnyqt 1.1.5
    A model querying and transformation library for TGraphs and EMF models developed
    funnyqt.emf/eclassifierSourceDoc + Usages
    Returns the eclassifier with the given `name`.
      `name` may be a simple, qualified name, or a map of the form {nsURI name}.
      In the latter case, the lookup is restricted to the package with the given
      nsURI (and its subpackages).
      Throws an exception if no such classifier could be found, or if the given
      simple name is ambiguous.
      Also see: `with-ns-uris` and `with-epackage-registry`

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.core/flush!SourceDoc + Usages
    Issues all previously queued OpenCL commands in a command-queue to the device
      associated with the command-queue.
    
      See https://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clFlush.html,
      http://www.jocl.org/doc/org/jocl/CL.html#clFinish-org.jocl.cl_command_queue-
    
      Example:
    
          (flush! my-queue)
      

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.core/host-eventSourceDoc + Usages
    Creates new `cl_event` on the host (in OpenCL terminology,
      known as "user" event.
    
      If called without `ctx` argument, uses [[*context*]].
    
      If `ctx` is `nil`, throws ExceptionInfo
    
      See https://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clCreateUserEvent.html,
      http://www.jocl.org/doc/org/jocl/CL.html#clCreateUserEvent-org.jocl.cl_context-int:A-
      

    Inputs: [{:keys [ssl-context ssl-ca-cert ssl-cert ssl-key ssl-protocols cipher-suites follow-redirects force-redirects connect-timeout-milliseconds socket-timeout-milliseconds metric-registry server-id metric-prefix enable-url-metrics?]} :- common/ClientOptions]
      Returns: HttpAsyncClient

    Inputs: [context :- MetricsServiceContext domain :- schema/Keyword settings :- DefaultRegistrySettings]
      Returns: {schema/Any DefaultRegistrySettings}
    
      Update the `registry-settings` atom for the given domain. If called again for the same domain,
      the new settings will be merged in, and lists such as :default-metrics-allowed, will be concat'd
      together.

    Inputs: [metrics-config :- MetricsConfig]
      Returns: MetricsServiceContext
    
      Create the initial service context for the metrics-service. Initialize all registries in the
      config, add them to the `registries` atom, and include that in the service context map, along with
      an empty atom for `registry-settings` and the metrics config.

    Inputs: [service-context :- MetricsServiceContext]
      Returns: MetricsServiceContext
    
      Add Graphite reporters to all registries with Graphite enabled in the config, using the
      configured settings for each registry. Returns an updated service context. Should be called from
      `start` of the metrics-service.

    datamos 0.1.6.2
    Messaging platform displaying the capabilities of RDF triples.
    datamos.rdf-content/compose-rdf-messageSourceDoc + Usages
    Returns full message, with values for :datamos/logistic and :datamos/rdf-content.
      Settings is used to retrieve sender. Content is the RDF message to be sent. RCPT is the recepient of the message.
      RCPT is a datamos function defined as a keyword. Example :datamos-fn/registry

    datamos 0.1.6.2
    Messaging platform displaying the capabilities of RDF triples.
    datamos.msg-functions/compose-messageSourceDoc + Usages
    Returns full message, with values for :datamos/logistic and :datamos/rdf-content.
      Settings is used to retrieve sender. Content is the RDF message to be sent. RCPT is the recepient of the message.
      RCPT is a datamos function defined as a keyword. Example :datamos-fn/registry

    strukt 1.1.0
    ClojureScript map factory with shape validation using prost and cljs.spec
    strukt.core/defstruktSourceDoc + Usages
    Define a strukt map factory as fn *name* in current namespace. *type* is optionally a keyword, or the *name* will be keywordized and used. *spec* is a keyword pointing to a spec definiton in the spec registry. *primary-key* is a keyword that represents the main field on the strukt, and will be used for the shorthand primary-key value factory. *defaults* is a map of default values.

    cljain 0.6.0-beta1
    Enjoy JAIN-SIP in Clojure's way.
    cljain.dum/register-to!SourceDoc + Usages
    Send REGISTER sip message to target registry server, and auto refresh register before
      expired.
    
      Notice: please call 'global-set-account' before you call 'register-to!'. in this version,
      use dynamic binding form to bind *current-account* can not work for auto-refresh.

    twilio-rest 1.0.0
    Adapter library for the Twilio web service.
    twilio.messages/ensure-accountSourceDoc + Usages
    Create a new subaccount and associated application with
       the following defaults for new numbers:
       :config {
        :country <two digit country code>
        :area-code <by country>
        :message-url <local URL for replies to numbers>
        :message-url-method <:get or :post>
        :message-status-url <local URL>}
      }
    
      Populates the namespace registry with the current state
      

    hydrox 0.1.17
    dive deeper into your code
    hydrox.analyse/remove-fileSourceDoc + Usages
    removes a file to the folio
       (-> {:project (util/read-project (io/file "example/project.clj"))}
           (add-file (io/file "example/src/example/core.clj"))
           (remove-file (io/file "example/src/example/core.clj"))
           (dissoc :project))
       => {:registry {}
           :references {}
           :namespace-lu {}}

    com.vitalreactor.twilio-rest 0.9.0
    Adapter library for the Twilio web service.
    twilio.messages/ensure-accountSourceDoc + Usages
    Create a new subaccount and associated application with
       the following defaults for new numbers:
       :config {
        :country <two digit country code>
        :area-code <by country>
        :message-url <local URL for replies to numbers>
        :message-url-method <:get or :post>
        :message-status <local URL>}
      }
    
      Populates the namespace registry with the current state
      

    iapetos 0.1.8
    A Clojure Prometheus Client
    iapetos.collector.ring/wrap-instrumentationSourceDoc + Usages
    Wrap the given Ring handler to write metrics to the given registry:
    
       - `http_requests_total`
       - `http_request_latency_seconds`
       - `http_exceptions_total`
    
       Note that you have to call [[initialize]] on your registry first, to register
       the necessary collectors.
    
       Be aware that you should implement `path-fn` (which generates the value for
       the `:path` label) if you have any kind of ID in your URIs – since otherwise
       there will be one timeseries created for each observed ID.
    
       For additional labels in the metrics use `label-fn`, which takes the request
       as a first argument and the response as the second argument.
    
       Since collectors, and thus their labels, have to be registered before they
       are ever used, you need to provide the list of `:labels` when calling
       [[initialize]].

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.core/kernelSourceDoc + Usages
    Creates `cl_kernel` objects for the kernel function specified by `name`,
      or, if the name is not specified, all kernel functions in a `program`.
    
      **Needs to be released after use.**
    
      In case of OpenCL errors during the program build, throws
      `Exceptioninfo`.
    
      See https://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clCreateKernel.html,
      https://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clCreateKernelsInProgram.html,
      http://www.jocl.org/doc/org/jocl/CL.html#clCreateKernel-org.jocl.cl_program-java.lang.String-int:A-
      http://www.jocl.org/doc/org/jocl/CL.html#clCreateKernelsInProgram-org.jocl.cl_program-int-org.jocl.cl_kernel:A-int:A-
      Examples:
    
          (kernel program "dumb_kernel") ; `cl_kernel` object
          (kernel program) ; all kernels in a vector
      

    trapperkeeper-comidi-metrics 0.1.2
    Comidi/HTTP Metrics for Trapperkeeper
    puppetlabs.metrics.http/initialize-http-metrics!SourceDoc + Usages
    Inputs: [registry :- (schema/maybe MetricRegistry) hostname :- schema/Str route-metadata :- comidi/RouteMetadata]
      Returns: (schema/maybe HttpMetrics)
    
      Initialize a MetricRegistry with metrics for a list of HTTP endpoints.  The
      registry will be populated with a `num-cpus` metric for the system, a Counter
      and a Histogram for tracking active requests, and a Timer that will be used
      to measure all requests.  `route-metadata` is the comidi route metadata for
      all of the routes that we want to track metrics for; for each of these, a Timer
      will be initialized, as well as a Ratio that keeps track of the percentage of
      total requests that were directed to the named endpoint.  This function is
      intended for use with the `wrap-with-request-metrics` Ring middleware from
      this library, and the `wrap-with-route-metadata` Ring middleware from comidi.

    hara.io.scheduler 2.8.6
    patterns and utilities
    hara.io.scheduler/start!SourceDoc + Usages
    starts the scheduler
     
       (start! sch)
       ;; => {:ticker {:time #inst "2016-10-25T01:20:06.000-00:00",
       ;;              :array [6 20 8 2 25 10 2016]}
       ;;     :clock {:start-time #inst "2016-10-25T01:18:52.184-00:00",
       ;;             :current-time #inst "2016-10-25T01:20:06.001-00:00",
       ;;             :running true},
       ;;     :cache {},
       ;;     :registry {:print-task-2 (#inst "2016-10-25T01:20:06.000-00:00"),
       ;;                :print-task-1 (#inst "2016-10-25T01:20:05.000-00:00")},
       ;;     :array {:handlers [],
       ;;             :ticker {:time #inst "2016-10-25T01:20:06.000-00:00",
       ;;                      :array [6 20 8 2 25 10 2016]}
       ;;             :registry {:print-task-2 (#inst "2016-10-25T01:20:06.000-00:00"),
       ;;                        :print-task-1 (#inst "2016-10-25T01:20:05.000-00:00")},
       ;;             :cache {}}}
       

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

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.core/finish!SourceDoc + Usages
    Blocks until all previously queued OpenCL commands in a command-queue
      are issued to the associated device and have completed. Returns the queue.
      If called with no arguments, works on the default [*command-queue*]
    
      See https://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clFinish.html,
      http://www.jocl.org/doc/org/jocl/CL.html#clFinish-org.jocl.cl_command_queue-
    
      Example:
    
          (finish! my-queue)
      

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.core/enq-barrier!SourceDoc + Usages
    A synchronization point that enqueues a barrier operation. Returns the queue.
    
      See https://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clEnqueueBarrierWithWaitList,
      http://www.jocl.org/doc/org/jocl/CL.html#clEnqueueBarrierWithWaitList-org.jocl.cl_command_queue-int-org.jocl.cl_event:A-org.jocl.cl_event-
    
      Examples:
    
      (enq-barrier! queue (events ev-nd) ev-map)
      (enq-barrier! queue)
      (enq-barrier! queue ev-map)
      

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.core/enq-marker!SourceDoc + Usages
    Enqueues a marker command which waits for either a list of events to complete,
      or all previously enqueued commands to complete. Returns the queue.
    
      See https://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clEnqueueMarkerWithWaitList,
    
      http://www.jocl.org/doc/org/jocl/CL.html#clEnqueueMarkerWithWaitList-org.jocl.cl_command_queue-int-org.jocl.cl_event:A-org.jocl.cl_event-
      Examples:
    
      (enq-marker! queue (events ev-nd) ev-map)
      (enq-marker! queue)
      (enq-marker! queue ev-map)
      

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.core/enq-fill!SourceDoc + Usages
    Enqueues a command to fill a buffer object with a [[Mem]] pattern.
    
      In case of OpenCL errors, throws an `ExceptionInfo`.
    
      See https://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clEnqueueFillBuffer.html
      http://www.jocl.org/doc/org/jocl/CL.html#clEnqueueFillBuffer-org.jocl.cl_command_queue-org.jocl.cl_mem-org.jocl.Pointer-long-long-long-int-org.jocl.cl_event:A-org.jocl.cl_event-
    
      Examples:
    
          (enq-fill! my-queue cl-buf (float-array [1 2 3 4]) 2 (events) ev)
      

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.core/enq-copy!SourceDoc + Usages
    Enqueues a command to copy from one [[CLMem]] memory object to another.
    
      In case of OpenCL errors, throws an `ExceptionInfo`.
    
      See https://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clEnqueueCopyBuffer.html
      http://www.jocl.org/doc/org/jocl/CL.html#clEnqueueCopyBuffer-org.jocl.cl_command_queue-org.jocl.cl_mem-org.jocl.cl_mem-long-long-long-int-org.jocl.cl_event:A-org.jocl.cl_event-
    
      Examples:
    
          (enq-copy! my-queue cl-src cl-dst 4 8 32 (events) ev)
      

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.core/set-status!SourceDoc + Usages
    Sets the status of a host event to indicate whether it is complete
      or there is an error (a negative value). It can be called only once to change
      the status. If called with only the first argument, sets the status to
      `CL/CL_COMPLETE`. Returns the event.
    
      See https://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clSetUsereventstatus.html,
      http://www.jocl.org/doc/org/jocl/CL.html#clSetUserEventStatus-org.jocl.cl_event-int-
    
      Examples:
    
          (set-status! ev) ;; event's status will be CL_COMPLETE
          (set-status! ev -12) ;; indicates and error code -12
      

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.core/context*SourceDoc + Usages
    Creates `cl_context` for an array of `device`s, with optional
      `cl_context_properties`, error reporting core.async channel `ch`
      and user data that should accompany the error report.
    
      If `devices` is empty, throws `ExceptionInfo`.
    
      **Needs to be released after use.**
    
      This is a low-level alternative to [[context]].
    
      See http://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clCreateContext.html
      See   throws `Illegalargumentexception`http://www.jocl.org/doc/org/jocl/CL.html#clCreateContext-org.jocl.cl_context_properties-int-org.jocl.cl_device_id:A-org.jocl.CreateContextFunction-java.lang.Object-int:A-
      

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.core/platformsSourceDoc + Usages
    Returns a vector of all available OpenCL platforms (`cl_platform_id`s).
      `cl_platform_id` objects do not need to be released explicitly.
    
      Platforms are represented by the [`org.jocl.platform_id`]
      (http://www.jocl.org/doc/org/jocl/cl_platform_id.html) datastructure.
    
      See http://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clGetPlatformIDs.html
      and http://www.jocl.org/doc/org/jocl/CL.html#clGetPlatformIDs-int-org.jocl.cl_platform_id:A-int:A-
      

    metrics-clojure-ring 2.10.0
    Various things gluing together metrics-clojure and ring.
    metrics.ring.instrument/instrument-bySourceDoc + Usages
    Instrument a ring handler using the metrics returned by the `metrics-for`
       function. `metrics-by` should be a function which takes an atom, a registry
       and a request and return a collection of metrics objects that pertain to
       some type of request.
    
       For example, `metrics-by-uri` maintains separate metrics for each endpoint
    
       This middleware should be added as late as possible (nearest to the outside of
       the "chain") for maximum effect.
      

    specviz 0.2.4
    Generate Graphviz images from Clojure specs
    specviz.core/diagramSourceDoc + Usages
    Generate a diagram of the specs.
    
      `filename` only the name of the file. Both <filename>.png, and <filename>.dot
      files will be generated.
    
      `root` can be a keyword, naming a spec in the registry, or a namespace symbol
      from which to load all specs. From these starting points, all
      dependent specs are included, recursively.
      ex: `:specviz.graphviz/shape`, `'specviz.graphviz`
    
      `excluded-namespaces` collection of strings representing namespaces, or
      partial namespaces, which should be excluded from the
      diagram. ex: `["clojure.core" "string"]`

    strukt 1.1.0
    ClojureScript map factory with shape validation using prost and cljs.spec
    strukt.core/strukt*SourceDoc + Usages
    Create a strukt map factory with *name*. *type* is a keyword and will be used to identify the type of strukt. *spec* is a keyword pointing to a spec definiton in the spec registry. *primary-key* is a keyword that represents the main field on the strukt, and will be used for the shorthand primary-key value factory. *defaults* is a map of default values.
    
      Returns a strukt map factory fn that can be called with no arguments, a single value to associated with *primary-key*, a map of keys and values, or variadic keyword arguments.

    discord.clj 1.1.0
    A library for creating Discord bots in Clojure.
    discord.bot/defcommandSourceDoc + Usages
    Defines a one-off command and adds that to the global extension registry. This is a single
       function that will respond to commands and is not a part of a larger command infrastructure.
    
       Example:
       (defcommand botsay [client message]
       	(say (:content message))
       	(delete message))
    
       The above code expands into the following:
    
       (do
       	(defn botsay [client message]
       		(say (:content message))
       		(delete message))
    
       	(register-extension! :botsay botsay))
       

    Gets a WebGL context from a canvas element.
    `context-attributes` may be a map in the following form:
    
        {:alpha
         :depth
         :stencil
         :antialias
         :premultiplied-apha
         :preserve-drawing-buffer}
    
    If you don't specify any key, the default value is assumed.
    For further information on context creation parameters see
    
    [WebGLContextAttributes]
    (https://www.khronos.org/registry/webgl/specs/1.0.2/#WEBGLCONTEXTATTRIBUTES);
    

    derivatives 0.3.1-alpha
    Chains of derived values
    org.martinklepsch.derivatives/buildSourceDoc + Usages
    Given a spec return a map of similar structure replacing it's values with
      derived atoms built based on the depedency information encoded in the spec
    
      WARNING: This will create derived atoms for all keys so it may lead
      to some uneccesary computations To avoid this issue consider using
      `derivatives-pool` which manages derivatives in a registry
      removing them as soon as they become unused

    clojure-hadoop 1.4.4
    Library to aid writing Hadoop jobs in Clojure.
    clojure-hadoop.flow/define-sinkSourceDoc + Usages
    A sink is a function stored in the component registry which takes
       zero or more arguments and returns a map.  Any keys which are valid
       for defjob and define-step can be included here.  Any keys included
       in the including step will override the default key-value pairs in
       define-sink.  Sinks are defined using the :sink key to define-step
       expressions.

    measure 0.1.7
    Say things about your application with authority, using Coda Hale's Metrics.
    measure.core/console-reporterSourceDoc + Usages
    `console-reporter` creates a reporter that periodically writes
       the given registry to the console.
    
       Metrics will be printed at a fixed interval, by default once
       per minute.
    
       Options are:
    
       * :rate-unit - A time unit (`:minutes`, `:seconds`, `:millis`, `:nanos`) to which to convert all rates.
       * :time-unit - A time  unit (`:minutes`, `:seconds`, `:millis`, `:nanos`) to which to convert all durations.
       * :frequency - How much time should pass between console outputs
       * :frequency-unit - A time unit (`:minutes`, `:seconds`, `:millis`, `:nanos`) describing the frequency; defaults to `:minutes`.

    com.tbaldridge.hermod 0.1.3
    A Mailbox based distributed computing library
    com.tbaldridge.hermod/mailboxSourceDoc + Usages
    Returns a mailbox after it has been registered with the mailbox registry.
       Puts to mailboxes are non-blocking and may drop messages if network buffers
       are full. Takes from mailboxes may block.
    
       Mailboxes implement java.io.Closeable and so may be used with with-open blocks.
    
       Mailboxes implmeent clojure.core.async.impl.protocols/Channel and so may be used
       as an argument to close!
    
      [name buffer]
    
      name - optional, name for the mailbox (should be unique to this JVM instance)
      buffer - optional, a buffer to use for delivered messages, must be non-blocking

    clj-osf 0.1.2
    Clojure API for Open Semantic Framework web services queries
    clj-osf.auth.lister/dataset-groups-accessesSourceDoc + Usages
    Specifies that this query will return all the group access records in the OSF network instance.
      This information will only be returned if the requester has permissions on the core OSF registry dataset.
      
      ##### Parameters
      
      * `[uri]` the URI of the target dataset for which you want the access records for all its users
    
      ##### Usage
    
      ```
      (auth/lister
        (auth/dataset-group-accesses "http://sandbox.opensemanticframework.org/datasets/test/"))
      ```

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.legacy/command-queue-1SourceDoc + Usages
    Creates a host or device command queue on a specific device.
    
      ** If you need to support legacy OpenCL 1.2 or earlier platforms,
      you MUST use this  function instead of [command-queue], which is for
      OpenCL 2.0 and higher. What is important is the version of the platform,
      not the devices.**
    
      Arguments are:
    
      * `ctx` - the `cl_context` for the queue;
      * `device` - the `cl_device_id` for the queue;
      * `x` - if integer, the size of the (on device) queue, otherwise treated
      as property;
      * `properties` - additional optional keyword properties: `:profiling`,
      `:queue-on-device`, `:out-of-order-exec-mode`, and `queue-on-device-default`;
    
      **Needs to be released after use.**
    
      See also [[command-queue-1*]].
    
      If called with invalid context or device, throws `ExceptionInfo`.
      If called with any invalid property, throws NullPointerexception.
    
      See https://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clCreateCommandQueueWithProperties.html,
      https://www.khronos.org/registry/cl/sdk/1.2/docs/man/xhtml/clCreateCommandQueue.html,
      http://www.jocl.org/doc/org/jocl/CL.html#clCreateCommandQueueWithProperties-org.jocl.cl_context-org.jocl.cl_device_id-org.jocl.cl_queue_properties-int:A-
      http://www.jocl.org/doc/org/jocl/CL.html#clCreateCommandQueue-org.jocl.cl_context-org.jocl.cl_device_id-long-int:A-
    
      Examples:
    
           (command-queue-1 ctx)
           (command-queue-1 ctx dev)
           (command-queue-1 ctx dev :profiling)
           (command-queue-1 ctx dev 524288 :queue-on-device)
      

    iapetos 0.1.8
    A Clojure Prometheus Client
    iapetos.collector.ring/wrap-metricsSourceDoc + Usages
    A combination of [[wrap-instrumentation]] and [[wrap-metrics-expose]].
    
       Note that you have to call [[initialize]] on your registry first, to register
       the necessary collectors.
    
       Be aware that you should implement `path-fn` (which generates the value for
       the `:path` label) if you have any kind of ID in your URIs – since otherwise
       there will be one timeseries created for each observed ID.
    
       For additional labels in the metrics use `label-fn`, which takes the request
       as a first argument and the response as the second argument.
    
       Since collectors, and thus their labels, have to be registered before they
       are ever used, you need to provide the list of `:labels` when calling
       [[initialize]].

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.core/program-with-sourceSourceDoc + Usages
    Creates a `cl_program` for the context and loads the source code
      specified by the text strings given in the `source` sequence.
      When called with one argument, uses [[*context*]].
    
      In case of OpenCL errors during the program creation, throws
      `Exceptioninfo`.
    
      **Needs to be released after use.**
    
      See also [[build-program!]]
    
      See https://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clCreateProgramWithSource.html,
      http://www.jocl.org/doc/org/jocl/CL.html#clCreateProgramWithSource-org.jocl.cl_context-int-java.lang.String:A-long:A-int:A-
    
      Example:
    
          (def source (slurp "path-to-kernels/my_kernel.cl"))
          (program-with-source ctx [source])
      

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.core/svm-buffer*SourceDoc + Usages
    Creates a svm buffer object in `ctx`, given `size` in bytes, bitfield
      `flags` describing memory allocation usage, and alignment size.
    
      Flags defined by the OpenCL standard are available as constants in the
      [org.jocl.CL](http://www.jocl.org/doc/org/jocl/CL.html) class.
    
      **Needs to be released after use.**
    
      This is a low-level alternative to [[svm-buffer!]]
      If  `ctx` is nil or the buffer size is invalid, throws `IllegalArgumentException`.
    
      See http://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clSVMAlloc.html,
      http://www.jocl.org/doc/org/jocl/CL.html#clSVMAlloc-org.jocl.cl_context-long-long-int-
    
      Example:
    
          (svm-buffer* ctx 24 (bit-or CL/CL_MEM_SVM_FINE_GRAIN_BUFFER CL/CL_MEM_SVM_ATOMICS) 0)
      

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.core/cl-buffer*SourceDoc + Usages
    Creates a cl buffer object in `ctx`, given `size` in bytes and a bitfield
      `flags` describing memory allocation usage.
    
      Flags defined by the OpenCL standard are available as constants in the
      [org.jocl.CL](http://www.jocl.org/doc/org/jocl/CL.html) class.
    
      **Needs to be released after use.**
    
      This is a low-level alternative to [[cl-buffer]]
      If  `ctx` is nil or the buffer size is invalid, throws `ExceptionInfo`.
    
      See http://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clCreateBuffer.html,
      http://www.jocl.org/doc/org/jocl/CL.html#clCreateBuffer-org.jocl.cl_context-long-long-org.jocl.Pointer-int:A-
    
      Example:
    
      (cl-buffer* ctx 24 CL/CL_MEM_READ_ONLY)
      

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.core/contextSourceDoc + Usages
    Creates `cl_context` for a vector of `device`s, with optional
      hashmap of `properties`, error reporting core.async channel `ch`
      and user data that should accompany the error report. If called with
      no arguments, creates a context using all devices of the default
      platform (`*platform`).
    
      If `devices` is empty, throws `ExceptionInfo`.
    
      **Needs to be released after use.** (see [[with-context]]).
    
      See http://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clCreateContext.html
      , http://www.jocl.org/doc/org/jocl/CL.html#clCreateContext-org.jocl.cl_context_properties-int-org.jocl.cl_device_id:A-org.jocl.CreateContextFunction-java.lang.Object-int:A-
    
      Examples:
    
            (context)
            (context (devices (first (platforms))))
            (context (devices (first (platforms))) {:platform p} (chan) :my-data)
      

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.core/num-devices*SourceDoc + Usages
    Queries `platform` for the number of devices of `device-type`s. Device types
      are given as a bitfield, where each type is defined in the OpenCL standard.
      Available device types are accessible through `org.jocl.CL/CL_DEVICE_TYPE_X`
      constants. If there are no such devices, returns 0.
    
      NOTE: You should prefer a higher-level [[num-devices]] function, unless you
      code.
    
      When called with an invalid platform, throws [ExceptionInfo]
      (http://clojuredocs.org/clojure.core/ex-info).
    
      See http://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clGetDeviceIDs.html
      and http://www.jocl.org/doc/org/jocl/CL.html#clGetDeviceIDs-int-org.jocl.cl_device_id:A-int:A-
      

    hara.io.scheduler 2.8.6
    patterns and utilities
    hara.io.scheduler/stop!SourceDoc + Usages
    stops the scheduler
              
       (stop! sch)
       ;; Schedule will stop but running instances will continue to run until completion
       ;;
       ;; => {:array {:handlers
       ;;             [{:status :ready,
       ;;               :val {:name :print-task-1,
       ;;                     :mode :async,
       ;;                     :arglist [:timestamp :params :instance]}} 
       ;;              {:status :ready,
       ;;               :val {:name :print-task-2,
       ;;                     :mode :async,
       ;;                     :arglist [:timestamp :params :instance]}}]},
       ;;     :registry #reg {},
       ;;     :cache #cache {},
       ;;     :clock #clock {:start-time nil, :current-time nil, :running false},
       ;;     :ticker {:time #inst "2016-10-25T01:22:58.000-00:00",
       ;;              :array [58 22 8 2 25 10 2016]}}
       

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.legacy/command-queue-1*SourceDoc + Usages
    Creates a host or device command queue on a specific device.
    
      ** If you need to support legacy OpenCL 1.2 or earlier platforms,
      you MUST use this  function instead of [command-queue*], which is for
      OpenCL 2.0 and higher. What is important is the version of the platform,
      not the devices.**
    
      Arguments are:
    
      * `ctx` - the `cl_context` for the queue;
      * `device` - the `cl_device_id` for the queue;
      * `size` - the size of the (on device) queue;
      * `properties` - long bitmask containing properties, defined by the OpenCL
      standard are available as constants in the org.jocl.CL class.
    
      This is a low-level version of [[command-queue-1]].
    
      If called with invalid context or device, throws `ExceptionInfo`.
    
      See https://www.khronos.org/registry/cl/sdk/1.2/docs/man/xhtml/clCreateCommandQueue.html,
      http://www.jocl.org/doc/org/jocl/CL.html#clCreateCommandQueue-org.jocl.cl_context-org.jocl.cl_device_id-long-int:A-
    
      Examples:
          (command-queue-1* ctx dev 524288  (bit-or CL/CL_QUEUE_PROFILING_ENABLED
                                                    CL/CL_QUEUE_ON_DEVICE))
          (command-queue-1* ctx dev CL/CL_QUEUE_PROFILING_ENABLED)
      

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.core/command-queue*SourceDoc + Usages
    Creates a host or device command queue on a specific device.
    
      ** If you need to support OpenCL 1.2 platforms, you MUST use the alternative
      [command-queue-1*] function or or risk JVM crash. What is important is the
      version of the platform, not the devices. This function is for platforms
      (regardless of the devices) supporting OpenCL 2.0 and higher. **
    
      Arguments are:
    
      * `ctx` - the `cl_context` for the queue;
      * `device` - the `cl_device_id` for the queue;
      * `size` - the size of the (on device) queue;
      * `properties` - long bitmask containing properties, defined by the OpenCL
      standard are available as constants in the org.jocl.CL class.
    
      This is a low-level version of [[command-queue]].
    
      If called with invalid context or device, throws `ExceptionInfo`.
    
      See https://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clCreateCommandQueueWithProperties.html,
      http://www.jocl.org/doc/org/jocl/CL.html#clCreateCommandQueueWithProperties-org.jocl.cl_context-org.jocl.cl_device_id-org.jocl.cl_queue_properties-int:A-
    
      Examples:
          (command-queue* ctx dev 524288  (bit-or CL/CL_QUEUE_PROFILING_ENABLED
                                                  CL/CL_QUEUE_ON_DEVICE))
          (command-queue* ctx dev CL/CL_QUEUE_PROFILING_ENABLED)
      

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.core/cl-sub-bufferSourceDoc + Usages
    Creates a cl buffer object ([[CLBuffer]]) that shares data with an existing
      buffer object.
    
      * `buffer` has to be a valid [[CLBuffer]] object.
      * `origin` and `size` are numbers that denote offset and size of the
      region in the origin buffer.
      * `flag` and `flags` are memory allocation usage keywords same as in
      [[cl-buffer]]
    
      **Needs to be released after use.**
    
      See http://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clCreateSubBuffer.html,
      http://www.jocl.org/doc/org/jocl/CL.html#clCreateSubBuffer-org.jocl.cl_mem-long-int-org.jocl.cl_buffer_region-int:A-
    
      Examples:
    
          (def cl-buff (cl-buffer ctx 32 :write-only))
          (cl-sub-buffer cl-buff 8 16 :write-only)
          (cl-sub-buffer cl-buff 8 16)
      

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.core/cl-sub-buffer*SourceDoc + Usages
    Creates a cl buffer object ([[CLBuffer]]) that shares data with an existing
      buffer object.
    
      * `buffer` has to be a valid [[BLBuffer]] buffer object.
      * `flags` is a bitfield that specifies allocation usage (see [[cl-buffer*]]).
      * `create-type` is a type of buffer object to be created (in OpenCL 2.0, only
      `CL/CL_BUFFER_CREATE_TYPE_REGION` is supported).
      * `region` is a `cl_buffer_region` that specifies offset and size
      of the subbuffer.
    
      **Needs to be released after use.**
    
      See http://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clCreateBuffer.html,
      http://www.jocl.org/doc/org/jocl/CL.html#clCreateBuffer-org.jocl.cl_context-long-long-org.jocl.Pointer-int:A-
    
      Examples:
    
      (def cl-buff (cl-buffer ctx 32 :write-only))
      (def region (cl_buffer_region. 8 16))
      (cl-sub-buffer* cl-buff CL/CL_MEM_READ_WRITE CL/CL_BUFFER_CREATE_TYPE_REGION region)
      (cl-sub-buffer* cl-buff CL/CL_MEM_READ_ONLY region)
      

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.core/cl-bufferSourceDoc + Usages
    Creates a cl buffer object ([[CLBuffer]]) in `ctx`, given `size` in bytes
      and one or more memory allocation usage keyword flags: `:read-write`,
      `:read-only`, `:write-only`, `:use-host-ptr`, `:alloc-host-ptr`,
      `:copy-host-ptr`, `:host-write-only`, `:host-read-only`, `:host-no-access`.
    
      If called with two arguments, uses the default `*context*`
      (see [[with-context]]).
    
      **Needs to be released after use.**
    
      If  `ctx` is nil or the buffer size is invalid, throws `ExceptionInfo`.
      If some of the flags is invalid, throws `IllegalArgumentexception`.
    
      See http://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clCreateBuffer.html,
      http://www.jocl.org/doc/org/jocl/CL.html#clCreateBuffer-org.jocl.cl_context-long-long-org.jocl.Pointer-int:A-
    
      Examples:
    
      (cl-buffer 32 :read-only)
      (cl-buffer ctx 24 :write-only)
      

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.core/devices*SourceDoc + Usages
    Queries `platform` for the devices of `device-type`s, and returns them as an
      array of `cl_device_id`s. The types are given as a bitfield, where each type
      is a number constant defined in the OpenCL standard.
      Available device types are accessible through `org.jocl.CL/CL_DEVICE_TYPE_X`
      constants. If there are no such devices, returns a zero-length array.
    
      Root level devices do not need to be explicitly released.
    
      NOTE: You should prefer a higher-level [[devices]] function, unless you
      already have a `device-type` in a long number form in your code, and/or you
      want to get resulting devices in an array rather than in a vector.
    
      When called with an invalid platform, throws [ExceptionInfo]
      (http://clojuredocs.org/clojure.core/ex-info).
    
      See http://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clGetDeviceIDs.html
      and http://www.jocl.org/doc/org/jocl/CL.html#clGetDeviceIDs-int-org.jocl.cl_device_id:A-int:A-
      

    hydrox 0.1.17
    dive deeper into your code
    hydrox.analyse/add-fileSourceDoc + Usages
    adds a file to the folio
       (-> {:project (util/read-project (io/file "example/project.clj"))}
           (add-file (io/file "example/test/example/core_test.clj"))
           (add-file (io/file "example/src/example/core.clj"))
           (dissoc :project))
       => (contains-in
           {:registry {(str user-dir "/example/test/example/core_test.clj")
                       {'example.core
                       {'foo {:docs vector?, :meta {:added "0.1"}}}},
                       (str user-dir "/example/src/example/core.clj")
                       {'example.core
                        {'foo {:source "(defn foo\n  [x]\n  (println x \"Hello, World!\"))"}}}},
            :references {'example.core
                         {'foo {:docs vector?, :meta {:added "0.1"},
                                :source "(defn foo\n  [x]\n  (println x \"Hello, World!\"))"}}},
            :namespace-lu {'example.core (str user-dir "/example/src/example/core.clj")}})

    measure 0.1.7
    Say things about your application with authority, using Coda Hale's Metrics.
    measure.core/graphite-reporterSourceDoc + Usages
    `graphite-reporter` creates a reporter for the given registry that
       sends measurements to a Graphite server.
    
       Metrics will be sent at a fixed interval, defaulting once every
       five seconds.  Metrics are sent using the names with which they
       were registered; if given, an optional prefix is prepended to each
       name.
    
       Options are:
    
       * :port - The port on which graphite is listening; defaults to 2003
       * :prefix - A string to be prefixed to the name of each metric.
       * :rate-unit - A time unit (`:minutes`, `:seconds`, `:millis`, `:nanos`) to which to conver all rates.
       * :time-unit - A time unit (`:minutes`, `:seconds`, `:millis`, `:nanos`) to which to convert all durations.
       * :frequency - How much time should pass between submissions; defaults to 1.
       * :frequency-unit - A time unit (`:minutes`, `:seconds`, `:millis`, `:nanos`) describing the frequency; defaults to `:seconds`.

    Inputs: ([opts :- common/RawUserRequestOptions callback :- common/ResponseCallbackFn client :- HttpAsyncClient] [opts :- common/RawUserRequestOptions callback :- common/ResponseCallbackFn client :- HttpAsyncClient metric-registry :- (schema/maybe MetricRegistry) metric-namespace :- (schema/maybe schema/Str)] [opts :- common/RawUserRequestOptions callback :- common/ResponseCallbackFn client :- HttpAsyncClient metric-registry :- (schema/maybe MetricRegistry) metric-namespace :- (schema/maybe schema/Str) enable-url-metrics? :- schema/Bool])
      Returns: common/ResponsePromise
    
      Issues an async HTTP request with the specified client and returns a promise
       object to which the value of
       `(callback {:opts _ :status _ :headers _ :body _})` or
       `(callback {:opts _ :error _})` will be delivered.
    
       When unspecified, `callback` is the identity function.
    
       opts:
    
       * :url
       * :method - the HTTP method (:get, :head, :post, :put, :delete, :trace,
                   :options, :patch)
       * :headers - a map of headers
       * :body - the body; may be a String or any type supported by clojure's reader
       * :decompress-body - if `true`, an 'accept-encoding' header with a value of
            'gzip, deflate' will be added to the request, and the response will be
            automatically decompressed if it contains a recognized 'content-encoding'
            header.  defaults to `true`.
       * :as - used to control the data type of the response body.  Supported values
           are `:text`, `:stream` and `:unbuffered-stream`. `:text` will return a `String`,
           `:stream` and `:unbuffered-stream` will return an `InputStream`. Note that
           `:stream` holds the full response in memory (i.e. a `ByteArrayInputStream`).
           Use `:unbufferred-stream` for large response bodies or to consume less memory.
           Defaults to `:stream`.
       * :query-params - used to set the query parameters of an http request
       * :metric-id - array of strings or keywords, used to set the metrics to be
           timed for the request.

    Takes a symbol naming a function, and one or more of the following:
    
      :args A regex spec for the function arguments as they were a list to be
        passed to apply - in this way, a single spec can handle functions with
        multiple arities
      :ret A spec for the function's return value
      :fn A spec of the relationship between args and ret - the
        value passed is {:args conformed-args :ret conformed-ret} and is
        expected to contain predicates that relate those values
    
      Qualifies fn-sym with resolve, or using *ns* if no resolution found.
      Registers an fspec in the global registry, where it can be retrieved
      by calling get-spec with the var or full-qualified symbol.
    
      Once registered, function specs are included in doc, checked by
      instrument, tested by the runner cljs.spec.test.alpha/run-tests, and (if
      a macro) used to explain errors during macroexpansion.
    
      Note that :fn specs require the presence of :args and :ret specs to
      conform values, and so :fn specs will be ignored if :args or :ret
      are missing.
    
      Returns the qualified fn-sym.
    
      For example, to register function specs for the symbol function:
    
      (s/fdef cljs.core/symbol
        :args (s/alt :separate (s/cat :ns string? :n string?)
                     :str string?
                     :sym symbol?)
        :ret symbol?)

    spec.alpha 0.1.143
    Specification of data and functions
    clojure.spec.alpha/fdefSourceDoc + Usages
    Takes a symbol naming a function, and one or more of the following:
    
      :args A regex spec for the function arguments as they were a list to be
        passed to apply - in this way, a single spec can handle functions with
        multiple arities
      :ret A spec for the function's return value
      :fn A spec of the relationship between args and ret - the
        value passed is {:args conformed-args :ret conformed-ret} and is
        expected to contain predicates that relate those values
    
      Qualifies fn-sym with resolve, or using *ns* if no resolution found.
      Registers an fspec in the global registry, where it can be retrieved
      by calling get-spec with the var or fully-qualified symbol.
    
      Once registered, function specs are included in doc, checked by
      instrument, tested by the runner clojure.spec.test.alpha/check, and (if
      a macro) used to explain errors during macroexpansion.
    
      Note that :fn specs require the presence of :args and :ret specs to
      conform values, and so :fn specs will be ignored if :args or :ret
      are missing.
    
      Returns the qualified fn-sym.
    
      For example, to register function specs for the symbol function:
    
      (s/fdef clojure.core/symbol
        :args (s/alt :separate (s/cat :ns string? :n string?)
                     :str string?
                     :sym symbol?)
        :ret symbol?)

    clojure-future-spec 1.9.0-alpha9-1
    Backport of clojure.spec for Clojure 1.8
    clojure.spec/fdefSourceDoc + Usages
    Takes a symbol naming a function, and one or more of the following:
    
      :args A regex spec for the function arguments as they were a list to be
        passed to apply - in this way, a single spec can handle functions with
        multiple arities
      :ret A spec for the function's return value
      :fn A spec of the relationship between args and ret - the
        value passed is {:args conformed-args :ret conformed-ret} and is
        expected to contain predicates that relate those values
    
      Qualifies fn-sym with resolve, or using *ns* if no resolution found.
      Registers an fspec in the global registry, where it can be retrieved
      by calling get-spec with the var or fully-qualified symbol.
    
      Once registered, function specs are included in doc, checked by
      instrument, tested by the runner clojure.spec.test/run-tests, and (if
      a macro) used to explain errors during macroexpansion.
    
      Note that :fn specs require the presence of :args and :ret specs to
      conform values, and so :fn specs will be ignored if :args or :ret
      are missing.
    
      Returns the qualified fn-sym.
    
      For example, to register function specs for the symbol function:
    
      (s/fdef clojure.core/symbol
        :args (s/alt :separate (s/cat :ns string? :n string?)
                     :str string?
                     :sym symbol?)
        :ret symbol?)

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.core/enq-svm-unmap!SourceDoc + Usages
    Enqueues a command to indicate that the host has completed updating the region
      given by svm [[SVMMem]] and which was specified in a previous call to
      [[enq-svm-map!]].
    
      Arguments:
    
      * `queue` (optional): the `cl_command_queue` that unmaps the object.
      If omitted, [[*command-queue*]] will be used.
      *  `svm`: the [[SVMMem]] that is going to be unmapped.
      * `wait-events` (optional): [[events]] array specifying the events (if any)
      that need to complete before this operation.
      * `event` (optional): if specified, the `cl_event` object tied to
      the execution of this operation.
    
      If event is specified, the operation is asynchronous, otherwise it blocks the
      current thread until the data transfer completes. See also [[register]].
    
      See also [[enq-svm-map!]].
    
      See https://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clEnqueueSVMUnmap,
      http://www.jocl.org/doc/org/jocl/CL.html#clEnqueueSVMUnmap-org.jocl.cl_command_queue-org.jocl.Pointer-int-org.jocl.cl_event:A-org.jocl.cl_event-
    
      Examples:
    
          (enq-svm-unmap! queue svm-data byte-buff (events ev-nd) ev-map)
          (enq-svm-unmap! queue svm-data byte-buff ev-map)
          (enq-svm-unmap! queue svm-data byte-buff)
          (enq-svm-unmap! svm-data byte-buff)
    

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.core/enq-svm-map*SourceDoc + Usages
    Enqueues a command that will allow the host to update a region of a SVM buffer.
    . Returns the mapped `java.nio.ByteBuffer` (which is the same byte buffer that is
      already accessible through `(byte-buffer svm)`). Together with [[enq-svm-unmap!]],
      works as a synchronization point.
    
      Arguments:
    
      * `queue` (optional): the `cl_command_queue` that maps the object.
      If omitted, [[*command-queue*]] will be used.
      * `svm`: the [[SVMMem]] that is going to be mapped to.
      * `blocking`: whether the operation is blocking (CL/CL_TRUE) or non-blocking
      (CL/CL_FALSE).
      * `flags`: a bitfield that indicates whether the memory is mapped for reading
      (`CL/CL_MAP_READ`), writing (`CL/CL_MAP_WRITE`), both
      `(bit-or CL/CL_MAP_READ CL/CL_MAP_WRITE)` or `CL_MAP_WRITE_INVALIDATE_REGION`.
      * `wait-events` (optional): [[events]] array specifying the events (if any)
      that need to complete before this operation.
      * `event` (optional): if specified, the `cl_event` object tied to
      the execution of this operation.
    
      This is a low-level version of [[enq-svm-map!]].
    
      See https://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clEnqueueSVMMap.html,
      http://www.jocl.org/doc/org/jocl/CL.html#clEnqueueSVMMap-org.jocl.cl_command_queue-boolean-long-org.jocl.Pointer-long-int-org.jocl.cl_event:A-org.jocl.cl_event-
    
      Examples:
    
          (enq-svm-map* queue svm-data false 0 CL/CL_WRITE (events ev-nd) ev-map)
      

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.core/enq-unmap!SourceDoc + Usages
    Enqueues a command to unmap a previously mapped memory region.
      Returns the queue.
    
      Arguments:
    
      * `queue` (optional): the `cl_command_queue` that unmaps the object.
      If omitted, [[*command-queue*]] will be used.
      *  `cl`: the [[CLMem]] that is going to be unmapped.
      *  `host`: the host byte buffer that is going to be unmapped.
      * `wait-events` (optional): [[events]] array specifying the events (if any)
      that need to complete before this operation.
      * `event` (optional): if specified, the `cl_event` object tied to
      the execution of this operation.
    
      If event is specified, the operation is asynchronous, otherwise it blocks the
      current thread until the data transfer completes. See also [[register]].
    
      See also [[enq-map-buffer!]].
    
      See https://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clEnqueueUnmapMemObject,
      http://www.jocl.org/doc/org/jocl/CL.html#clEnqueueUnmapMemObject-org.jocl.cl_command_queue-org.jocl.cl_mem-java.nio.ByteBuffer-int-org.jocl.cl_event:A-org.jocl.cl_event-
    
      Examples:
    
          (enq-unmap! queue cl-data byte-buff (events ev-nd) ev-map)
          (enq-unmap! queue cl-data byte-buff ev-map)
          (enq-unmap! queue cl-data byte-buff)
          (enq-unmap! cl-data byte-buff)
      

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.core/enq-map-buffer*SourceDoc + Usages
    Enqueues a command to map a region of the cl buffer into the host
      address space. Returns the mapped `java.nio.ByteBuffer`. The result
      must be unmapped by calling [[enq-unmap!]] for the effects of working
      with the mapping byte buffer to be transfered back to the device memory.
    
      Arguments:
    
      * `queue` (optional): the `cl_command_queue` that maps the object.
      If omitted, [[*command-queue*]] will be used.
      * `cl`: the [[CLMem]] that is going to be mapped to.
      * `blocking`: whether the operation is blocking (CL/CL_TRUE) or non-blocking
      (CL/CL_FALSE).
      *  `offset`: integer value of the memory offset in bytes.
      * `req-size`: integer value of the requested size in bytes (if larger than
        the available data, it will be shrinked.).
      * `flags`: a bitfield that indicates whether the memory is mapped for reading
      (`CL/CL_MAP_READ`), writing (`CL/CL_MAP_WRITE`) or both
      `(bit-or CL/CL_MAP_READ CL/CL_MAP_WRITE)`.
      * `wait-events` (optional): [[events]] array specifying the events (if any)
      that need to complete before this operation.
      * `event` (optional): if specified, the `cl_event` object tied to
      the execution of this operation.
    
      This is a low-level version of [[enq-map-buffer!]].
    
      See https://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clEnqueueMapBuffer.html,
      http://www.jocl.org/doc/org/jocl/CL.html#clEnqueueMapBuffer-org.jocl.cl_command_queue-org.jocl.cl_mem-boolean-long-long-long-int-org.jocl.cl_event:A-org.jocl.cl_event-int:A-
    
      Examples:
    
          (enq-map-buffer* queue cl-data true 0 CL/CL_WRITE (events ev-nd) ev-map)
      

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.core/enq-write!SourceDoc + Usages
    Enqueues a command to write to a cl object from host memory.
      Returns the queue.
    
      Arguments:
    
      * `queue` (optional): the `cl_command_queue` that writes the object.
      If omitted, [[*command-queue*]] will be used.
      * `cl`: the [[CLMem]] that is going to be written to.
      * `host`: [[Mem]] object on the host that the data is to be transferred from.
      Must be a direct buffer is the writing is asynchronous.
      * `blocking`: boolean indicator of synchronization.
      * `offset`: the offset in bytes in the buffer object to write to.
      * `wait-events` (optional): [[events]] array specifying the events (if any)
      that need to complete before this operation.
      * `event` (optional): if specified, the `cl_event` object tied to
      the execution of this operation.
    
      If event is specified, the operation is asynchronous, otherwise it blocks the
      current thread until the data transfer completes, unless explicitly specifiend
      with `blocking`. See also [[register]].
    
      See https://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clEnqueueWriteBuffer.html,
      http://www.jocl.org/doc/org/jocl/CL.html#clEnqueueWriteBuffer-org.jocl.cl_command_queue-org.jocl.cl_mem-boolean-long-long-org.jocl.Pointer-int-org.jocl.cl_event:A-org.jocl.cl_event-
    
      Examples:
    
          (let [host-data (direct-buffer 32)
                ev (event)
                notifications (chan)
                follow (register notifications)]
            (enq-write! my-queue cl-data host-data ev) ;; asynchronous
            (follow ev)
            (<!! notifications))
    
          (enq-write! my-queu cl-data host-data) ;; blocking
      

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.core/enq-read!SourceDoc + Usages
    Enqueues a command to read from a cl object to host memory.
      Returns the queue.
    
      * `queue` (optional): the `cl_command_queue` that reads the object.
      If omitted, [[*command-queue*]] will be used.
      * `cl`: the [[CLMem]] that is going to be read from.
      * `host`: [[Mem]] object on the host that the data is to be transferred to.
      Must be a direct buffer is the reading is asynchronous.
      * `blocking`: boolean indicator of synchronization.
      * `offset`: the offset in bytes in the buffer object to read from.
      * `wait-events` (optional): [[events]] array specifying the events (if any)
      that need to complete before this operation.
      * `event` (optional): if specified, the `cl_event` object tied to
      the execution of this operation.
    
      If event is specified, the operation is asynchronous, otherwise it blocks the
      current thread until the data transfer completes, unless explicitly specifiend
      with `blocking`. See also [[register]].
    
      See https://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clEnqueueReadBuffer.html,
      http://www.jocl.org/doc/org/jocl/CL.html#clEnqueueReadBuffer-org.jocl.cl_command_queue-org.jocl.cl_mem-boolean-long-long-org.jocl.Pointer-int-org.jocl.cl_event:A-org.jocl.cl_event-
    
      Examples:
    
          (let [host-data (direct-buffer 32)
                ev (event)
                notifications (chan)
                follow (register notifications)]
            (enq-read! my-queue cl-data host-data ev) ;; asynchronous
            (follow ev)
            (<!! notifications))
    
          (enq-read! my-queu cl-data host-data) ;; blocking
      

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.core/enq-nd!SourceDoc + Usages
    Enqueues a command to asynchronously execute a kernel on a device.
      Returns the queue.
    
      Arguments:
    
      * `queue` (optional): the `cl_command_queue` that executes the kernel.
      If omitted, [[*command-queue*]] will be used.
      * `kernel`: the `cl_kernel` that is going to be executed.
      * `work-size`: [[WorkSize]] containing the settings of execution
      (global work size, local work size, global work offset).
      * `wait-events` (optional): [[events]] array specifying the events (if any)
      that need to complete before this command can be executed.
      * `event` (optional): if specified, the `cl_event` object tied to
      the execution of this command.
    
      If an OpenCL error occurs during the call, throws `ExceptionInfo`.
    
      See https://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clEnqueueNDRangeKernel.html,
      http://www.jocl.org/doc/org/jocl/CL.html#clEnqueueNDRangeKernel-org.jocl.cl_command_queue-org.jocl.cl_kernel-int-long:A-long:A-long:A-int-org.jocl.cl_event:A-org.jocl.cl_event-
    
      Examples:
    
          (enq-nd! my-kernel (work-size [8]))
          (enq-nd! my-queue my-kernel (work-size [8]))
          (enq-nd! my-queue my-kernel (work-size [8] (events event1 event2) my-event))
      

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.core/command-queueSourceDoc + Usages
    Creates a host or device command queue on a specific device.
    
      ** If you need to support OpenCL 1.2 platforms, you MUST use the alternative
      [command-queue-1] function or or risk JVM crash. What is important is the
      version of the platform, not the devices. This function is for platforms
      (regardless of the devices) supporting OpenCL 2.0 and higher. **
    
      Arguments are:
    
      * `ctx` - the `cl_context` for the queue;
      * `device` - the `cl_device_id` for the queue;
      * `x` - if integer, the size of the (on device) queue, otherwise treated
      as property;
      * `properties` - additional optional keyword properties: `:profiling`,
      `:queue-on-device`, `:out-of-order-exec-mode`, and `queue-on-device-default`;
    
      **Needs to be released after use.**
    
      See also [[command-queue*]].
    
      If called with invalid context or device, throws `ExceptionInfo`.
      If called with any invalid property, throws NullPointerexception.
    
      See https://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clCreateCommandQueueWithProperties.html,
      http://www.jocl.org/doc/org/jocl/CL.html#clCreateCommandQueueWithProperties-org.jocl.cl_context-org.jocl.cl_device_id-org.jocl.cl_queue_properties-int:A-
    
      Examples:
    
           (command-queue ctx)
           (command-queue ctx dev)
           (command-queue ctx dev :profiling :queue-on-device :out-of-order-execution-mode)
           (command-queue ctx dev 524288 :queue-on-device)
      

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.core/set-arg!SourceDoc + Usages
    Sets the argument value for a specific positional argument of a kernel.
      Returns the changed `cl_kernel` object. `value` should implement [[Argument]]
      protocol.
    
      The arguement can be a [[Mem]] ([[CLBuffer]], [[CLImage]], Java primitive arrays),
      or a number.
      In the case of [[Mem]] objects, the memory object will be set as an argument.
      In the case the argument is a number, its long value will be used as a size
      of the local memory to be allocated on the device.
    
      In case of OpenCL errors during the program build, throws
      `Exceptioninfo`. if `value` is of the type that is not supported,
      throws `IllegalArgumentexception`.
    
      See [[kernel]], [[program]], [[Argument]], [[cl-buffer]].
    
      See https://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clSetKernelArg.html,
      http://www.jocl.org/doc/org/jocl/CL.html#clSetKernelArg-org.jocl.cl_kernel-int-long-org.jocl.Pointer-
    
      Examples:
    
          (set-arg! my-kernel 0 cl-buffer0)
          (set-arg! my-kernel 1 cl-buffer1)
          (set-arg! my-kernel 2 (int-array 8))
          (set-arg! my-kernel 3 42)
      

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.core/build-program!SourceDoc + Usages
    Builds (compiles and links) a program executable; returns the program
      changed with side effects on `program` argument.
    
      Accepts the following arguments (nil is allowed for all optional arguments):
    
      * `program`: previously loaded `cl_program` that contains the program
      source or binary;
      * `devices` (optional): an optional sequence of `cl_device`s associated with
      the program (if not supplied, all devices are used);
      * `options` (optional): an optional string of compiler options
      (such as "-Dname=value");
      * `ch` (optional): core.async channel for notifications. If supplied,
      the build will be asynchronous;
      * `user-data` (optional): passed as part of notification data.
    
      In case of OpenCL errors during the program build, throws
      `Exceptioninfo`.
    
      See https://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clBuildProgram.html,
      http://www.jocl.org/doc/org/jocl/CL.html#clBuildProgram-org.jocl.cl_program-int-org.jocl.cl_device_id:A-java.lang.String-org.jocl.BuildProgramFunction-java.lang.Object-
    
      Examples:
    
          (build-program! program) ; synchronous
          (build-program! program ch) ; asynchronous
          (build-program! program "-cl-std=CL2.0" ch) ; asynchronous
          (build-program! program [dev] "-cl-std=CL2.0" ch) ; async
          (build-program! program [dev] "-cl-std=CL2.0" ch :my-data) ; async
      

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.core/registerSourceDoc + Usages
    Creates a convenience function that registers callbacks for events.
      It is a high-level alternative to [[set-event-callback*]]. MUST be called
      AFTER the event is used in the enqueue operation.
    
      * `channel` is a channel for communicating asynchronous notifications
      * `callback-type` is an optional keyword that specifies the command execution
      status that will be the default for the resulting function: `:complete`,
      `:submitted`, or `running`.
    
      Returns a function with the following arguments:
    
      * `e` - user event that is being followed
      * `callback-type` - optional command execution status; if ommited, the default
      is used
      * `data` - optional notification data
    
      When called, the created function returns `channel` with registered callback.
    
      See [[event-callback]], [[set-event-callback*]], [[event]].
      See https://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clSetEventCallback.html,
      http://www.jocl.org/doc/org/jocl/CL.html#clSetEventCallback-org.jocl.cl_event-int-org.jocl.EventCallbackFunction-java.lang.Object-
    
      Example:
    
          (def notifications (chan))
          (def follow (register notifications))
          (def e (event))
          (enq-read! comm-queue cl-object host-object e
          (follow e)
          (:event (<!! notifications))
      

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.core/svm-bufferSourceDoc + Usages
    Creates a svm buffer object ([[SVMBuffer]]) in `ctx`, given `size` and `alignment`
      in bytes and one or more memory allocation usage keyword flags: `:read-write`,
      `:read-only`, `:write-only`, :fine-grain-buffer, and/or :atomics
    
      If called with two arguments, uses the default alignment (platform dependent)
      and default `*context*` (see [[with-context]]). If called with one argument,
      use the default context, and alignment,and :read-write flag.
    
      **Needs to be released after use.** If you rely on the [[release]] method,
      be sure that all enqueued processing that uses this buffer finishes prior
      to that (watch out for non-blocking enqueues!).
    
      If  `ctx` is nil or the buffer size is invalid, throws `IllegalArgumentException`.
      If some of the flags is invalid, throws `NullPointerException`.
    
      See http://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clSVMAlloc.html,
      http://www.jocl.org/doc/org/jocl/CL.html#clSVMAlloc-org.jocl.cl_context-long-long-int-
    
      Examples:
    
          (svm-buffer 32 :read-only)
          (svm-buffer ctx 24 0 :fine-grain-buffer :atomics)
      

    strictly-specking-standalone 0.1.1
    A Clojure library to help validate edn configuration data, and hopefully more
    strictly-specking-standalone.spec/fdefSourceDoc + Usages
    Takes a symbol naming a function, and one or more of the following:
    
      :args A regex spec for the function arguments as they were a list to be
        passed to apply - in this way, a single spec can handle functions with
        multiple arities
      :ret A spec for the function's return value
      :fn A spec of the relationship between args and ret - the
        value passed is {:args conformed-args :ret conformed-ret} and is
        expected to contain predicates that relate those values
    
      Qualifies fn-sym with resolve, or using *ns* if no resolution found.
      Registers an fspec in the global registry, where it can be retrieved
      by calling get-spec with the var or fully-qualified symbol.
    
      Once registered, function specs are included in doc, checked by
      instrument, tested by the runner clojure.spec.test/run-tests, and (if
      a macro) used to explain errors during macroexpansion.
    
      Note that :fn specs require the presence of :args and :ret specs to
      conform values, and so :fn specs will be ignored if :args or :ret
      are missing.
    
      Returns the qualified fn-sym.
    
      For example, to register function specs for the symbol function:
    
      (s/fdef clojure.core/symbol
        :args (s/alt :separate (s/cat :ns string? :n string?)
                     :str string?
                     :sym symbol?)
        :ret symbol?)

    riemann 0.3.1
    A network event stream processor. Intended for analytics, metrics, and alerting;
    riemann.config/service!SourceDoc + Usages
    Ensures that a given service, or its equivalent, is in the next core. If the
      current core includes an equivalent service, uses that service instead.
      Returns the service which will be used in the final core.
    
      This allows configuration to specify and use services in a way which can,
      where possible, re-use existing services without interruption--e.g., when
      reloading. For example, say you want to use a threadpool executor:
    
      ```clojure
      (let [executor (service! (ThreadPoolExecutor. 1 2 ...))]
        (where (service "graphite")
          (on executor
            graph)))
      ```
    
      If you reload this config, the *old* executor is busily processing messages
      from the old set of streams. When the new config evaluates (service! ...)
      it creates a new ThreadPoolExecutor and compares it to the existing core's
      services. If it's equivalent, service! will re-use the *existing*
      executor, which prevents having to shut down the old executor.
    
      But if you *change* the dynamics of the new executor somehow--maybe by
      adjusting a queue depth or max pool size--they won't compare as equivalent.
      When the core transitions, the old executor will be shut down, and the new
      one used to handle any further graphite events.
    
      Note: Yeah, this does duplicate some of the work done in core/transition!.
      No, I'm not really sure what to do about it. Maybe we need a named service
      registry so all lookups are dynamic. :-/

    riemann 0.3.1
    A network event stream processor. Intended for analytics, metrics, and alerting;
    riemann.config/service!SourceDoc + Usages
    Ensures that a given service, or its equivalent, is in the next core. If the
      current core includes an equivalent service, uses that service instead.
      Returns the service which will be used in the final core.
    
      This allows configuration to specify and use services in a way which can,
      where possible, re-use existing services without interruption--e.g., when
      reloading. For example, say you want to use a threadpool executor:
    
      ```clojure
      (let [executor (service! (ThreadPoolExecutor. 1 2 ...))]
        (where (service "graphite")
          (on executor
            graph)))
      ```
    
      If you reload this config, the *old* executor is busily processing messages
      from the old set of streams. When the new config evaluates (service! ...)
      it creates a new ThreadPoolExecutor and compares it to the existing core's
      services. If it's equivalent, service! will re-use the *existing*
      executor, which prevents having to shut down the old executor.
    
      But if you *change* the dynamics of the new executor somehow--maybe by
      adjusting a queue depth or max pool size--they won't compare as equivalent.
      When the core transitions, the old executor will be shut down, and the new
      one used to handle any further graphite events.
    
      Note: Yeah, this does duplicate some of the work done in core/transition!.
      No, I'm not really sure what to do about it. Maybe we need a named service
      registry so all lookups are dynamic. :-/

    clj-apache-https 1.0.18
    Clojure HTTP library using the Apache HttpClient. Based on clj-apache-http, but
    com.twinql.clojure.async-client/connection-managerSourceDoc + Usages
    Returns a PoolingClientConnectionManager with the specified options.
       Param options is a hash-map that may include the following. Any unset
       vars will default to the value in *default-opts*.
    
       :worker-threads         The number of threads the connection manager may use.
    
       :hostname-verifier      The hostname verifier to use for SSL connections.
    
       :time-to-live           Connection time-to-live, in milliseconds.
    
       :http-params            A map of options for the http clients in the pool.
                               These typically include timeout settings, proxy
                               settings, and other fine-grained settings. See
                               the available options in the rename-to var of
                               http.clj for available settings. See
                               test/async-client.clj for an example of how to set
                               up this hash. You can create these client params
                               like this:
    
                               {
                                   :so-timeout 2000           ;; milliseconds
                                   :connection-timeout 1000   ;; milliseconds
                               }
    
       :internal-exception-handler
                              A function for handling exceptions within the
                              IOReactor. The function should take one parameter,
                              which is a Java Exception object. It should return
                              true if it's OK for the reactor to continue
                              processing requests after the exception, or false
                              to shut down the reactor. If you don't supply this,
                              the reactor will shut down on all IO and runtime
                              exceptions. An example exception handler that logs
                              an exception and continues looks like this:
    
                              (defn log-ex [ex] (prn (. ex getMessage) true))
    
    
       :scheme-registry        An instance of
                               org.apache.http.nio.conn.scheme.SchemeRegistry
                               describing how to handle http and https protocols.
                               You really only need to set this if you are
                               connecting on non-standard http/https ports, or if
                               you are using client SSL certificates. If you leave
                               this nil, the client will use a default scheme
                               registry that knows how to communicate via http
                               on port 80 and https on port 443.
    
       :max-total-connections  The maximum total number of concurrent connections
                               to all hosts.
    
       :max-conns-per-route    Param max-conns-per-route is a hash-map specifying
                               the maximum number of connections to a specific
                               host. It should be a map like the one below,
                               which specifies a maximum of 12 simulataneous
                               connections to secure.mysite.com and a maximum of
                               8 simultaneous connections to public.theirhost.com:
    
                               {"secure.mysite.com" 12 "public.theirhost.com" 8}
    
                               Param conns-per-route may be nil, in which case,
                               the underlying Apache library defaults to 2
                               connections per route.
    
       To make things easy, you can merge your own hash with *default-opts*
       or *default-opts*.
    
       Typically, you want to create a single connection manager with a reasonably
       large pool of connections, then use that manager for all of the http clients
       you create.

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.core/enq-svm-map!SourceDoc + Usages
    Enqueues a command that will allow the host to update a region of a SVM buffer.
    . Returns the mapped `java.nio.ByteBuffer` (which is the same byte buffer that is
      already accessible through `(byte-buffer svm)`). Together with [[enq-svm-unmap!]],
      works as a synchronization point.
    
      Arguments:
    
      * `queue` (optional): the `cl_command_queue` that maps the object.
      If omitted, [[*command-queue*]] will be used.
      * `svm`: the [[SVMMem]] that is going to be mapped to.
      *  `offset` (optional): integer value of the memory offset in bytes.
      * `flags` (optional): a bitfield that indicates whether the memory is mapped for reading
      :read, :write, and/or :write-invalidate-region.
      * `wait-events` (optional): [[events]] array specifying the events (if any)
      that need to complete before this operation.
      * `event` (optional): if specified, the `cl_event` object tied to
      the execution of this operation.
    
      If event is specified, the operation is asynchronous, otherwise it blocks the
      current thread until the data transfer completes. See also [[register]].
    
      See also [[enq-svm-map*]].
    
      See https://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clEnqueueSVMMap.html,
      http://www.jocl.org/doc/org/jocl/CL.html#clEnqueueSVMMap-org.jocl.cl_command_queue-boolean-long-org.jocl.Pointer-long-int-org.jocl.cl_event:A-org.jocl.cl_event-
    
      Examples:
    
          (enq-svm-map queue svm-data 0 [:write :read] (events ev-nd) ev-map)
          (enq-svm-map queue svm-data [:write :read] (events ev-nd) ev-map)
          (enq-svm-map queue svm-data :write ev-map)
          (enq-svm-map queue svm-data :read)
          (enq-svm-map svm-data :write-invalidate-region)
      

    clojurecl 0.9.0
    ClojureCL is a Clojure library for parallel computations with OpenCL.
    uncomplicate.clojurecl.core/enq-map-buffer!SourceDoc + Usages
    Enqueues a command to map a region of the cl buffer into the host
      address space. Returns the mapped `java.nio.ByteBuffer`. The result
      must be unmapped by calling [[enq-unmap!]] for the effects of working
      with the mapping byte buffer to be transfered back to the device memory.
    
      Arguments:
    
      * `queue` (optional): the `cl_command_queue` that maps the object.
      If omitted, [[*command-queue*]] will be used.
      * `cl`: the [[CLMem]] that is going to be mapped to.
      * `blocking`: whether the operation is blocking or non-blocking.
      * `offset`: integer value of the memory offset in bytes.
      * `req-size`: integer value of the requested size in bytes (if larger than
         the available data, it will be shrinked).
      * flags: one keyword or a sequence of keywords that indicates memory mapping
      settings: `:read`, `:write`, and/or `:write-invalidate-settings`.
      * `wait-events` (optional): [[events]] array specifying the events (if any)
      that need to complete before this operation.
      * `event` (optional): if specified, the `cl_event` object tied to
      the execution of this operation.
    
      If event is specified, the operation is asynchronous, otherwise it blocks the
      current thread until the data transfer completes. See also [[register]].
    
      See https://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clEnqueueMapBuffer.html,
      http://www.jocl.org/doc/org/jocl/CL.html#clEnqueueMapBuffer-org.jocl.cl_command_queue-org.jocl.cl_mem-boolean-long-long-long-int-org.jocl.cl_event:A-org.jocl.cl_event-int:A-
    
      Examples:
    
          (enq-map-buffer! queue cl-data :write (events ev-nd) ev-map)
          (enq-map-buffer! queue cl-data [:write :read])
          (enq-map-buffer! cl-data :write)
      

    Inputs: [opts :- common/ClientOptions]
      Returns: (schema/protocol common/HTTPClient)
    
      Creates a client to be used for making one or more HTTP requests.
    
       opts (base set):
    
       * :force-redirects - used to set whether or not the client should follow
           redirects on POST or PUT requests. Defaults to false.
       * :follow-redirects - used to set whether or  not the client should follow
           redirects in general. Defaults to true. If set to false, will override
           the :force-redirects setting.
       * :connect-timeout-milliseconds - maximum number of milliseconds that the
           client will wait for a connection to be established.  A value of zero is
           interpreted as infinite.  A negative value for or the absence of this
           option is interpreted as undefined (system default).
       * :socket-timeout-milliseconds - maximum number of milliseconds that the
           client will allow for no data to be available on the socket before
           closing the underlying connection, 'SO_TIMEOUT' in socket terms.  A
           timeout of zero is interpreted as an infinite timeout.  A negative value
           for or the absence of this setting is interpreted as undefined (system
           default).
       * :ssl-protocols - used to set the list of SSL protocols that the client
           could select from when talking to the server. Defaults to 'TLSv1',
           'TLSv1.1', and 'TLSv1.2'.
       * :cipher-suites - used to set the cipher suites that the client could
           select from when talking to the server. Defaults to the complete
           set of suites supported by the underlying language runtime.
       * :metric-registry - a MetricRegistry instance used to collect metrics
           on client requests.
    
       opts (ssl-specific where only one of the following combinations permitted):
    
       * :ssl-context - an instance of SSLContext
    
       OR
    
       * :ssl-cert - path to a PEM file containing the client cert
       * :ssl-key - path to a PEM file containing the client private key
       * :ssl-ca-cert - path to a PEM file containing the CA cert
    
       OR
    
       * :ssl-ca-cert - path to a PEM file containing the CA cert