{:group-id "io.github.hlship", :artifact-id "trace", :version "1.3", :analysis {"clj" ({:added "1.1.0", :name net.lewisship.bench, :publics ({:name bench, :file "net/lewisship/bench.clj", :line 107, :arglists ([& exprs] [opts & exprs]), :doc "Benchmarks a sequence of expressions. Criterium is used to perform the benchmarking,\nthen the results are reported in a tabular format, with the fastest and slowest\nexpressions highlighted (marked in green and yellow, respectively).\n\nThe first argument may be a map of options, rather than an expression to benchmark.\n\nOptions:\n: :quick?  If true (the default), used quick benchmarking options\n: :round-robin? If true (the default is false), uses round-robin testing of the expressions rather\n  than running an independent benchmark for each expression.\n: report? If true (the default), print a report and return nil.  Otherwise,\n  returns a seq of benchmarking stats as returned by Criterium.\n: progress? If true (the default is false), enable Criterium progress reporting during benchmark\n  collection.\n: sort? If true (the default is false), then when results are printed, they are\n  sorted fastest to slowest (with no highlighting).\n\nIn addition, the options are passed to Criterium, allowing overrides of the options\nit uses when benchmarking, such as :samples, etc.", :type :macro} {:name bench*, :file "net/lewisship/bench.clj", :line 84, :arglists ([opts blocks]), :doc "The core of the [[bench]] macro; the expressions to `bench` are converted into blocks, each a map\nwith keys :f (a no-args function) and :expr-str (the string representation of the form being\nbenchmarked).", :type :var} {:name bench-for, :file "net/lewisship/bench.clj", :line 152, :arglists ([bindings & exprs] [opts bindings & exprs]), :doc "Often you will want to benchmark an expression (or set of expressions)\nwhile varying the exact values inside the expression; `bench-for` takes\na vector of bindings, like `clojure.core/for` and builds a new list of\nexpressions for each iteration of the `for`.  The\nstring version of the expression (used in the output report)\nwill have the local symbols from the `for` replaced with the values for this iteration.\n\nExample:\n\n```\n(let [coll (range 1000)]\n  (bench-for [n [5 50 500 5000]]\n    (reduce + (take n coll))))\n\n```\n\nWill be reported as four expressions:\n\n```\n(reduce + (take 5 coll))\n(reduce + (take 50 coll))\n(reduce + (take 500 coll))\n(reduce + (take 5000 coll))\n```\n\nNote that the expression is only modified for the string representation\nused in the report; the actual expression is executed unchanged.", :type :macro}), :doc "Useful wrappers around criterium.\n"} {:name net.lewisship.trace, :publics ({:name *compile-trace*, :file "net/lewisship/trace.clj", :line 27, :dynamic true, :doc "If false (the default), calls to `trace` evaluate to nil (and `trace>` and `trace>>` simply return\nthe threaded value).", :type :var} {:name *enable-trace*, :file "net/lewisship/trace.clj", :line 32, :dynamic true, :doc "If false (the default is true) then compiled calls to `trace` (and `trace>` and `trace>>`)\nare a no-op.", :type :var} {:name set-compile-trace!, :file "net/lewisship/trace.clj", :line 37, :arglists ([value]), :doc "Sets the default value of the `*compile-trace*` var.\n\nRemember that after changing this, it may be necessary to re-load namespaces for the change to take effect.", :type :var} {:name set-enable-trace!, :file "net/lewisship/trace.clj", :line 44, :arglists ([value]), :doc "Sets the default value of the `*enable-trace*` var.\n\nChanges take effect immediately.\n\nWhen this global flag is true, tracing is enabled for all namespaces.\nWhen this flag is false, tracing is only enabled for namespaces specifically enabled via\n[[set-ns-override!]].", :type :var} {:name set-ns-override!, :file "net/lewisship/trace.clj", :line 142, :arglists ([] [enabled?] [ns-symbol enabled?]), :added "1.1", :doc "Enables or disables tracing for a single namespace (by default, the current namespace).\nThe namespace must be a simple symbol.  Enabling tracing for a namespace overrides the\nglobal flag managed by [[set-enable-trace!]] (tracing occurs if either the global flag\nis true, or the namespace is specifically enabled).\n\nManages a set of namespaces that are enabled in this way.", :type :var} {:name setup-default, :file "net/lewisship/trace.clj", :line 135, :arglists ([]), :doc "Enables tracing output with a default tap of `pprint`.\n", :type :var} {:name trace, :file "net/lewisship/trace.clj", :line 55, :arglists ([& kvs]), :doc "Calls to trace generate a map that is passed to `tap>`.\n\nThe map includes keys:\n\n* :in - a symbol of the namespace and function\n* :line - the line number of the trace invocation (if available)\n* :thread - the string name of the current thread\n\nAdditional keys and values may be supplied.\n\n`trace` expands to nil, if compilation is disabled.\n\nAny invocation of `trace` evaluates to nil.", :type :macro} {:name trace-result-reader, :file "net/lewisship/trace.clj", :line 116, :arglists ([form]), :added "1.2.0", :doc "A reader for the #trace/result tagged literal.  When compilation is off,\nreturns the form unchanged.  When compilation is enabled, it will trace\nthe form (as :form) and its evaluation (as :result), and evaluate\nto the result.", :type :var} {:name trace>, :file "net/lewisship/trace.clj", :line 78, :arglists ([value & kvs]), :doc "A version of `trace` that works inside `->` thread expressions.  Within the\n`trace>` body, `%` is bound to the threaded value. When compilation is disabled,\nit simply evaluates to the threaded value.", :type :macro} {:name trace>>, :file "net/lewisship/trace.clj", :line 94, :arglists ([& kvs-then-value]), :doc "A version of `trace` that works inside `->>` thread expressions.  Within the\n`trace>>` body, `%` is bound to the threaded value.  When compilation is disabled,\nit simply evaluates to the threaded value.", :type :macro}), :doc "Light-weight, asynchronous logging built around `clojure.core/tap>`.\n\nFollows the same pattern as `clojure.core/assert`: When tracing is not compiled,\nthe tracing macros should create no runtime overhead.\n\nWhen tracing is compiled, a check occurs to see if tracing is enabled; only then\ndo the most expensive operations (e.g., identifying the function containing the\ntrace call) occur, as well as the call to `clojure.core/tap>`."})}, :pom-str "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<project xmlns=\"http://maven.apache.org/POM/4.0.0\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:schemaLocation=\"http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd\">\n  <modelVersion>4.0.0</modelVersion>\n  <packaging>jar</packaging>\n  <groupId>io.github.hlship</groupId>\n  <artifactId>trace</artifactId>\n  <version>1.3</version>\n  <name>trace</name>\n  <dependencies>\n    <dependency>\n      <groupId>org.clojure</groupId>\n      <artifactId>clojure</artifactId>\n      <version>1.11.2</version>\n    </dependency>\n    <dependency>\n      <groupId>org.clj-commons</groupId>\n      <artifactId>pretty</artifactId>\n      <version>2.6.0</version>\n    </dependency>\n    <dependency>\n      <groupId>criterium</groupId>\n      <artifactId>criterium</artifactId>\n      <version>0.4.6</version>\n    </dependency>\n  </dependencies>\n  <build>\n    <sourceDirectory>src</sourceDirectory>\n    <resources>\n      <resource>\n        <directory>resources</directory>\n      </resource>\n    </resources>\n  </build>\n  <repositories>\n    <repository>\n      <id>clojars</id>\n      <url>https://repo.clojars.org/</url>\n    </repository>\n  </repositories>\n  <scm>\n    <tag>1.3</tag>\n    <url>https://github.com/hlship/trace</url>\n  </scm>\n  <licenses>\n    <license>\n      <name>Apache License, Version 2.0</name>\n      <url>https://www.apache.org/licenses/LICENSE-2.0.html</url>\n    </license>\n  </licenses>\n</project>\n"}