Latest Blog

Announcing lambdaisland/uri 1.0.0

I just released lambdaisland/uri, a pure Clojure/ClojureScript URI library. It is available on Github and Clojars.

This is a small piece of the code base that powers It’s inspired by Ruby’s Addressable::URI, the most solid URI implementation I’ve seen to date, although it only offers a small part of the functionality that library offers.

It’s written in pure Clojure/ClojureScript, with only minimal use of .cljc reader conditionals to smooth over differences in regular expression syntax, and differences in core protocols. It does not rely on any URI functionality offered by the host, such as, so it’s usable across all current and future Clojure implementations (Clojure, ClojureScript, ClojureCLR).

Currently all this library offers is parsing a URI to its components (scheme, host, path, etc.), manipulating those components individually, and performing RFC compliant joining. lambdaisland.uri.URI instances print with a #lambdaisland/uri "foo://bar" reader tag, and a reader function is provided for use with clojure.edn/read.

The main missing parts are URI normalization and validation. These will be added in later versions. The intention is for this to become a modern Clojure URI library that can serve us for the time to come. Contributions are more than welcome. The code is released under the Mozilla Public License 2.0, a non-viral copyleft license (link to ‘tl;dr legal’).

The code has extensive test coverage, and has CI set up for Clojure and ClojureScript (doo+phantomjs) to make sure it stays cross-platform compatible.

Example code:

(require '[lambdaisland.uri :refer [uri join]])

;; uri :: String -> lambdaisland.uri.URI
(uri "//")
;;=> #lambdaisland/uri "//"

;; A URI is a record, use assoc to update specific parts
;; Use `str` if you want the URI back as a string
 (assoc (uri "//")
        :scheme "https"
        :user "arne"
        :password "supersecret"
        :host ""
        :port "3333"
        :path "/hello/world"
        :query "q=5"
        :fragment "section1"))
;;=> ""

;; RFC compliant joining of relative URIs
(join "//" "./~arne/site/" "../foo.png")
;;=> #lambdaisland/uri "//"

;; Arguments to `join` are coerced, you can pass strings,, or any x
;; for which `(str x)` returns a URI string.
(join ( "")  (uri "./~arne/site/") "../foo.png")
;;=> #lambdaisland/uri ""

;; URI implements IFn for keyword based lookup, so it's fully
;; interface-compatible with Clojure maps.
(:path (uri ""))

;; Instances of URI are printed with a #lambdaisland/uri reader tag. To read
;; them back from EDN, use the provided readers.
(require '[clojure.edn :as edn])

 {:readers lambdaisland.uri/edn-readers}
 "#lambdaisland/uri \"\"")

About the author

Arne divides his time between making Clojure tutorial videos for Lambda Island, and working on open-source projects like Chestnut. He is also available for in-person training and mentoring. You can support Arne through his Patreon page, which also gives you access to exclusive content.

More blog posts

re-frame Subscriptions Got Even Better

Up until recently, to use re-frame subscriptions in Reagent views, you had to use a form-2 component.

A form-2 component is a function that returns another function, which does the actual rendering of the component to hiccup. In contrast, a form-1 component renders the hiccup directly.

;; form-1
(defn todo-item [todo]
   [todo-checkbox (:id todo) (:completed todo)]
   [:label {:unselectable "on"} title]
   [:button.destroy {:on-click #(dispatch [:todos/remove (:id todo)])}]])

;; form-2
(defn todo-item [todo]
  (fn [todo]
     [todo-checkbox (:id todo) (:completed todo)]
     [:label {:unselectable "on"} title]
     [:button.destroy {:on-click #(dispatch [:todos/remove (:id todo)])}]]))

Game Development with Clojure/ClojureScript

This weekend it’s Ludum Dare again, the world’s longest running game jam. The idea is that, alone or with a team, you build a game in a weekend based on a certain theme.

We got a little team together here in Berlin, and so I’ve been reviewing what options there are for someone wanting to build a game in Clojure or Clojurescript.

The good news is there are plenty of options, as you’ll see from the list below. You can do desktop games, browser based games with canvas or webgl, and you can even create Unity 3D games, all from your comfortable Clojure parentheses.

Union Types with Clojure.Spec

Elm and other statically typed languages have a great feature called Union Types (also called Sum Types or Algebraic Data Types).

Here’s an example taken from Elm. Suppose your system used to represent users as integers, maybe just an auto-incrementing primary key, but then switched to UUIDs represented as strings.

To correctly model this situation, you need a way to create a type that can be either an integer or a string, that’s what union types give you.