395 lines
30 KiB
HTML
395 lines
30 KiB
HTML
<!DOCTYPE html>
|
||
<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
|
||
<head>
|
||
<meta charset="utf-8"/>
|
||
<title>Clojure Guides: How to use Maven to build Clojure projects</title>
|
||
|
||
|
||
<meta name="description" content="This guide describes how to use Maven to build projects written in Clojure (or in Clojure,
|
||
and other languages, such as Java). Although Leiningen is more popular build tool in the
|
||
Clojure community, Maven is also used for some projects, such as Clojure Contrib
|
||
libraries, and may be useful when you need to perform some special tasks during build,
|
||
that aren't covered by Leiningen's plugins, or when you're integrating Clojure code into
|
||
an existing Maven project.What is Maven?">
|
||
|
||
<meta property="og:description" content="This guide describes how to use Maven to build projects written in Clojure (or in Clojure,
|
||
and other languages, such as Java). Although Leiningen is more popular build tool in the
|
||
Clojure community, Maven is also used for some projects, such as Clojure Contrib
|
||
libraries, and may be useful when you need to perform some special tasks during build,
|
||
that aren't covered by Leiningen's plugins, or when you're integrating Clojure code into
|
||
an existing Maven project.What is Maven?">
|
||
|
||
<meta property="og:url" content="https://clojure-doc.github.io/articles/ecosystem/maven/" />
|
||
<meta property="og:title" content="How to use Maven to build Clojure projects" />
|
||
<meta property="og:type" content="article" />
|
||
|
||
<link rel="canonical" href="https://clojure-doc.github.io/articles/ecosystem/maven/">
|
||
<meta name="viewport" content="width=device-width, initial-scale=1">
|
||
<link href="https://fonts.googleapis.com/css?family=Alegreya:400italic,700italic,400,700" rel="stylesheet"
|
||
type="text/css">
|
||
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.0/css/bootstrap.min.css">
|
||
<link href="https://maxcdn.bootstrapcdn.com/font-awesome/4.2.0/css/font-awesome.min.css" rel="stylesheet">
|
||
<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.7.0/styles/default.min.css">
|
||
<link href="../../../css/screen.css" rel="stylesheet" type="text/css" />
|
||
</head>
|
||
<body>
|
||
|
||
|
||
<nav class="navbar navbar-default">
|
||
<div class="container">
|
||
<div class="navbar-header">
|
||
<button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#navbar" aria-expanded="false" aria-controls="navbar">
|
||
<span class="sr-only">Toggle navigation</span>
|
||
<span class="icon-bar"></span>
|
||
<span class="icon-bar"></span>
|
||
<span class="icon-bar"></span>
|
||
</button>
|
||
<a class="navbar-brand" href="../../../index.html">Clojure Guides</a>
|
||
</div>
|
||
<div id="navbar" class="navbar-collapse collapse">
|
||
<ul class="nav navbar-nav navbar-right">
|
||
<li ><a href="../../../index.html">Home</a></li>
|
||
<li><a href="https://github.com/clojure-doc/clojure-doc.github.io">Contribute</a></li>
|
||
</ul>
|
||
</div><!--/.nav-collapse -->
|
||
</div><!--/.container-fluid -->
|
||
</nav>
|
||
|
||
|
||
<div class="container">
|
||
|
||
|
||
<div class="row">
|
||
<div class="col-lg-9">
|
||
<div id="content">
|
||
|
||
<div id="custom-page">
|
||
<div id="page-header">
|
||
<h2>How to use Maven to build Clojure projects</h2>
|
||
</div>
|
||
|
||
<p>This guide describes how to use Maven to build projects written in Clojure (or in Clojure,
|
||
and other languages, such as Java). Although Leiningen is more popular build tool in the
|
||
Clojure community, Maven is also used for some projects, such as Clojure Contrib
|
||
libraries, and may be useful when you need to perform some special tasks during build,
|
||
that aren't covered by Leiningen's plugins, or when you're integrating Clojure code into
|
||
an existing Maven project.</p><h2 id="what-is-maven">What is Maven?</h2><p><a href="http://maven.apache.org">Maven</a> is a software project life cycle management tool. It implements dependencies
|
||
resolution (with automatic download of missing dependencies from repositories), building &
|
||
testing of code, deployment of software, etc. Maven's functionality is extensible with
|
||
plugins, so it's possible to use it not only for Java code (primary goal of this tool),
|
||
but also for code, written in other languages. You can read more about Maven in
|
||
<a href="http://www.sonatype.com/products/maven/documentation/book-defguide">following, freely available book</a>.</p><p>Maven differs from other tools, such as Ant - it describes <em>what</em> we want to do, in
|
||
contrast with Ant, that describes <em>how</em> to it. Maven uses declarative style to
|
||
describe tasks that we want to execute, and all described tasks are performed by
|
||
the corresponding plugins.</p><p>Description of software lifecycle and information about project is stored in <code>pom.xml</code>,
|
||
a file that should exist in root directory of the project (and in root directories of
|
||
sub-projects, if your project is separated into several modules). Project's information
|
||
includes name, identifier and version of the project, and often includes more information:
|
||
URL of project's site, information about source code repository (so you can use <code>mvn scm:update</code> goal to update code, for example), etc.</p><h2 id="lifecycle-phases">Lifecycle Phases</h2><p>Project Object Model (POM) defines set of stages for project's lifecycle - they are
|
||
called "lifecycle phases". Each phase can include several tasks (goals), that define what
|
||
will be performed on given stage. There are several common stages: compilation (<code>compile</code>),
|
||
testing (<code>test</code>), creation of package (<code>package</code>), and installation (<code>install</code>). Each of these
|
||
phases has dependencies on other phases, that should be executed before its invocation
|
||
(compilation should be executed before testing, testing before packaging, etc.).</p><p>Usually developer uses phase's name to start a process. For example, <code>mvn package</code>, or <code>mvn install</code>, etc. But developer can also execute concrete Maven's goal. To do this, he
|
||
should specify name of plugin, that implements concrete goal, and task name in given
|
||
plugin. For example, <code>mvn clojure:run</code> will start Clojure and execute script, specified in
|
||
configuration. We need to mention, that list of goals, that are executed for concrete
|
||
lifecycle phase isn't constant - you can change this list by modifying plugin's
|
||
configuration.</p><h2 id="maven-and-clojure">Maven and Clojure</h2><p>Clojure's support in Maven is provided by
|
||
<a href="https://github.com/talios/clojure-maven-plugin">clojure-maven-plugin</a>, that is available
|
||
in Maven's central repository, so it always available. (Besides <code>clojure-maven-plugin</code>,
|
||
there is also <a href="https://github.com/pallet/zi">Zi</a> plugin, that was developed as part of
|
||
<a href="http://palletops.com/">Pallet</a> project. In contrast to <code>clojure-maven-plugin</code> it's
|
||
written in Clojure, and more tightly integrated with Clojure-specific subsystems, such
|
||
Marginalia, Ritz, etc.)</p><p>As a base for your projects you can use <code>pom.xml</code> file from
|
||
<a href="https://github.com/talios/clojure-maven-example">clojure-maven-example</a> project.</p><p>If you already have <code>pom.xml</code> in your project, then to enable this plugin, you will need to
|
||
add following code into <code><plugins></code> section of <code>pom.xml</code>:</p><pre><code class="xml"> <plugin>
|
||
<groupId>com.theoryinpractise</groupId>
|
||
<artifactId>clojure-maven-plugin</artifactId>
|
||
<version>1.3.10</version>
|
||
</plugin>
|
||
</code></pre><p><em>Attention:</em> version number could be changed as development continues. To find latest
|
||
plugin's version number you can use sites <a href="http://mvnrepository.com/artifact/com.theoryinpractise/clojure-maven-plugin">mvnrepository</a> or <a href="http://jarvana.com/jarvana/">Jarvana</a>, that contains
|
||
information about packages, registered in Maven's repositories. Besides this, you can
|
||
omit plugin version - in this case, Maven will automatically use latest available version
|
||
(although this isn't always good idea).</p><p>Declaration of this plugin will give you all implemented functionality - compilation,
|
||
testing & running of code, written in Clojure, etc. Although, out of box you'll need to
|
||
use complete goals names, such as <code>clojure:compile</code>, <code>clojure:test</code> & <code>clojure:run</code>.</p><p>But you can make your life easier if you'll add these goals into list of goals for
|
||
concrete lifecycle phases (<code>compile</code> and <code>test</code>). To do this you need to add section
|
||
<code><executions></code> into plugin's description, as in following example:</p><pre><code class="xml"> <plugin>
|
||
<groupId>com.theoryinpractise</groupId>
|
||
<artifactId>clojure-maven-plugin</artifactId>
|
||
<version>1.3.10</version>
|
||
<executions>
|
||
<execution>
|
||
<id>compile</id>
|
||
<phase>compile</phase>
|
||
<goals>
|
||
<goal>compile</goal>
|
||
</goals>
|
||
</execution>
|
||
<execution>
|
||
<id>test</id>
|
||
<phase>test</phase>
|
||
<goals>
|
||
<goal>test</goal>
|
||
</goals>
|
||
</execution>
|
||
</executions>
|
||
</plugin>
|
||
</code></pre><p>In this case, source code, written in Clojure will be compiled - this useful if you
|
||
implement <code>gen-class</code>, that will be used from Java, or if you don't want to provide source
|
||
code for your application. But sometimes it's much better just to pack source code into
|
||
jar, and it will compiled during loading of package (this is default behaviour when you're
|
||
declaring <code>clojure</code> packaging type) - this allows to avoid binary incompatibility between
|
||
different versions of Clojure. To put source code into jar, you need to add following
|
||
code into <code>resources</code> section (or change packaging type to <code>clojure</code>):</p><pre><code class="xml"> <resource>
|
||
<directory>src/main/clojure</directory>
|
||
</resource>
|
||
</code></pre><p>By default, Clojure's source code is placed in the <code>src/main/clojure</code> directory of the
|
||
project's tree, while source code for tests is placed in the <code>src/test/clojure</code> directory.
|
||
These default values could be changed in <a href="index.html#configure">plugin's configuration</a>.</p><h3 id="goals-in-the-clojure-maven-plugin">Goals in the Clojure Maven Plugin</h3><p><code>clojure-maven-plugin</code> implements several commands (goals) that could be divided into
|
||
following groups:</p><ul><li><p>Goals that work with source code (usually they are linked with corresponding phases of
|
||
lifecycle, as it's shown above):</p><ul><li><code>clojure:compile</code>: compiles source code, written in Clojure;</li><li><code>clojure:test</code>: executes tests, written in Clojure.</li><li><code>clojure:test-with-junit</code>: executes tests using JUnit;</li><li><code>clojure:add-source</code>: adds directory with source code to archive <code>...-sources.jar</code>;</li><li><code>clojure:add-testsource</code>: add directory with tests source code into archive
|
||
<code>...-testsources.jar</code>.</li></ul></li><li><p>Goals for execution of project's code:</p><ul><li><code>clojure:run</code>: executes script (or scripts) defined by <code>script</code> and/or <code>scripts</code>
|
||
configuration directives. This goals is often used to run project with correct
|
||
dependencies;</li><li><code>clojure:repl</code>: starts Clojure REPL with all dependencies, specified in project. If
|
||
necessary, it also executes script specified in configuration option <code>replScript</code> - for
|
||
example, you can put some initialization code into it. If the JLine library was
|
||
specified in dependencies, then it will be loaded automatically, making your work in
|
||
REPL more comfortable;</li><li><code>clojure:swank</code>: starts Swank server, so you can connect to it from Emacs SLIME. By
|
||
default, this server is running on port 4005 (this value could be changed with system
|
||
option <code>clojure.swank.port</code>);</li><li><code>clojure:nailgun</code>: starts Nailgun server, so you can connect to it from Vim with
|
||
<a href="http://kotka.de/projects/clojure/vimclojure.html">vimclojure</a>. By default, this server is running on port 2113 (this value could be
|
||
changed with system option <code>clojure.nailgun.port</code>).</li></ul></li><li><p>Auxiliary tasks:</p><ul><li><code>clojure:marginalia</code>: generates documentation using <a href="http://fogus.github.com/marginalia/">Marginalia</a>;</li><li><code>clojure:autodoc</code>: generates documentation using <a href="http://tomfaulhaber.github.com/autodoc/">autodoc</a>;</li><li><code>clojure:gendoc</code>: generates documentation using gendoc.</li></ul></li></ul><h3 id="clojure-related-repositories">Clojure-related repositories</h3><p>There are several Clojure-related repositories. All Clojure versions (stable &
|
||
development) are published at <a href="http://dev.clojure.org/display/doc/Maven+Settings+and+Repositories">Sonatype repository</a> that is periodically synchronized with
|
||
Maven Central. <a href="http://clojars.org">Clojars</a> is repository that is used by Clojure community to publish their
|
||
projects.</p><p>To use repository you need to add following code into <code>repositories</code> section in <code>pom.xml</code>:</p><pre><code class="xml"> <repository>
|
||
<id>clojars</id>
|
||
<url>http://clojars.org/repo/</url>
|
||
</repository>
|
||
</code></pre><h3 id="dependencies-management">Dependencies Management</h3><p>Maven automatically downloads the all necessary dependencies from the default repository (known as
|
||
Maven Central), and
|
||
repositories, specified by user (as shown above). Downloaded packages are stored in
|
||
user's home directory and could be used by other projects without additional downloading.
|
||
Each package is uniquely identified by combination of three parameters - group's name
|
||
(the <code>groupId</code> tag), artifact's name (the <code>artifactId</code> tag), and version (the <code>version</code> tag).</p><p>To use Clojure in your project you need at least specify dependency on language itself.
|
||
Right now, the stable version of Clojure is 1.4.0. To declare this dependency, add
|
||
following code into <code>dependencies</code> section of <code>pom.xml</code> file:</p><pre><code class="xml"> <dependency>
|
||
<groupId>org.clojure</groupId>
|
||
<artifactId>clojure</artifactId>
|
||
<version>1.4.0</version>
|
||
</dependency>
|
||
</code></pre><p>If you want to use the latest version of the language, then you need to add corresponding
|
||
repository (snapshots) and use version number like <code>1.5.0-master-SNAPSHOT</code> instead of version
|
||
<code>1.4.0</code>.</p><p>To perform some tasks, implemented by <code>clojure-maven-plugin</code>, you need to specify additional
|
||
dependencies.</p><p>If you will use <code>clojure:swank</code> goal, then you need to specify dependency on <code>swank-clojure</code> package:</p><pre><code class="xml"> <dependency>
|
||
<groupId>swank-clojure</groupId>
|
||
<artifactId>swank-clojure</artifactId>
|
||
<version>1.4.2</version>
|
||
</dependency>
|
||
</code></pre><p>If you will use <code>clojure:nailgun</code> task, then you need to download distribution from
|
||
<a href="http://kotka.de/projects/clojure/vimclojure.html">vimclojure</a>'s site, build it, as described in documentation, and install into local
|
||
Maven repository. And after this, you need to add following dependency on
|
||
<code>vimclojure</code> with following code:</p><pre><code class="xml"><dependency>
|
||
<groupId>de.kotka</groupId>
|
||
<artifactId>vimclojure</artifactId>
|
||
<version>X.Y.Z</version>
|
||
</dependency>
|
||
</code></pre><p>The JLine library isn't required, but it could be useful if you plan to use the REPL -
|
||
this library implements support for command history and other nice things. Presence of this library is detected
|
||
automatically when <code>mvn clojure:repl</code> goal is executed. You can add dependency for this
|
||
library with following code:</p><pre><code class="xml"> <dependency>
|
||
<groupId>jline</groupId>
|
||
<artifactId>jline</artifactId>
|
||
<version>0.9.94</version>
|
||
</dependency>
|
||
</code></pre><h3 id="plugins-configuration">Plugin's Configuration</h3><p>Developer can change plugin's configuration options, such as location of source code,
|
||
scripts names, etc. To change some parameter, you need to add its new value into
|
||
<code>configuration</code> section of the plugin's description. For example, you can specify name of
|
||
the script, that will be executed during testing, using following code:</p><pre><code class="xml"><plugin>
|
||
<groupId>com.theoryinpractise</groupId>
|
||
<artifactId>clojure-maven-plugin</artifactId>
|
||
<version>1.3.10</version>
|
||
<configuration>
|
||
<testScript>src/test/clojure/test.clj</testScript>
|
||
</configuration>
|
||
.....
|
||
</plugin>
|
||
</code></pre><p>Following options are used to specify options related to source code & compilation:</p><ul><li><code>sourceDirectories</code> - this option defines list of directories (each of them should be
|
||
wrapped into <code>sourceDirectory</code> tag) that contains source code written in Clojure, and that
|
||
will be packed into resulting jar (and compiled, if corresponding option is specified);</li><li><code>testSourceDirectories</code> - defines list of directories (each of them should be wrapped into
|
||
<code>testSourceDirectory</code> tag) with tests, written in Clojure;</li><li><code>warnOnReflection</code> - option that enables (<code>true</code>) or disables (<code>false</code>) warnings about
|
||
reflection during compilation of source code.</li></ul><p>Besides this, you can control which namespaces will be compiled and/or for which
|
||
namespaces testing of source code will be performed. To do this, you need to add
|
||
<code>namespaces</code> tag into configuration and list corresponding namespaces inside it (each of
|
||
item should be wrapped into <code>namespace</code> tag). You can use regular expressions to specify
|
||
all necessary namespaces, and you can also use <code>!</code> to exclude namespaces from this list. In
|
||
addition to this option, you can use other two: <code>compileDeclaredNamespaceOnly</code> and
|
||
<code>testDeclaredNamespaceOnly</code> (with values <code>true</code> or <code>false</code>) - they control, will be these
|
||
namespace limitations applied during compilation and/or testing.</p><p>There are also several options that are used to specify parameters for execution of your
|
||
code and/or tests:</p><ul><li><code>script</code> and <code>scripts</code> - defines one (<code>script</code> tag) or several (<code>scripts</code> tag with nested <code>script</code>
|
||
tags) names of scripts with code, that will executed when you'll execute the
|
||
<code>clojure:run</code> task;</li><li><code>testScript</code>: defines name of script that will executed when you'll execute <code>clojure:test</code>
|
||
task. If there was no value specified in plugin's configuration, then plugin will
|
||
automatically generate run script for all tests, that was found in project;</li><li><code>replScript</code> - defines name of script, that will executed if you'll execute <code>clojure:repl</code> task
|
||
(it's also used by <code>clojure:swank</code> and <code>clojure:nailgun</code> tasks). This code will executed
|
||
before entering into REPL, so you can use it to specify initialization code for your
|
||
working environment;</li><li><code>runWithTests</code> - enables (<code>true</code>) or disables (<code>false</code>) executions of tests if you run REPL or
|
||
your code via Maven. You can also change this value by using Maven's command-line
|
||
option. For example, using following command <code>mvn clojure:repl -Dclojure.runwith.test=false</code>;</li><li><code>clojureOptions</code> - using this option you can specify command-line options that will be
|
||
passed to <code>java</code> process on every invocation.</li></ul><h2 id="wrapping-up">Wrapping Up</h2><p>I think, that this article provides enough information for you to start use Maven together
|
||
with Clojure. If you have Clojure-only project, and you don't plan to use all power of
|
||
Maven, then may be you can look to the <a href="https://clojure-doc.org/articles/ecosystem/maven/leiningen.md">Leiningen</a> - this tool was created to build
|
||
projects, written mostly in Clojure. Another interesting project is <a href="http://polyglot.sonatype.org/">Polyglot Maven</a>, the
|
||
main goal of it is creation of special DSL (Domain Specificl Language) using different
|
||
languages (Clojure, Scala, Groovy) for description of Maven's configurations (for Clojure
|
||
this language is almost the same as language implemented in Leiningen).</p><p>Other examples of using Maven with Clojure you can find in different projects: <a href="https://github.com/liebke/incanter/tree/1.0.x">Incanter</a>
|
||
(as example of project, consisting from several modules), <a href="https://github.com/relevance/labrepl">labrepl</a> and
|
||
the <a href="https://github.com/talios/clojure-maven-example">clojure-maven-example</a>.</p><h2 id="where-to-learn-more">Where To Learn More</h2><p>More information on Clojure and Maven you can also find in
|
||
following blog posts:</p><ul><li><a href="http://muckandbrass.com/web/display/~cemerick/2010/03/25/Why+using+Maven+for+Clojure+builds+is+a+no-brainer">Why using Maven for Clojure builds is a no-brainer</a> (including video, that shows how to work with the <code>clojure-maven-plugin</code>)</li><li><a href="http://pupeno.com/blog/how-to-create-a-clojure-application/">How to create a Clojure application</a></li><li><a href="http://stuartsierra.com/2009/09/03/mavens-not-so-bad">Maven’s Not So Bad</a>.</li></ul><h2 id="contributors">Contributors</h2><p><a href="http://alexott.net/en/index.html">Alex Ott</a>, 2012 (original author)</p>
|
||
|
||
<div id="prev-next">
|
||
|
||
<a href="../web_development/index.html">« Web Development (Overview)</a>
|
||
|
||
|
||
||
|
||
|
||
|
||
<a href="../community/index.html">Clojure Community »</a>
|
||
|
||
</div>
|
||
</div>
|
||
|
||
</div>
|
||
</div>
|
||
|
||
<div class="col-md-3">
|
||
<div id="sidebar">
|
||
<h3>Links</h3>
|
||
<ul id="links">
|
||
|
||
<li><a href="../../about/index.html">About</a></li>
|
||
|
||
<li><a href="../../content/index.html">Table of Contents</a></li>
|
||
|
||
<li><a href="../../tutorials/getting_started/index.html">Getting Started with Clojure</a></li>
|
||
|
||
<li><a href="../../tutorials/introduction/index.html">Introduction to Clojure</a></li>
|
||
|
||
<li><a href="../../tutorials/emacs/index.html">Clojure with Emacs</a></li>
|
||
|
||
<li><a href="../../tutorials/vim_fireplace/index.html">Clojure with Vim and fireplace.vim</a></li>
|
||
|
||
<li><a href="../../tutorials/eclipse/index.html">Starting with Eclipse and Counterclockwise For Clojure Development</a></li>
|
||
|
||
<li><a href="../../tutorials/basic_web_development/index.html">Basic Web Development</a></li>
|
||
|
||
<li><a href="../../tutorials/parsing_xml_with_zippers/index.html">Parsing XML in Clojure</a></li>
|
||
|
||
<li><a href="../../tutorials/growing_a_dsl_with_clojure/index.html">Growing a DSL with Clojure</a></li>
|
||
|
||
<li><a href="../../language/core_overview/index.html">Overview of clojure.core, the standard Clojure library</a></li>
|
||
|
||
<li><a href="../../language/namespaces/index.html">Clojure Namespaces and Vars</a></li>
|
||
|
||
<li><a href="../../language/collections_and_sequences/index.html">Collections and Sequences in Clojure</a></li>
|
||
|
||
<li><a href="../../language/functions/index.html">Functions in Clojure</a></li>
|
||
|
||
<li><a href="../../language/laziness/index.html">Laziness in Clojure</a></li>
|
||
|
||
<li><a href="../../language/interop/index.html">Clojure interoperability with Java</a></li>
|
||
|
||
<li><a href="../../language/macros/index.html">Clojure Macros and Metaprogramming</a></li>
|
||
|
||
<li><a href="../../language/polymorphism/index.html">Polymorphism in Clojure: Protocols and Multimethods</a></li>
|
||
|
||
<li><a href="../../language/concurrency_and_parallelism/index.html">Concurrency and Parallelism in Clojure</a></li>
|
||
|
||
<li><a href="../../language/glossary/index.html">Clojure Terminology Guide</a></li>
|
||
|
||
<li><a href="../libraries_directory/index.html">A Directory of Clojure Libraries</a></li>
|
||
|
||
<li><a href="../libraries_authoring/index.html">Library Development and Distribution</a></li>
|
||
|
||
<li><a href="../generating_documentation/index.html">Generating Documentation</a></li>
|
||
|
||
<li><a href="../data_processing/index.html">Data Processing (Help Wanted)</a></li>
|
||
|
||
<li><a href="../web_development/index.html">Web Development (Overview)</a></li>
|
||
|
||
<li><a href="index.html">How to use Maven to build Clojure projects</a></li>
|
||
|
||
<li><a href="../community/index.html">Clojure Community</a></li>
|
||
|
||
<li><a href="../user_groups/index.html">Clojure User Groups</a></li>
|
||
|
||
<li><a href="../running_cljug/index.html">Running a Clojure User Group</a></li>
|
||
|
||
<li><a href="../books/index.html">Books about Clojure and ClojureScript</a></li>
|
||
|
||
<li><a href="../../cookbooks/data_structures/index.html">Data Structures (Help wanted)</a></li>
|
||
|
||
<li><a href="../../cookbooks/strings/index.html">Strings</a></li>
|
||
|
||
<li><a href="../../cookbooks/math/index.html">Mathematics with Clojure</a></li>
|
||
|
||
<li><a href="../../cookbooks/date_and_time/index.html">Date and Time (Help wanted)</a></li>
|
||
|
||
<li><a href="../../cookbooks/files_and_directories/index.html">Working with Files and Directories in Clojure</a></li>
|
||
|
||
<li><a href="../../cookbooks/middleware/index.html">Middleware in Clojure</a></li>
|
||
|
||
<li><a href="../java_jdbc/home.html">java.jdbc - Getting Started</a></li>
|
||
|
||
<li><a href="../java_jdbc/using_sql.html">java.jdbc - Manipulating data with SQL</a></li>
|
||
|
||
<li><a href="../java_jdbc/using_ddl.html">java.jdbc - Using DDL and Metadata</a></li>
|
||
|
||
<li><a href="../java_jdbc/reusing_connections.html">java.jdbc - How to reuse database connections</a></li>
|
||
|
||
<li><a href="../core_typed/home/index.html">core.typed - User Documentation Home</a></li>
|
||
|
||
<li><a href="../core_typed/user_documentation/index.html">core.typed - User Documentation</a></li>
|
||
|
||
<li><a href="../core_typed/rationale/index.html">core.typed - Rationale</a></li>
|
||
|
||
<li><a href="../core_typed/quick_guide.html">core.typed - Quick Guide</a></li>
|
||
|
||
<li><a href="../core_typed/start/introduction_and_motivation/index.html">core.typed - Getting Started: Introduction and Motivation</a></li>
|
||
|
||
<li><a href="../core_typed/types/index.html">core.typed - Types</a></li>
|
||
|
||
<li><a href="../core_typed/start/annotations/index.html">core.typed - Annotations</a></li>
|
||
|
||
<li><a href="../core_typed/poly_fn/index.html">core.typed - Polymorphic Functions</a></li>
|
||
|
||
<li><a href="../core_typed/filters/index.html">core.typed - Filters</a></li>
|
||
|
||
<li><a href="../core_typed/mm_protocol_datatypes/index.html">core.typed - Protocols</a></li>
|
||
|
||
<li><a href="../core_typed/loops/index.html">core.typed - Looping constructs</a></li>
|
||
|
||
<li><a href="../core_typed/function_types/index.html">core.typed - Functions</a></li>
|
||
|
||
<li><a href="../core_typed/limitations/index.html">core.typed - Limitations</a></li>
|
||
|
||
</ul>
|
||
|
||
|
||
</div>
|
||
</div>
|
||
</div>
|
||
<footer>Copyright © 2021 Multiple Authors
|
||
<p style="text-align: center;">Powered by <a href="http://cryogenweb.org">Cryogen</a></p></footer>
|
||
</div>
|
||
<script src="https://code.jquery.com/jquery-1.11.0.min.js"></script>
|
||
<script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.0/js/bootstrap.min.js"></script>
|
||
<script src="../../../js/highlight.pack.js" type="application/javascript"></script>
|
||
<script>hljs.initHighlightingOnLoad();</script>
|
||
|
||
|
||
</body>
|
||
</html>
|