Clojure Programming Cookbook

By Makoto Hashimoto and Nicolas Modrzyk

This book is for Clojure developers who have some Clojure programming experience and are well aware of their shortcomings. If you want to learn to tackle common problems, become an expert, and develop a solid skill set, then this book is for you.

• Language: English
• Publisher: Packt Publishing
• Release date: Oct 28, 2016
• ISBN: 9781785888519

Book preview

Table of Contents

Clojure Programming Cookbook

Credits

About the Authors

About the Reviewer

www.PacktPub.com

eBooks, discount offers, and more

Why subscribe?

Preface

What this book covers

What you need for this book

Who this book is for

Sections

Getting ready

How to do it…

How it works…

There's more…

See also

Conventions

Reader feedback

Customer support

Downloading the example code

Downloading the color images of this book 

Errata

Piracy

Questions

1. Live Programming with Clojure

Introduction

REPL up!

Getting ready

How to do it...

How it works...

There's more...

See also

Working with primitive data types

Getting ready

How to do it...

Using numbers

Using strings and characters

Using booleans and nil

Using symbols and keywords

How it works...

There's more...

Using bindings of vars, conditions, loops, and error handling

Getting ready

How to do it...

def and let

if and if-not

when and when-not

case and cond

do and dotimes

loop and recur

try... catch... throw

How it works...

Using and defining functions

Getting ready

How to do it...

Defining simple functions

Defining variadic functions

Defining multiple arity functions

Defining functions that specify arguments using a keyword

Defining functions with pre-condition and post-condition

How it works...

There's more...

Using third-party libraries

Getting ready

How to do it...

Adding the JAR file manually to your classpath

Using Leiningen and a project.clj file

Viewing dependencies

one-off

New dependencies at runtime

Using namespaces

Getting ready

How to do it...

Creating a new namespace

Inspecting namespaces

Adding functions with :import and :refer

Loading namespaces from files

Reloading namespaces

How to organize namespaces

There's more...

Namespace for public API

tools.namespace

What's next?

2. Interacting with Collections

Introduction

Clojure collections and their basic functions

Getting ready

How to do it...

Lists

Vectors

Maps

Sets

How it works...

Clojure collections

Differences between lists and vectors

Clojure is immutable

There's more...

Converting collections between different types

Using distinct

Accessing and updating elements from collections

Getting ready

How to do it...

Accessing collections using the nth function

Accessing maps or sets using get

Maps, sets, and keywords are functions to access collections

Accessing a collection using second, next, ffirst, and nfirst

Using update to update collections

How it works...

There's more...

Using get for vectors

Using collections as keys in maps

Using get-in

Using assoc-in

Using update-in

Filtering elements from collections

Getting ready

How to do it...

Filtering multiples of three

Filtering items of a map

Filtering non-nil values

Removing odd values from a sequence

Using keep

Using keep-indexed

There's more...

Filter as a transducer

Filtering with core.async

Transforming and sorting collections

Getting ready

How to do it...

Using built-in sort

Migrating to sort-by

Using sorted-set

Working with sorted collection subsets

Sorting Clojure maps

Sorted map structure

Are you sorted yet?

How it works...

There's more...

Sorting lines of a file

Merging and splitting collections

Getting ready

How to do it...

Using merge and merge-with for merging

The zipmap merges keys and values for maps

Using interleave

Using split-at and split-with to split collections

How it works...

There's more...

Using group-by to split collections

Using the filter function to split collections

How to become lazy

Getting ready

How to do it...

The iterate function

Realized?

Random sequences with repeatedly

Using the macro lazy-seq

How it works...

There's more...

Other lazy-seq-producing functions

Force evaluation with doall

Lazy evaluation with files

The map function and calling rest

3. Clojure Next

Introduction

Using destructuring techniques

Getting ready

How to do it...

Sequential destructuring

Using map destructuring

How it works...

There's more...

Sequential destructuring for string

Conditional destructing with core.match

Using functional programming style

Getting ready

How to do it...

Functions taking functions as their arguments

map

reduce

apply

Using anonymous functions

Anonymous functions using fn

Using function literals to define anonymous functions

Functions returning functions

constantly

complement

partial

comp

every-pred and some-fn

How it works...

Clojure functions are first-class functions

Pure functions

There's more...

reduce and apply

loop and recur

Using threading macros

Getting ready

How to do it...

Introducing the -> macro

Introducing the ->> macro

Introducing the cond-> and the cond->> macros

Introducing some-> and some->>

How it works...

There's more...

Introducing as->

Flambo preview

Defining simple macros

Getting ready

How to do it...

Your first macro

Your second macro

How it works...

There's more...

Using quotes

Macros everywhere

Defining more advanced macros

Getting ready

How to do it...

Tracking when code was started

Logging a message with macro

How it works...

There's more...

deftest

Using protocols

Getting ready

How to do it...

Defining a record

Defining a type

Defining a protocol

How it works...

Records and types are Java classes

Differentiating between records and types

There's more...

Defining a mutable protocol and type

Defining multimethods

Getting ready

How to do it...

Defining a multimethod

How it works...

There's more...

Transducers for dummies

Getting ready

How to do it...

How it works...

Composable functions

Inserting elements

Writing your own transducers

Short circuit

There's more...

Transducers with core.async

Summing things up

Logic programming in Clojure

Getting ready

Baby logic steps

Getting to know the o vocabulary

conso: check for vector association

resto: check for the rest of a vector

membero

appendo: appending list

conde

Matche

Beginner logic

Keeping fresh

Finding only one result

Mature logic

Range of values

How to do it...

Generating data

Generating more data with more logic variables

Using a project

How it works...

There's more...

Validating the results of a function

Working with external data

4. File Access and the Network

Introduction

Manipulating files and directories

Getting ready

How to do it...

spit and slurp

Reader and writer with with-open

Creating a file and directory

Copying a file

Deleting a file and a directory

Listing files and directories in a directory

How it works...

slurp and spit

with-open macro

There's more...

Reading HTTP resource

Examining the source code

Manipulating various formats of files - XML, JSON, YAML, and EDN

Getting ready

How to do it...

XML

JSON

YAML isn't a markup language

MessagePack, Clojure library

How it works...

There's more...

Extensible Data Notation

Making use of Clojure HTTP client

Getting ready

How to do it...

How it works...

There's more...

async HTTP and core async

Using queues and topics in the RabbitMQ

Getting ready

Installing RabbitMQ

How to do it...

Producing hello world messages and consuming them

Declaring the namespace and loading Langohr libraries and IP address of the Docker container

Defining a producer function

Defining a message handler and consumer

Testing producer and consumer

Using blocking consumer

How it works...

Connect to broker and open channel

How producer works

Declaring queue

Producing messages

How consumer works

Consumer messages

Defining message handler

There's more...

Using fanout exchange

fanout-producer

fanout-consumer

Running the fanout consumers

Testing fanout consumers

Using topic exchange

Topic-publisher

Topic-consumer

Running the topic consumers

Testing the topic consumers

See also

Using Kafka

Getting ready

Downloading Kafka 0.8.2.2

Start ZooKeeper and Kafka server

Create topic

Run a console consumer

Using clj-kafka

How to do it...

Declaring the namespace and load Clojure library

Producing messages

Consuming a messages

How it works...

Producing messages

Consuming messages

There's more...

Creating a new topic

See also

Using MQTT

Getting ready

Installing the MQTT broker

MQTT graphical client

Send our first MQTT message

Getting some Clojure

How to do it...

How it works...

There's more...

Streaming access to provide high performance

Getting ready

How to do it...

Streaming out

Streaming in

Streaming with line-seq

How it works...

There's more...

Using Apache Camel to connect everything

Getting ready

How to do it...

Importing Camel classes

Your first ride on Camel with Clojure

Writing more Clojure idiomatic code with Camel

How it works...

There's more...

See also

5. Working with Other Languages

Introduction

Calling Java methods and accessing Java objects from Clojure

Getting ready

How to do it...

Instantiating objects

Calling instance methods

Calling class methods

Accessing instance fields

Accessing class fields

Accessing inner classes

Referencing classes

Using arrays

How it works...

Summary of how Clojure accesses Java methods and objects

Clojure does not inherit Java's checked exception

Summary of array accesses

Print strings of Java's primitives

There's more...

Chained calls with the double-dot macro

Using the doto macro

Using reflections

Extending Java superclasses and implementing Java interfaces

Getting ready

How to do it...

Using proxy

Using reify for implementing interfaces

How it works...

There's more...

Defining anonymous classes in Clojure

Using annotations

Calling Clojure from Java

Getting ready

How to do it...

Defining a simple named class using gen-class

Defining a class with instance methods and constructors in Clojure

Creating a JAR file callable from Java

How it works...

The project.clj for generating Java classes

AOT compilation

There's more...

Defining an interface and implementing a class callable from Java

Using Maven for Clojure and Java projects

Calling Scala from Clojure

Getting ready

How to do it...

Using Leiningen to develop Scala and Clojure

Importing Scala classes

Calling instance methods

Calling singleton methods

Accessing tuples

Accessing Scala fields

How it works...

There's more...

Using SBT

Creating an SBT-based project

Writing source code

ClojureCLR

Getting ready

Installing Visual Code Studio and creating a project

Installing Mono Studio IDE

Lein CLR

How to do it...

Calling .NET code from Clojure

Starting an REPL

Working with IO

Parsing some XML using C# code

Calling a REST API using Clojure/C#

UI Prototyping

Putting it all together

How it works...

Compiling Clojure code for .NET

Adding Clojure code to a Visual Studio project

Running Clojure code using Clojure.RT

Using Xamarin Mono Studio

There's more...

ClojureScript

Getting ready

How to do it...

Autocompiling your code

Fibonacci'ed

How it works...

Interacting with JavaScript

Using jQuery from ClojureScript

Creating a ClojureScript library

Using a third-party library

There's more...

Running in the REPL

Compiling code for both Clojure and ClojureScript

6. Concurrency and Parallelism

Introduction

Solving concurrent problems using Clojure

Getting ready

How to do it...

Using atoms

Creating and referring atom

Updating atom

Using validator

Using CAS operation

Software Transactional Memory using ref and dosync

Creating ref

Updating refs using alter

Using ensure

Using watcher and a refined transaction code

Using commute

Using agents

Creating agents

Updating agents

How it works...

Summary of three reference types in Clojure

Coordinated/uncoordinated

Synchronous/asynchronous

How STM works in Clojure

Alter and commute

There's more...

promise and deliver

pmap, pcalls, and pvalues

pcalls

pvalues

See also

Distributed actor-based dev with Akka

Getting ready

How to do it...

Your first okku

Creating actors

Dispatching messages

How it works...

Actor system

Understanding actors

There's more...

Calling remote actors

Request and reply

See also

Using Spyglass and Couchbase to share state between JVMs

Getting ready

Setting up dependencies in project.clj

Setting up Couchbase Server as a Memcached server

Using docker-compose to start Couchbase Server

Creating a directory and a file for docker-compose

Start Couchbase cluster

Check if Docker processes are running

Summary of Couchbase cluster

Using Couchbase web administrator console

Logging into the web console

Adding nodes to the cluster

Adding Cluster

Defining Memcached bucket

How to do it...

Defining to use Spyglass library

Connecting server

Set values

Get values from another REPL

Testing time to live

Disconnecting

How it works...

What is Memcached?

Access Memcached from Telnet

Couchbase Server

There's more...

Using get-multi

Using async-get

Using CAS operations

See also

Reactive programming with meltdown

Getting ready

How to do it...

Defining a reactor

Sending a message to a reactor

Going the sync way

How it works...

Selectors

Streams

Streams and reduce

Combining functions with a graph

Custom streams

There's more...

Bridging core.async

Getting ready

Memories - reviewing core.async basics

Pub/sub

How to do it...

Async socket server

Async socket client

Chiming

There's more...

Client to Python WebSockets

Clojure WebSocket server

On Quasar/Pulsar

Getting ready

How to do it...

How it works...

Watching over other actors lifecycles

State of an actor

There's more...

Blazar

7. Advanced Tips

Introduction

Hacking the Clojure code

Getting ready

How to do it...

How it works...

There's more...

Using Reader Conditionals, compile to Clojure, and ClojureScript

Getting ready

How to do it...

Your first Reader Conditional

Using Reader Conditionals in namespaces

How it works...

The form of Reader Conditionals and Splice macros

Macros in ClojureScript

There's more...

Building an application for Clojure and ClojureScript

Adding a cljc file for demonstrating Quil

Testing cljc code in both Clojure and ClojureScript

Building and running a demo

See also

Real-time shared development with an REPL

Getting ready

How to do it...

Shared REPLs

Using Atom and proto-repl

Using an embedded NREPL

There's more...

Custom REPL using Java interop

Server

Client

The async custom REPL server

Server REPL or more on real-time work on production code

Declarative data descriptions and validations with plumatic/schema

Getting ready

How to do it...

My first schema

Using schema for records and other types

Defining functions with validations

How it works...

Performance considerations

Generating test data

There's more...

Data coercion with prismatic/schema

Using core.typed

core.spec

8. Web Applications

Introduction

Clojure with Vaadin - easy web widgets

Getting ready

Project settings

The Clojure/Vaadin flow

How to do it...

Using the Calendar widget

Reacting to events

Clicking a button

Using and reloading namespaces

Server-side push

There's more...

Reactive Vaadin - ideas

Reactive Vaadin - CPU monitoring

Reactive Vaadin - Telegram on Raspberry Pi

Deployment bonus

Quickly create a REST API with Liberator

Getting ready

How to do it...

Your first Liberator

Using defresource

Parameterized resources

Defining GET/POST/PUT/DELETE methods for REST APIs

How it works...

Methods and status codes of HTTP

Tracing requests

There's more...

Persistent REST resources using clojure.java.jdbc

Preparing for jdbc

Our service spec

Creating a product table and defining access functions

Defining resources and starting a server

Accessing from an HTTP client

Working with Immutant - reusing infrastructure

Getting ready

How to do it...

Simple messaging with Artemis

Remote messaging

Remote procedure call with queues

Scheduling code execution

Piping and defining data transformation pipelines

Using WebSockets made easy

There's more...

Packaging as standalone

Packaging as a deployable web archive (WAR file)

Developing with om.next, the next-generation ClojureScript library

Getting ready

Creating a new project for om.next

Updating the om version

Tips for dependencies

Starting figwheel

How to do it...

Getting started with om.next

Using states

How it works...

React fundamentals

defui

reconciler

Life cycle of components

There's more...

Task list using om.next

Defining the namespace and libraries to use

Defining state

Defining read

Defining mutate

Defining UIs

9. Testing

Introduction

Behavior-driven development

Getting ready

Dependencies

The first feature

Designing a folder structure to organize features

How to do it...

Many assumptions with tables

Reading assumptions from a CSV file

Doing it with Excel

Doing it with web APIs and MongoDB

There's more...

VirtualBox

Freactive

Flambo, or BDD meets Apache Spark

EEP for BDD

OpenCV

Testing with random inputs and pattern-based testing

Getting ready

Libraries

Generating random values or groups of values

Random values based on schema

How to do it...

Your first test.check specification

Auto-running tests

More specifications and generators

Generators and de-structuring

Herbert

There's more...

Benchmarking with Criterium, performance tips, and other tools

Getting ready

How to do it...

Using Criterium

How it works...

Type hints

Using appropriate data types

Maps versus records versus types

Primitive arrays

Working with transient data structures

Memoize functions

There's more...

Logging with timbre and profiling with tufte

Using jvisualvm

10. Deployment and DevOps

Introduction

Riemann - monitoring deliverance and slacking

Getting ready

Installing the Riemann service

Configuring the Riemann daemon

The Riemann dashboard

Riemann-health

Just enough dashboard configuration

Preparing to send events

How to do it...

Basic event reporting for a service

Expiring events

How it works...

There's more...

From Riemann to Slack webhooks

From Slack bots to Riemann

Deploying Clojure with Docker

Getting ready

Installing Docker on OS X or Windows

Installing Docker on Debian

Preparing the Clojure application

Packaging the application into a JAR file

Creating the Docker container

How to do it...

Connecting directly to a remote Docker

There's more...

Clojure on Amazon Web Services

Getting ready

Signing up on AWS

Getting the access key and secret access key

Setting up dependencies in your project.clj

How to do it...

Using EC2

Using S3

Using Amazon SQS

Serverless Clojure with AWS Lambda

Clojure namespace helloworld

Hello World - the AWS part

Hello Stream

Real-world Lambdas

How it works...

What is Amazon EC2?

Amazon S3

Buckets and keys

Objects

There's no more...

Clojure Programming Cookbook

---

Clojure Programming Cookbook

Copyright © 2016 Packt Publishing

All rights reserved. No part of this book may be reproduced, stored in a retrieval system, or transmitted in any form or by any means, without the prior written permission of the publisher, except in the case of brief quotations embedded in critical articles or reviews.

Every effort has been made in the preparation of this book to ensure the accuracy of the information presented. However, the information contained in this book is sold without warranty, either express or implied. Neither the authors, nor Packt Publishing, and its dealers and distributors will be held liable for any damages caused or alleged to be caused directly or indirectly by this book.

Packt Publishing has endeavored to provide trademark information about all of the companies and products mentioned in this book by the appropriate use of capitals. However, Packt Publishing cannot guarantee the accuracy of this information.

First published: October 2016

Production reference: 1211016

Published by Packt Publishing Ltd.

Livery Place

35 Livery Street

Birmingham 

B3 2PB, UK.

ISBN 978-1-78588-503-7

www.packtpub.com

Credits

About the Authors

Makoto Hashimoto is a technical enthusiast in Japan. He has been involved in a lot of projects as an IT architect and led them successfully with his technical leadership. Makoto loves programming, especially with functional programming languages. Thus, he became an enthusiast of Clojure since his first encounter with this language. Recently, he is often involved in projects of the big data domain, and he constantly thinks up new ways to use Clojure for this domain. He loves spending time with his family during weekends and apart from that he loves cooking, classical music, arts and sports.

Makoto has also written two books in Japanese. You can find them at http://amzn.to/2e0jySv and http://amzn.to/2eg3gq8.

To my coauthor, Nicolas, working with you has been a great honor for me. Many thanks for your valuable advices and encouragements.To my family, I would like to thank my family and friends for their constant encouragements and support. Without you, there is no way that I would have been able to complete this work.

Nicolas Modrzyk has many years of experience in the field of IT and has spent many years in Asia. He loves making ideas a reality and the fact that this reality brings people from all around the planet together. He's been involved in many IT projects, helping customers reach their goal and in general trying to make IT easier to reach for everyone.

Nicolas fell into the Clojure soup 5 years ago; it helped him become more focused, and stop wasting time on the things that are not worth it. Clojure is more than just a fantastic programming language; it is a life full of adventure. Hopefully, this book takes you on the road to that adventure.

Nicolas has also written a book, Oishii Clojure (http://gihyo.jp/book/2013/978-4-7741-5991-1), in Japanese, with plenty of short Clojure recipes to enjoy the Clojure language and to make you want to try new things.

Thank you, Makoto, for reaching out and making this book a fantastic adventure! Also, I'm looking forward to our next one! To my daughters, Mei and Manon, I think about you always, even during those late nights spent working on the book. To my loving family and awesome friends, for their continuous support, even in those times when I only talk about Clojure.

About the Reviewer

Eduard Bondarenko is a long-time Ruby and Clojure programmer. He got into Android development recently. He prefers concise and expressive code with some comments, and has tried many programming languages, such as Python, Erlang, Nodejs, Elm, Scala, and others. Eduard has reviewed a couple of Clojure books, and he liked all of them for their interesting and broad topics. Besides programming, he likes to spend time with his family, play soccer, and travel.

I want to thank my family for supporting my desire to work on the book, and the authors for the demonstration of different and extraordinary applications of Clojure.

www.PacktPub.com

eBooks, discount offers, and more

Did you know that Packt offers eBook versions of every book published, with PDF and ePub files available? You can upgrade to the eBook version at www.PacktPub.com and as a print book customer, you are entitled to a discount on the eBook copy. Get in touch with us at [e-mail] for more details.

At www.PacktPub.com, you can also read a collection of free technical articles, sign up for a range of free newsletters and receive exclusive discounts and offers on Packt books and eBooks.

https://www.packtpub.com/mapt

Get the most in-demand software skills with Mapt. Mapt gives you full access to all Packt books and video courses, as well as industry-leading tools to help you plan your personal development and advance your career.

Why subscribe?

Fully searchable across every book published by Packt

Copy and paste, print, and bookmark content

On demand and accessible via a web browser

Preface

This is a book designed to make you want to try things. It will take you back to the days when you had tons of energy and were ready to just start and make things happen.

Clojure is a one of a kind programming language, where the core is very important, and you can just write efficient code, based on strong building blocks.

With the upcoming release of Clojure 1.9, this language is ahead of other languages due to its simplicity and conciseness. So whether you are embarking on a weekend programming project with Raspberry Pi or getting ready to challenge the world with your new start-up, the tons of good recipes provided in this book are for you.

This book can mostly be read in any order, but make sure that you go through the first few recipes to review the basics of Clojure.

Make things happen and enjoy every piece of it.

What this book covers

Chapter 1, Live Programming with Clojure, helps you review how the Clojure basics work with different data types, how the code control flows, and also how to integrate third-party libraries. You probably know this already, but you simply cannot start a good cookbook without a strong base.

Chapter 2, Interacting with Collections, covers selecting, filtering, transforming, merging, joining, and how to become lazy. Laziness is one of the greatest Clojure feature, and we want to make sure that you will always be lazy enough.

Chapter 3, Clojure Next, introduces you to macros, advanced macros, transducers (what transducers are, anyway), and logic programming. It covers preprocessing and postprocessing of Clojure data as code features.

Chapter 4, File Access and the Network, covers StreamingQueues and real-time networking, which gives you the power to think about distributed systems and how to connect your IoT devices. It also covers files and how to manipulate files to help you with lightweight processing for interconnections.

Chapter 5, Working with Other Languages, introduces you to the basic Clojure tooling that allows you to easily integrate code written in other languages, such as Java, Scala, and .NET, all the way to Clojure on the JavaScript runtime, ClojureScript.

Chapter 6, Concurrency and Parallelism, helps you learn multiple ways of splitting jobs among Clojure processes, interacting with Scala-like actors, and to also sharing states between different instances. Of course, this chapter covers the simplest way of writing a parallel code in Clojure, core.async.

Chapter 7, Advanced Tips, helps you if you want to know how to perform not only pair programming but also shared real-time pair programming. You will also see how to hack the Clojure source code yourself.

Chapter 8, Web Applications, takes you through web applications, web services, or API endpoints or whatever you call them. You also learn how to use nice-looking widgets with Vaadin, how to write rest-like APIs with Liberator, and use Immutant, a set of server-side services at the finger of your Clojure code. 

Chapter 9, Testing, not only helps you with validating your code but also with using random pattern testing for the cases you had not thought about. This chapter also introduces behavior-driven development in Clojure with some OpenCV validation, and finally, explains how to benchmark the speed of your code.

Chapter 10, Deployment and DevOps, covers dockerizing your Clojure code, making it run locally as it would in the Cloud, putting real-time monitoring in place for your critical services, and finally, your favorite Amazon tricks are also covered here.

What you need for this book

You need a bit of time, a computer, and a text editor. That's all this book requires. Of course, previous functional programming experience is a big plus, but having motivation and energy is pretty much all you need.

Who this book is for

This book is for people who want to make things happen. Follow along the lines of the zillions of code samples included in this book, and go ahead from there. Each example should make you want to try things around, and bring up some new ideas. This book should start by being just a cookbook, but by the end, will become your cookbook.

Sections

In this book, you will find several headings that appear frequently (Getting ready, How to do it, How it works, There's more, and See also).

To give clear instructions on how to complete a recipe, we use these sections as follows:

Getting ready

This section tells you what to expect in the recipe, and describes how to set up any software or any preliminary settings required for the recipe.

How to do it…

This section contains the steps required to follow the recipe.

How it works…

This section usually consists of a detailed explanation of what happened in the previous section.

There's more…

This section consists of additional information about the recipe in order to make the reader more knowledgeable about the recipe.

See also

This section provides helpful links to other useful information for the recipe.

Conventions

In this book, you will find a number of text styles that distinguish between different kinds of information. Here are some examples of these styles and an explanation of their meaning.

Code words in text, database table names, folder names, filenames, file extensions, pathnames, dummy URLs, user input, and Twitter handles are shown as follows: However, declaring libraries in project.clj is much simpler than doing it in the pom.xml file of Maven.

A block of code is set as follows:

String str = Hello .concat(world !);

Any command-line input or output is written as follows:

$ mv lein ~/bin

New terms and important words are shown in bold. Words that you see on the screen, for example, in menus or dialog boxes, appear in the text like this: Go to the Data Buckets tab and click on the Create New Data Bucket option.

Note

Warnings or important notes appear in a box like this.

Tip

Tips and tricks appear like this.

Reader feedback

Feedback from our readers is always welcome. Let us know what you think about this book-what you liked or disliked. Reader feedback is important for us as it helps us develop titles that you will really get the most out of.

To send us general feedback, simply e-mail [e-mail], and mention the book's title in the subject of your message.

If there is a topic that you have expertise in and you are interested in either writing or contributing to a book, see our author guide at www.packtpub.com/authors .

Customer support

Now that you are the proud owner of a Packt book, we have a number of things to help you to get the most from your purchase.

Downloading the example code

You can download the example code files for this book from your account at http://www.packtpub.com. If you purchased this book elsewhere, you can visit http://www.packtpub.com/support and register to have the files e-mailed directly to you.

You can download the code files by following these steps:

Log in or register to our website using your e-mail address and password.

Hover the mouse pointer on the SUPPORT tab at the top.

Click on Code Downloads & Errata.

Enter the name of the book in the Search box.

Select the book for which you're looking to download the code files.

Choose from the drop-down menu where you purchased this book from.

Click on Code Download.

You can also download the code files by clicking on the Code Files button on the book's webpage at the Packt Publishing website. This page can be accessed by entering the book's name in the Search box. Please note that you need to be logged in to your Packt account.

Once the file is downloaded, please make sure that you unzip or extract the folder using the latest version of:

WinRAR / 7-Zip for Windows

Zipeg / iZip / UnRarX for Mac

7-Zip / PeaZip for Linux

The code bundle for the book is also hosted on GitHub at https://github.com/PacktPublishing/Clojure-Programming-Cookbook. We also have other code bundles from our rich catalog of books and videos available at https://github.com/PacktPublishing/. Check them out!

Downloading the color images of this book 

We also provide you with a PDF file that has color images of the screenshots/diagrams used in this book. The color images will help you better understand the changes in the output. You can download this file from https://www.packtpub.com/sites/default/files/downloads/ClojureProgrammingCookbook_ColorImages.pdf.

Errata

Although we have taken every care to ensure the accuracy of our content, mistakes do happen. If you find a mistake in one of our books-maybe a mistake in the text or the code-we would be grateful if you could report this to us. By doing so, you can save other readers from frustration and help us improve subsequent versions of this book. If you find any errata, please report them by visiting http://www.packtpub.com/submit-errata, selecting your book, clicking on the Errata Submission Form link, and entering the details of your errata. Once your errata are verified, your submission will be accepted and the errata will be uploaded to our website or added to any list of existing errata under the Errata section of that title.

To view the previously submitted errata, go to https://www.packtpub.com/books/content/support and enter the name of the book in the search field. The required information will appear under the Errata section.

Piracy

Piracy of copyrighted material on the Internet is an ongoing problem across all media. At Packt, we take the protection of our copyright and licenses very seriously. If you come across any illegal copies of our works in any form on the Internet, please provide us with the location address or website name immediately so that we can pursue a remedy.

Please contact us at [e-mail] with a link to the suspected pirated material.

We appreciate your help in protecting our authors and our ability to bring you valuable content.

Questions

If you have a problem with any aspect of this book, you can contact us at [e-mail], and we will do our best to address the problem.

Chapter 1. Live Programming with Clojure

In this chapter, we will cover the following topics:

REPL up!

Working with primitive data types

Using bindings of vars, conditions, loops, and error handling

Using and defining functions

Using third-party libraries

Using namespaces

Introduction

Clojure is a blend of Lisp and Java. Clojure allows you to solve what you want quickly and keeps code simple. Once you learn Clojure, it's great fun to use it! Clojure provides the following fantastic features:

Clojure is a dialect of Lisp and supports the functional programing style

It runs on Java Virtual Machine (JVM) and can use Java's assets seamlessly

It also supports immutability and concurrent programming

In this chapter, we will review how to set up a Clojure REPL environment and Clojures' basic structure, including primitive data types, programming flow controls, and functions. Then we will go over how to use third-party libraries and namespaces.

Let's take you to Clojure's fantastic world; we'll begin with REPL up!

REPL up!

REPL is the interpreter of Clojure, and it is an acronym of Read Evaluate Print Loop. Unlike other interpreter languages, such as Python or Ruby, Clojure REPL automatically compiles into Java's byte code after the reading expression. Then, REPL evaluates the expression and returns the result of the expression. This dynamic compilation feature of REPL makes Clojure code execution as fast as executing pre-compiled code.

Getting ready

Before you set up your Clojure environment, the Java Development Kit (JDK) is necessary. The JDK version should be 1.6 or later. Throughout the book, we will use JDK 1.8 to develop and test the code.

This is how the command-line result will look, once you type java -version:

How to do it...

Leiningen is a standard build tool for Clojure. It simplifies the Clojure development, including setting up your project, compiling and testing code, and creating libraries for deployment.

It's easy to set up a Clojure environment using Leiningen. There are only a few steps before you can enjoy Clojure in REPL!

Here are the steps we need to perform to run Clojure REPL:

Download and set up Leiningen from http://leiningen.org/.

Download the lein script (or on Windows, lein.bat).

 Place it on your $PATH where your shell can find it (for example, ~/bin):

$ mv lein ~/bin

Set it to be executable:

$ chmod a+x ~/bin/lein

Run lein, and it will download the self-install package:

 Create a new project and go there. Using Leiningen, you can create a project from a project template. This example creates a project called living-clojure:

$ lein new living-clojure

 Run REPL and put Clojure code into it:

How it works...

Here is a very simple code to demonstrate how REPL works. This code simply loops forever with read, eval, and println functions:

user=> (defn simple-repl