December 2020 – Clojure docs and tutorials

Clojure Agents

On: December 31, 2020December 31, 2020 By: cljdude

Most of the time, Clojure does not need locks like Java and other languages. This is because of atom s, ref s, and agent s. I’ll focus on Clojure agents in this short post.

Agents are handled in single-threaded queues. By lining up calls of a function in a queue, no locks are needed. When combined with send-off , deadlocks won’t happen.

Here’s a quick example.

(ns agentexample.core)

(def x (agent 0))

(defn mod-x
  [z]
  (Thread/sleep 500)
  (inc z)
  )

(defn foo
  []
  (println "Starting send-offs for agent")
  (dotimes [_  10]
      (send-off x mod-x)
      (println "x is now" @x))
  (Thread/sleep 8000)
  (println "final value ... " @x)
  (shutdown-agents))


(foo)

(ns agentexample.core)

(def x (agent 0))

(defn mod-x

[z]

(Thread/sleep 500)

(inc z)

)

(defn foo

[]

(println "Starting send-offs for agent")

(dotimes [_ 10]

(send-off x mod-x)

(println "x is now" @x))

(Thread/sleep 8000)

(println "final value ... " @x)

(shutdown-agents))

(foo)

A few things are going on here, so let’s look at them.

Continue reading “Clojure Agents” →

Quick OOP Example

On: December 13, 2020January 6, 2021 By: cljdude

Want some Object Oriented Programming in Clojure? Here’s a quick example.

Let’s create a dog object.

(ns temp2020toss.dogo)

(defprotocol Bark
  "Just a protocol"
  (barking [this] "bark")
  (hungry [this] "hangry")
  (sleeping[this] "zzzz"))

(defrecord Dog [breed ^Integer age color]
  Bark
  (barking [this] (str "barking my breed ... " (:breed this)))
  (hungry [this] (str "I'm so hungry I could age one whole year to ... " (str (inc (:age this)))))
  (sleeping [this] (str "Really tired, and it has nothing to do with my fur color that is " (:color this)))
  )

(ns temp2020toss.dogo)

(defprotocol Bark

"Just a protocol"

(barking [this] "bark")

(hungry [this] "hangry")

(sleeping[this] "zzzz"))

(defrecord Dog [breed ^Integer age color]

Bark

(barking [this] (str "barking my breed ... " (:breed this)))

(hungry [this] (str "I'm so hungry I could age one whole year to ... " (str (inc (:age this)))))

(sleeping [this] (str "Really tired, and it has nothing to do with my fur color that is " (:color this)))

)

Now let’s use the dog object.

(ns temp2020toss.core
  (:gen-class)
  (:require [temp2020toss.dogo]
            [temp2020toss.dogo :refer :all])
  (:import (temp2020toss.dogo Dog)))

(defn -main
  "I don't do a whole lot ... yet."
  [& args]
  (println "Hello, World!")

  (let [my-dog (Dog. "chow" 8 "green")]
    (println "-->" (:breed my-dog))
    (println "-->" (barking my-dog))))

(ns temp2020toss.core

(:gen-class)

(:require [temp2020toss.dogo]

[temp2020toss.dogo :refer :all])

(:import (temp2020toss.dogo Dog)))

(defn -main

"I don't do a whole lot ... yet."

[& args]

(println "Hello, World!")

(let [my-dog (Dog. "chow" 8 "green")]

(println "-->" (:breed my-dog))

(println "-->" (barking my-dog))))

See, OOP in Clojure is fairly simple. This sample uses protocols with records, but you can add polymorphism with just a little extra work. For polymorphism, use records and multimethods.

Razvan’s ‘defrecord’ Example

On: December 12, 2020December 13, 2020 By: cljdude

I absolutely love the user razvan’s Clojure defrecord example over at stackoverflow, so I copied it here. I know I’ll never find it again if I don’t. Look at the original over on stackoverflow at this link.

Here’s the example …

Clojure defrecord example:

;;define Address record
(defrecord Address [city state])

;;define Person record
(defrecord Person [firstname lastname ^Address address])

;;buid the constructor
(defn make-person ([fname lname city state]
    (->Person fname lname (->Address city state))))

;;create a person
(def person1 (make-person "John" "Doe" "LA" "CA"))

;;retrieve values
(:firstname person1)
(:city (:address person1))

;;define Address record

(defrecord Address [city state])

;;define Person record

(defrecord Person [firstname lastname ^Address address])

;;buid the constructor

(defn make-person ([fname lname city state]

(->Person fname lname (->Address city state))))

;;create a person

(def person1 (make-person "John" "Doe" "LA" "CA"))

;;retrieve values

(:firstname person1)

(:city (:address person1))

If you’re looking for more information on combining protocols with records in Clojure, then Matthew Boston has the blog for you!

pr and prn

On: December 8, 2020December 8, 2020 By: cljdude

NOTE: All the code in this tutorial can be quickly tested at the REPL using the command lein repl to start a REPL to test with.

One of the first things you learn when learning clojure is print and println . For example,

(println "Hello world!")

1	(println "Hello world!")

That’s probably the first Clojure program you ever wrote. Maybe you wrote this variation.

(print "Hello world!")

1	(print "Hello world!")

Because println or print are the first ways learned of displaying output in Clojure, most Clojure developers continue using them when debugging code. Nothing wrong with that. But sometimes it is better to use a more specialized tool.

In steps the prn and pr commands. These two commands are tailored for printing objects. At first glance, they appear to work the same as print and println . However, they actually show more information in some instances.

If using print or println , the \n in the following code quietly gets replaced by the action of a new line being printed.

(pr "Hello\nworld!")

1	(pr "Hello\nworld!")

When pr or prn are used, the two characters \ and n are displayed instead of an actual new line. This is very handy when hidden characters are fowling up your layout, or needed to be visible when debugging code.

Final note: The only difference between pr and prn , is that prn prints a new line after the objects it is printing out.