path: root/api-index.json

{"namespaces":
 [{"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/accumulators-api.html",
   "name":"clojure.contrib.accumulators",
   "author":"Konrad Hinsen",
   "doc":
   "A generic accumulator interface and implementations of various\naccumulators."},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/agent-utils-api.html",
   "name":"clojure.contrib.agent-utils",
   "author":"Christophe Grande",
   "doc":
   "Miscellaneous agent utilities\n(note to other contrib members: feel free to add to this lib)"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/apply-macro-api.html",
   "name":"clojure.contrib.apply-macro",
   "doc":null},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/base64-api.html",
   "name":"clojure.contrib.base64",
   "author":"Stuart Sierra",
   "doc":
   "Base-64 encoding and (maybe later) decoding.  \n\nThis is mainly here as an example.  It is much slower than the\nApache Commons Codec implementation or sun.misc.BASE64Encoder."},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/classpath-api.html",
   "name":"clojure.contrib.classpath",
   "author":"Stuart Sierra",
   "doc":"Utilities for dealing with the JVM's classpath"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/combinatorics-api.html",
   "name":"clojure.contrib.combinatorics",
   "author":"Mark Engelberg",
   "doc":
   "Efficient, functional algorithms for generating lazy\nsequences for common combinatorial functions. (See the source code \nfor a longer description.)"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/command-line-api.html",
   "name":"clojure.contrib.command-line",
   "author":"Chris Houser",
   "doc":
   "Process command-line arguments according to a given cmdspec"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/complex-numbers-api.html",
   "name":"clojure.contrib.complex-numbers",
   "author":"Konrad Hinsen",
   "doc":
   "Complex numbers\nNOTE: This library is in evolution. Most math functions are\n      not implemented yet."},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/cond-api.html",
   "name":"clojure.contrib.cond",
   "author":"Stephen C. Gilardi",
   "doc":"Extensions to the basic cond function."},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/condition-api.html",
   "name":"clojure.contrib.condition",
   "author":"Stephen C. Gilardi",
   "doc":
   "Flexible raising and handling of conditions:\n\nFunctions:\n\n              raise: raises a condition\n       handler-case: dispatches raised conditions to appropriate handlers\n  print-stack-trace: prints abbreviated or full condition stack traces\n\nData:\n\n  A condition is a map containing values for these keys:\n\n    - :type, a condition type specifier, typically a keyword\n    - :stack-trace, a stack trace to the site of the raise\n    - :message, a human-readable message (optional)\n    - :cause, a wrapped exception or condition (optional)\n    - other keys given as arguments to raise (optional)\n\nNote: requires AOT compilation.\n\nBased on an idea from Chouser:\nhttp://groups.google.com/group/clojure/browse_frm/thread/da1285c538f22bb5"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/core-api.html",
   "name":"clojure.contrib.core",
   "author":"Laurent Petit (and others)",
   "doc":
   "Functions/macros variants of the ones that can be found in clojure.core \n(note to other contrib members: feel free to add to this lib)"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/dataflow-api.html",
   "name":"clojure.contrib.dataflow",
   "author":"Jeffrey Straszheim",
   "doc":"A library to support a dataflow model of state"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/datalog-api.html",
   "name":"clojure.contrib.datalog",
   "author":"Jeffrey Straszheim",
   "doc":"A Clojure implementation of Datalog"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/def-api.html",
   "name":"clojure.contrib.def",
   "doc":null},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/duck-streams-api.html",
   "name":"clojure.contrib.duck-streams",
   "author":"Stuart Sierra",
   "doc":
   "This file defines \"duck-typed\" I/O utility functions for Clojure.\nThe 'reader' and 'writer' functions will open and return an\ninstance of java.io.BufferedReader and java.io.PrintWriter,\nrespectively, for a variety of argument types -- filenames as\nstrings, URLs, java.io.File's, etc.  'reader' even works on http\nURLs.\n\nNote: this is not really \"duck typing\" as implemented in languages\nlike Ruby.  A better name would have been \"do-what-I-mean-streams\"\nor \"just-give-me-a-stream\", but ducks are funnier."},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/error-kit-api.html",
   "name":"clojure.contrib.error-kit",
   "author":"Chris Houser",
   "doc":
   "EXPERIMENTAL\nSystem for defining and using custom errors\nPlease contact Chouser if you have any suggestions for better names\nor API adjustments."},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/except-api.html",
   "name":"clojure.contrib.except",
   "author":"Stephen C. Gilardi",
   "doc":
   "Provides functions that make it easy to specify the class, cause, and\nmessage when throwing an Exception or Error. The optional message is\nformatted using clojure.core/format."},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/fcase-api.html",
   "name":"clojure.contrib.fcase",
   "author":"Stuart Sierra",
   "doc":
   "This file defines a generic \"case\" macro called \"fcase\" which takes\nthe equality-testing function as an argument.  It also defines a\ntraditional \"case\" macro that tests using \"=\" and variants that\ntest for regular expressions and class membership.\n\n\nNote (December 23, 2008): This library has been supplanted by the\ninclusion of \"condp\" in clojure.core as of Clojure SVN rev. 1180."},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/find-namespaces-api.html",
   "name":"clojure.contrib.find-namespaces",
   "author":"Stuart Sierra",
   "doc":"Search for ns declarations in dirs, JARs, or CLASSPATH"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/fnmap-api.html",
   "name":"clojure.contrib.fnmap",
   "author":"Stuart Sierra",
   "doc":
   "Maps that dispatch get/assoc to user-defined functions.\n\nNote: requires AOT-compilation"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/gen-html-docs-api.html",
   "name":"clojure.contrib.gen-html-docs",
   "author":"Craig Andera",
   "doc":
   "Generates a single HTML page that contains the documentation for\none or more Clojure libraries."},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/generic.arithmetic-api.html",
   "name":"clojure.contrib.generic.arithmetic",
   "author":"Konrad Hinsen",
   "doc":
   "Generic arithmetic interface\nThis library defines generic versions of + - * / as multimethods\nthat can be defined for any type. The minimal required \nimplementations for a type are binary + and * plus unary - and /.\nEverything else is derived from these automatically. Explicit\nbinary definitions for - and / can be provided for\nefficiency reasons."},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/generic.collection-api.html",
   "name":"clojure.contrib.generic.collection",
   "author":"Konrad Hinsen",
   "doc":
   "Generic arithmetic interface\nThis library defines generic versions of common\ncollection-related functions as multimethods that can be\ndefined for any type."},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/generic.comparison-api.html",
   "name":"clojure.contrib.generic.comparison",
   "author":"Konrad Hinsen",
   "doc":
   "Generic comparison interface\nThis library defines generic versions of = < > <= >= zero?\nas multimethods that can be defined for any type. Of the\ngreater/less-than relations, types must minimally implement >."},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/generic.functor-api.html",
   "name":"clojure.contrib.generic.functor",
   "author":"Konrad Hinsen",
   "doc":"Generic functor interface (fmap)"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/generic.math-functions-api.html",
   "name":"clojure.contrib.generic.math-functions",
   "author":"Konrad Hinsen",
   "doc":
   "Generic math function interface\nThis library defines generic versions of common mathematical\nfunctions such as sqrt or sin as multimethods that can be\ndefined for any type."},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/graph-api.html",
   "name":"clojure.contrib.graph",
   "author":"Jeffrey Straszheim",
   "doc":"Basic graph theory algorithms"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/greatest-least-api.html",
   "name":"clojure.contrib.greatest-least",
   "author":"Vincent Foley",
   "doc":
   "Various functions for finding greatest and least values in a collection"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/http.agent-api.html",
   "name":"clojure.contrib.http.agent",
   "author":"Stuart Sierra",
   "doc":
   "Agent-based asynchronous HTTP client.\n\nThis is a HTTP client library based on Java's HttpURLConnection\nclass and Clojure's Agent system.  It allows you to make multiple\nHTTP requests in parallel.\n\nStart an HTTP request with the 'http-agent' function, which\nimmediately returns a Clojure Agent.  You will never deref this\nagent; that is handled by the accessor functions.  The agent will\nexecute the HTTP request on a separate thread.\n\nIf you pass a :handler function to http-agent, that function will be\ncalled as soon as the HTTP response body is ready.  The handler\nfunction is called with one argument, the HTTP agent itself.  The\nhandler can read the response body by calling the 'stream' function\non the agent.\n\nThe value returned by the handler function becomes part of the state\nof the agent, and you can retrieve it with the 'result' function.\nIf you call 'result' before the HTTP request has finished, it will\nblock until the handler function returns.\n\nIf you don't provide a handler function, the default handler will\nbuffer the entire response body in memory, which you can retrieve\nwith the 'bytes', 'string', or 'stream' functions.  Like 'result',\nthese functions will block until the HTTP request is completed.\n\nIf you want to check if an HTTP request is finished without\nblocking, use the 'done?' function.\n\nA single GET request could be as simple as:\n\n  (string (http-agent \"http://www.stuartsierra.com/\"))\n\nA simple POST might look like:\n\n  (http-agent \"http...\" :method \"POST\" :body \"foo=1\")\n\nAnd you could write the response directly to a file like this:\n\n  (require '[clojure.contrib.duck-streams :as d])\n\n  (http-agent \"http...\"\n              :handler (fn [agnt] \n                         (with-open [w (d/writer \"/tmp/out\")] \n                           (d/copy (stream agnt) w))))"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/http.connection-api.html",
   "name":"clojure.contrib.http.connection",
   "doc":"Low-level HTTP client API around HttpURLConnection"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/import-static-api.html",
   "name":"clojure.contrib.import-static",
   "author":"Stuart Sierra",
   "doc":"Import static Java methods/fields into Clojure"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/jar-api.html",
   "name":"clojure.contrib.jar",
   "author":"Stuart Sierra",
   "doc":"Utilities for working with Java JAR files"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/java-utils-api.html",
   "name":"clojure.contrib.java-utils",
   "author":
   "Stuart Halloway, Stephen C. Gilardi, Shawn Hoover, Perry Trolard, Stuart Sierra",
   "doc":
   "A set of utilties for dealing with Java stuff like files and properties.\n\nDesign goals:\n\n(1) Ease-of-use. These APIs should be convenient. Performance is secondary.\n\n(2) Duck typing. I hate having to think about the difference between\n    a string that names a file, and a File. Ditto for a ton of other \n    wrapper classes in the Java world (URL, InternetAddress). With these\n    APIs you should be able to think about domain equivalence, not type\n    equivalence.\n\n(3) No bossiness. I am not marking any of these functions as private\n    the docstrings will tell you the intended usage but do what works for you. \t\t\t\t\t\n\nFeedback welcome!\n\nIf something in this module violates the principle of least surprise, please \nlet me (Stu) and the Clojure community know via the mailing list."},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/jmx-api.html",
   "name":"clojure.contrib.jmx",
   "author":"Stuart Halloway",
   "doc":
   "JMX support for Clojure\n\nRequires post-Clojure 1.0 git edge for clojure.test, clojure.backtrace.\nThis is prerelease.\nThis API will change.\nSend reports to stu@thinkrelevance.com.\n\nUsage\n  (require '[clojure.contrib.jmx :as jmx])\n\nWhat beans do I have?\n\n  (jmx/mbean-names \"*:*\")\n  -> #<HashSet [java.lang:type=MemoryPool,name=CMS Old Gen, \n                java.lang:type=Memory, ...]\n\nWhat attributes does a bean have?\n\n  (jmx/attribute-names \"java.lang:type=Memory\")\n  -> (:Verbose :ObjectPendingFinalizationCount \n      :HeapMemoryUsage :NonHeapMemoryUsage)\n\nWhat is the value of an attribute? \n\n  (jmx/read \"java.lang:type=Memory\" :ObjectPendingFinalizationCount)\n  -> 0\n\nCan't I just have *all* the attributes in a Clojure map?\n\n  (jmx/mbean \"java.lang:type=Memory\")\n  -> {:NonHeapMemoryUsage\n       {:used 16674024, :max 138412032, :init 24317952, :committed 24317952},\n      :HeapMemoryUsage\n       {:used 18619064, :max 85393408, :init 0, :committed 83230720},\n      :ObjectPendingFinalizationCount 0,\n      :Verbose false}\n\nCan I find and invoke an operation?\n\n  (jmx/operation-names \"java.lang:type=Memory\")\n  -> (:gc)  \n  (jmx/invoke \"java.lang:type=Memory\" :gc)\n  -> nil\n\nWhat about some other process? Just run *any* of the above code\ninside a with-connection:\n\n  (jmx/with-connection {:host \"localhost\", :port 3000} \n    (jmx/mbean \"java.lang:type=Memory\"))\n  -> {:ObjectPendingFinalizationCount 0, \n      :HeapMemoryUsage ... etc.}\n\nCan I serve my own beans?  Sure, just drop a Clojure ref\ninto an instance of clojure.contrib.jmx.Bean, and the bean\nwill expose read-only attributes for every key/value pair\nin the ref:\n\n  (jmx/register-mbean\n     (Bean.\n     (ref {:string-attribute \"a-string\"}))\n     \"my.namespace:name=Value\")"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/json.read-api.html",
   "name":"clojure.contrib.json.read",
   "author":"Stuart Sierra",
   "doc":
   "JavaScript Object Notation (JSON) parser\n\nFor more information on JSON, see http://www.json.org/\n\nThis library parses data in JSON format.  This is a fairly strict\nimplementation of JSON as described at json.org, not a full-fledged\nJavaScript parser.  JavaScript functions and object constructors\nare not supported.  Object field names must be quoted strings; they\nmay not be bare symbols.\n\nIf you want to convert map keys from strings to keywords, use\nclojure.contrib.walk/keywordize-keys"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/json.write-api.html",
   "name":"clojure.contrib.json.write",
   "author":"Stuart Sierra",
   "doc":
   "JavaScript Object Notation (JSON) generator.\n\nThis library will generate JSON from the following types:\n * nil\n * all primitives (Boolean, Byte, Short, Integer, Long, Float, Double)\n * String (actually any CharSequence)\n * java.util.Map (including Clojure maps)\n * java.util.Collection (including Clojure vectors, lists, and sets)\n * Java arrays\n\nYou can extend this library to handle new types by adding methods to\nprint-json.\n\nThis library does NOT attempt to preserve round-trip equality between\nJSON and Clojure data types. That is, if you write a JSON string with\nthis library, then read it back with clojure.contrib.json.read, you\nwon't necessarily get the exact same data structure.  For example,\nClojure sets are written as JSON arrays, which will be read back as\nClojure vectors.\n\nIf you want indented output, try the clojure-json library at\nhttp://github.com/danlarkin/clojure-json\n\nThis implementation attempts to follow the description of JSON at\n<http://json.org/>.  Maps become JSON objects, all other collections\nbecome JSON arrays.  JSON object keys are always converted to strings.\nWithin strings, all non-ASCII characters are hexadecimal escaped."},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/lazy-seqs-api.html",
   "name":"clojure.contrib.lazy-seqs",
   "author":"Stephen C. Gilardi",
   "doc":
   "\n==== Lazy sequences ====\n\n primes - based on the \"naive\" implemention described in [1] plus a\n          small \"wheel\" which eliminates multiples of 2, 3, 5, and\n          7 from consideration by incrementing past them. Also inspired\n          by code from Christophe Grand in [2].\n\n fibs   - all the Fibonacci numbers\n\n powers-of-2 - all the powers of 2\n\n ==== Lazy sequence functions ====\n\n (rotations, partition-all, shuffle, rand-elt  moved to seq_utils.clj)\n (permutations and combinations moved to combinatorics.clj)\n\n [1] http://www.cs.hmc.edu/~oneill/papers/Sieve-JFP.pdf\n [2] http://clj-me.blogspot.com/2008/06/primes.html"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/lazy-xml-api.html",
   "name":"clojure.contrib.lazy-xml",
   "author":"Chris Houser",
   "doc":"Functions to parse xml lazily and emit back to text."},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/logging-api.html",
   "name":"clojure.contrib.logging",
   "author":"Alex Taggart, Timothy Pratley",
   "doc":
   "Logging macros which delegate to a specific logging implementation. At\nmacro-expansion-time a specific implementation is selected from, in order,\nApache commons-logging, log4j, and finally java.util.logging.\n\nLogging levels are specified by clojure keywords corresponding to the\nvalues used in log4j and commons-logging:\n  :trace, :debug, :info, :warn, :error, :fatal\n\nLogging occurs with the log macro, or the level-specific convenience macros,\nwhich write either directly or via an agent.  For performance reasons, direct\nlogging is enabled by default, but setting the *allow-direct-logging* boolean\natom to false will disable it. If logging is invoked within a transaction it\nwill always use an agent.\n\nThe log macros will not evaluate their 'message' unless the specific logging\nlevel is in effect. Alternately, you can use the spy macro when you have code\nthat needs to be evaluated, and also want to output the code and its result to\nthe debug log.\n\nUnless otherwise specified, the current namespace (as identified by *ns*) will\nbe used as the log-ns (similar to how the java class name is usually used).\nNote: your log configuration should display the name that was passed to the\nlogging implementation, and not perform stack-inspection, otherwise you'll see\nsomething like \"fn__72$impl_write_BANG__39__auto____81\" in your logs.\n\nUse the enabled? macro to write conditional code against the logging level\n(beyond simply whether or not to call log, which is handled automatically).\n\nYou can redirect all java writes of System.out and System.err to the log\nsystem by calling log-capture!.  To rebind *out* and *err* to the log system\ninvoke with-logs.  In both cases a log-ns (e.g., \"com.example.captured\")\nneeds to be specified to namespace the output."},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/macro-utils-api.html",
   "name":"clojure.contrib.macro-utils",
   "author":"Konrad Hinsen",
   "doc":
   "Local macros and symbol macros\n\nLocal macros are defined by a macrolet form. They are usable only\ninside its body. Symbol macros can be defined globally\n(defsymbolmacro) or locally (symbol-macrolet). A symbol\nmacro defines a form that replaces a symbol during macro\nexpansion. Function arguments and symbols bound in let\nforms are not subject to symbol macro expansion.\n\nLocal macros are most useful in the definition of the expansion\nof another macro, they may be used anywhere. Global symbol\nmacros can be used only inside a with-symbol-macros form."},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/macros-api.html",
   "name":"clojure.contrib.macros",
   "author":"Konrad Hinsen",
   "doc":"Various small macros"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/map-utils-api.html",
   "name":"clojure.contrib.map-utils",
   "author":"Jason Wolfe, Chris Houser",
   "doc":"Utilities for operating on Clojure maps."},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/math-api.html",
   "name":"clojure.contrib.math",
   "author":"Mark Engelberg",
   "doc":
   "Math functions that deal intelligently with the various\ntypes in Clojure's numeric tower, as well as math functions\ncommonly found in Scheme implementations.\n\nexpt - (expt x y) is x to the yth power, returns an exact number\n  if the base is an exact number, and the power is an integer,\n  otherwise returns a double.\nabs - (abs n) is the absolute value of n\ngcd - (gcd m n) returns the greatest common divisor of m and n\nlcm - (lcm m n) returns the least common multiple of m and n\n\nThe behavior of the next three functions on doubles is consistent\nwith the behavior of the corresponding functions\nin Java's Math library, but on exact numbers, returns an integer.\n\nfloor - (floor n) returns the greatest integer less than or equal to n.\n  If n is an exact number, floor returns an integer,\n  otherwise a double.\nceil - (ceil n) returns the least integer greater than or equal to n.\n  If n is an exact number, ceil returns an integer,\n  otherwise a double.\nround - (round n) rounds to the nearest integer.\n  round always returns an integer.  round rounds up for values\n  exactly in between two integers.\n\n\nsqrt - Implements the sqrt behavior I'm accustomed to from PLT Scheme,\n  specifically, if the input is an exact number, and is a square\n  of an exact number, the output will be exact.  The downside\n  is that for the common case (inexact square root), some extra\n  computation is done to look for an exact square root first.\n  So if you need blazingly fast square root performance, and you\n  know you're just going to need a double result, you're better\n  off calling java's Math/sqrt, or alternatively, you could just\n  convert your input to a double before calling this sqrt function.\n  If Clojure ever gets complex numbers, then this function will\n  need to be updated (so negative inputs yield complex outputs).\nexact-integer-sqrt - Implements a math function from the R6RS Scheme\n  standard.  (exact-integer-sqrt k) where k is a non-negative integer,\n  returns [s r] where k = s^2+r and k < (s+1)^2.  In other words, it\n  returns the floor of the square root and the "},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/miglayout-api.html",
   "name":"clojure.contrib.miglayout",
   "author":"Stephen C. Gilardi",
   "doc":
   "Clojure support for the MiGLayout layout manager\nhttp://www.miglayout.com/\n\nExample:\n\n  (use '[clojure.contrib.miglayout.test :as mlt :only ()])\n  (dotimes [i 5] (mlt/run-test i))"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/mmap-api.html",
   "name":"clojure.contrib.mmap",
   "author":"Chris Houser",
   "doc":
   "Functions for memory-mapping files, plus some functions that use a\nmmaped file for \"normal\" activies -- slurp, load-file, etc."},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/mock-api.html",
   "name":"clojure.contrib.mock",
   "doc":null},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/monadic-io-streams-api.html",
   "name":"clojure.contrib.monadic-io-streams",
   "author":"Konrad Hinsen",
   "doc":
   "Monadic I/O with Java input/output streams\nDefines monadic I/O statements to be used in a state monad\nwith an input or output stream as the state. The macro\nmonadic-io creates a stream, runs a monadic I/O statement\non it, and closes the stream. This structure permits the\ndefinition of purely functional compound I/O statements\nwhich are applied to streams that can never escape from the\nmonadic statement sequence."},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/monads-api.html",
   "name":"clojure.contrib.monads",
   "author":"Konrad Hinsen",
   "doc":
   "This library contains the most commonly used monads as well\nas macros for defining and using monads and useful monadic\nfunctions."},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/ns-utils-api.html",
   "name":"clojure.contrib.ns-utils",
   "author":"Stephen C. Gilardi",
   "doc":"Namespace utilities"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/pprint-api.html",
   "name":"clojure.contrib.pprint",
   "author":"Tom Faulhaber",
   "doc":
   "This module comprises two elements:\n1) A pretty printer for Clojure data structures, implemented in the \n   function \"pprint\"\n2) A Common Lisp compatible format function, implemented as \n   \"cl-format\" because Clojure is using the name \"format\" \n   for its Java-based format function.\n\nSee documentation for those functions for more information or complete \ndocumentation on the the clojure-contrib web site on github."},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/probabilities.finite-distributions-api.html",
   "name":"clojure.contrib.probabilities.finite-distributions",
   "author":"Konrad Hinsen",
   "doc":
   "Finite probability distributions\nThis library defines a monad for combining finite probability\ndistributions."},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/probabilities.monte-carlo-api.html",
   "name":"clojure.contrib.probabilities.monte-carlo",
   "author":"Konrad Hinsen",
   "doc":
   "Monte-Carlo method support\n\nMonte-Carlo methods transform an input random number stream\n(usually having a continuous uniform distribution in the\ninterval [0, 1)) into a random number stream whose distribution\nsatisfies certain conditions (usually the expectation value\nis equal to some desired quantity). They are thus\ntransformations from one probability distribution to another one.\n\nThis library represents a Monte-Carlo method by a function that\ntakes as input the state of a random number stream with\nuniform distribution (see\nclojure.contrib.probabilities.random-numbers) and returns a\nvector containing one sample value of the desired output\ndistribution and the final state of the input random number\nstream. Such functions are state monad values and can be\ncomposed using operations defined in clojure.contrib.monads."},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/probabilities.random-numbers-api.html",
   "name":"clojure.contrib.probabilities.random-numbers",
   "author":"Konrad Hinsen",
   "doc":
   "Random number streams\n\nThis library provides random number generators with a common\nstream interface. They all produce pseudo-random numbers that are\nuniformly distributed in the interval [0, 1), i.e. 0 is a\npossible value but 1 isn't. For transformations to other\ndistributions, see clojure.contrib.probabilities.monte-carlo.\n\nAt the moment, the only generator provided is a rather simple\nlinear congruential generator."},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/profile-api.html",
   "name":"clojure.contrib.profile",
   "author":"Stuart Sierra",
   "doc":
   "Simple code profiling & timing measurement.\n\nWrap any section of code in the prof macro, giving it a name, like this:\n\n       (defn my-function [x y]\n         (let [sum (prof :addition (+ x y))\n               product (prof :multiplication (* x y))]\n           [sum product]))\n\nThe run your code in the profile macro, like this:\n\n       (profile (dotimes [i 10000] (my-function 3 4)))\n\nWhich prints a report for each named section of code:\n\n          Name      mean       min       max     count       sum\n      addition       265         0     37000     10000   2655000\nmultiplication       274         0     53000     10000   2747000\n\nTimes are measured in nanoseconds, to the maximum precision available\nunder the JVM.  See the function documentation for more details."},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/prxml-api.html",
   "name":"clojure.contrib.prxml",
   "author":"Stuart Sierra",
   "doc":
   "Compact syntax for generating XML. See the documentation of \"prxml\" \nfor details."},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/repl-ln-api.html",
   "name":"clojure.contrib.repl-ln",
   "author":"Stephen C. Gilardi",
   "doc":
   "A repl with that provides support for lines and line numbers in the\ninput stream."},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/repl-utils-api.html",
   "name":"clojure.contrib.repl-utils",
   "author":"Chris Houser, Christophe Grand, Stephen Gilardi",
   "doc":"Utilities meant to be used interactively at the REPL"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/seq-utils-api.html",
   "name":"clojure.contrib.seq-utils",
   "author":"Stuart Sierra (and others)",
   "doc":"Sequence utilities for Clojure"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/server-socket-api.html",
   "name":"clojure.contrib.server-socket",
   "author":"Craig McDaniel",
   "doc":"Server socket library - includes REPL on socket"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/set-api.html",
   "name":"clojure.contrib.set",
   "author":"Jason Wolfe",
   "doc":
   "Clojure functions for operating on sets (supplemental to clojure.set)"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/shell-out-api.html",
   "name":"clojure.contrib.shell-out",
   "author":"Chris Houser",
   "doc":
   "Conveniently launch a sub-process providing to its stdin and\ncollecting its stdout"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/singleton-api.html",
   "name":"clojure.contrib.singleton",
   "author":"Stuart Sierra",
   "doc":"Singleton functions"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/sql-api.html",
   "name":"clojure.contrib.sql",
   "author":"Stephen C. Gilardi",
   "doc":
   "A Clojure interface to sql databases via jdbc\n\nSee clojure.contrib.sql.test for an example"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/str-utils-api.html",
   "name":"clojure.contrib.str-utils",
   "author":"Stuart Sierra",
   "doc":"String utilities for Clojure"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/str-utils2-api.html",
   "name":"clojure.contrib.str-utils2",
   "author":"Stuart Sierra",
   "doc":
   "This is a library of string manipulation functions.  It\nis intented as a replacement for clojure.contrib.str-utils.\n\nYou cannot (use 'clojure.contrib.str-utils2) because it defines\nfunctions with the same names as functions in clojure.core.\nInstead, do (require '[clojure.contrib.str-utils2 :as s]) \nor something similar.\n\nGoals:\n  1. Be functional\n  2. String argument first, to work with ->\n  3. Performance linear in string length\n\nSome ideas are borrowed from\nhttp://github.com/francoisdevlin/devlinsf-clojure-utils/"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/stream-utils-api.html",
   "name":"clojure.contrib.stream-utils",
   "author":"Konrad Hinsen",
   "doc":
   "Functions for setting up computational pipelines via data streams.\n\nNOTE: This library is experimental. It may change significantly\n      with future release.\n\nThis library defines:\n- an abstract stream type, whose interface consists of the\n  multimethod stream-next\n- a macro for implementing streams\n- implementations of stream for\n  1) Clojure sequences, and vectors\n  2) nil, representing an empty stream\n- tools for writing stream transformers, including the\n  monad stream-m\n- various utility functions for working with streams\n\nStreams are building blocks in the construction of computational\npipelines. A stream is represented by its current state plus\na function that takes a stream state and obtains the next item\nin the stream as well as the new stream state. The state is\nimplemented as a Java class or a Clojure type (as defined by the\nfunction clojure.core/type), and the function is provided as an\nimplementation of the multimethod stream-next for this class or type.\n\nWhile setting up pipelines using this mechanism is somewhat more\ncumbersome than using Clojure's lazy seq mechanisms, there are a\nfew advantages:\n- The state of a stream can be stored in any Clojure data structure,\n  and the stream can be re-generated from it any number of times.\n  Any number of states can be stored this way.\n- The elements of the stream are never cached, so keeping a reference\n  to a stream state does not incur an uncontrollable memory penalty.\n\nNote that the stream mechanism is thread-safe as long as the\nconcrete stream implementations do not use any mutable state.\n\nStream transformers take any number of input streams and produce one\noutput stream. They are typically written using the stream-m\nmonad. In the definition of a stream transformer, (pick s) returns\nthe next value of stream argument s, whereas pick-all returns the\nnext value of all stream arguments in the form of a vector."},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/swing-utils-api.html",
   "name":"clojure.contrib.swing-utils",
   "doc":null},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/test-is-api.html",
   "name":"clojure.contrib.test-is",
   "author":"Stuart Sierra",
   "doc":
   "Backwards-compatibility for clojure.contrib.test-is\n\nThe clojure.contrib.test-is library moved from Contrib into the\nClojure distribution as clojure.test.\n\nThis happened on or around clojure-contrib Git commit\n82cf0409d0fcb71be477ebfc4da18ee2128a2ad1 on June 25, 2009.\n\nThis file makes the clojure.test interface available under the old\nnamespace clojure.contrib.test-is.\n\nThis includes support for the old syntax of the 'are' macro.\n\nThis was suggested by Howard Lewis Ship in ticket #26, \nhttp://www.assembla.com/spaces/clojure-contrib/tickets/26"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/trace-api.html",
   "name":"clojure.contrib.trace",
   "author":"Stuart Sierra, Michel Salim",
   "doc":
   "This file defines simple \"tracing\" macros to help you see what your\ncode is doing."},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/types-api.html",
   "name":"clojure.contrib.types",
   "author":"Konrad Hinsen",
   "doc":"General and algebraic data types"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/with-ns-api.html",
   "name":"clojure.contrib.with-ns",
   "author":"Stuart Sierra",
   "doc":"Temporary namespace macro"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/zip-filter-api.html",
   "name":"clojure.contrib.zip-filter",
   "author":"Chris Houser",
   "doc":
   "System for filtering trees and nodes generated by zip.clj in\ngeneral, and xml trees in particular."},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/condition.Condition-api.html",
   "name":"clojure.contrib.condition.Condition",
   "doc":null},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/pprint.examples.json-api.html",
   "name":"clojure.contrib.pprint.examples.json",
   "author":"Tom Faulhaber (based on the version by Stuart Sierra)",
   "doc":
   "Pretty printing JavaScript Object Notation (JSON) generator.\n\nThis is an example of using a pretty printer dispatch function to generate JSON output"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib/pprint.examples.xml-api.html",
   "name":"clojure.contrib.pprint.examples.xml",
   "author":"Tom Faulhaber, based on the original by Stuart Sierra",
   "doc":
   "A version of prxml that uses a pretty print dispatch function."}],
 "vars":
 [{"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//agent-utils-api.html#clojure.contrib.agent-utils/capture-and-send",
   "namespace":"clojure.contrib.agent-utils",
   "arglists":[["vars", "agent", "action", "&", "args"]],
   "doc":
   "Capture the current value of the specified vars and rebind \nthem on the agent thread before executing the action.\n\nExample:\n  (capture-and-send [*out*] a f b c)",
   "name":"capture-and-send"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//apply-macro-api.html#clojure.contrib.apply-macro/apply-macro",
   "namespace":"clojure.contrib.apply-macro",
   "arglists":[["macro", "&", "args"]],
   "doc":
   "This is evil.  Don't ever use it.  It makes a macro behave like a\nfunction.  Seriously, how messed up is that?\n\nEvaluates all args, then uses them as arguments to the macro as with\napply.\n\n(def things [true true false])\n(apply-macro and things)\n;; Expands to:  (and true true false)",
   "name":"apply-macro"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//base64-api.html#clojure.contrib.base64/encode",
   "namespace":"clojure.contrib.base64",
   "arglists":[["input", "output", "alphabet", "line-length"]],
   "doc":
   "Encodes bytes of input, writing Base 64 text on output.  alphabet\nis a 65-character String containing the 64 characters to use in the\nencoding; the 65th character is the pad character.  line-length is\nthe maximum number of characters per line, nil for no line breaks.",
   "name":"encode"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//base64-api.html#clojure.contrib.base64/encode-str",
   "namespace":"clojure.contrib.base64",
   "arglists":[["s"], ["s", "encoding", "line-length"]],
   "doc":
   "Encodes String in base 64; returns a String.  If not specified,\nencoding is UTF-8 and line-length is nil.",
   "name":"encode-str"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//combinatorics-api.html#clojure.contrib.combinatorics/cartesian-product",
   "namespace":"clojure.contrib.combinatorics",
   "arglists":[["&", "seqs"]],
   "doc":"All the ways to take one item from each sequence",
   "name":"cartesian-product"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//combinatorics-api.html#clojure.contrib.combinatorics/combinations",
   "namespace":"clojure.contrib.combinatorics",
   "arglists":[["items", "n"]],
   "doc":
   "All the unique ways of taking n different elements from items",
   "name":"combinations"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//combinatorics-api.html#clojure.contrib.combinatorics/lex-permutations",
   "namespace":"clojure.contrib.combinatorics",
   "arglists":[["c"]],
   "doc":
   "Fast lexicographic permutation generator for a sequence of numbers",
   "name":"lex-permutations"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//combinatorics-api.html#clojure.contrib.combinatorics/permutations",
   "namespace":"clojure.contrib.combinatorics",
   "arglists":[["items"]],
   "doc":"All the permutations of items, lexicographic by index",
   "name":"permutations"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//combinatorics-api.html#clojure.contrib.combinatorics/selections",
   "namespace":"clojure.contrib.combinatorics",
   "arglists":[["items", "n"]],
   "doc":
   "All the ways of taking n (possibly the same) elements from the sequence of items",
   "name":"selections"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//combinatorics-api.html#clojure.contrib.combinatorics/subsets",
   "namespace":"clojure.contrib.combinatorics",
   "arglists":[["items"]],
   "doc":"All the subsets of items",
   "name":"subsets"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//cond-api.html#clojure.contrib.cond/cond-let",
   "namespace":"clojure.contrib.cond",
   "arglists":[["bindings", "&", "clauses"]],
   "doc":
   "Takes a binding-form and a set of test/expr pairs. Evaluates each test\none at a time. If a test returns logical true, cond-let evaluates and\nreturns expr with binding-form bound to the value of test and doesn't\nevaluate any of the other tests or exprs. To provide a default value\neither provide a literal that evaluates to logical true and is\nbinding-compatible with binding-form, or use :else as the test and don't\nrefer to any parts of binding-form in the expr. (cond-let binding-form)\nreturns nil.",
   "name":"cond-let"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//core-api.html#clojure.contrib.core/-?>",
   "namespace":"clojure.contrib.core",
   "arglists":[["x", "form"], ["x", "form", "&", "forms"]],
   "doc":
   "Same as clojure.core/-> but returns nil as soon as the threaded value is nil itself (thus short-circuiting any pending computation).\nExamples :\n(-?> \"foo\" .toUpperCase (.substring 1)) returns \"OO\"\n(-?> nil .toUpperCase (.substring 1)) returns nil\n",
   "name":"-?>"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//core-api.html#clojure.contrib.core/.?.",
   "namespace":"clojure.contrib.core",
   "arglists":[["x", "form"], ["x", "form", "&", "forms"]],
   "doc":
   "Same as clojure.core/.. but returns nil as soon as the threaded value is nil itself (thus short-circuiting any pending computation).\nExamples :\n(.?. \"foo\" .toUpperCase (.substring 1)) returns \"OO\"\n(.?. nil .toUpperCase (.substring 1)) returns nil\n",
   "name":".?."},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//core-api.html#clojure.contrib.core/dissoc-in",
   "namespace":"clojure.contrib.core",
   "arglists":[["m", ["k", "&", "ks", "as", "keys"]]],
   "doc":
   "Dissociates an entry from a nested associative structure returning a new\nnested structure. keys is a sequence of keys. Any empty maps that result\nwill not be present in the new structure.",
   "name":"dissoc-in"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//core-api.html#clojure.contrib.core/new-by-name",
   "namespace":"clojure.contrib.core",
   "arglists":[["class-name", "&", "args"]],
   "doc":
   "Constructs a Java object whose class is specified by a String.",
   "name":"new-by-name"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//core-api.html#clojure.contrib.core/seqable?",
   "namespace":"clojure.contrib.core",
   "arglists":[["x"]],
   "doc":"Returns true if (seq x) will succeed, false otherwise.",
   "name":"seqable?"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//def-api.html#clojure.contrib.def/defalias",
   "namespace":"clojure.contrib.def",
   "arglists":[["name", "orig"], ["name", "orig", "doc"]],
   "doc":
   "Defines an alias for a var: a new var with the same root binding (if\nany) and similar metadata. The metadata of the alias is its initial\nmetadata (as provided by def) merged into the metadata of the original.",
   "name":"defalias"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//def-api.html#clojure.contrib.def/defhinted",
   "namespace":"clojure.contrib.def",
   "arglists":[["sym", "init"]],
   "doc":
   "Defines a var with a type hint matching the class of the given\ninit.  Be careful about using any form of 'def' or 'binding' to a\nvalue of a different type.  See http://paste.lisp.org/display/73344",
   "name":"defhinted"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//def-api.html#clojure.contrib.def/defmacro-",
   "namespace":"clojure.contrib.def",
   "arglists":[["name", "&", "decls"]],
   "doc":"Same as defmacro but yields a private definition",
   "name":"defmacro-"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//def-api.html#clojure.contrib.def/defn-memo",
   "namespace":"clojure.contrib.def",
   "arglists":[["fn-name", "&", "defn-stuff"]],
   "doc":
   "Just like defn, but memoizes the function using clojure.core/memoize",
   "name":"defn-memo"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//def-api.html#clojure.contrib.def/defnk",
   "namespace":"clojure.contrib.def",
   "arglists":[["fn-name", "&", "fn-tail"]],
   "doc":
   "Define a function accepting keyword arguments. Symbols up to the first\nkeyword in the parameter list are taken as positional arguments.  Then\nan alternating sequence of keywords and defaults values is expected. The\nvalues of the keyword arguments are available in the function body by\nvirtue of the symbol corresponding to the keyword (cf. :keys destructuring).\ndefnk accepts an optional docstring as well as an optional metadata map.",
   "name":"defnk"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//def-api.html#clojure.contrib.def/defonce-",
   "namespace":"clojure.contrib.def",
   "arglists":[["name", "expr"], ["name", "expr", "doc"]],
   "doc":"Same as defonce but yields a private definition",
   "name":"defonce-"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//def-api.html#clojure.contrib.def/defstruct-",
   "namespace":"clojure.contrib.def",
   "arglists":[["name", "&", "decls"]],
   "doc":"Same as defstruct but yields a private definition",
   "name":"defstruct-"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//def-api.html#clojure.contrib.def/defunbound",
   "namespace":"clojure.contrib.def",
   "arglists":[["name"], ["name", "doc"]],
   "doc":"Defines an unbound var with optional doc string",
   "name":"defunbound"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//def-api.html#clojure.contrib.def/defunbound-",
   "namespace":"clojure.contrib.def",
   "arglists":[["name", "&", "decls"]],
   "doc":"Same as defunbound but yields a private definition",
   "name":"defunbound-"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//def-api.html#clojure.contrib.def/defvar",
   "namespace":"clojure.contrib.def",
   "arglists":[["name"], ["name", "init"], ["name", "init", "doc"]],
   "doc":"Defines a var with an optional intializer and doc string",
   "name":"defvar"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//def-api.html#clojure.contrib.def/defvar-",
   "namespace":"clojure.contrib.def",
   "arglists":[["name", "&", "decls"]],
   "doc":"Same as defvar but yields a private definition",
   "name":"defvar-"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//def-api.html#clojure.contrib.def/name-with-attributes",
   "namespace":"clojure.contrib.def",
   "arglists":[["name", "macro-args"]],
   "doc":
   "To be used in macro definitions.\nHandles optional docstrings and attribute maps for a name to be defined\nin a list of macro arguments. If the first macro argument is a string,\nit is added as a docstring to name and removed from the macro argument\nlist. If afterwards the first macro argument is a map, its entries are\nadded to the name's metadata map and the map is removed from the\nmacro argument list. The return value is a vector containing the name\nwith its extended metadata map and the list of unprocessed macro\narguments.",
   "name":"name-with-attributes"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//duck-streams-api.html#clojure.contrib.duck-streams/*append-to-writer*",
   "namespace":"clojure.contrib.duck-streams",
   "doc":
   "If true, writer and spit will open files in append mode.\nDefaults to false.  Use append-writer or append-spit.",
   "name":"*append-to-writer*"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//duck-streams-api.html#clojure.contrib.duck-streams/*buffer-size*",
   "namespace":"clojure.contrib.duck-streams",
   "doc":
   "Size, in bytes or characters, of the buffer used when\ncopying streams.",
   "name":"*buffer-size*"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//duck-streams-api.html#clojure.contrib.duck-streams/*byte-array-type*",
   "namespace":"clojure.contrib.duck-streams",
   "doc":"Type object for a Java primitive byte array.",
   "name":"*byte-array-type*"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//duck-streams-api.html#clojure.contrib.duck-streams/*default-encoding*",
   "namespace":"clojure.contrib.duck-streams",
   "doc":
   "Name of the default encoding to use when reading & writing.\nDefault is UTF-8.",
   "name":"*default-encoding*"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//duck-streams-api.html#clojure.contrib.duck-streams/append-spit",
   "namespace":"clojure.contrib.duck-streams",
   "arglists":[["f", "content"]],
   "doc":"Like spit but appends to file.",
   "name":"append-spit"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//duck-streams-api.html#clojure.contrib.duck-streams/append-writer",
   "namespace":"clojure.contrib.duck-streams",
   "arglists":[["x"]],
   "doc":
   "Like writer but opens file for appending.  Does not work on streams\nthat are already open.",
   "name":"append-writer"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//duck-streams-api.html#clojure.contrib.duck-streams/copy",
   "namespace":"clojure.contrib.duck-streams",
   "arglists":[["input", "output"]],
   "doc":
   "Copies input to output.  Returns nil.\nInput may be an InputStream, Reader, File, byte[], or String.\nOutput may be an OutputStream, Writer, or File.\n\nDoes not close any streams except those it opens itself \n(on a File).\n\nWriting a File fails if the parent directory does not exist.",
   "name":"copy"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//duck-streams-api.html#clojure.contrib.duck-streams/file-str",
   "namespace":"clojure.contrib.duck-streams",
   "arglists":[["&", "args"]],
   "doc":
   "Concatenates args as strings and returns a java.io.File.  Replaces\nall / and \\ with File/separatorChar.  Replaces ~ at the start of\nthe path with the user.home system property.",
   "name":"file-str"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//duck-streams-api.html#clojure.contrib.duck-streams/make-parents",
   "namespace":"clojure.contrib.duck-streams",
   "arglists":[["file"]],
   "doc":"Creates all parent directories of file.",
   "name":"make-parents"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//duck-streams-api.html#clojure.contrib.duck-streams/pwd",
   "namespace":"clojure.contrib.duck-streams",
   "arglists":[[]],
   "doc":
   "Returns current working directory as a String.  (Like UNIX 'pwd'.)\nNote: In Java, you cannot change the current working directory.",
   "name":"pwd"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//duck-streams-api.html#clojure.contrib.duck-streams/read-lines",
   "namespace":"clojure.contrib.duck-streams",
   "arglists":[["f"]],
   "doc":
   "Like clojure.core/line-seq but opens f with reader.  Automatically\ncloses the reader AFTER YOU CONSUME THE ENTIRE SEQUENCE.",
   "name":"read-lines"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//duck-streams-api.html#clojure.contrib.duck-streams/reader",
   "namespace":"clojure.contrib.duck-streams",
   "arglists":[["x"]],
   "doc":
   "Attempts to coerce its argument into an open\njava.io.BufferedReader.  Argument may be an instance of Reader,\nBufferedReader, InputStream, File, URI, URL, Socket, or String.\n\nIf argument is a String, it tries to resolve it first as a URI, then\nas a local file name.  URIs with a 'file' protocol are converted to\nlocal file names.  Uses *default-encoding* as the text encoding.\n\nShould be used inside with-open to ensure the Reader is properly\nclosed.",
   "name":"reader"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//duck-streams-api.html#clojure.contrib.duck-streams/slurp*",
   "namespace":"clojure.contrib.duck-streams",
   "arglists":[["f"]],
   "doc":"Like clojure.core/slurp but opens f with reader.",
   "name":"slurp*"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//duck-streams-api.html#clojure.contrib.duck-streams/spit",
   "namespace":"clojure.contrib.duck-streams",
   "arglists":[["f", "content"]],
   "doc":
   "Opposite of slurp.  Opens f with writer, writes content, then\ncloses f.",
   "name":"spit"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//duck-streams-api.html#clojure.contrib.duck-streams/to-byte-array",
   "namespace":"clojure.contrib.duck-streams",
   "arglists":[["arg"]],
   "doc":
   "Converts argument into a Java byte array.  Argument may be\na String, File, InputStream, or Reader.  If the argument is already\na byte array, returns it.",
   "name":"to-byte-array"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//duck-streams-api.html#clojure.contrib.duck-streams/with-in-reader",
   "namespace":"clojure.contrib.duck-streams",
   "arglists":[["f", "&", "body"]],
   "doc":
   "Opens a PushbackReader on f, binds it to *in*, and evaluates body.",
   "name":"with-in-reader"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//duck-streams-api.html#clojure.contrib.duck-streams/with-out-append-writer",
   "namespace":"clojure.contrib.duck-streams",
   "arglists":[["f", "&", "body"]],
   "doc":"Like with-out-writer but appends to file.",
   "name":"with-out-append-writer"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//duck-streams-api.html#clojure.contrib.duck-streams/with-out-writer",
   "namespace":"clojure.contrib.duck-streams",
   "arglists":[["f", "&", "body"]],
   "doc":
   "Opens a writer on f, binds it to *out*, and evalutes body.\nAnything printed within body will be written to f.",
   "name":"with-out-writer"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//duck-streams-api.html#clojure.contrib.duck-streams/write-lines",
   "namespace":"clojure.contrib.duck-streams",
   "arglists":[["f", "lines"]],
   "doc":
   "Writes lines (a seq) to f, separated by newlines.  f is opened with\nwriter, and automatically closed at the end of the sequence.",
   "name":"write-lines"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//duck-streams-api.html#clojure.contrib.duck-streams/writer",
   "namespace":"clojure.contrib.duck-streams",
   "arglists":[["x"]],
   "doc":
   "Attempts to coerce its argument into an open java.io.PrintWriter\nwrapped around a java.io.BufferedWriter.  Argument may be an\ninstance of Writer, PrintWriter, BufferedWriter, OutputStream, File,\nURI, URL, Socket, or String.\n\nIf argument is a String, it tries to resolve it first as a URI, then\nas a local file name.  URIs with a 'file' protocol are converted to\nlocal file names.\n\nShould be used inside with-open to ensure the Writer is properly\nclosed.",
   "name":"writer"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//error-kit-api.html#clojure.contrib.error-kit/bind-continue",
   "namespace":"clojure.contrib.error-kit",
   "arglists":[["continue-name", ["args*"], "&", "body"]],
   "doc":
   "Special form to be used inside a 'with-handler'.\nControl can be passed to this 'continue' form from a 'raise' enclosed\nin this with-handler's dynamic scope, when this 'continue-name' is\ngiven to a 'continue' form.",
   "name":"bind-continue"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//error-kit-api.html#clojure.contrib.error-kit/deferror",
   "namespace":"clojure.contrib.error-kit",
   "arglists":
   [["name", ["parent-error?"], "doc-string?", ["args*"], "&", "body"],
    ["name", ["parent-error?"], "doc-string?", "args-destruct-map",
     "&", "body"]],
   "doc":"Define a new error type",
   "name":"deferror"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//error-kit-api.html#clojure.contrib.error-kit/do-not-handle",
   "namespace":"clojure.contrib.error-kit",
   "arglists":[[]],
   "doc":
   "Use in a tail position of a 'handle' form to indicate 'raise' should\nnot consider the error handled, but should continue searching for an\nappropriate 'handle' form.  Allows finer-grain control over catching\nthan just the error type.",
   "name":"do-not-handle"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//error-kit-api.html#clojure.contrib.error-kit/error",
   "namespace":"clojure.contrib.error-kit",
   "arglists":[["details"]],
   "doc":"Base type for all error-kit errors",
   "name":"error"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//error-kit-api.html#clojure.contrib.error-kit/handle",
   "namespace":"clojure.contrib.error-kit",
   "arglists":
   [["error-name?", ["args*"], "&", "body"],
    ["error-name?", "args-destruct-map-args", "&", "body"]],
   "doc":
   "Special form to be used inside a 'with-handler'.  When\nany error is 'raised' from withing the dynamic scope of 'body' that\nis of error-name's type or a derived type, the args will be bound\nand the body executed.  If no 'error-name' is given, the body will\nbe executed for regardless of the type of error raised.  The body\nmay return a value, in which case that will be the return value of\nthe entire 'with-handler' form, or it may use any of the special\nreturn forms, 'do-not-handle', 'continue-with', or 'continue'.",
   "name":"handle"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//error-kit-api.html#clojure.contrib.error-kit/raise",
   "namespace":"clojure.contrib.error-kit",
   "arglists":[["err-name", "&", "args"]],
   "doc":
   "Raise an error of the type err-name, constructed with the given args",
   "name":"raise"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//error-kit-api.html#clojure.contrib.error-kit/raise*",
   "namespace":"clojure.contrib.error-kit",
   "arglists":[["err"]],
   "doc":
   "Raise the given error object, best if created by an error\nconstructor defined with deferror.  See also 'raise' macro.",
   "name":"raise*"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//error-kit-api.html#clojure.contrib.error-kit/throw-msg",
   "namespace":"clojure.contrib.error-kit",
   "arglists":[["class-name"]],
   "doc":
   "Returns a function that throws a Java Exception with the given\nname.  Useful to associate a new error-kit error type with a\nparticular Java Exception class, via the :unhandled error key.",
   "name":"throw-msg"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//error-kit-api.html#clojure.contrib.error-kit/with-handler",
   "namespace":"clojure.contrib.error-kit",
   "arglists":[["&", "forms"]],
   "doc":
   "This is error-kit's dynamic scope form.  The body will be executed\nin a dynamic context that includes all of the following 'handle' and\n'bind-continue' forms.",
   "name":"with-handler"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//except-api.html#clojure.contrib.except/throw-arg",
   "namespace":"clojure.contrib.except",
   "arglists":[["&", "args"]],
   "doc":
   "Throws an IllegalArgumentException. All arguments are optional:\n\n      cause? format? format-args*\n\n- cause defaults to nil, if present it must be a Throwable\n- format is a format string for clojure.core/format\n- format-args are objects that correspond to format specifiers in\n  format.",
   "name":"throw-arg"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//except-api.html#clojure.contrib.except/throw-if",
   "namespace":"clojure.contrib.except",
   "arglists":[["test", "&", "args"]],
   "doc":
   "Throws an Exception or Error if test is true. args are those documented\nfor throwf.",
   "name":"throw-if"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//except-api.html#clojure.contrib.except/throw-if-not",
   "namespace":"clojure.contrib.except",
   "arglists":[["test", "&", "args"]],
   "doc":
   "Throws an Exception or Error if test is false. args are those documented\nfor throwf.",
   "name":"throw-if-not"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//except-api.html#clojure.contrib.except/throwf",
   "namespace":"clojure.contrib.except",
   "arglists":[["&", "args"]],
   "doc":
   "Throws an Exception or Error with an optional message formatted using\nclojure.core/format. All arguments are optional:\n\n    class? cause? format? format-args*\n\n- class defaults to Exception, if present it must name a kind of\n  Throwable\n- cause defaults to nil, if present it must be a Throwable\n- format is a format string for clojure.core/format\n- format-args are objects that correspond to format specifiers in\n  format.",
   "name":"throwf"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//fcase-api.html#clojure.contrib.fcase/case",
   "namespace":"clojure.contrib.fcase",
   "arglists":[["test-value", "&", "clauses"]],
   "doc":
   "Like cond, but test-value is compared against the value of each\ntest expression with =.  If they are equal, executes the \"body\"\nexpression.  Optional last expression is executed if none of the\ntest expressions match.",
   "name":"case"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//fcase-api.html#clojure.contrib.fcase/fcase",
   "namespace":"clojure.contrib.fcase",
   "arglists":
   [["compare-fn", "case-value", "&", "test-expr-clauses"]],
   "doc":
   "Generic switch/case macro.  'fcase' is short for 'function case'.\n\nThe 'compare-fn' is a fn of two arguments.\n\nThe 'test-expr-clauses' are value-expression pairs without\nsurrounding parentheses, like in Clojure's 'cond'.\n\nThe 'case-value' is evaluated once and cached.  Then, 'compare-fn'\nis called once for each clause, with the clause's test value as its\nfirst argument and 'case-value' as its second argument.  If\n'compare-fn' returns logical true, the clause's expression is\nevaluated and returned.  If 'compare-fn' returns false/nil, we go to\nthe next test value.\n\nIf 'test-expr-clauses' contains an odd number of items, the last\nitem is the default expression evaluated if no case-value matches.\nIf there is no default expression and no case-value matches, fcase\nreturns nil.\n\nSee specific forms of this macro in 'case' and 're-case'.\n\nThe test expressions in 'fcase' are always evaluated linearly, in\norder.  For a large number of case expressions it may be more\nefficient to use a hash lookup.",
   "name":"fcase"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//fcase-api.html#clojure.contrib.fcase/in-case",
   "namespace":"clojure.contrib.fcase",
   "arglists":[["test-value", "&", "clauses"]],
   "doc":
   "Like case, but test expressions are sequences.  The test expression\nis true if any item in the sequence is equal (tested with '=') to\nthe test value.",
   "name":"in-case"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//fcase-api.html#clojure.contrib.fcase/instance-case",
   "namespace":"clojure.contrib.fcase",
   "arglists":[["test-value", "&", "clauses"]],
   "doc":
   "Like case, but the test expressions are Java class names, tested with\n'instance?'.",
   "name":"instance-case"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//fcase-api.html#clojure.contrib.fcase/re-case",
   "namespace":"clojure.contrib.fcase",
   "arglists":[["test-value", "&", "clauses"]],
   "doc":
   "Like case, but the test expressions are regular expressions, tested\nwith re-find.",
   "name":"re-case"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//fnmap-api.html#clojure.contrib.fnmap/fnmap",
   "namespace":"clojure.contrib.fnmap",
   "arglists":
   [["getter", "setter"], ["getter", "setter", "&", "keyvals"]],
   "doc":
   "Creates a fnmap, or functional map.  A fnmap behaves like an\nordinary Clojure map, except that calls to get and assoc are\nfiltered through user-defined getter and setter functions, which\noperate on an internal map.\n\n(getter m key) should return a value for key.\n\n(setter m key value) should assoc key with value and return a new\nmap for m.\n\nAll other map operations are passed through to the internal map.",
   "name":"fnmap"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//generic.collection-api.html#clojure.contrib.generic.collection/assoc",
   "namespace":"clojure.contrib.generic.collection",
   "arglists":[["coll", "&", "key-val-pairs"]],
   "doc":
   "Returns a new collection in which the values corresponding to the\ngiven keys are updated by the given values. Each type of collection\ncan have specific restrictions on the possible keys.",
   "name":"assoc"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//generic.collection-api.html#clojure.contrib.generic.collection/conj",
   "namespace":"clojure.contrib.generic.collection",
   "arglists":[["coll", "&", "xs"]],
   "doc":
   "Returns a new collection resulting from adding all xs to coll.",
   "name":"conj"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//generic.collection-api.html#clojure.contrib.generic.collection/dissoc",
   "namespace":"clojure.contrib.generic.collection",
   "arglists":[["coll", "&", "keys"]],
   "doc":
   "Returns a new collection in which the entries corresponding to the\ngiven keys are removed. Each type of collection can have specific\nrestrictions on the possible keys.",
   "name":"dissoc"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//generic.collection-api.html#clojure.contrib.generic.collection/empty",
   "namespace":"clojure.contrib.generic.collection",
   "arglists":[["coll"]],
   "doc":
   "Returns an empty collection of the same kind as the argument",
   "name":"empty"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//generic.collection-api.html#clojure.contrib.generic.collection/get",
   "namespace":"clojure.contrib.generic.collection",
   "arglists":[["coll", "key"], ["coll", "key", "not-found"]],
   "doc":
   "Returns the element of coll referred to by key. Each type of collection\ncan have specific restrictions on the possible keys.",
   "name":"get"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//generic.collection-api.html#clojure.contrib.generic.collection/into",
   "namespace":"clojure.contrib.generic.collection",
   "arglists":[["to", "from"]],
   "doc":
   "Returns a new coll consisting of to-coll with all of the items of\nfrom-coll conjoined.",
   "name":"into"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//generic.collection-api.html#clojure.contrib.generic.collection/seq",
   "namespace":"clojure.contrib.generic.collection",
   "arglists":[["s"]],
   "doc":"Returns a seq on the object s.",
   "name":"seq"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//generic.functor-api.html#clojure.contrib.generic.functor/fmap",
   "namespace":"clojure.contrib.generic.functor",
   "arglists":[["f", "s"]],
   "doc":
   "Applies function f to each item in the data structure s and returns\na structure of the same kind.",
   "name":"fmap"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//graph-api.html#clojure.contrib.graph/add-loops",
   "namespace":"clojure.contrib.graph",
   "arglists":[["g"]],
   "doc":"For each node n, add the edge n->n if not already present.",
   "name":"add-loops"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//graph-api.html#clojure.contrib.graph/component-graph",
   "namespace":"clojure.contrib.graph",
   "arglists":[["g"], ["g", "sccs"]],
   "doc":
   "Given a graph, perhaps with cycles, return a reduced graph that is acyclic.\nEach node in the new graph will be a set of nodes from the old.\nThese sets are the strongly connected components.  Each edge will\nbe the union of the corresponding edges of the prior graph.",
   "name":"component-graph"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//graph-api.html#clojure.contrib.graph/dependency-list",
   "namespace":"clojure.contrib.graph",
   "arglists":[["g"]],
   "doc":
   "Similar to a topological sort, this returns a vector of sets. The\nset of nodes at index 0 are independent.  The set at index 1 depend\non index 0; those at 2 depend on 0 and 1, and so on.  Those withing\na set have no mutual dependencies.  Assume the input graph (which\nmuch be acyclic) has an edge a->b when a depends on b.",
   "name":"dependency-list"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//graph-api.html#clojure.contrib.graph/fixed-point",
   "namespace":"clojure.contrib.graph",
   "arglists":[["data", "fun", "max", "equal"]],
   "doc":
   "Repeatedly apply fun to data until (equal old-data new-data)\nreturns true.  If max iterations occur, it will throw an\nexception.  Set max to nil for unlimited iterations.",
   "name":"fixed-point"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//graph-api.html#clojure.contrib.graph/get-neighbors",
   "namespace":"clojure.contrib.graph",
   "arglists":[["g", "n"]],
   "doc":"Get the neighbors of a node.",
   "name":"get-neighbors"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//graph-api.html#clojure.contrib.graph/lazy-walk",
   "namespace":"clojure.contrib.graph",
   "arglists":[["g", "n"], ["g", "ns", "v"]],
   "doc":
   "Return a lazy sequence of the nodes of a graph starting a node n.  Optionally,\nprovide a set of visited notes (v) and a collection of nodes to\nvisit (ns).",
   "name":"lazy-walk"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//graph-api.html#clojure.contrib.graph/post-ordered-nodes",
   "namespace":"clojure.contrib.graph",
   "arglists":[["g"]],
   "doc":
   "Return a sequence of indexes of a post-ordered walk of the graph.",
   "name":"post-ordered-nodes"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//graph-api.html#clojure.contrib.graph/recursive-component?",
   "namespace":"clojure.contrib.graph",
   "arglists":[["g", "ns"]],
   "doc":"Is the component (recieved from scc) self recursive?",
   "name":"recursive-component?"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//graph-api.html#clojure.contrib.graph/remove-loops",
   "namespace":"clojure.contrib.graph",
   "arglists":[["g"]],
   "doc":"For each node n, remove any edges n->n.",
   "name":"remove-loops"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//graph-api.html#clojure.contrib.graph/reverse-graph",
   "namespace":"clojure.contrib.graph",
   "arglists":[["g"]],
   "doc":
   "Given a directed graph, return another directed graph with the\norder of the edges reversed.",
   "name":"reverse-graph"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//graph-api.html#clojure.contrib.graph/scc",
   "namespace":"clojure.contrib.graph",
   "arglists":[["g"]],
   "doc":
   "Returns, as a sequence of sets, the strongly connected components\nof g.",
   "name":"scc"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//graph-api.html#clojure.contrib.graph/self-recursive-sets",
   "namespace":"clojure.contrib.graph",
   "arglists":[["g"]],
   "doc":
   "Returns, as a sequence of sets, the components of a graph that are\nself-recursive.",
   "name":"self-recursive-sets"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//graph-api.html#clojure.contrib.graph/stratification-list",
   "namespace":"clojure.contrib.graph",
   "arglists":[["g1", "g2"]],
   "doc":
   "Similar to dependency-list (see doc), except two graphs are\nprovided.  The first is as dependency-list.  The second (which may\nhave cycles) provides a partial-dependency relation.  If node a\ndepends on node b (meaning an edge a->b exists) in the second\ngraph, node a must be equal or later in the sequence.",
   "name":"stratification-list"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//graph-api.html#clojure.contrib.graph/transitive-closure",
   "namespace":"clojure.contrib.graph",
   "arglists":[["g"]],
   "doc":
   "Returns the transitive closure of a graph.  The neighbors are lazily computed.\n\nNote: some version of this algorithm return all edges a->a\nregardless of whether such loops exist in the original graph.  This\nversion does not.  Loops will be included only if produced by\ncycles in the graph.  If you have code that depends on such\nbehavior, call (-> g transitive-closure add-loops)",
   "name":"transitive-closure"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//greatest-least-api.html#clojure.contrib.greatest-least/all-greatest",
   "namespace":"clojure.contrib.greatest-least",
   "arglists":[["&", "args"]],
   "doc":"Returns all the greatest elements.",
   "name":"all-greatest"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//greatest-least-api.html#clojure.contrib.greatest-least/all-greatest-by",
   "namespace":"clojure.contrib.greatest-least",
   "arglists":[["f", "&", "args"]],
   "doc":
   "Return all the elements for which f yields the greatest value.",
   "name":"all-greatest-by"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//greatest-least-api.html#clojure.contrib.greatest-least/all-least",
   "namespace":"clojure.contrib.greatest-least",
   "arglists":[["&", "args"]],
   "doc":"Returns all the least elements.",
   "name":"all-least"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//greatest-least-api.html#clojure.contrib.greatest-least/all-least-by",
   "namespace":"clojure.contrib.greatest-least",
   "arglists":[["f", "&", "args"]],
   "doc":
   "Return all the elements for which f yields the least value.",
   "name":"all-least-by"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//greatest-least-api.html#clojure.contrib.greatest-least/greatest",
   "namespace":"clojure.contrib.greatest-least",
   "arglists":[["&", "args"]],
   "doc":"Return the greatest argument.",
   "name":"greatest"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//greatest-least-api.html#clojure.contrib.greatest-least/greatest-by",
   "namespace":"clojure.contrib.greatest-least",
   "arglists":[["f", "&", "args"]],
   "doc":"Return the argument for which f yields the greatest value.",
   "name":"greatest-by"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//greatest-least-api.html#clojure.contrib.greatest-least/least",
   "namespace":"clojure.contrib.greatest-least",
   "arglists":[["&", "args"]],
   "doc":"Return the smallest element.",
   "name":"least"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//greatest-least-api.html#clojure.contrib.greatest-least/least-by",
   "namespace":"clojure.contrib.greatest-least",
   "arglists":[["f", "&", "args"]],
   "doc":"Return the argument for which f yields the smallest value.",
   "name":"least-by"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//import-static-api.html#clojure.contrib.import-static/import-static",
   "namespace":"clojure.contrib.import-static",
   "arglists":[["class", "&", "fields-and-methods"]],
   "doc":
   "Imports the named static fields and/or static methods of the class\nas (private) symbols in the current namespace.\n\nExample: \n    user=> (import-static java.lang.Math PI sqrt)\n    nil\n    user=> PI\n    3.141592653589793\n    user=> (sqrt 16)\n    4.0\n\nNote: The class name must be fully qualified, even if it has already\nbeen imported.  Static methods are defined as MACROS, not\nfirst-class fns.",
   "name":"import-static"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//jar-api.html#clojure.contrib.jar/filenames-in-jar",
   "namespace":"clojure.contrib.jar",
   "arglists":[["jar-file"]],
   "doc":
   "Returns a sequence of Strings naming the non-directory entries in\nthe JAR file.",
   "name":"filenames-in-jar"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//jar-api.html#clojure.contrib.jar/jar-file?",
   "namespace":"clojure.contrib.jar",
   "arglists":[["file"]],
   "doc":
   "Returns true if file is a normal file with a .jar or .JAR extension.",
   "name":"jar-file?"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//java-utils-api.html#clojure.contrib.java-utils/as-file",
   "namespace":"clojure.contrib.java-utils",
   "doc":
   "Interpret a String or a java.io.File as a File. Building block\nfor clojure.contrib.java-utils/file, which you should prefer\nin most cases.",
   "name":"as-file"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//java-utils-api.html#clojure.contrib.java-utils/as-properties",
   "namespace":"clojure.contrib.java-utils",
   "arglists":[["m"]],
   "doc":
   "Convert any seq of pairs to a java.utils.Properties instance.\nUses as-str to convert both keys and values into strings.",
   "name":"as-properties"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//java-utils-api.html#clojure.contrib.java-utils/as-str",
   "namespace":"clojure.contrib.java-utils",
   "arglists":[[], ["x"], ["x", "&", "ys"]],
   "doc":
   "Like clojure.core/str, but if an argument is a keyword or symbol,\nits name will be used instead of its literal representation.\n\nExample:\n   (str :foo :bar)     ;;=> \":foo:bar\"\n   (as-str :foo :bar)  ;;=> \"foobar\" \n\nNote that this does not apply to keywords or symbols nested within\ndata structures; they will be rendered as with str.\n\nExample:\n   (str {:foo :bar})     ;;=> \"{:foo :bar}\"\n   (as-str {:foo :bar})  ;;=> \"{:foo :bar}\" ",
   "name":"as-str"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//java-utils-api.html#clojure.contrib.java-utils/as-url",
   "namespace":"clojure.contrib.java-utils",
   "arglists":[["arg"]],
   "doc":"Coerces argument (URL, URI, or String) to a java.net.URL.",
   "name":"as-url"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//java-utils-api.html#clojure.contrib.java-utils/delete-file",
   "namespace":"clojure.contrib.java-utils",
   "arglists":[["f", "&", ["silently"]]],
   "doc":
   "Delete file f. Raise an exception if it fails unless silently is true.",
   "name":"delete-file"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//java-utils-api.html#clojure.contrib.java-utils/delete-file-recursively",
   "namespace":"clojure.contrib.java-utils",
   "arglists":[["f", "&", ["silently"]]],
   "doc":
   "Delete file f. If it's a directory, recursively delete all its contents.\nRaise an exception if any deletion fails unless silently is true.",
   "name":"delete-file-recursively"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//java-utils-api.html#clojure.contrib.java-utils/file",
   "namespace":"clojure.contrib.java-utils",
   "arglists":
   [["arg"], ["parent", "child"], ["parent", "child", "&", "more"]],
   "doc":"Returns a java.io.File from string or file args.",
   "name":"file"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//java-utils-api.html#clojure.contrib.java-utils/get-system-property",
   "namespace":"clojure.contrib.java-utils",
   "arglists":[["stringable"], ["stringable", "default"]],
   "doc":"Get a system property.",
   "name":"get-system-property"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//java-utils-api.html#clojure.contrib.java-utils/read-properties",
   "namespace":"clojure.contrib.java-utils",
   "arglists":[["file-able"]],
   "doc":"Read properties from file-able.",
   "name":"read-properties"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//java-utils-api.html#clojure.contrib.java-utils/relative-path-string",
   "namespace":"clojure.contrib.java-utils",
   "doc":
   "Interpret a String or java.io.File as a relative path string. \nBuilding block for clojure.contrib.java-utils/file.",
   "name":"relative-path-string"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//java-utils-api.html#clojure.contrib.java-utils/set-system-properties",
   "namespace":"clojure.contrib.java-utils",
   "arglists":[["settings"]],
   "doc":"Set some system properties. Nil clears a property.",
   "name":"set-system-properties"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//java-utils-api.html#clojure.contrib.java-utils/wall-hack-field",
   "namespace":"clojure.contrib.java-utils",
   "arglists":[["class-name", "field-name", "obj"]],
   "doc":"Access to private or protected field.",
   "name":"wall-hack-field"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//java-utils-api.html#clojure.contrib.java-utils/wall-hack-method",
   "namespace":"clojure.contrib.java-utils",
   "arglists":
   [["class-name", "method-name", "params", "obj", "&", "args"]],
   "doc":
   "Calls a private or protected method.\nparams is a vector of class which correspond to the arguments to the method\nobj is nil for static methods, the instance object otherwise\nthe method name is given as a symbol or a keyword (something Named)",
   "name":"wall-hack-method"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//java-utils-api.html#clojure.contrib.java-utils/with-system-properties",
   "namespace":"clojure.contrib.java-utils",
   "arglists":[["settings", "&", "body"]],
   "doc":
   "setting => property-name value\n\nSets the system properties to the supplied values, executes the body, and\nsets the properties back to their original values. Values of nil are\ntranslated to a clearing of the property.",
   "name":"with-system-properties"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//java-utils-api.html#clojure.contrib.java-utils/write-properties",
   "namespace":"clojure.contrib.java-utils",
   "arglists":[["m", "file-able"], ["m", "file-able", "comments"]],
   "doc":"Write properties to file-able.",
   "name":"write-properties"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//jmx-api.html#clojure.contrib.jmx/*connection*",
   "namespace":"clojure.contrib.jmx",
   "doc":
   "The connection to be used for JMX ops. Defaults to the local process.",
   "name":"*connection*"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//jmx-api.html#clojure.contrib.jmx/as-object-name",
   "namespace":"clojure.contrib.jmx",
   "arglists":[["string-or-name"]],
   "doc":"Interpret an object as a JMX ObjectName.",
   "name":"as-object-name"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//jmx-api.html#clojure.contrib.jmx/build-attribute-info",
   "namespace":"clojure.contrib.jmx",
   "arglists":
   [["attr-name", "attr-value"],
    ["name", "type", "desc", "readable?", "writable?", "is?"]],
   "doc":
   "Construct an MBeanAttributeInfo. Normally called with a key/value pair from a Clojure map.",
   "name":"build-attribute-info"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//jmx-api.html#clojure.contrib.jmx/guess-attribute-typename",
   "namespace":"clojure.contrib.jmx",
   "arglists":[["value"]],
   "doc":
   "Guess the attribute typename for MBeanAttributeInfo based on the attribute value.",
   "name":"guess-attribute-typename"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//jmx-api.html#clojure.contrib.jmx/jmx->clj",
   "namespace":"clojure.contrib.jmx",
   "doc":
   "Coerce JMX data structures into Clojure data.\nHandles CompositeData, TabularData, maps, and atoms.",
   "name":"jmx->clj"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//jmx-api.html#clojure.contrib.jmx/jmx-url",
   "namespace":"clojure.contrib.jmx",
   "arglists":[[], ["overrides"]],
   "doc":"Build a JMX URL from options.",
   "name":"jmx-url"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//jmx-api.html#clojure.contrib.jmx/map->attribute-infos",
   "namespace":"clojure.contrib.jmx",
   "arglists":[["attr-map"]],
   "doc":
   "Construct an MBeanAttributeInfo[] from a Clojure associative.",
   "name":"map->attribute-infos"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//jmx-api.html#clojure.contrib.jmx/maybe-atomize",
   "namespace":"clojure.contrib.jmx",
   "arglists":[["k"]],
   "doc":
   "Convert a list of length 1 into its contents, leaving other things alone.\nUsed to simplify keys in the tabular data API.",
   "name":"maybe-atomize"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//jmx-api.html#clojure.contrib.jmx/maybe-keywordize",
   "namespace":"clojure.contrib.jmx",
   "arglists":[["s"]],
   "doc":
   "Convert a string key to a keyword, leaving other types alone. Used to\nsimplify keys in the tabular data API.",
   "name":"maybe-keywordize"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//jmx-api.html#clojure.contrib.jmx/with-connection",
   "namespace":"clojure.contrib.jmx",
   "arglists":[["opts", "&", "body"]],
   "doc":
   "Execute body with JMX connection specified by opts (:port).",
   "name":"with-connection"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//json.read-api.html#clojure.contrib.json.read/*json-keyword-keys*",
   "namespace":"clojure.contrib.json.read",
   "doc":
   "If true, JSON object keys will be converted to keywords\ninstead of strings.  Defaults to false.  There are no checks that\nthe strings form valid keywords.",
   "name":"*json-keyword-keys*"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//json.read-api.html#clojure.contrib.json.read/read-json",
   "namespace":"clojure.contrib.json.read",
   "arglists":[[], ["s"], ["stream", "eof-error?", "eof-value"]],
   "doc":
   "Read one JSON record from s, which may be a String or a\njava.io.PushbackReader.",
   "name":"read-json"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//json.write-api.html#clojure.contrib.json.write/json-str",
   "namespace":"clojure.contrib.json.write",
   "arglists":[["x"]],
   "doc":"Converts x to a JSON-formatted string.",
   "name":"json-str"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//json.write-api.html#clojure.contrib.json.write/print-json",
   "namespace":"clojure.contrib.json.write",
   "arglists":[["x"]],
   "doc":
   "Prints x as JSON.  Nil becomes JSON null.  Keywords become\nstrings, without the leading colon.  Maps become JSON objects, all\nother collection types become JSON arrays.  Java arrays become JSON\narrays.  Unicode characters in strings are escaped as \\uXXXX.\nNumbers print as with pr.",
   "name":"print-json"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//lazy-seqs-api.html#clojure.contrib.lazy-seqs/fibs",
   "namespace":"clojure.contrib.lazy-seqs",
   "arglists":[[]],
   "doc":"Returns a lazy sequence of all the Fibonacci numbers.",
   "name":"fibs"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//lazy-seqs-api.html#clojure.contrib.lazy-seqs/powers-of-2",
   "namespace":"clojure.contrib.lazy-seqs",
   "arglists":[[]],
   "doc":"Returns a lazy sequence of all the powers of 2",
   "name":"powers-of-2"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//lazy-seqs-api.html#clojure.contrib.lazy-seqs/primes",
   "namespace":"clojure.contrib.lazy-seqs",
   "doc":"Lazy sequence of all the prime numbers.",
   "name":"primes"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//logging-api.html#clojure.contrib.logging/*allow-direct-logging*",
   "namespace":"clojure.contrib.logging",
   "doc":
   "A boolean indicating whether direct logging (as opposed to via an agent) is\nallowed when not operating from within a transaction. Defaults to true.",
   "name":"*allow-direct-logging*"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//logging-api.html#clojure.contrib.logging/*impl-name*",
   "namespace":"clojure.contrib.logging",
   "doc":"The name of the logging implementation used.",
   "name":"*impl-name*"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//logging-api.html#clojure.contrib.logging/*logging-agent*",
   "namespace":"clojure.contrib.logging",
   "doc":
   "The default agent used for performing logging durng a transaction or when\ndirect logging is disabled.",
   "name":"*logging-agent*"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//logging-api.html#clojure.contrib.logging/agent-write!",
   "namespace":"clojure.contrib.logging",
   "arglists":[["_", "log", "level", "message", "throwable"]],
   "doc":
   "Writes the message immediately, and ignores the first argument. Used by the\nlogging agent. End-users should never need to call this function.",
   "name":"agent-write!"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//logging-api.html#clojure.contrib.logging/debug",
   "namespace":"clojure.contrib.logging",
   "arglists":[["message"], ["message", "throwable"]],
   "doc":"Logs a message at the debug level.",
   "name":"debug"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//logging-api.html#clojure.contrib.logging/enabled?",
   "namespace":"clojure.contrib.logging",
   "arglists":[["level"], ["level", "log-ns"]],
   "doc":
   "Returns true if the specific logging level is enabled.  Use of this function\nshould only be necessary if one needs to execute alternate code paths beyond\nwhether the log should be written to.",
   "name":"enabled?"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//logging-api.html#clojure.contrib.logging/error",
   "namespace":"clojure.contrib.logging",
   "arglists":[["message"], ["message", "throwable"]],
   "doc":"Logs a message at the error level.",
   "name":"error"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//logging-api.html#clojure.contrib.logging/fatal",
   "namespace":"clojure.contrib.logging",
   "arglists":[["message"], ["message", "throwable"]],
   "doc":"Logs a message at the fatal level.",
   "name":"fatal"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//logging-api.html#clojure.contrib.logging/impl-enabled?",
   "namespace":"clojure.contrib.logging",
   "doc":
   "Implementation-specific check if a particular level is enabled. End-users\nshould not need to call this function.",
   "name":"impl-enabled?"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//logging-api.html#clojure.contrib.logging/impl-get-log",
   "namespace":"clojure.contrib.logging",
   "doc":
   "Returns an implementation-specific log by string namespace. End-users should\nnot need to call this function.",
   "name":"impl-get-log"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//logging-api.html#clojure.contrib.logging/impl-write!",
   "namespace":"clojure.contrib.logging",
   "doc":
   "Implementation-specific write of a log message. End-users should not need to\ncall this function.",
   "name":"impl-write!"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//logging-api.html#clojure.contrib.logging/info",
   "namespace":"clojure.contrib.logging",
   "arglists":[["message"], ["message", "throwable"]],
   "doc":"Logs a message at the info level.",
   "name":"info"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//logging-api.html#clojure.contrib.logging/log",
   "namespace":"clojure.contrib.logging",
   "arglists":
   [["level", "message"], ["level", "message", "throwable"],
    ["level", "message", "throwable", "log-ns"]],
   "doc":
   "Logs a message, either directly or via an agent. Also see the level-specific\nconvenience macros.",
   "name":"log"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//logging-api.html#clojure.contrib.logging/log-capture!",
   "namespace":"clojure.contrib.logging",
   "arglists":[["log-ns"]],
   "doc":
   "Captures System.out and System.err, redirecting all writes of those streams\nto :info and :error logging, respectively. The specified log-ns value will\nbe used to namespace all redirected logging. NOTE: this will not redirect\noutput of *out* or *err*; for that, use with-logs.",
   "name":"log-capture!"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//logging-api.html#clojure.contrib.logging/log-stream",
   "namespace":"clojure.contrib.logging",
   "arglists":[["level", "log-ns"]],
   "doc":
   "Creates a PrintStream that will output to the log. End-users should not need\nto invoke this function.",
   "name":"log-stream"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//logging-api.html#clojure.contrib.logging/log-uncapture!",
   "namespace":"clojure.contrib.logging",
   "arglists":[[]],
   "doc":
   "Restores System.out and System.err to their original values.",
   "name":"log-uncapture!"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//logging-api.html#clojure.contrib.logging/spy",
   "namespace":"clojure.contrib.logging",
   "arglists":[["expr"]],
   "doc":
   "Evaluates expr and outputs the form and its result to the debug log; returns \nthe result of expr.",
   "name":"spy"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//logging-api.html#clojure.contrib.logging/trace",
   "namespace":"clojure.contrib.logging",
   "arglists":[["message"], ["message", "throwable"]],
   "doc":"Logs a message at the trace level.",
   "name":"trace"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//logging-api.html#clojure.contrib.logging/warn",
   "namespace":"clojure.contrib.logging",
   "arglists":[["message"], ["message", "throwable"]],
   "doc":"Logs a message at the warn level.",
   "name":"warn"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//logging-api.html#clojure.contrib.logging/with-logs",
   "namespace":"clojure.contrib.logging",
   "arglists":[["log-ns", "&", "body"]],
   "doc":
   "Evaluates exprs in a context in which *out* and *err* are bound to :info and\n:error logging, respectively. The specified log-ns value will be used to\nnamespace all redirected logging.",
   "name":"with-logs"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//macro-utils-api.html#clojure.contrib.macro-utils/defsymbolmacro",
   "namespace":"clojure.contrib.macro-utils",
   "arglists":[["symbol", "expansion"]],
   "doc":
   "Define a symbol macro. Because symbol macros are not part of\nClojure's built-in macro expansion system, they can be used only\ninside a with-symbol-macros form.",
   "name":"defsymbolmacro"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//macro-utils-api.html#clojure.contrib.macro-utils/deftemplate",
   "namespace":"clojure.contrib.macro-utils",
   "arglists":[["name", "params", "&", "forms"]],
   "doc":
   "Define a macro that expands into forms after replacing the\nsymbols in params (a vector) by the corresponding parameters\ngiven in the macro call.",
   "name":"deftemplate"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//macro-utils-api.html#clojure.contrib.macro-utils/macrolet",
   "namespace":"clojure.contrib.macro-utils",
   "arglists":[["fn-bindings", "&", "exprs"]],
   "doc":
   "Define local macros that are used in the expansion of exprs. The\nsyntax is the same as for letfn forms.",
   "name":"macrolet"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//macro-utils-api.html#clojure.contrib.macro-utils/mexpand",
   "namespace":"clojure.contrib.macro-utils",
   "arglists":[["form"]],
   "doc":
   "Like clojure.core/macroexpand, but takes into account symbol macros.",
   "name":"mexpand"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//macro-utils-api.html#clojure.contrib.macro-utils/mexpand-1",
   "namespace":"clojure.contrib.macro-utils",
   "arglists":[["form"]],
   "doc":
   "Like clojure.core/macroexpand-1, but takes into account symbol macros.",
   "name":"mexpand-1"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//macro-utils-api.html#clojure.contrib.macro-utils/mexpand-all",
   "namespace":"clojure.contrib.macro-utils",
   "arglists":[["form"]],
   "doc":"Perform a full recursive macro expansion of a form.",
   "name":"mexpand-all"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//macro-utils-api.html#clojure.contrib.macro-utils/symbol-macrolet",
   "namespace":"clojure.contrib.macro-utils",
   "arglists":[["symbol-bindings", "&", "exprs"]],
   "doc":
   "Define local symbol macros that are used in the expansion of exprs.\nThe syntax is the same as for let forms.",
   "name":"symbol-macrolet"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//macro-utils-api.html#clojure.contrib.macro-utils/with-symbol-macros",
   "namespace":"clojure.contrib.macro-utils",
   "arglists":[["&", "exprs"]],
   "doc":"Fully expand exprs, including symbol macros.",
   "name":"with-symbol-macros"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//macros-api.html#clojure.contrib.macros/const",
   "namespace":"clojure.contrib.macros",
   "arglists":[["expr"]],
   "doc":"Evaluate the constant expression expr at compile time.",
   "name":"const"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//macros-api.html#clojure.contrib.macros/letfn-",
   "namespace":"clojure.contrib.macros",
   "arglists":[["fn-bindings", "&", "exprs"]],
   "doc":
   "OBSOLETE: use clojure.core/letfn\nA variant of let for local function definitions. fn-bindings consists\nof name/args/body triples, with (letfn [name args body] ...)\nbeing equivalent to (let [name (fn name args body)] ...).",
   "name":"letfn-"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//macros-api.html#clojure.contrib.macros/with-direct-linking",
   "namespace":"clojure.contrib.macros",
   "arglists":[["symbols?", "&", "body"]],
   "doc":
   "EXPERIMENTAL!\nCompiles the functions in body with direct links to the functions\nnamed in symbols, i.e. without a var lookup for each invocation.\nSymbols is a vector of symbols that name either vars or namespaces.\nA namespace reference is replaced by the list of all symbols in the\nnamespace that are bound to functions. If symbols is not provided,\nthe default value ['clojure.core] is used. The symbol *ns* can be\nused to refer to the current namespace.",
   "name":"with-direct-linking"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//map-utils-api.html#clojure.contrib.map-utils/deep-merge-with",
   "namespace":"clojure.contrib.map-utils",
   "arglists":[["f", "&", "maps"]],
   "doc":
   "Like merge-with, but merges maps recursively, applying the given fn\nonly when there's a non-map at a particular level.\n\n(deepmerge + {:a {:b {:c 1 :d {:x 1 :y 2}} :e 3} :f 4}\n             {:a {:b {:c 2 :d {:z 9} :z 3} :e 100}})\n-> {:a {:b {:z 3, :c 3, :d {:z 9, :x 1, :y 2}}, :e 103}, :f 4}",
   "name":"deep-merge-with"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//map-utils-api.html#clojure.contrib.map-utils/lazy-get",
   "namespace":"clojure.contrib.map-utils",
   "arglists":[["map", "key", "not-found"]],
   "doc":
   "Like get, but doesn't evaluate not-found unless it is needed.",
   "name":"lazy-get"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//map-utils-api.html#clojure.contrib.map-utils/safe-get",
   "namespace":"clojure.contrib.map-utils",
   "arglists":[["map", "key"]],
   "doc":"Like get, but throws an exception if the key is not found.",
   "name":"safe-get"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//map-utils-api.html#clojure.contrib.map-utils/safe-get-in",
   "namespace":"clojure.contrib.map-utils",
   "arglists":[["map", "ks"]],
   "doc":
   "Like get-in, but throws an exception if any key is not found.",
   "name":"safe-get-in"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//math-api.html#clojure.contrib.math/abs",
   "namespace":"clojure.contrib.math",
   "arglists":[["n"]],
   "doc":"(abs n) is the absolute value of n",
   "name":"abs"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//math-api.html#clojure.contrib.math/ceil",
   "namespace":"clojure.contrib.math",
   "arglists":[["n"]],
   "doc":
   "(ceil n) returns the least integer greater than or equal to n.\nIf n is an exact number, ceil returns an integer, otherwise a double.",
   "name":"ceil"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//math-api.html#clojure.contrib.math/exact-integer-sqrt",
   "namespace":"clojure.contrib.math",
   "arglists":[["n"]],
   "doc":
   "(exact-integer-sqrt n) expects a non-negative integer n, and returns [s r] where n = s^2+r and n < (s+1)^2.  In other words, it returns the floor of the square root and the 'remainder'.\nFor example, (exact-integer-sqrt 15) is [3 6] because 15 = 3^2+6.",
   "name":"exact-integer-sqrt"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//math-api.html#clojure.contrib.math/expt",
   "namespace":"clojure.contrib.math",
   "arglists":[["base", "pow"]],
   "doc":
   "(expt base pow) is base to the pow power.\nReturns an exact number if the base is an exact number and the power is an integer, otherwise returns a double.",
   "name":"expt"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//math-api.html#clojure.contrib.math/floor",
   "namespace":"clojure.contrib.math",
   "arglists":[["n"]],
   "doc":
   "(floor n) returns the greatest integer less than or equal to n.\nIf n is an exact number, floor returns an integer, otherwise a double.",
   "name":"floor"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//math-api.html#clojure.contrib.math/gcd",
   "namespace":"clojure.contrib.math",
   "arglists":[["a", "b"]],
   "doc":"(gcd a b) returns the greatest common divisor of a and b",
   "name":"gcd"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//math-api.html#clojure.contrib.math/lcm",
   "namespace":"clojure.contrib.math",
   "arglists":[["a", "b"]],
   "doc":"(lcm a b) returns the least common multiple of a and b",
   "name":"lcm"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//math-api.html#clojure.contrib.math/round",
   "namespace":"clojure.contrib.math",
   "arglists":[["n"]],
   "doc":
   "(round n) rounds to the nearest integer.\nround always returns an integer.  Rounds up for values exactly in between two integers.",
   "name":"round"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//math-api.html#clojure.contrib.math/sqrt",
   "namespace":"clojure.contrib.math",
   "arglists":[["n"]],
   "doc":"Square root, but returns exact number if possible.",
   "name":"sqrt"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//mmap-api.html#clojure.contrib.mmap/buffer-stream",
   "namespace":"clojure.contrib.mmap",
   "arglists":[["buf"]],
   "doc":
   "Returns an InputStream for a ByteBuffer, such as returned by mmap.",
   "name":"buffer-stream"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//mmap-api.html#clojure.contrib.mmap/mmap",
   "namespace":"clojure.contrib.mmap",
   "arglists":[["f"]],
   "doc":"Memory-map the file named f.  Returns a ByteBuffer.",
   "name":"mmap"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//mmap-api.html#clojure.contrib.mmap/slurp",
   "namespace":"clojure.contrib.mmap",
   "arglists":[["f"]],
   "doc":"Reads the file named by f and returns it as a string.",
   "name":"slurp"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//pprint-api.html#clojure.contrib.pprint/*print-base*",
   "namespace":"clojure.contrib.pprint",
   "doc":"The base to use for printing integers and rationals.",
   "name":"*print-base*"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//pprint-api.html#clojure.contrib.pprint/*print-circle*",
   "namespace":"clojure.contrib.pprint",
   "doc":"Mark circular structures (N.B. This is not yet used)",
   "name":"*print-circle*"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//pprint-api.html#clojure.contrib.pprint/*print-lines*",
   "namespace":"clojure.contrib.pprint",
   "doc":
   "Maximum number of lines to print in a pretty print instance (N.B. This is not yet used)",
   "name":"*print-lines*"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//pprint-api.html#clojure.contrib.pprint/*print-miser-width*",
   "namespace":"clojure.contrib.pprint",
   "doc":
   "The column at which to enter miser style. Depending on the dispatch table, \nmiser style add newlines in more places to try to keep lines short allowing for further \nlevels of nesting.",
   "name":"*print-miser-width*"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//pprint-api.html#clojure.contrib.pprint/*print-pprint-dispatch*",
   "namespace":"clojure.contrib.pprint",
   "doc":
   "The pretty print dispatch function. Use with-pprint-dispatch or set-pprint-dispatch\nto modify.",
   "name":"*print-pprint-dispatch*"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//pprint-api.html#clojure.contrib.pprint/*print-pretty*",
   "namespace":"clojure.contrib.pprint",
   "doc":"Bind to true if you want write to use pretty printing",
   "name":"*print-pretty*"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//pprint-api.html#clojure.contrib.pprint/*print-radix*",
   "namespace":"clojure.contrib.pprint",
   "doc":
   "Print a radix specifier in front of integers and rationals. If *print-base* is 2, 8, \nor 16, then the radix specifier used is #b, #o, or #x, respectively. Otherwise the \nradix specifier is in the form #XXr where XX is the decimal value of *print-base* ",
   "name":"*print-radix*"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//pprint-api.html#clojure.contrib.pprint/*print-right-margin*",
   "namespace":"clojure.contrib.pprint",
   "doc":
   "Pretty printing will try to avoid anything going beyond this column.\nSet it to nil to have pprint let the line be arbitrarily long. This will ignore all \nnon-mandatory newlines.",
   "name":"*print-right-margin*"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//pprint-api.html#clojure.contrib.pprint/*print-shared*",
   "namespace":"clojure.contrib.pprint",
   "doc":
   "Mark repeated structures rather than repeat them (N.B. This is not yet used)",
   "name":"*print-shared*"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//pprint-api.html#clojure.contrib.pprint/*print-suppress-namespaces*",
   "namespace":"clojure.contrib.pprint",
   "doc":
   "Don't print namespaces with symbols. This is particularly useful when \npretty printing the results of macro expansions",
   "name":"*print-suppress-namespaces*"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//pprint-api.html#clojure.contrib.pprint/cl-format",
   "namespace":"clojure.contrib.pprint",
   "arglists":[["writer", "format-in", "&", "args"]],
   "doc":
   "An implementation of a Common Lisp compatible format function. cl-format formats its\narguments to an output stream or string based on the format control string given. It \nsupports sophisticated formatting of structured data.\n\nWriter is an instance of java.io.Writer, true to output to *out* or nil to output \nto a string, format-in is the format control string and the remaining arguments \nare the data to be formatted.\n\nThe format control string is a string to be output with embedded 'format directives' \ndescribing how to format the various arguments passed in.\n\nIf writer is nil, cl-format returns the formatted result string. Otherwise, cl-format \nreturns nil.\n\nFor example:\n (let [results [46 38 22]]\n        (cl-format true \"There ~[are~;is~:;are~]~:* ~d result~:p: ~{~d~^, ~}~%\" \n                   (count results) results))\n\nPrints to *out*:\n There are 3 results: 46, 38, 22\n\nDetailed documentation on format control strings is available in the \"Common Lisp the \nLanguage, 2nd edition\", Chapter 22 (available online at:\nhttp://www.cs.cmu.edu/afs/cs.cmu.edu/project/ai-repository/ai/html/cltl/clm/node200.html#SECTION002633000000000000000) \nand in the Common Lisp HyperSpec at \nhttp://www.lispworks.com/documentation/HyperSpec/Body/22_c.htm",
   "name":"cl-format"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//pprint-api.html#clojure.contrib.pprint/pp",
   "namespace":"clojure.contrib.pprint",
   "arglists":[[]],
   "doc":
   "A convenience macro that pretty prints the last thing output. This is\nexactly equivalent to (pprint *1).",
   "name":"pp"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//pprint-api.html#clojure.contrib.pprint/pprint",
   "namespace":"clojure.contrib.pprint",
   "arglists":[["object"], ["object", "writer"]],
   "doc":
   "Pretty print object to the optional output writer. If the writer is not provided, \nprint the object to the currently bound value of *out*.",
   "name":"pprint"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//pprint-api.html#clojure.contrib.pprint/pprint-indent",
   "namespace":"clojure.contrib.pprint",
   "arglists":[["relative-to", "n"]],
   "doc":
   "Create an indent at this point in the pretty printing stream. This defines how \nfollowing lines are indented. relative-to can be either :block or :current depending \nwhether the indent should be computed relative to the start of the logical block or\nthe current column position. n is an offset. \n\nOutput is sent to *out* which must be a pretty printing writer.",
   "name":"pprint-indent"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//pprint-api.html#clojure.contrib.pprint/pprint-logical-block",
   "namespace":"clojure.contrib.pprint",
   "arglists":[["options*", "body"]],
   "doc":
   "Execute the body as a pretty printing logical block with output to *out* which \nmust be a pretty printing writer. When used from pprint or cl-format, this can be \nassumed. \n\nBefore the body, the caller can optionally specify options: :prefix, :per-line-prefix, \nand :suffix.",
   "name":"pprint-logical-block"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//pprint-api.html#clojure.contrib.pprint/pprint-newline",
   "namespace":"clojure.contrib.pprint",
   "arglists":[["kind"]],
   "doc":
   "Print a conditional newline to a pretty printing stream. kind specifies if the \nnewline is :linear, :miser, :fill, or :mandatory. \n\nOutput is sent to *out* which must be a pretty printing writer.",
   "name":"pprint-newline"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//pprint-api.html#clojure.contrib.pprint/pprint-tab",
   "namespace":"clojure.contrib.pprint",
   "arglists":[["kind", "colnum", "colinc"]],
   "doc":
   "Tab at this point in the pretty printing stream. kind specifies whether the tab\nis :line, :section, :line-relative, or :section-relative. \n\nColnum and colinc specify the target column and the increment to move the target\nforward if the output is already past the original target.\n\nOutput is sent to *out* which must be a pretty printing writer.\n\nTHIS FUNCTION IS NOT YET IMPLEMENTED.",
   "name":"pprint-tab"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//pprint-api.html#clojure.contrib.pprint/set-pprint-dispatch",
   "namespace":"clojure.contrib.pprint",
   "arglists":[["function"]],
   "doc":
   "Set the pretty print dispatch function to a function matching (fn [obj] ...)\nwhere obj is the object to pretty print. That function will be called with *out* set\nto a pretty printing writer to which it should do its printing.\n\nFor example functions, see *simple-dispatch* and *code-dispatch* in \nclojure.contrib.pprint.dispatch.clj.",
   "name":"set-pprint-dispatch"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//pprint-api.html#clojure.contrib.pprint/use-method",
   "namespace":"clojure.contrib.pprint",
   "arglists":[["multifn", "dispatch-val", "func"]],
   "doc":
   "Installs a function as a new method of multimethod associated with dispatch-value. ",
   "name":"use-method"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//pprint-api.html#clojure.contrib.pprint/with-pprint-dispatch",
   "namespace":"clojure.contrib.pprint",
   "arglists":[["function", "&", "body"]],
   "doc":
   "Execute body with the pretty print dispatch function bound to function.",
   "name":"with-pprint-dispatch"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//pprint-api.html#clojure.contrib.pprint/write",
   "namespace":"clojure.contrib.pprint",
   "arglists":[["object", "&", "kw-args"]],
   "doc":
   "Write an object subject to the current bindings of the printer control variables.\nUse the kw-args argument to override individual variables for this call (and any \nrecursive calls). Returns the string result if :stream is nil or nil otherwise.\n\nThe following keyword arguments can be passed with values:\n  Keyword              Meaning                              Default value\n  :stream              Writer for output or nil             true (indicates *out*)\n  :base                Base to use for writing rationals    Current value of *print-base*\n  :circle*             If true, mark circular structures    Current value of *print-circle*\n  :length              Maximum elements to show in sublists Current value of *print-length*\n  :level               Maximum depth                        Current value of *print-level*\n  :lines*              Maximum lines of output              Current value of *print-lines*\n  :miser-width         Width to enter miser mode            Current value of *print-miser-width*\n  :dispatch            The pretty print dispatch function   Current value of *print-pprint-dispatch*\n  :pretty              If true, do pretty printing          Current value of *print-pretty*\n  :radix               If true, prepend a radix specifier   Current value of *print-radix*\n  :readably*           If true, print readably              Current value of *print-readably*\n  :right-margin        The column for the right margin      Current value of *print-right-margin*\n  :suppress-namespaces If true, no namespaces in symbols    Current value of *print-suppress-namespaces*\n\n  * = not yet supported",
   "name":"write"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//pprint-api.html#clojure.contrib.pprint/write-out",
   "namespace":"clojure.contrib.pprint",
   "arglists":[["object"]],
   "doc":
   "Write an object to *out* subject to the current bindings of the printer control \nvariables. Use the kw-args argument to override individual variables for this call (and \nany recursive calls).\n\n*out* must be a PrettyWriter if pretty printing is enabled. This is the responsibility\nof the caller.\n\nThis method is primarily intended for use by pretty print dispatch functions that \nalready know that the pretty printer will have set up their environment appropriately.\nNormal library clients should use the standard \"write\" interface. ",
   "name":"write-out"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//profile-api.html#clojure.contrib.profile/*enable-profiling*",
   "namespace":"clojure.contrib.profile",
   "doc":
   "Set this to false before loading/compiling to omit\nprofiling code.",
   "name":"*enable-profiling*"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//profile-api.html#clojure.contrib.profile/print-summary",
   "namespace":"clojure.contrib.profile",
   "arglists":[["profile-summary"]],
   "doc":"Prints a table of the results returned by summarize.",
   "name":"print-summary"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//profile-api.html#clojure.contrib.profile/prof",
   "namespace":"clojure.contrib.profile",
   "arglists":[["name", "&", "body"]],
   "doc":
   "If *enable-profiling* is true, wraps body in profiling code.\nReturns the result of body. Profile timings will be stored in\n*profile-data* using name, which must be a keyword, as the key.\nTimings are measured with System/nanoTime.",
   "name":"prof"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//profile-api.html#clojure.contrib.profile/profile",
   "namespace":"clojure.contrib.profile",
   "arglists":[["&", "body"]],
   "doc":
   "Runs body with profiling enabled, then prints a summary of\nresults.  Returns nil.",
   "name":"profile"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//profile-api.html#clojure.contrib.profile/summarize",
   "namespace":"clojure.contrib.profile",
   "arglists":[["profile-data"]],
   "doc":
   "Takes the raw data returned by with-profile-data and returns a map\nfrom names to summary statistics.  Each value in the map will look\nlike:\n\n   {:mean ..., :min ..., :max ..., :count ..., :sum ...}\n\n:mean, :min, and :max are how long the profiled section took to run,\nin nanoseconds.  :count is the total number of times the profiled\nsection was executed.  :sum is the total amount of time spent in the\nprofiled section, in nanoseconds.",
   "name":"summarize"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//profile-api.html#clojure.contrib.profile/with-profile-data",
   "namespace":"clojure.contrib.profile",
   "arglists":[["&", "body"]],
   "doc":
   "Executes body with *profile-data* bound to an atom of a new map.\nReturns the raw profile data as a map.  Keys in the map are profile\nnames (keywords), and values are lists of elapsed time, in\nnanoseconds.",
   "name":"with-profile-data"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//repl-ln-api.html#clojure.contrib.repl-ln/print-repl-info",
   "namespace":"clojure.contrib.repl-ln",
   "arglists":[[]],
   "doc":"Prints info about the current repl",
   "name":"print-repl-info"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//repl-ln-api.html#clojure.contrib.repl-ln/repl",
   "namespace":"clojure.contrib.repl-ln",
   "arglists":[["&", "options"]],
   "doc":
   "A repl that supports line numbers. For definitions and evaluations made\nat the repl, the repl-name and line number will be reported as the\norigin. Use set-repl-name and set-repl-prompt to customize the repl name\nand prompt. This repl supports all of the keyword arguments documented\nfor clojure.main/repl with the following change and additions:\n\n     - :prompt has a new default\n       default: #(clojure.core/print (repl-prompt))\n\n     - :name-fmt, Name format string\n       default: the name-fmt of the parent repl, or \"repl-%S\"\n\n     - :prompt-fmt, Prompt format string\n       default: the prompt-fmt of the parent repl, or \"%S:%L %N=> \"",
   "name":"repl"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//repl-ln-api.html#clojure.contrib.repl-ln/repl-info",
   "namespace":"clojure.contrib.repl-ln",
   "arglists":[[]],
   "doc":"Returns a map of info about the current repl",
   "name":"repl-info"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//repl-ln-api.html#clojure.contrib.repl-ln/repl-prompt",
   "namespace":"clojure.contrib.repl-ln",
   "arglists":[[]],
   "doc":
   "Returns the current repl prompt based on this repl's prompt-fmt",
   "name":"repl-prompt"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//repl-ln-api.html#clojure.contrib.repl-ln/set-repl-name",
   "namespace":"clojure.contrib.repl-ln",
   "arglists":[[], ["name-fmt"]],
   "doc":
   "Sets the repl name format to the string name-fmt. Include the following\ncodes in the name to make the corresponding dynamic values part of it:\n\n  %S - repl serial number\n  %T - thread id\n  %D - nesting depth in this thread\n\nWith no arguments, resets the repl name to its default: \"repl-%S\"",
   "name":"set-repl-name"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//repl-ln-api.html#clojure.contrib.repl-ln/set-repl-prompt",
   "namespace":"clojure.contrib.repl-ln",
   "arglists":[[], ["prompt-fmt"]],
   "doc":
   "Sets the repl prompt. Include the following codes in the prompt to make\nthe corresponding dynamic values part of it:\n\n  %S - repl serial number\n  %T - thread id\n  %D - nesting depth in this thread\n  %L - input line number\n  %N - namespace name\n\nWith no arguments, resets the repl pompt to its default: \"%S:%L %N=> \"",
   "name":"set-repl-prompt"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//repl-ln-api.html#clojure.contrib.repl-ln/stream-repl",
   "namespace":"clojure.contrib.repl-ln",
   "arglists":[["&", "options"]],
   "doc":
   "Repl entry point that provides convenient overriding of input, output,\nand err streams via sequential keyword-value pairs. Default values\nfor :in, :out, and :err are streams associated with System/in,\nSystem/out, and System/err using UTF-8 encoding. Also supports all the\noptions provided by clojure.contrib.repl-ln/repl.",
   "name":"stream-repl"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//seq-utils-api.html#clojure.contrib.seq-utils/fill-queue",
   "namespace":"clojure.contrib.seq-utils",
   "arglists":[["filler-func", "&", "optseq"]],
   "doc":
   "filler-func will be called in another thread with a single arg\n'fill'.  filler-func may call fill repeatedly with one arg each\ntime which will be pushed onto a queue, blocking if needed until\nthis is possible.  fill-queue will return a lazy seq of the values\nfiller-func has pushed onto the queue, blocking if needed until each\nnext element becomes available.  filler-func's return value is ignored.",
   "name":"fill-queue"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//seq-utils-api.html#clojure.contrib.seq-utils/find-first",
   "namespace":"clojure.contrib.seq-utils",
   "arglists":[["pred", "coll"]],
   "doc":
   "Returns the first item of coll for which (pred item) returns logical true.\nConsumes sequences up to the first match, will consume the entire sequence\nand return nil if no match is found.",
   "name":"find-first"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//seq-utils-api.html#clojure.contrib.seq-utils/flatten",
   "namespace":"clojure.contrib.seq-utils",
   "arglists":[["x"]],
   "doc":
   "Takes any nested combination of sequential things (lists, vectors,\netc.) and returns their contents as a single, flat sequence.\n(flatten nil) returns nil.",
   "name":"flatten"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//seq-utils-api.html#clojure.contrib.seq-utils/frequencies",
   "namespace":"clojure.contrib.seq-utils",
   "arglists":[["coll"]],
   "doc":
   "Returns a map from distinct items in coll to the number of times\nthey appear.",
   "name":"frequencies"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//seq-utils-api.html#clojure.contrib.seq-utils/group-by",
   "namespace":"clojure.contrib.seq-utils",
   "arglists":[["f", "coll"]],
   "doc":
   "Returns a sorted map of the elements of coll keyed by the result of\nf on each element. The value at each key will be a vector of the\ncorresponding elements, in the order they appeared in coll.",
   "name":"group-by"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//seq-utils-api.html#clojure.contrib.seq-utils/includes?",
   "namespace":"clojure.contrib.seq-utils",
   "arglists":[["coll", "x"]],
   "doc":
   "Returns true if coll contains something equal (with =) to x,\nin linear time.",
   "name":"includes?"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//seq-utils-api.html#clojure.contrib.seq-utils/indexed",
   "namespace":"clojure.contrib.seq-utils",
   "arglists":[["s"]],
   "doc":
   "Returns a lazy sequence of [index, item] pairs, where items come\nfrom 's' and indexes count up from zero.\n\n(indexed '(a b c d))  =>  ([0 a] [1 b] [2 c] [3 d])",
   "name":"indexed"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//seq-utils-api.html#clojure.contrib.seq-utils/partition-all",
   "namespace":"clojure.contrib.seq-utils",
   "arglists":[["n", "coll"], ["n", "step", "coll"]],
   "doc":
   "Returns a lazy sequence of lists like clojure.core/partition, but may\ninclude lists with fewer than n items at the end.",
   "name":"partition-all"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//seq-utils-api.html#clojure.contrib.seq-utils/partition-by",
   "namespace":"clojure.contrib.seq-utils",
   "arglists":[["f", "coll"]],
   "doc":
   "Applies f to each value in coll, splitting it each time f returns\na new value.  Returns a lazy seq of lazy seqs.",
   "name":"partition-by"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//seq-utils-api.html#clojure.contrib.seq-utils/positions",
   "namespace":"clojure.contrib.seq-utils",
   "arglists":[["pred", "coll"]],
   "doc":
   "Returns a lazy sequence containing the positions at which pred\nis true for items in coll.",
   "name":"positions"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//seq-utils-api.html#clojure.contrib.seq-utils/rand-elt",
   "namespace":"clojure.contrib.seq-utils",
   "arglists":[["s"]],
   "doc":"Return a random element of this seq",
   "name":"rand-elt"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//seq-utils-api.html#clojure.contrib.seq-utils/rec-cat",
   "namespace":"clojure.contrib.seq-utils",
   "arglists":[["binding-name", "&", "exprs"]],
   "doc":
   "Similar to lazy-cat but binds the resulting sequence to the supplied \nbinding-name, allowing for recursive expressions.",
   "name":"rec-cat"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//seq-utils-api.html#clojure.contrib.seq-utils/rec-seq",
   "namespace":"clojure.contrib.seq-utils",
   "arglists":[["binding-name", "&", "body"]],
   "doc":
   "Similar to lazy-seq but binds the resulting seq to the supplied \nbinding-name, allowing for recursive expressions.",
   "name":"rec-seq"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//seq-utils-api.html#clojure.contrib.seq-utils/reductions",
   "namespace":"clojure.contrib.seq-utils",
   "arglists":[["f", "coll"], ["f", "init", "coll"]],
   "doc":
   "Returns a lazy seq of the intermediate values of the reduction (as\nper reduce) of coll by f, starting with init.",
   "name":"reductions"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//seq-utils-api.html#clojure.contrib.seq-utils/rotations",
   "namespace":"clojure.contrib.seq-utils",
   "arglists":[["x"]],
   "doc":"Returns a lazy seq of all rotations of a seq",
   "name":"rotations"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//seq-utils-api.html#clojure.contrib.seq-utils/separate",
   "namespace":"clojure.contrib.seq-utils",
   "arglists":[["f", "s"]],
   "doc":
   "Returns a vector:\n[ (filter f s), (filter (complement f) s) ]",
   "name":"separate"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//seq-utils-api.html#clojure.contrib.seq-utils/seq-on",
   "namespace":"clojure.contrib.seq-utils",
   "arglists":[["s"]],
   "doc":
   "Returns a seq on the object s. Works like the built-in seq but as\na multimethod that can have implementations for new classes and types.",
   "name":"seq-on"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//seq-utils-api.html#clojure.contrib.seq-utils/shuffle",
   "namespace":"clojure.contrib.seq-utils",
   "arglists":[["coll"]],
   "doc":"Return a random permutation of coll",
   "name":"shuffle"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//server-socket-api.html#clojure.contrib.server-socket/create-repl-server",
   "namespace":"clojure.contrib.server-socket",
   "arglists":
   [["port", "backlog", "bind-addr"], ["port", "backlog"], ["port"]],
   "doc":"create a repl on a socket",
   "name":"create-repl-server"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//server-socket-api.html#clojure.contrib.server-socket/create-server",
   "namespace":"clojure.contrib.server-socket",
   "arglists":
   [["port", "fun", "backlog", "bind-addr"],
    ["port", "fun", "backlog"], ["port", "fun"]],
   "doc":
   "Creates a server socket on port. Upon accept, a new thread is\ncreated which calls:\n\n(fun input-stream output-stream)\n\nOptional arguments support specifying a listen backlog and binding\nto a specific endpoint.",
   "name":"create-server"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//set-api.html#clojure.contrib.set/proper-subset?",
   "namespace":"clojure.contrib.set",
   "arglists":[["set1", "set2"]],
   "doc":"Is s1 a proper subset of s2?",
   "name":"proper-subset?"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//set-api.html#clojure.contrib.set/proper-superset?",
   "namespace":"clojure.contrib.set",
   "arglists":[["set1", "set2"]],
   "doc":"Is s1 a proper superset of s2?",
   "name":"proper-superset?"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//set-api.html#clojure.contrib.set/subset?",
   "namespace":"clojure.contrib.set",
   "arglists":[["set1", "set2"]],
   "doc":"Is set1 a subset of set2?",
   "name":"subset?"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//set-api.html#clojure.contrib.set/superset?",
   "namespace":"clojure.contrib.set",
   "arglists":[["set1", "set2"]],
   "doc":"Is set1 a superset of set2?",
   "name":"superset?"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//shell-out-api.html#clojure.contrib.shell-out/sh",
   "namespace":"clojure.contrib.shell-out",
   "arglists":[["&", "args"]],
   "doc":
   "Passes the given strings to Runtime.exec() to launch a sub-process.\n\nOptions are\n\n:in    may be given followed by a String specifying text to be fed to the \n       sub-process's stdin.  \n:out   option may be given followed by :bytes or a String. If a String \n       is given, it will be used as a character encoding name (for \n       example \"UTF-8\" or \"ISO-8859-1\") to convert the \n       sub-process's stdout to a String which is returned.\n       If :bytes is given, the sub-process's stdout will be stored in \n       a byte array and returned.  Defaults to UTF-8.\n:return-map\n       when followed by boolean true, sh returns a map of\n         :exit => sub-process's exit code\n         :out  => sub-process's stdout (as byte[] or String)\n         :err  => sub-process's stderr (as byte[] or String)\n       when not given or followed by false, sh returns a single\n       array or String of the sub-process's stdout followed by its\n       stderr\n:env   override the process env with a map (or the underlying Java\n       String[] if you are a masochist).\n:dir   override the process dir with a String or java.io.File.\n\nYou can bind :env or :dir for multiple operations using with-sh-env\nand with-sh-dir.",
   "name":"sh"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//singleton-api.html#clojure.contrib.singleton/global-singleton",
   "namespace":"clojure.contrib.singleton",
   "arglists":[["f"]],
   "doc":
   "Returns a global singleton function.  f is a function of no\narguments that creates and returns some object.  The singleton\nfunction will call f just once, the first time it is needed, and\ncache the value for all subsequent calls.\n\nWarning: global singletons are often unsafe in multi-threaded code.\nConsider per-thread-singleton instead.",
   "name":"global-singleton"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//singleton-api.html#clojure.contrib.singleton/per-thread-singleton",
   "namespace":"clojure.contrib.singleton",
   "arglists":[["f"]],
   "doc":
   "Returns a per-thread singleton function.  f is a function of no\narguments that creates and returns some object.  The singleton\nfunction will call f only once for each thread, and cache its value\nfor subsequent calls from the same thread.  This allows you to\nsafely and lazily initialize shared objects on a per-thread basis.\n\nWarning: due to a bug in JDK 5, it may not be safe to use a\nper-thread-singleton in the initialization function for another\nper-thread-singleton.  See\nhttp://bugs.sun.com/bugdatabase/view_bug.do?bug_id=5025230",
   "name":"per-thread-singleton"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//str-utils-api.html#clojure.contrib.str-utils/chomp",
   "namespace":"clojure.contrib.str-utils",
   "arglists":[["s"]],
   "doc":
   "Removes all trailing newline \\n or return \\r characters from\nstring.  Note: String.trim() is similar and faster.",
   "name":"chomp"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//str-utils-api.html#clojure.contrib.str-utils/chop",
   "namespace":"clojure.contrib.str-utils",
   "arglists":[["s"]],
   "doc":"Removes the last character of string.",
   "name":"chop"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//str-utils-api.html#clojure.contrib.str-utils/re-gsub",
   "namespace":"clojure.contrib.str-utils",
   "arglists":[["regex", "replacement", "string"]],
   "doc":
   "Replaces all instances of 'pattern' in 'string' with\n'replacement'.  Like Ruby's 'String#gsub'.\n\nIf (ifn? replacment) is true, the replacement is called with the\nmatch.\n",
   "name":"re-gsub"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//str-utils-api.html#clojure.contrib.str-utils/re-partition",
   "namespace":"clojure.contrib.str-utils",
   "arglists":[["re", "string"]],
   "doc":
   "Splits the string into a lazy sequence of substrings, alternating\nbetween substrings that match the patthern and the substrings\nbetween the matches.  The sequence always starts with the substring\nbefore the first match, or an empty string if the beginning of the\nstring matches.\n\nFor example: (re-partition #\"[a-z]+\" \"abc123def\")\n\nReturns: (\"\" \"abc\" \"123\" \"def\")",
   "name":"re-partition"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//str-utils-api.html#clojure.contrib.str-utils/re-split",
   "namespace":"clojure.contrib.str-utils",
   "arglists":[["pattern", "string"], ["pattern", "string", "limit"]],
   "doc":
   "Splits the string on instances of 'pattern'.  Returns a sequence of\nstrings.  Optional 'limit' argument is the maximum number of\nsplits.  Like Perl's 'split'.",
   "name":"re-split"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//str-utils-api.html#clojure.contrib.str-utils/re-sub",
   "namespace":"clojure.contrib.str-utils",
   "arglists":[["regex", "replacement", "string"]],
   "doc":
   "Replaces the first instance of 'pattern' in 'string' with\n'replacement'.  Like Ruby's 'String#sub'.\n\nIf (ifn? replacement) is true, the replacement is called with\nthe match.\n",
   "name":"re-sub"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//str-utils-api.html#clojure.contrib.str-utils/str-join",
   "namespace":"clojure.contrib.str-utils",
   "arglists":[["separator", "sequence"]],
   "doc":
   "Returns a string of all elements in 'sequence', separated by\n'separator'.  Like Perl's 'join'.",
   "name":"str-join"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//str-utils2-api.html#clojure.contrib.str-utils2/blank?",
   "namespace":"clojure.contrib.str-utils2",
   "arglists":[["s"]],
   "doc":"True if s is nil, empty, or contains only whitespace.",
   "name":"blank?"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//str-utils2-api.html#clojure.contrib.str-utils2/butlast",
   "namespace":"clojure.contrib.str-utils2",
   "arglists":[["s", "n"]],
   "doc":
   "Returns s without the last n characters.  Returns an empty string\nif n is greater than the length of s.\n\nNote the argument order is the opposite of clojure.core/butlast;\nthis is to keep the string as the first argument for use with ->",
   "name":"butlast"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//str-utils2-api.html#clojure.contrib.str-utils2/capitalize",
   "namespace":"clojure.contrib.str-utils2",
   "arglists":[["s"]],
   "doc":
   "Converts first character of the string to upper-case, all other\ncharacters to lower-case.",
   "name":"capitalize"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//str-utils2-api.html#clojure.contrib.str-utils2/chomp",
   "namespace":"clojure.contrib.str-utils2",
   "arglists":[["s"]],
   "doc":
   "Removes all trailing newline \\n or return \\r characters from\nstring.  Note: String.trim() is similar and faster.",
   "name":"chomp"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//str-utils2-api.html#clojure.contrib.str-utils2/chop",
   "namespace":"clojure.contrib.str-utils2",
   "arglists":[["s"]],
   "doc":
   "Removes the last character of string, does nothing on a zero-length\nstring.",
   "name":"chop"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//str-utils2-api.html#clojure.contrib.str-utils2/codepoints",
   "namespace":"clojure.contrib.str-utils2",
   "arglists":[["s"]],
   "doc":
   "Returns a sequence of integer Unicode code points in s.  Handles\nUnicode supplementary characters (above U+FFFF) correctly.",
   "name":"codepoints"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//str-utils2-api.html#clojure.contrib.str-utils2/contains?",
   "namespace":"clojure.contrib.str-utils2",
   "arglists":[["s", "substring"]],
   "doc":"True if s contains the substring.",
   "name":"contains?"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//str-utils2-api.html#clojure.contrib.str-utils2/dochars",
   "namespace":"clojure.contrib.str-utils2",
   "arglists":[["bindings", "&", "body"]],
   "doc":
   "bindings => [name string]\n\nRepeatedly executes body, with name bound to each character in\nstring.  Does NOT handle Unicode supplementary characters (above\nU+FFFF).",
   "name":"dochars"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//str-utils2-api.html#clojure.contrib.str-utils2/docodepoints",
   "namespace":"clojure.contrib.str-utils2",
   "arglists":[["bindings", "&", "body"]],
   "doc":
   "bindings => [name string]\n\nRepeatedly executes body, with name bound to the integer code point\nof each Unicode character in the string.  Handles Unicode\nsupplementary characters (above U+FFFF) correctly.",
   "name":"docodepoints"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//str-utils2-api.html#clojure.contrib.str-utils2/drop",
   "namespace":"clojure.contrib.str-utils2",
   "arglists":[["s", "n"]],
   "doc":
   "Drops first n characters from s.  Returns an empty string if n is\ngreater than the length of s.\n\nNote the argument order is the opposite of clojure.core/drop; this\nis to keep the string as the first argument for use with ->",
   "name":"drop"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//str-utils2-api.html#clojure.contrib.str-utils2/escape",
   "namespace":"clojure.contrib.str-utils2",
   "arglists":[["s", "cmap"]],
   "doc":
   "Returns a new String by applying cmap (a function or a map) to each\ncharacter in s.  If cmap returns nil, the original character is\nadded to the output unchanged.",
   "name":"escape"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//str-utils2-api.html#clojure.contrib.str-utils2/get",
   "namespace":"clojure.contrib.str-utils2",
   "arglists":[["s", "i"]],
   "doc":"Gets the i'th character in string.",
   "name":"get"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//str-utils2-api.html#clojure.contrib.str-utils2/grep",
   "namespace":"clojure.contrib.str-utils2",
   "arglists":[["re", "coll"]],
   "doc":
   "Filters elements of coll by a regular expression.  The String\nrepresentation (with str) of each element is tested with re-find.",
   "name":"grep"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//str-utils2-api.html#clojure.contrib.str-utils2/join",
   "namespace":"clojure.contrib.str-utils2",
   "arglists":[["separator", "coll"]],
   "doc":
   "Returns a string of all elements in coll, separated by\nseparator.  Like Perl's join.",
   "name":"join"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//str-utils2-api.html#clojure.contrib.str-utils2/lower-case",
   "namespace":"clojure.contrib.str-utils2",
   "arglists":[["s"]],
   "doc":"Converts string to all lower-case.",
   "name":"lower-case"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//str-utils2-api.html#clojure.contrib.str-utils2/ltrim",
   "namespace":"clojure.contrib.str-utils2",
   "arglists":[["s"]],
   "doc":"Removes whitespace from the left side of string.",
   "name":"ltrim"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//str-utils2-api.html#clojure.contrib.str-utils2/map-str",
   "namespace":"clojure.contrib.str-utils2",
   "arglists":[["f", "coll"]],
   "doc":
   "Apply f to each element of coll, concatenate all results into a\nString.",
   "name":"map-str"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//str-utils2-api.html#clojure.contrib.str-utils2/partial",
   "namespace":"clojure.contrib.str-utils2",
   "arglists":[["f", "&", "args"]],
   "doc":
   "Like clojure.core/partial for functions that take their primary\nargument first.\n\nTakes a function f and its arguments, NOT INCLUDING the first\nargument.  Returns a new function whose first argument will be the\nfirst argument to f.\n\nExample: (str-utils2/partial str-utils2/take 2)\n         ;;=> (fn [s] (str-utils2/take s 2))",
   "name":"partial"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//str-utils2-api.html#clojure.contrib.str-utils2/partition",
   "namespace":"clojure.contrib.str-utils2",
   "arglists":[["s", "re"]],
   "doc":
   "Splits the string into a lazy sequence of substrings, alternating\nbetween substrings that match the patthern and the substrings\nbetween the matches.  The sequence always starts with the substring\nbefore the first match, or an empty string if the beginning of the\nstring matches.\n\nFor example: (partition \"abc123def\" #\"[a-z]+\")\nreturns: (\"\" \"abc\" \"123\" \"def\")",
   "name":"partition"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//str-utils2-api.html#clojure.contrib.str-utils2/repeat",
   "namespace":"clojure.contrib.str-utils2",
   "arglists":[["s", "n"]],
   "doc":"Returns a new String containing s repeated n times.",
   "name":"repeat"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//str-utils2-api.html#clojure.contrib.str-utils2/replace",
   "namespace":"clojure.contrib.str-utils2",
   "arglists":[["string", "pattern", "replacement"]],
   "doc":
   "Replaces all instances of pattern in string with replacement.  \n\nAllowed argument types for pattern and replacement are:\n 1. String and String\n 2. Character and Character\n 3. regex Pattern and String\n    (Uses java.util.regex.Matcher.replaceAll)\n 4. regex Pattern and function\n    (Calls function with re-groups of each match, uses return \n     value as replacement.)",
   "name":"replace"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//str-utils2-api.html#clojure.contrib.str-utils2/replace-first",
   "namespace":"clojure.contrib.str-utils2",
   "arglists":[["s", "pattern", "replacement"]],
   "doc":
   "Replaces the first instance of pattern in s with replacement.\n\nAllowed argument types for pattern and replacement are:\n 1. String and String\n 2. regex Pattern and String\n    (Uses java.util.regex.Matcher.replaceAll)\n 3. regex Pattern and function",
   "name":"replace-first"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//str-utils2-api.html#clojure.contrib.str-utils2/reverse",
   "namespace":"clojure.contrib.str-utils2",
   "arglists":[["s"]],
   "doc":"Returns s with its characters reversed.",
   "name":"reverse"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//str-utils2-api.html#clojure.contrib.str-utils2/rtrim",
   "namespace":"clojure.contrib.str-utils2",
   "arglists":[["s"]],
   "doc":"Removes whitespace from the right side of string.",
   "name":"rtrim"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//str-utils2-api.html#clojure.contrib.str-utils2/split",
   "namespace":"clojure.contrib.str-utils2",
   "arglists":[["s", "re"], ["s", "re", "limit"]],
   "doc":
   "Splits string on a regular expression.  Optional argument limit is\nthe maximum number of splits.",
   "name":"split"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//str-utils2-api.html#clojure.contrib.str-utils2/split-lines",
   "namespace":"clojure.contrib.str-utils2",
   "arglists":[["s"]],
   "doc":"Splits s on \\n or \\r\\n.",
   "name":"split-lines"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//str-utils2-api.html#clojure.contrib.str-utils2/swap-case",
   "namespace":"clojure.contrib.str-utils2",
   "arglists":[["s"]],
   "doc":
   "Changes upper case characters to lower case and vice-versa.\nHandles Unicode supplementary characters correctly.  Uses the\nlocale-sensitive String.toUpperCase() and String.toLowerCase()\nmethods.",
   "name":"swap-case"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//str-utils2-api.html#clojure.contrib.str-utils2/tail",
   "namespace":"clojure.contrib.str-utils2",
   "arglists":[["s", "n"]],
   "doc":"Returns the last n characters of s.",
   "name":"tail"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//str-utils2-api.html#clojure.contrib.str-utils2/take",
   "namespace":"clojure.contrib.str-utils2",
   "arglists":[["s", "n"]],
   "doc":
   "Take first n characters from s, up to the length of s.\n\nNote the argument order is the opposite of clojure.core/take; this\nis to keep the string as the first argument for use with ->",
   "name":"take"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//str-utils2-api.html#clojure.contrib.str-utils2/trim",
   "namespace":"clojure.contrib.str-utils2",
   "arglists":[["s"]],
   "doc":"Removes whitespace from both ends of string.",
   "name":"trim"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//str-utils2-api.html#clojure.contrib.str-utils2/upper-case",
   "namespace":"clojure.contrib.str-utils2",
   "arglists":[["s"]],
   "doc":"Converts string to all upper-case.",
   "name":"upper-case"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//swing-utils-api.html#clojure.contrib.swing-utils/action-translation-table",
   "namespace":"clojure.contrib.swing-utils",
   "doc":"Translation table for the make-action constructor.",
   "name":"action-translation-table"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//swing-utils-api.html#clojure.contrib.swing-utils/add-action-listener",
   "namespace":"clojure.contrib.swing-utils",
   "arglists":[["component", "f", "&", "args"]],
   "doc":
   "Adds an ActionLister to component. When the action fires, f will be\ninvoked with the event as its first argument followed by args.\nReturns the listener.",
   "name":"add-action-listener"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//swing-utils-api.html#clojure.contrib.swing-utils/add-key-typed-listener",
   "namespace":"clojure.contrib.swing-utils",
   "arglists":[["component", "f", "&", "args"]],
   "doc":
   "Adds a KeyListener to component that only responds to KeyTyped events.\nWhen a key is typed, f is invoked with the KeyEvent as its first argument\nfollowed by args. Returns the listener.",
   "name":"add-key-typed-listener"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//swing-utils-api.html#clojure.contrib.swing-utils/add-menu-item",
   "namespace":"clojure.contrib.swing-utils",
   "arglists":[["parent", "item"]],
   "doc":
   "Adds a menu item to the parent according to the item description.\n  The item description is a map of the following structure.\n\nEither:\n  - one single :action specifying a javax.swing.Action to be associated\n    with the item.\n  - a specification suitable for make-action\n  - a set of :name, :mnemonic and :items keys, specifying a submenu with\n    the given sequence of item entries.\n  - an empty map specifying a separator.",
   "name":"add-menu-item"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//swing-utils-api.html#clojure.contrib.swing-utils/do-swing",
   "namespace":"clojure.contrib.swing-utils",
   "arglists":[["&", "body"]],
   "doc":
   "Executes body in the Swing event thread asynchronously. Returns\nimmediately after scheduling the execution.",
   "name":"do-swing"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//swing-utils-api.html#clojure.contrib.swing-utils/do-swing*",
   "namespace":"clojure.contrib.swing-utils",
   "arglists":[["schedule", "thunk"]],
   "doc":
   "Runs thunk in the Swing event thread according to schedule:\n- :later => schedule the execution and return immediately\n- :now   => wait until the execution completes.",
   "name":"do-swing*"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//swing-utils-api.html#clojure.contrib.swing-utils/do-swing-and-wait",
   "namespace":"clojure.contrib.swing-utils",
   "arglists":[["&", "body"]],
   "doc":
   "Executes body in the Swing event thread synchronously. Returns\nafter the execution is complete.",
   "name":"do-swing-and-wait"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//swing-utils-api.html#clojure.contrib.swing-utils/make-action",
   "namespace":"clojure.contrib.swing-utils",
   "arglists":[["spec"]],
   "doc":
   "Create an Action proxy from the given action spec. The standard keys\nrecognised are: :name, :accelerator, :command-key, :long-desc,\n:short-desc, :mnemonic and :icon - corresponding to the similar named\nAction properties.  The :handler value is used in the actionPerformed\nmethod of the proxy to pass on the event.",
   "name":"make-action"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//swing-utils-api.html#clojure.contrib.swing-utils/make-menubar",
   "namespace":"clojure.contrib.swing-utils",
   "arglists":[["menubar-items"]],
   "doc":
   "Create a menubar containing the given sequence of menu items. The menu\nitems are described by a map as is detailed in the docstring of the\nadd-menu-item function.",
   "name":"make-menubar"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//swing-utils-api.html#clojure.contrib.swing-utils/menu-constructor-dispatch",
   "namespace":"clojure.contrib.swing-utils",
   "doc":
   "An atom containing the dispatch set for the add-menu-item method.",
   "name":"menu-constructor-dispatch"},
  {"source-url":
   "http://github.com/richhickey/clojure-contrib/blob/607389029cfec50f32b73c00a6f66d0a1dbcda23/src/clj/clojure/test.clj#L239",
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//test-is-api.html#clojure.contrib.test-is/*load-tests*",
   "namespace":"clojure.contrib.test-is",
   "doc":
   "True by default.  If set to false, no test functions will\nbe created by deftest, set-test, or with-test.  Use this to omit\ntests when compiling or loading production code.",
   "name":"*load-tests*"},
  {"source-url":
   "http://github.com/richhickey/clojure-contrib/blob/607389029cfec50f32b73c00a6f66d0a1dbcda23/src/clj/clojure/test.clj#L245",
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//test-is-api.html#clojure.contrib.test-is/*stack-trace-depth*",
   "namespace":"clojure.contrib.test-is",
   "doc":
   "The maximum depth of stack traces to print when an Exception\nis thrown during a test.  Defaults to nil, which means print the \ncomplete stack trace.",
   "name":"*stack-trace-depth*"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//test-is-api.html#clojure.contrib.test-is/apply-template",
   "namespace":"clojure.contrib.test-is",
   "arglists":[["expr", "values"]],
   "doc":
   "Replaces _1, _2, _3, etc. in expr with corresponding elements of\nvalues.  Returns the modified expression.  For use in macros.",
   "name":"apply-template"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//test-is-api.html#clojure.contrib.test-is/are",
   "namespace":"clojure.contrib.test-is",
   "arglists":[["expr", "&", "args"]],
   "doc":
   "Checks multiple assertions with a template expression.\nSee clojure.contrib.template/do-template for an explanation of\ntemplates.\n\nExample: (are (= _1 _2)  \n              2 (+ 1 1)\n              4 (* 2 2))\nExpands to: \n         (do (is (= 2 (+ 1 1)))\n             (is (= 4 (* 2 2))))\n\nNote: This breaks some reporting features, such as line numbers.",
   "name":"are"},
  {"source-url":
   "http://github.com/richhickey/clojure-contrib/blob/607389029cfec50f32b73c00a6f66d0a1dbcda23/src/clj/clojure/test.clj#L404",
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//test-is-api.html#clojure.contrib.test-is/assert-any",
   "namespace":"clojure.contrib.test-is",
   "arglists":[["msg", "form"]],
   "doc":
   "Returns generic assertion code for any test, including macros, Java\nmethod calls, or isolated symbols.",
   "name":"assert-any"},
  {"source-url":
   "http://github.com/richhickey/clojure-contrib/blob/607389029cfec50f32b73c00a6f66d0a1dbcda23/src/clj/clojure/test.clj#L386",
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//test-is-api.html#clojure.contrib.test-is/assert-predicate",
   "namespace":"clojure.contrib.test-is",
   "arglists":[["msg", "form"]],
   "doc":
   "Returns generic assertion code for any functional predicate.  The\n'expected' argument to 'report' will contains the original form, the\n'actual' argument will contain the form with all its sub-forms\nevaluated.  If the predicate returns false, the 'actual' form will\nbe wrapped in (not...).",
   "name":"assert-predicate"},
  {"source-url":
   "http://github.com/richhickey/clojure-contrib/blob/607389029cfec50f32b73c00a6f66d0a1dbcda23/src/clj/clojure/test.clj#L618",
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//test-is-api.html#clojure.contrib.test-is/compose-fixtures",
   "namespace":"clojure.contrib.test-is",
   "arglists":[["f1", "f2"]],
   "doc":
   "Composes two fixture functions, creating a new fixture function\nthat combines their behavior.",
   "name":"compose-fixtures"},
  {"source-url":
   "http://github.com/richhickey/clojure-contrib/blob/607389029cfec50f32b73c00a6f66d0a1dbcda23/src/clj/clojure/test.clj#L557",
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//test-is-api.html#clojure.contrib.test-is/deftest",
   "namespace":"clojure.contrib.test-is",
   "arglists":[["name", "&", "body"]],
   "doc":
   "Defines a test function with no arguments.  Test functions may call\nother tests, so tests may be composed.  If you compose tests, you\nshould also define a function named test-ns-hook; run-tests will\ncall test-ns-hook instead of testing all vars.\n\nNote: Actually, the test body goes in the :test metadata on the var,\nand the real function (the value of the var) calls test-var on\nitself.\n\nWhen *load-tests* is false, deftest is ignored.",
   "name":"deftest"},
  {"source-url":
   "http://github.com/richhickey/clojure-contrib/blob/607389029cfec50f32b73c00a6f66d0a1dbcda23/src/clj/clojure/test.clj#L573",
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//test-is-api.html#clojure.contrib.test-is/deftest-",
   "namespace":"clojure.contrib.test-is",
   "arglists":[["name", "&", "body"]],
   "doc":"Like deftest but creates a private var.",
   "name":"deftest-"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//test-is-api.html#clojure.contrib.test-is/do-template",
   "namespace":"clojure.contrib.test-is",
   "arglists":[["expr", "&", "args"]],
   "doc":
   "Repeatedly evaluates template expr (in a do block) using values in\nargs.  args are grouped by the number of holes in the template.\nExample: (do-template (check _1 _2) :a :b :c :d)\nexpands to (do (check :a :b) (check :c :d))",
   "name":"do-template"},
  {"source-url":
   "http://github.com/richhickey/clojure-contrib/blob/607389029cfec50f32b73c00a6f66d0a1dbcda23/src/clj/clojure/test.clj#L275",
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//test-is-api.html#clojure.contrib.test-is/file-position",
   "namespace":"clojure.contrib.test-is",
   "arglists":[["n"]],
   "doc":
   "Returns a vector [filename line-number] for the nth call up the\nstack.",
   "name":"file-position"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//test-is-api.html#clojure.contrib.test-is/find-holes",
   "namespace":"clojure.contrib.test-is",
   "arglists":[["form"]],
   "doc":"Recursively finds all symbols starting with _ in form.",
   "name":"find-holes"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//test-is-api.html#clojure.contrib.test-is/find-pure-exprs",
   "namespace":"clojure.contrib.test-is",
   "arglists":[["form"]],
   "doc":
   "Recursively finds all sub-expressions in form that do not contain\nany symbols starting with _",
   "name":"find-pure-exprs"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//test-is-api.html#clojure.contrib.test-is/find-symbols",
   "namespace":"clojure.contrib.test-is",
   "arglists":[["form"]],
   "doc":"Recursively finds all symbols in form.",
   "name":"find-symbols"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//test-is-api.html#clojure.contrib.test-is/flatten-map",
   "namespace":"clojure.contrib.test-is",
   "arglists":[["m"]],
   "doc":"Transforms a map into a vector like [key value key value].",
   "name":"flatten-map"},
  {"source-url":
   "http://github.com/richhickey/clojure-contrib/blob/607389029cfec50f32b73c00a6f66d0a1dbcda23/src/clj/clojure/test.clj#L375",
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//test-is-api.html#clojure.contrib.test-is/function?",
   "namespace":"clojure.contrib.test-is",
   "arglists":[["x"]],
   "doc":
   "Returns true if argument is a function or a symbol that resolves to\na function (not a macro).",
   "name":"function?"},
  {"source-url":
   "http://github.com/richhickey/clojure-contrib/blob/607389029cfec50f32b73c00a6f66d0a1dbcda23/src/clj/clojure/test.clj#L368",
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//test-is-api.html#clojure.contrib.test-is/get-possibly-unbound-var",
   "namespace":"clojure.contrib.test-is",
   "arglists":[["v"]],
   "doc":"Like var-get but returns nil if the var is unbound.",
   "name":"get-possibly-unbound-var"},
  {"source-url":
   "http://github.com/richhickey/clojure-contrib/blob/607389029cfec50f32b73c00a6f66d0a1dbcda23/src/clj/clojure/test.clj#L300",
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//test-is-api.html#clojure.contrib.test-is/inc-report-counter",
   "namespace":"clojure.contrib.test-is",
   "arglists":[["name"]],
   "doc":
   "Increments the named counter in *report-counters*, a ref to a map.\nDoes nothing if *report-counters* is nil.",
   "name":"inc-report-counter"},
  {"source-url":
   "http://github.com/richhickey/clojure-contrib/blob/607389029cfec50f32b73c00a6f66d0a1dbcda23/src/clj/clojure/test.clj#L501",
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//test-is-api.html#clojure.contrib.test-is/is",
   "namespace":"clojure.contrib.test-is",
   "arglists":[["form"], ["form", "msg"]],
   "doc":
   "Generic assertion macro.  'form' is any predicate test.\n'msg' is an optional message to attach to the assertion.\n\nExample: (is (= 4 (+ 2 2)) \"Two plus two should be 4\")\n\nSpecial forms:\n\n(is (thrown? c body)) checks that an instance of c is thrown from\nbody, fails if not; then returns the thing thrown.\n\n(is (thrown-with-msg? c re body)) checks that an instance of c is\nthrown AND that the message on the exception matches (with\nre-matches) the regular expression re.",
   "name":"is"},
  {"source-url":
   "http://github.com/richhickey/clojure-contrib/blob/607389029cfec50f32b73c00a6f66d0a1dbcda23/src/clj/clojure/test.clj#L624",
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//test-is-api.html#clojure.contrib.test-is/join-fixtures",
   "namespace":"clojure.contrib.test-is",
   "arglists":[["fixtures"]],
   "doc":
   "Composes a collection of fixtures, in order.  Always returns a valid\nfixture function, even if the collection is empty.",
   "name":"join-fixtures"},
  {"source-url":
   "http://github.com/richhickey/clojure-contrib/blob/607389029cfec50f32b73c00a6f66d0a1dbcda23/src/clj/clojure/test.clj#L312",
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//test-is-api.html#clojure.contrib.test-is/report",
   "namespace":"clojure.contrib.test-is",
   "doc":
   "Generic reporting function, may be overridden to plug in\ndifferent report formats (e.g., TAP, JUnit).  Assertions such as\n'is' call 'report' to indicate results.  The argument given to\n'report' will be a map with a :type key.  See the documentation at\nthe top of test_is.clj for more information on the types of\narguments for 'report'.",
   "name":"report"},
  {"source-url":
   "http://github.com/richhickey/clojure-contrib/blob/607389029cfec50f32b73c00a6f66d0a1dbcda23/src/clj/clojure/test.clj#L695",
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//test-is-api.html#clojure.contrib.test-is/run-all-tests",
   "namespace":"clojure.contrib.test-is",
   "arglists":[[], ["re"]],
   "doc":
   "Runs all tests in all namespaces; prints results.\nOptional argument is a regular expression; only namespaces with\nnames matching the regular expression (with re-matches) will be\ntested.",
   "name":"run-all-tests"},
  {"source-url":
   "http://github.com/richhickey/clojure-contrib/blob/607389029cfec50f32b73c00a6f66d0a1dbcda23/src/clj/clojure/test.clj#L684",
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//test-is-api.html#clojure.contrib.test-is/run-tests",
   "namespace":"clojure.contrib.test-is",
   "arglists":[[], ["&", "namespaces"]],
   "doc":
   "Runs all tests in the given namespaces; prints results.\nDefaults to current namespace if none given.  Returns a map\nsummarizing test results.",
   "name":"run-tests"},
  {"source-url":
   "http://github.com/richhickey/clojure-contrib/blob/607389029cfec50f32b73c00a6f66d0a1dbcda23/src/clj/clojure/test.clj#L581",
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//test-is-api.html#clojure.contrib.test-is/set-test",
   "namespace":"clojure.contrib.test-is",
   "arglists":[["name", "&", "body"]],
   "doc":
   "Experimental.\nSets :test metadata of the named var to a fn with the given body.\nThe var must already exist.  Does not modify the value of the var.\n\nWhen *load-tests* is false, set-test is ignored.",
   "name":"set-test"},
  {"source-url":
   "http://github.com/richhickey/clojure-contrib/blob/607389029cfec50f32b73c00a6f66d0a1dbcda23/src/clj/clojure/test.clj#L703",
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//test-is-api.html#clojure.contrib.test-is/successful?",
   "namespace":"clojure.contrib.test-is",
   "arglists":[["summary"]],
   "doc":
   "Returns true if the given test summary indicates all tests\nwere successful, false otherwise.",
   "name":"successful?"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//test-is-api.html#clojure.contrib.test-is/template?",
   "namespace":"clojure.contrib.test-is",
   "arglists":[["form"]],
   "doc":"Returns true if form is a valid template expression.",
   "name":"template?"},
  {"source-url":
   "http://github.com/richhickey/clojure-contrib/blob/607389029cfec50f32b73c00a6f66d0a1dbcda23/src/clj/clojure/test.clj#L649",
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//test-is-api.html#clojure.contrib.test-is/test-all-vars",
   "namespace":"clojure.contrib.test-is",
   "arglists":[["ns"]],
   "doc":
   "Calls test-var on every var interned in the namespace, with fixtures.",
   "name":"test-all-vars"},
  {"source-url":
   "http://github.com/richhickey/clojure-contrib/blob/607389029cfec50f32b73c00a6f66d0a1dbcda23/src/clj/clojure/test.clj#L660",
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//test-is-api.html#clojure.contrib.test-is/test-ns",
   "namespace":"clojure.contrib.test-is",
   "arglists":[["ns"]],
   "doc":
   "If the namespace defines a function named test-ns-hook, calls that.\nOtherwise, calls test-all-vars on the namespace.  'ns' is a\nnamespace object or a symbol.\n\nInternally binds *report-counters* to a ref initialized to\n*inital-report-counters*.  Returns the final, dereferenced state of\n*report-counters*.",
   "name":"test-ns"},
  {"source-url":
   "http://github.com/richhickey/clojure-contrib/blob/607389029cfec50f32b73c00a6f66d0a1dbcda23/src/clj/clojure/test.clj#L635",
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//test-is-api.html#clojure.contrib.test-is/test-var",
   "namespace":"clojure.contrib.test-is",
   "arglists":[["v"]],
   "doc":
   "If v has a function in its :test metadata, calls that function,\nwith *testing-vars* bound to (conj *testing-vars* v).",
   "name":"test-var"},
  {"source-url":
   "http://github.com/richhickey/clojure-contrib/blob/607389029cfec50f32b73c00a6f66d0a1dbcda23/src/clj/clojure/test.clj#L534",
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//test-is-api.html#clojure.contrib.test-is/testing",
   "namespace":"clojure.contrib.test-is",
   "arglists":[["string", "&", "body"]],
   "doc":
   "Adds a new string to the list of testing contexts.  May be nested,\nbut must occur inside a test function (deftest).",
   "name":"testing"},
  {"source-url":
   "http://github.com/richhickey/clojure-contrib/blob/607389029cfec50f32b73c00a6f66d0a1dbcda23/src/clj/clojure/test.clj#L294",
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//test-is-api.html#clojure.contrib.test-is/testing-contexts-str",
   "namespace":"clojure.contrib.test-is",
   "arglists":[[]],
   "doc":
   "Returns a string representation of the current test context. Joins\nstrings in *testing-contexts* with spaces.",
   "name":"testing-contexts-str"},
  {"source-url":
   "http://github.com/richhickey/clojure-contrib/blob/607389029cfec50f32b73c00a6f66d0a1dbcda23/src/clj/clojure/test.clj#L282",
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//test-is-api.html#clojure.contrib.test-is/testing-vars-str",
   "namespace":"clojure.contrib.test-is",
   "arglists":[[]],
   "doc":
   "Returns a string representation of the current test.  Renders names\nin *testing-vars* as a list, then the source file and line of\ncurrent assertion.",
   "name":"testing-vars-str"},
  {"source-url":
   "http://github.com/richhickey/clojure-contrib/blob/607389029cfec50f32b73c00a6f66d0a1dbcda23/src/clj/clojure/test.clj#L486",
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//test-is-api.html#clojure.contrib.test-is/try-expr",
   "namespace":"clojure.contrib.test-is",
   "arglists":[["msg", "form"]],
   "doc":
   "Used by the 'is' macro to catch unexpected exceptions.\nYou don't call this.",
   "name":"try-expr"},
  {"source-url":
   "http://github.com/richhickey/clojure-contrib/blob/607389029cfec50f32b73c00a6f66d0a1dbcda23/src/clj/clojure/test.clj#L601",
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//test-is-api.html#clojure.contrib.test-is/use-fixtures",
   "namespace":"clojure.contrib.test-is",
   "doc":
   "Wrap test runs in a fixture function to perform setup and\nteardown. Using a fixture-type of :each wraps every test\nindividually, while:once wraps the whole run in a single function.",
   "name":"use-fixtures"},
  {"source-url":
   "http://github.com/richhickey/clojure-contrib/blob/607389029cfec50f32b73c00a6f66d0a1dbcda23/src/clj/clojure/test.clj#L545",
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//test-is-api.html#clojure.contrib.test-is/with-test",
   "namespace":"clojure.contrib.test-is",
   "arglists":[["definition", "&", "body"]],
   "doc":
   "Takes any definition form (that returns a Var) as the first argument.\nRemaining body goes in the :test metadata function for that Var.\n\nWhen *load-tests* is false, only evaluates the definition, ignoring\nthe tests.",
   "name":"with-test"},
  {"source-url":
   "http://github.com/richhickey/clojure-contrib/blob/607389029cfec50f32b73c00a6f66d0a1dbcda23/src/clj/clojure/test.clj#L265",
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//test-is-api.html#clojure.contrib.test-is/with-test-out",
   "namespace":"clojure.contrib.test-is",
   "arglists":[["&", "body"]],
   "doc":"Runs body with *out* bound to the value of *test-out*.",
   "name":"with-test-out"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//trace-api.html#clojure.contrib.trace/*trace-depth*",
   "namespace":"clojure.contrib.trace",
   "doc":"Current stack depth of traced function calls.",
   "name":"*trace-depth*"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//trace-api.html#clojure.contrib.trace/deftrace",
   "namespace":"clojure.contrib.trace",
   "arglists":[["name", "&", "definition"]],
   "doc":
   "Use in place of defn; traces each call/return of this fn, including\narguments.  Nested calls to deftrace'd functions will print a\ntree-like structure.",
   "name":"deftrace"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//trace-api.html#clojure.contrib.trace/dotrace",
   "namespace":"clojure.contrib.trace",
   "arglists":[["fns", "&", "exprs"]],
   "doc":
   "Given a sequence of function identifiers, evaluate the body\nexpressions in an environment in which the identifiers are bound to\nthe traced functions.  Does not work on inlined functions,\nsuch as clojure.core/+",
   "name":"dotrace"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//trace-api.html#clojure.contrib.trace/trace",
   "namespace":"clojure.contrib.trace",
   "arglists":[["value"], ["name", "value"]],
   "doc":
   "Sends name (optional) and value to the tracer function, then\nreturns value.  May be wrapped around any expression without\naffecting the result.",
   "name":"trace"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//trace-api.html#clojure.contrib.trace/trace-fn-call",
   "namespace":"clojure.contrib.trace",
   "arglists":[["name", "f", "args"]],
   "doc":
   "Traces a single call to a function f with args.  'name' is the\nsymbol name of the function.",
   "name":"trace-fn-call"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//trace-api.html#clojure.contrib.trace/trace-indent",
   "namespace":"clojure.contrib.trace",
   "arglists":[[]],
   "doc":"Returns an indentation string based on *trace-depth*",
   "name":"trace-indent"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//trace-api.html#clojure.contrib.trace/tracer",
   "namespace":"clojure.contrib.trace",
   "arglists":[["name", "value"]],
   "doc":
   "This function is called by trace.  Prints to standard output, but\nmay be rebound to do anything you like.  'name' is optional.",
   "name":"tracer"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//types-api.html#clojure.contrib.types/defadt",
   "namespace":"clojure.contrib.types",
   "arglists":[["type-tag", "&", "constructors"]],
   "doc":
   "Define an algebraic data type name by an exhaustive list of constructors.\nEach constructor can be a symbol (argument-free constructor) or a\nlist consisting of a tag symbol followed by the argument symbols.\nThe data type tag must be a keyword.",
   "name":"defadt"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//types-api.html#clojure.contrib.types/deftype",
   "namespace":"clojure.contrib.types",
   "arglists":
   [["type-tag", "constructor-name", "docstring?", "attr-map?"],
    ["type-tag", "constructor-name", "docstring?", "attr-map?",
     "constructor"],
    ["type-tag", "constructor-name", "docstring?", "attr-map?",
     "constructor", "deconstructor"]],
   "doc":
   "Define a data type by a type tag (a namespace-qualified keyword)\nand a symbol naming the constructor function. Optionally, a\nconstructor and a deconstructor function can be given as well,\nthe defaults being clojure.core/identity and clojure.core/list.\nThe full constructor associated with constructor-name calls the\nconstructor function and attaches the type tag to its result\nas metadata. The deconstructor function must return the arguments\nto be passed to the constructor in order to create an equivalent\nobject. It is used for printing and matching.",
   "name":"deftype"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//types-api.html#clojure.contrib.types/deftype-",
   "namespace":"clojure.contrib.types",
   "arglists":[["type-tag", "constructor-name", "&", "optional"]],
   "doc":"Same as deftype but the constructor is private.",
   "name":"deftype-"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//types-api.html#clojure.contrib.types/match",
   "namespace":"clojure.contrib.types",
   "arglists":[["value", "&", "clauses"]],
   "doc":
   "Given a value and a list of template-expr clauses, evaluate the first\nexpr whose template matches the value. There are four kinds of templates:\n1) Lists of the form (tag x1 x2 ...) match instances of types\n   whose constructor has the same form as the list.\n2) Quoted lists of the form '(x1 x2 ...) match lists of the same\n   length.\n3) Vectors of the form [x1 x2 ...] match vectors of the same length.\n4) Maps of the form {:key1 x1 :key2 x2 ...} match maps that have\n   the same keys as the template, but which can have additional keys\n   that are not part of the template.\nThe values x1, x2, ... can be symbols or non-symbol values. Non-symbols\nmust be equal to the corresponding values in the object to be matched.\nSymbols will be bound to the corresponding value in the object in the\nevaluation of expr. If the same symbol occurs more than once in a,\ntemplate the corresponding elements of the object must be equal\nfor the template to match.",
   "name":"match"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//with-ns-api.html#clojure.contrib.with-ns/with-ns",
   "namespace":"clojure.contrib.with-ns",
   "arglists":[["ns", "&", "body"]],
   "doc":
   "Evaluates body in another namespace.  ns is either a namespace\nobject or a symbol.  This makes it possible to define functions in\nnamespaces other than the current one.",
   "name":"with-ns"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//with-ns-api.html#clojure.contrib.with-ns/with-temp-ns",
   "namespace":"clojure.contrib.with-ns",
   "arglists":[["&", "body"]],
   "doc":
   "Evaluates body in an anonymous namespace, which is then immediately\nremoved.  The temporary namespace will 'refer' clojure.core.",
   "name":"with-temp-ns"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//zip-filter-api.html#clojure.contrib.zip-filter/ancestors",
   "namespace":"clojure.contrib.zip-filter",
   "arglists":[["loc"]],
   "doc":
   "Returns a lazy sequence of all ancestors of location loc, starting\nwith loc and proceeding to loc's parent node and on through to the\nroot of the tree.",
   "name":"ancestors"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//zip-filter-api.html#clojure.contrib.zip-filter/children",
   "namespace":"clojure.contrib.zip-filter",
   "arglists":[["loc"]],
   "doc":
   "Returns a lazy sequence of all immediate children of location loc,\nleft-to-right.",
   "name":"children"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//zip-filter-api.html#clojure.contrib.zip-filter/children-auto",
   "namespace":"clojure.contrib.zip-filter",
   "arglists":[["loc"]],
   "doc":
   "Returns a lazy sequence of all immediate children of location loc,\nleft-to-right, marked so that a following tag= predicate will auto-descend.",
   "name":"children-auto"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//zip-filter-api.html#clojure.contrib.zip-filter/descendants",
   "namespace":"clojure.contrib.zip-filter",
   "arglists":[["loc"]],
   "doc":
   "Returns a lazy sequence of all descendants of location loc, in\ndepth-first order, left-to-right, starting with loc.",
   "name":"descendants"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//zip-filter-api.html#clojure.contrib.zip-filter/left-locs",
   "namespace":"clojure.contrib.zip-filter",
   "arglists":[["loc"]],
   "doc":
   "Returns a lazy sequence of locations to the left of loc, starting with loc.",
   "name":"left-locs"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//zip-filter-api.html#clojure.contrib.zip-filter/leftmost?",
   "namespace":"clojure.contrib.zip-filter",
   "arglists":[["loc"]],
   "doc":
   "Returns true if there are no more nodes to the left of location loc.",
   "name":"leftmost?"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//zip-filter-api.html#clojure.contrib.zip-filter/right-locs",
   "namespace":"clojure.contrib.zip-filter",
   "arglists":[["loc"]],
   "doc":
   "Returns a lazy sequence of locations to the right of loc, starting with loc.",
   "name":"right-locs"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//zip-filter-api.html#clojure.contrib.zip-filter/rightmost?",
   "namespace":"clojure.contrib.zip-filter",
   "arglists":[["loc"]],
   "doc":
   "Returns true if there are no more nodes to the right of location loc.",
   "name":"rightmost?"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//condition-api.html#clojure.contrib.condition.Condition/-init",
   "namespace":"clojure.contrib.condition.Condition",
   "arglists":[["condition"]],
   "doc":
   "Constructs a Condition object with condition (a map) as its\nmetadata. Also initializes the superclass with the values at :message\nand :cause, if any, so they are also available via .getMessage and\n.getCause.",
   "name":"-init"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//condition-api.html#clojure.contrib.condition.Condition/-meta",
   "namespace":"clojure.contrib.condition.Condition",
   "arglists":[["this"]],
   "doc":"Returns this object's metadata, the condition",
   "name":"-meta"},
  {"source-url":null,
   "wiki-url":
   "http://richhickey.github.com/clojure-contrib//condition-api.html#clojure.contrib.condition.Condition/-post-init",
   "namespace":"clojure.contrib.condition.Condition",
   "arglists":[["this", "condition"]],
   "doc":
   "Adds :stack-trace to the condition. Drops the bottom 3 frames because\nthey are always the same: implementation details of Condition and raise.",
   "name":"-post-init"}]}