Defining functions¶

The most familiar (and common) way to define functions in Clojure is using the (defn ...) construct:

(defn <name> [ <param> ... ] 
    <body>)

(defn greeting [username]
    (str "Hello, " username "."))

#'user/greeting

; Now we can use it.

(println (greeting "Albert Einstein"))
;

Hello, Albert Einstein.

Add documentation string¶

Clojure supports metadata such as docstring, associated with the function defined.

(defn <name>
    <doc string>
    [param ...]
    <body>)

(defn greeting
"Generate a greeting message as a string
for the given username."
    [username]
    (str "Hello, " username "."))

#'user/greeting

; Now we can get some help on the function
(println (:doc (meta (var greeting))))
;

Generate a greeting message as a string
for the given username.

; We can still use the function as always.
(greeting "Albert Einstein")

"Hello, Albert Einstein."

Multiple arities¶

Definition:

arity is the number of parameters a function can accept.

(defn greeting
"Generates a greeting message for the given username.
    
- No paramete: default message.
- username: message for the user.
- title username: message will refer to the user by the title."
    ([] "Hi there.")
    ([username] (str "Hello, " username "."))
    ([title username]
     (str "Hello, " title ". " username ".")))

#'user/greeting

(println (:doc (meta (var greeting))))
;

Generates a greeting message for the given username.
    
- No paramete: default message.
- username: message for the user.
- title username: message will refer to the user by the title.

(greeting)

"Hi there."

(greeting "Albert Einstein")

"Hello, Albert Einstein."

(greeting "Prof" "Albert Einstein")

"Hello, Prof. Albert Einstein."

Anonymous Functions¶

Anonymous functions are functions that are created without given a name in the definition.
We can always bind functions to symbols.

(fn [param ...] body)

(fn [username]
    (str "Hello, " username "."))

#function[user/eval4096/fn--4097]

Invoking functions without names¶

Use them in a form.
Bind them to symbols, and use the symbols.

((fn [username] (str "Hello, " username ".")) "Albert Einstein")

"Hello, Albert Einstein."

(let [f (fn [username] (str "Hello, " username "."))]
    (f "Albert Einstein"))

"Hello, Albert Einstein."

; Note the symbol is only valid in the scope of `(let ...)`
(f "Albert Einstein")

Syntax error compiling at (REPL:2:1).
Unable to resolve symbol: f in this context

  Util.java:   221 clojure.lang.Util/runtimeException
   core.clj:  3214 clojure.core$eval/invokeStatic
   core.clj:  3210 clojure.core$eval/invoke
   main.clj:   437 clojure.main$repl$read_eval_print__9086$fn__9089/invoke
   main.clj:   458 clojure.main$repl$fn__9095/invoke
   main.clj:   368 clojure.main$repl/doInvoke
RestFn.java:  1523 clojure.lang.RestFn/invoke
   AFn.java:    22 clojure.lang.AFn/run
   AFn.java:    22 clojure.lang.AFn/run
Thread.java:   748 java.lang.Thread/run

Shorthand For Anonymous Functions¶

Clojure require so much of function construction that it has an even shorter hand to create anonymous functions.

#(body)

% is the first argument.
If more arguments are expected, use %1, %2, %3 etc.

#(str "Hello, " % ".")

#function[user/eval4150/fn--4151]

(#(str "Hello, " % ".") "Albert Einstein")

"Hello, Albert Einstein."

(let [f #(str "Hello, " % ".")]
    (f "Albert Einstein"))

"Hello, Albert Einstein."

Index

More On Building Functions in Clojure

Defn