Table of Contents

accumulators

A generic accumulator interface and implementations of various
accumulators.

agent-utils

Miscellaneous agent utilities
(note to other contrib members: feel free to add to this lib)

base64

Base-64 encoding and (maybe later) decoding.  
This is mainly here as an example.  It is much slower than the
Apache Commons Codec implementation or sun.misc.BASE64Encoder.

classpath

Utilities for dealing with the JVM's classpath

combinatorics

Efficient, functional algorithms for generating lazy
sequences for common combinatorial functions. (See the source code 
for a longer description.)

command-line

Process command-line arguments according to a given cmdspec

complex-numbers

Complex numbers
NOTE: This library is in evolution. Most math functions are
      not implemented yet.

cond

Extensions to the basic cond function.

condition

Flexible raising and handling of conditions:
Functions:
              raise: raises a condition
       handler-case: dispatches raised conditions to appropriate handlers
  print-stack-trace: prints abbreviated or full condition stack traces
Data:
  A condition is a map containing values for these keys:
    - :type, a condition type specifier, typically a keyword
    - :stack-trace, a stack trace to the site of the raise
    - :message, a human-readable message (optional)
    - :cause, a wrapped exception or condition (optional)
    - other keys given as arguments to raise (optional)
Note: requires AOT compilation.
Based on an idea from Chouser:
https://groups.google.com/group/clojure/browse_frm/thread/da1285c538f22bb5

core

Functions/macros variants of the ones that can be found in clojure.core 
(note to other contrib members: feel free to add to this lib)

dataflow

A library to support a dataflow model of state

datalog

A Clojure implementation of Datalog

def

duck-streams

This file defines "duck-typed" I/O utility functions for Clojure.
The 'reader' and 'writer' functions will open and return an
instance of java.io.BufferedReader and java.io.PrintWriter,
respectively, for a variety of argument types -- filenames as
strings, URLs, java.io.File's, etc.  'reader' even works on http
URLs.
Note: this is not really "duck typing" as implemented in languages
like Ruby.  A better name would have been "do-what-I-mean-streams"
or "just-give-me-a-stream", but ducks are funnier.

error-kit

EXPERIMENTAL
System for defining and using custom errors
Please contact Chouser if you have any suggestions for better names
or API adjustments.

except

Provides functions that make it easy to specify the class, cause, and
message when throwing an Exception or Error. The optional message is
formatted using clojure.core/format.

fcase

This file defines a generic "case" macro called "fcase" which takes
the equality-testing function as an argument.  It also defines a
traditional "case" macro that tests using "=" and variants that
test for regular expressions and class membership.
Note (December 23, 2008): This library has been supplanted by the
inclusion of "condp" in clojure.core as of Clojure SVN rev. 1180.

find-namespaces

Search for ns declarations in dirs, JARs, or CLASSPATH

fnmap

Maps that dispatch get/assoc to user-defined functions.
Note: requires AOT-compilation

gen-html-docs

Generates a single HTML page that contains the documentation for
one or more Clojure libraries.

generic.arithmetic

Generic arithmetic interface
This library defines generic versions of + - * / as multimethods
that can be defined for any type. The minimal required 
implementations for a type are binary + and * plus unary - and /.
Everything else is derived from these automatically. Explicit
binary definitions for - and / can be provided for
efficiency reasons.

generic.collection

Generic arithmetic interface
This library defines generic versions of common
collection-related functions as multimethods that can be
defined for any type.

generic.comparison

Generic comparison interface
This library defines generic versions of = < > <= >= zero?
as multimethods that can be defined for any type. Of the
greater/less-than relations, types must minimally implement >.

generic.functor

Generic functor interface (fmap)

generic.math-functions

Generic math function interface
This library defines generic versions of common mathematical
functions such as sqrt or sin as multimethods that can be
defined for any type.

graph

Basic graph theory algorithms

greatest-least

Various functions for finding greatest and least values in a collection

http.agent

Agent-based asynchronous HTTP client.
This is a HTTP client library based on Java's HttpURLConnection
class and Clojure's Agent system.  It allows you to make multiple
HTTP requests in parallel.
Start an HTTP request with the 'http-agent' function, which
immediately returns a Clojure Agent.  You will never deref this
agent; that is handled by the accessor functions.  The agent will
execute the HTTP request on a separate thread.
If you pass a :handler function to http-agent, that function will be
called as soon as the HTTP response body is ready.  The handler
function is called with one argument, the HTTP agent itself.  The
handler can read the response body by calling the 'stream' function
on the agent.
The value returned by the handler function becomes part of the state
of the agent, and you can retrieve it with the 'result' function.
If you call 'result' before the HTTP request has finished, it will
block until the handler function returns.
If you don't provide a handler function, the default handler will
buffer the entire response body in memory, which you can retrieve
with the 'bytes', 'string', or 'stream' functions.  Like 'result',
these functions will block until the HTTP request is completed.
If you want to check if an HTTP request is finished without
blocking, use the 'done?' function.
A single GET request could be as simple as:
  (string (http-agent "https://www.stuartsierra.com/"))
A simple POST might look like:
  (http-agent "http..." :method "POST" :body "foo=1")
And you could write the response directly to a file like this:
  (require '[clojure.contrib.duck-streams :as d])
  (http-agent "http..."
              :handler (fn [agnt] 
                         (with-open [w (d/writer "/tmp/out")] 
                           (d/copy (stream agnt) w))))

http.connection

Low-level HTTP client API around HttpURLConnection

import-static

Import static Java methods/fields into Clojure

jar

Utilities for working with Java JAR files

java-utils

javadoc.browse

Start a web browser from Clojure

jmx

JMX support for Clojure
Requires post-Clojure 1.0 git edge for clojure.test, clojure.backtrace.
This is prerelease.
This API will change.
Send reports to stu@thinkrelevance.com.
Usage
  (require '[clojure.contrib.jmx :as jmx])
What beans do I have?
  (jmx/mbean-names "*:*")
  -> #<HashSet [java.lang:type=MemoryPool,name=CMS Old Gen, 
                java.lang:type=Memory, ...]
What attributes does a bean have?
  (jmx/attribute-names "java.lang:type=Memory")
  -> (:Verbose :ObjectPendingFinalizationCount 
      :HeapMemoryUsage :NonHeapMemoryUsage)
What is the value of an attribute? 
  (jmx/read "java.lang:type=Memory" :ObjectPendingFinalizationCount)
  -> 0
Can't I just have *all* the attributes in a Clojure map?
  (jmx/mbean "java.lang:type=Memory")
  -> {:NonHeapMemoryUsage
       {:used 16674024, :max 138412032, :init 24317952, :committed 24317952},
      :HeapMemoryUsage
       {:used 18619064, :max 85393408, :init 0, :committed 83230720},
      :ObjectPendingFinalizationCount 0,
      :Verbose false}
Can I find and invoke an operation?
  (jmx/operation-names "java.lang:type=Memory")
  -> (:gc)  
  (jmx/invoke "java.lang:type=Memory" :gc)
  -> nil
What about some other process? Just run *any* of the above code
inside a with-connection:
  (jmx/with-connection {:host "localhost", :port 3000} 
    (jmx/mbean "java.lang:type=Memory"))
  -> {:ObjectPendingFinalizationCount 0, 
      :HeapMemoryUsage ... etc.}
Can I serve my own beans?  Sure, just drop a Clojure ref
into an instance of clojure.contrib.jmx.Bean, and the bean
will expose read-only attributes for every key/value pair
in the ref:
  (jmx/register-mbean
     (Bean.
     (ref {:string-attribute "a-string"}))
     "my.namespace:name=Value")

json.read

JavaScript Object Notation (JSON) parser
For more information on JSON, see https://www.json.org/
This library parses data in JSON format.  This is a fairly strict
implementation of JSON as described at json.org, not a full-fledged
JavaScript parser.  JavaScript functions and object constructors
are not supported.  Object field names must be quoted strings; they
may not be bare symbols.
If you want to convert map keys from strings to keywords, use
clojure.contrib.walk/keywordize-keys

json.write

JavaScript Object Notation (JSON) generator.
This library will generate JSON from the following types:
 * nil
 * all primitives (Boolean, Byte, Short, Integer, Long, Float, Double)
 * String (actually any CharSequence)
 * java.util.Map (including Clojure maps)
 * java.util.Collection (including Clojure vectors, lists, and sets)
 * Java arrays
You can extend this library to handle new types by adding methods to
print-json.
This library does NOT attempt to preserve round-trip equality between
JSON and Clojure data types. That is, if you write a JSON string with
this library, then read it back with clojure.contrib.json.read, you
won't necessarily get the exact same data structure.  For example,
Clojure sets are written as JSON arrays, which will be read back as
Clojure vectors.
If you want indented output, try the clojure-json library at
https://github.com/danlarkin/clojure-json
This implementation attempts to follow the description of JSON at
<https://json.org/>.  Maps become JSON objects, all other collections
become JSON arrays.  JSON object keys are always converted to strings.
Within strings, all non-ASCII characters are hexadecimal escaped.

lazy-seqs

==== Lazy sequences ====
 primes - based on the "naive" implemention described in [1] plus a
          small "wheel" which eliminates multiples of 2, 3, 5, and
          7 from consideration by incrementing past them. Also inspired
          by code from Christophe Grand in [2].
 fibs   - all the Fibonacci numbers
 powers-of-2 - all the powers of 2
 ==== Lazy sequence functions ====
 (rotations, partition-all, shuffle, rand-elt  moved to seq_utils.clj)
 (permutations and combinations moved to combinatorics.clj)
 [1] https://www.cs.hmc.edu/~oneill/papers/Sieve-JFP.pdf
 [2] https://clj-me.blogspot.com/2008/06/primes.html

lazy-xml

Functions to parse xml lazily and emit back to text.

logging

Logging macros which delegate to a specific logging implementation. At
macro-expansion-time a specific implementation is selected from, in order,
Apache commons-logging, log4j, and finally java.util.logging.
Logging levels are specified by clojure keywords corresponding to the
values used in log4j and commons-logging:
  :trace, :debug, :info, :warn, :error, :fatal
Logging occurs with the log macro, or the level-specific convenience macros,
which write either directly or via an agent.  For performance reasons, direct
logging is enabled by default, but setting the *allow-direct-logging* boolean
atom to false will disable it. If logging is invoked within a transaction it
will always use an agent.
The log macros will not evaluate their 'message' unless the specific logging
level is in effect. Alternately, you can use the spy macro when you have code
that needs to be evaluated, and also want to output the code and its result to
the debug log.
Unless otherwise specified, the current namespace (as identified by *ns*) will
be used as the log-ns (similar to how the java class name is usually used).
Note: your log configuration should display the name that was passed to the
logging implementation, and not perform stack-inspection, otherwise you'll see
something like "fn__72$impl_write_BANG__39__auto____81" in your logs.
Use the enabled? macro to write conditional code against the logging level
(beyond simply whether or not to call log, which is handled automatically).
You can redirect all java writes of System.out and System.err to the log
system by calling log-capture!.  To rebind *out* and *err* to the log system
invoke with-logs.  In both cases a log-ns (e.g., "com.example.captured")
needs to be specified to namespace the output.

macro-utils

Local macros and symbol macros
Local macros are defined by a macrolet form. They are usable only
inside its body. Symbol macros can be defined globally
(defsymbolmacro) or locally (symbol-macrolet). A symbol
macro defines a form that replaces a symbol during macro
expansion. Function arguments and symbols bound in let
forms are not subject to symbol macro expansion.
Local macros are most useful in the definition of the expansion
of another macro, they may be used anywhere. Global symbol
macros can be used only inside a with-symbol-macros form.

macros

Various small macros

map-utils

Utilities for operating on Clojure maps.

math

Math functions that deal intelligently with the various
types in Clojure's numeric tower, as well as math functions
commonly found in Scheme implementations.
expt - (expt x y) is x to the yth power, returns an exact number
  if the base is an exact number, and the power is an integer,
  otherwise returns a double.
abs - (abs n) is the absolute value of n
gcd - (gcd m n) returns the greatest common divisor of m and n
lcm - (lcm m n) returns the least common multiple of m and n
The behavior of the next three functions on doubles is consistent
with the behavior of the corresponding functions
in Java's Math library, but on exact numbers, returns an integer.
floor - (floor n) returns the greatest integer less than or equal to n.
  If n is an exact number, floor returns an integer,
  otherwise a double.
ceil - (ceil n) returns the least integer greater than or equal to n.
  If n is an exact number, ceil returns an integer,
  otherwise a double.
round - (round n) rounds to the nearest integer.
  round always returns an integer.  round rounds up for values
  exactly in between two integers.
sqrt - Implements the sqrt behavior I'm accustomed to from PLT Scheme,
  specifically, if the input is an exact number, and is a square
  of an exact number, the output will be exact.  The downside
  is that for the common case (inexact square root), some extra
  computation is done to look for an exact square root first.
  So if you need blazingly fast square root performance, and you
  know you're just going to need a double result, you're better
  off calling java's Math/sqrt, or alternatively, you could just
  convert your input to a double before calling this sqrt function.
  If Clojure ever gets complex numbers, then this function will
  need to be updated (so negative inputs yield complex outputs).
exact-integer-sqrt - Implements a math function from the R6RS Scheme
  standard.  (exact-integer-sqrt k) where k is a non-negative integer,
  returns [s r] where k = s^2+r and k < (s+1)^2.  In other words, it
  returns the floor of the square root and the 

miglayout

Clojure support for the MiGLayout layout manager
https://www.miglayout.com/
Example:
  (use '[clojure.contrib.miglayout.test :as mlt :only ()])
  (dotimes [i 5] (mlt/run-test i))

mmap

Functions for memory-mapping files, plus some functions that use a
mmaped file for "normal" activies -- slurp, load-file, etc.

mock

monadic-io-streams

Monadic I/O with Java input/output streams
Defines monadic I/O statements to be used in a state monad
with an input or output stream as the state. The macro
monadic-io creates a stream, runs a monadic I/O statement
on it, and closes the stream. This structure permits the
definition of purely functional compound I/O statements
which are applied to streams that can never escape from the
monadic statement sequence.

monads

This library contains the most commonly used monads as well
as macros for defining and using monads and useful monadic
functions.

ns-utils

Namespace utilities

pprint

This module comprises two elements:
1) A pretty printer for Clojure data structures, implemented in the 
   function "pprint"
2) A Common Lisp compatible format function, implemented as 
   "cl-format" because Clojure is using the name "format" 
   for its Java-based format function.
See documentation for those functions for more information or complete 
documentation on the the clojure-contrib web site on github.

probabilities.finite-distributions

Finite probability distributions
This library defines a monad for combining finite probability
distributions.

probabilities.monte-carlo

Monte-Carlo method support
Monte-Carlo methods transform an input random number stream
(usually having a continuous uniform distribution in the
interval [0, 1)) into a random number stream whose distribution
satisfies certain conditions (usually the expectation value
is equal to some desired quantity). They are thus
transformations from one probability distribution to another one.
This library represents a Monte-Carlo method by a function that
takes as input the state of a random number stream with
uniform distribution (see
clojure.contrib.probabilities.random-numbers) and returns a
vector containing one sample value of the desired output
distribution and the final state of the input random number
stream. Such functions are state monad values and can be
composed using operations defined in clojure.contrib.monads.

probabilities.random-numbers

Random number streams
This library provides random number generators with a common
stream interface. They all produce pseudo-random numbers that are
uniformly distributed in the interval [0, 1), i.e. 0 is a
possible value but 1 isn't. For transformations to other
distributions, see clojure.contrib.probabilities.monte-carlo.
At the moment, the only generator provided is a rather simple
linear congruential generator.

profile

Simple code profiling & timing measurement.
Wrap any section of code in the prof macro, giving it a name, like this:
       (defn my-function [x y]
         (let [sum (prof :addition (+ x y))
               product (prof :multiplication (* x y))]
           [sum product]))
The run your code in the profile macro, like this:
       (profile (dotimes [i 10000] (my-function 3 4)))
Which prints a report for each named section of code:
          Name      mean       min       max     count       sum
      addition       265         0     37000     10000   2655000
multiplication       274         0     53000     10000   2747000
Times are measured in nanoseconds, to the maximum precision available
under the JVM.  See the function documentation for more details.

prxml

Compact syntax for generating XML. See the documentation of "prxml" 
for details.

repl-ln

A repl with that provides support for lines and line numbers in the
input stream.

repl-utils

Utilities meant to be used interactively at the REPL

seq-utils

Sequence utilities for Clojure

server-socket

Server socket library - includes REPL on socket

set

Clojure functions for operating on sets (supplemental to clojure.set)

shell-out

Conveniently launch a sub-process providing to its stdin and
collecting its stdout

singleton

Singleton functions

sql

A Clojure interface to sql databases via jdbc
See clojure.contrib.sql.test for an example

str-utils

String utilities for Clojure

str-utils2

This is a library of string manipulation functions.  It
is intented as a replacement for clojure.contrib.str-utils.
You cannot (use 'clojure.contrib.str-utils2) because it defines
functions with the same names as functions in clojure.core.
Instead, do (require '[clojure.contrib.str-utils2 :as s]) 
or something similar.
Goals:
  1. Be functional
  2. String argument first, to work with ->
  3. Performance linear in string length
Some ideas are borrowed from
https://github.com/francoisdevlin/devlinsf-clojure-utils/

stream-utils

Functions for setting up computational pipelines via data streams.
NOTE: This library is experimental. It may change significantly
      with future release.
This library defines:
- an abstract stream type, whose interface consists of the
  multimethod stream-next
- a macro for implementing streams
- implementations of stream for
  1) Clojure sequences, and vectors
  2) nil, representing an empty stream
- tools for writing stream transformers, including the
  monad stream-m
- various utility functions for working with streams
Streams are building blocks in the construction of computational
pipelines. A stream is represented by its current state plus
a function that takes a stream state and obtains the next item
in the stream as well as the new stream state. The state is
implemented as a Java class or a Clojure type (as defined by the
function clojure.core/type), and the function is provided as an
implementation of the multimethod stream-next for this class or type.
While setting up pipelines using this mechanism is somewhat more
cumbersome than using Clojure's lazy seq mechanisms, there are a
few advantages:
- The state of a stream can be stored in any Clojure data structure,
  and the stream can be re-generated from it any number of times.
  Any number of states can be stored this way.
- The elements of the stream are never cached, so keeping a reference
  to a stream state does not incur an uncontrollable memory penalty.
Note that the stream mechanism is thread-safe as long as the
concrete stream implementations do not use any mutable state.
Stream transformers take any number of input streams and produce one
output stream. They are typically written using the stream-m
monad. In the definition of a stream transformer, (pick s) returns
the next value of stream argument s, whereas pick-all returns the
next value of all stream arguments in the form of a vector.

swing-utils

test-is

Backwards-compatibility for clojure.contrib.test-is
The clojure.contrib.test-is library moved from Contrib into the
Clojure distribution as clojure.test.
This happened on or around clojure-contrib Git commit
82cf0409d0fcb71be477ebfc4da18ee2128a2ad1 on June 25, 2009.
This file makes the clojure.test interface available under the old
namespace clojure.contrib.test-is.
This includes support for the old syntax of the 'are' macro.
This was suggested by Howard Lewis Ship in ticket #26, 
https://www.assembla.com/spaces/clojure-contrib/tickets/26

trace

This file defines simple "tracing" macros to help you see what your
code is doing.

types

General and algebraic data types

with-ns

Temporary namespace macro

zip-filter

System for filtering trees and nodes generated by zip.clj in
general, and xml trees in particular.