sabaini gmbh

Functions Anonymous

Defining anonymous functions is done with this 'special form' ie. builtin primitive:

user> (fn [a] (+ a 1))
#<user$eval913$fn__914 user$eval913$fn__914@61ade7f6>

That's the internal name of an anonymous fun. Define and call it in one go:

user> ((fn [a] (+ a 1)) 3)
4

Or bind it to a var:

user> (def f (fn [a] (+ a 1)))
#'user/f
user> (f 4)
5

There's a macro to create named functions though, and you can also pass in a docstring:

user> (defn g "The g func" [a b] (* a b))
#'user/g
user> (g 0 1)
0

Much more convenient of course.

Multiple Arieties, VarArgs

Like Erlang, Clojure supports functions with multiple arietes. I think I like Clojures' syntax better though:

user> (defn f
        ([a]
           (f a 2))
        ([a b]
           (* a b)))
#'user/f
user> (f 2)
4
user> (f 2 3)
6

That feels pretty clean.

There's syntax to support varargs (optional arguments) as well. With a wrong number of args you'd get:

user> (f)
ArityException Wrong number of args (0)...

For varargs, put an & after fixed args:

user> (defn h [a & moar] {a moar})
#'user/h

Optional arguments are passed in as a list:

user> (h 0 :a :b :c)
{0 (:a :b :c)}

If they're ommitted, the list is nil:

user> (h 1)
{1 nil}

We defined h to expect at least one argument though. When called without any arg, we still get a ArityException, as it should be:

user> (h)
ArityException ...

The idiom to destructure varargs is similar to Erlangs', ie. individual positional parameters can be placed in a vector:

user> (defn h [& [one two]] (str one two))
#'user/h
user> (h 1 2)
"12"
user> (h)
""

Reader Features and Inplace Functions

"Reader features" are basically Clojure terminology for a pre-processor with a set of predefined templates.

One of these is the in-place function. An in-place function is a shorthand for the anonymous function above, writing #(...) instead of (fn ...) and numbered args (where %1 is the first, %2 the seconded etc.). Defining a function to add 23 and calling it is:

user> (#( + %1 23) 2)
25

Blocks

Group several expressions with a do block. Useful in cases where syntactically only one expression is allowed, but more are needed for sideeffects:

user> (do (def a 2) (def b 5) (* a b))
10

Locals

You can perform local bindings with the (let ) form. Inside the parens, the bindings are effective and immutable.

user> (let [a 23]
        (def a "cat")
        (- a 1))
22

But a nested binding would shadow a binding in an outer scope:

user> (let [a 23]
        (+ a 1)
        (let [a "cat"] a))
"cat"

Loops, Recursive: see Recursive

I was wondering about the "recur" form -- why not just use recursion instead of bothering the user with a special case? Until it dawned on me that the JVM probably would have to support tail call optimization, which indeed it does not. TJoC opines that "recursion from a tail position is in many ways like a structured goto" -- quite so. But then again, it's maybe a good thing to have a specific form for tail calls so as to make more transparent what is going on.

user> (defn su [a]
(loop [sum 0, a1 a]
  (if (seq a1)
    (recur (+ sum (first a1)) (rest a1))
    sum)))
#'user/su
user> (su [1 2])
3
user> (reduce + [1 2])
3

Loading Namespaces

Declaring a namespace and loading another library with an alias:

peter> (ns peter (:require [clojure.string :as st]))
nil
peter> (st/split-lines "foo \n bar")
["foo " " bar"]

Using a specific function from another library:

peter> (ns peter (:require [clojure.java.shell :refer (sh)]))
nil
peter> (sh "hostname" "-s")
{:exit 0, :out "newton\n", :err ""}