Some of our colleagues at JDriven work with Scala and we talked about the book Functional Programming in Scala written by Paul Chiusano and Runar Bjarnason. We looked at one of the examples in the first chapter in the book to show the importance of having pure functions without side effects. The example is about buying a cup of coffee and charging a credit card with the purchase. In three examples a function with side effects is refactored to a pure function without side effects. When looking at the example I was wondering how this would look like in Clojure using only functions and simple immutable data structures. We can look at the examples in Scala to see how it is explained and implemented in the book. There are also Kotlin samples available. In this post we see a possible implementation in Clojure to buy coffee and charge our credit card.

The first example is a `buy-coffee` function with a credit card type as parameter. When we invoke the function with a credit card argument the credit card gets charged as side effect and a coffee type is created and returned. The coffee type is simply a map with a price key.

``````(ns mrhaki.coffee.cafe1)

(defn charge
"Charge credit card with given amount.
This function has side effects with a println in our example,
but in a real world implementation could also include
REST API calls, database access or other side effects."
[cc amount]
(println (str "Charge " amount " to credit card " (:number cc))))

"Sample function to buy a coffee and charge the given credit card
with the price of the coffee.
The function returns coffee."
[cc]
(let [cup {:price 2.99}]
(charge cc (:price cup))
cup))``````

Let’s write a simple test for the `buy-coffee` function:

``````(ns mrhaki.coffee.cafe1-test
(:require [clojure.test :refer :all]
[mrhaki.coffee.cafe1 :refer :all]))

(is (= {:price 2.99} (buy-coffee {:number "123-456"})))
(is (= {:price 2.99} (buy-coffee {:number "456-789"}))))``````

The test runs and shows the function works as expected, but we cannot test the side effect. If the side effect would involve calls to other systems, those systems would be called when we run our tests. That is something we would try to avoid, because it makes testing in isolation more difficult.

In the Scala example the next step is to pass in a Payment type that will take care of charging the credit card. This would make testing the function easier, because we can pass a testable implementation of the Payment type (e.g. a mock). So at least in our tests we can have an implementation that doesn’t access external systems.

For our Clojure example we can pass a payment function as argument to the `buy-coffee` function. This function takes a credit card type and amount as arguments and will be invoked in the `buy-coffee` function.

``````(ns mrhaki.coffee.cafe2)

"Sample function to buy coffee and charge the given credit card
with the price of the coffee.
The function to charge the credit card is given as second argument.
The fn-payment function must support a credit card as first
argument and an amount as second argument."
[cc fn-payment]
(let [cup {:price 2.99}]
(fn-payment cc (:price cup))
cup))``````

When we write a test we can now check how the payment function is invoked:

``````(ns mrhaki.coffee.cafe2-test
(:require [clojure.test :refer :all]
[mrhaki.coffee.cafe2 :refer :all]))

(let [payment (fn [cc amount]
(is (= "123-456" (:number cc)))
(is (= 2.99 amount)))]
(is (= {:price 2.99}
(buy-coffee {:number "123-456"} payment)))))``````

But our `buy-coffee` function is not pure. We have still the side effect, but we made the function better testable. It is also mentioned in Functional Programming in Scala that if we want to invoke our `buy-coffee` function multiple times, the credit card also gets charged multiple times and this would include extra processing fees as well.

The final implementation of the `buy-coffee` will no longer charge the credit card, but it will a charge type with all information needed for charging the credit card, together with returning the coffee type. In another function we can handle the actual charging of the credit card by invoking REST calls, database calls or what else is needed. But now it is no longer a concern of our `buy-coffee` function. Also we can now invoke the `buy-coffee` function multiple times and combine all returned charge types into a single charge, to save on processing fees.

In our Clojure example we change the `buy-coffee` function and return both a coffee type and a charge type. The charge type is a map with a key for the credit card and a key for the amount to be charged. Also we introduce the `buy-coffees` function to show how we can invoke `buy-coffee` multiple times and combine the charges into a single charge.

``````(ns mrhaki.coffee.cafe3)

"Sample function to buy coffee.
The function returns a vector with coffee as first element and
a charge type as second element."
[cc]
(let [cup {:price 2.99}]
[cup {:credit-card cc :amount (:price cup)}]))

(defn- combine
"Return a new charge with the sum of the amount values when
the credit card number keys are equal.
Throws exception when credit card numbers are not equal."
[charge1 charge2]
(if (= (:number charge1) (:number charge2))
(update-in charge1 [:amount] + (:amount charge2))
(throw (Exception. "Can't combine charges to different cards."))))

(defn- unzip
"Returns pair of collections where first collection is built from first
values of each pair in the coll argument and the second collection
is built from the second value of each pair."
[coll]
(reduce (fn [[coll-a coll-b] [a b]]
[(conj coll-a a) (conj coll-b b)])
[[] []]
coll))

"Buy multiple times a cofee and combine all charges for given credit card.
The first parameter accepts a credit card type and
the second parameter is the number of times a coffee is bought."
[cc n]
(let [[coffees charges] (unzip (repeatedly n #(buy-coffee cc)))]
[coffees (reduce combine charges)]))``````

And testing the functions is now much easier:

``````(ns mrhaki.coffee.cafe3-test
(:require [clojure.test :refer :all]
[mrhaki.coffee.cafe3 :refer :all]))

(let [[coffee charge] (buy-coffee {:number "123-456"})]
(is (= {:price 2.99} coffee))
(is (= {:credit-card {:number "123-456"} :amount 2.99} charge))))

(let [[coffees charge] (buy-coffees {:number "123-456"} 2)]
(is (= (repeat 2 {:price 2.99}) coffees))
(is (= {:credit-card {:number "123-456"} :amount 5.98} charge))))``````

The charge type also makes it easier to work with the charges. For example we can add a `coalesce` function that takes a collection of charge types and returns all charges per credit card. We can use this information to minimize the processing fees with the credit card company.

``````(ns mrhaki.coffee.cafe3)

...

(defn coalesce
"Coalesce same card charges."
[charges]
(->> charges
(group-by :credit-card)
(vals)
(map #(reduce combine %))))``````

And we can write the following test:

``````(ns mrhaki.coffee.cafe3-test
(:require [clojure.test :refer :all]
[mrhaki.coffee.cafe3 :refer :all]))
...

(deftest coalesce-test
(let [charge-1a {:credit-card {:number "123-456"} :amount 2.99}
charge-2a {:credit-card {:number "456-789"} :amount 2.99}
charge-1b {:credit-card {:number "123-456"} :amount 2.99}
charges (coalesce [charge-1a charge-2a charge-1b])]
(is (= {:credit-card {:number "123-456"} :amount 5.98} (first charges)))
(is (= {:credit-card {:number "456-789"} :amount 2.99} (second charges)))))``````

In the examples we use a map as type for the coffee, credit card and charge types. We can add records for these types to our Clojure examples to have some more semantics in our code. The good thing is that a records still can be used queries as a map, so a keyword function like `:price` still works for a `Coffee` record.

In the next example we add records and use them in the `buy-coffee` function. Notice the other functions still work without changes.

``````(ns mrhaki.coffee.cafe4)

;; Define records.
(defrecord Coffee [price])
(defrecord CreditCard [number])
(defrecord Charge [credit-card amount])

"Sample function to buy coffee.
The function returns a vector with coffee as first element and
a charge type as second element."
[cc]
(let [cup (->Coffee 2.99)
charge (->Charge cc (:price cup))]
[cup charge]))

(defn- combine
"Return a new charge with the sum of the amount values when
the credit card number keys are equal.
Throws exception when credit card numbers are not equal."
[charge1 charge2]
(if (= (:number charge1) (:number charge2))
(update-in charge1 [:amount] + (:amount charge2))
(throw (Exception. "Can't combine charges to different cards."))))

(defn- unzip
"Returns pair of collections where first collection is built from first
values of each pair in the coll argument and the second collection
is built from the second value of each pair."
[coll]
(reduce (fn [[coll-a coll-b] [a b]]
[(conj coll-a a) (conj coll-b b)])
[[] []]
coll))

"Buy multiple times a cofee and combine all charges for given credit card.
The first parameter accepts a credit card type and
the second parameter is the number of times a coffee is bought."
[cc n]
(let [[coffees charges] (unzip (repeatedly n #(buy-coffee cc)))]
[coffees (reduce combine charges)]))

(defn coalesce
"Coalesce same card charges."
[charges]
(->> charges
(group-by :credit-card)
(vals)
(map #(reduce combine %))))``````

In our tests we can now also use the functions to create a `Coffee`, `CreditCard` and `Charge` records:

``````(ns mrhaki.coffee.cafe4-test
(:require [clojure.test :refer :all]
[mrhaki.coffee.cafe4 :refer :all]))

(let [[coffee charge] (buy-coffee (->CreditCard "123-456"))]
(is (= (->Coffee 2.99) coffee))
(is (= (->Charge (->CreditCard "123-456") 2.99)) charge)))

(let [[coffees charge] (buy-coffees (->CreditCard "123-456") 2)]
(is (= (repeat 2 (->Coffee 2.99)) coffees))
(is (= (->Charge (->CreditCard "123-456") 5.98)) charge)))

(deftest coalesce-test
(let [cc1     (->CreditCard "123-456")
cc2     (->CreditCard "456-789")
charges (coalesce [(->Charge cc1 2.99)
(->Charge cc2 2.99)
(->Charge cc1 2.99)])]
(is (= (->Charge (->CreditCard "123-456") 5.98)) (first charges))
(is (= (->Charge (->CreditCard "456-789") 2.99)) (second charges))))``````

Written with Clojure 1.10.1