clojure partial clarification

Question

I'm reading a book on clojure, and I came by an example that I dont fully understand..

Here is the code in repl:

user=> (repeatedly 10 (rand-int 10))
ClassCastException java.lang.Integer cannot be cast to clojure.lang.IFn  clojure.core/repeatedly/fn--4705 (core.clj:4642)

user=> (repeatedly 10 (partial rand-int 10))
(5 0 5 5 2 4 8 8 0 0)

My question is: why is the partial needed here, and how does that fit into partial definition, and repeatedly definition & syntax. Partial ...

Takes a function f and fewer than the normal arguments to f, and
  returns a fn that takes a variable number of additional args. When
  called, the returned function calls f with args + additional args.

So how does this fit in?

Answer 1

Partial is just an easier way of defining an anonymous function that fixes some of the arguments to a function and then passes the rest from the arguments to the created function.

In this case

user> (repeatedly 10 (partial rand-int 10))
(3 1 3 6 1 2 7 1 5 3)

is equivalent to:

user> (repeatedly 10 #(rand-int 10))                        
(9 5 6 0 0 5 7 6 9 6)

Partial is a misnomer here because partial is being used to fix in advance all the arguments (or rather the only one) to rand-int.

a more intersting use of partial illustrates it's function better:

(partial + 4)

produces the equivalent of:

(fn [& unfixed-args] (apply + (concat [4] unfixed-args)))

(it does not literally produce this) The idea being to build a function that takes the un-fixed arguments, combines them with the fixed ones, and calls the function you passed to partial with enough arguments to work properly.

user> ((fn [& unfixed-args] (apply + (concat [4] unfixed-args))) 5 6 7 8 9)       
39
user> ((partial + 4) 5 6 7 8 9)
39   

I only use partial in practice when the number of arguments is variable. Otherwise I have a personal preference towards using the anonymous function reader form #( ... )