Why use (*')'s implicit 1 over an explicit 1? - clojure

Question

From the clojure docs, the function *':
Returns the product of nums. (*') returns 1. Supports arbitrary
precision. See also: *
I understand the use cases for arbitrary precision as explained in the example provided:
;; great so it gives the same results as *.
;; not quite check this out
(* 1234567890 9876543210)
;; ArithmeticException integer overflow
(*' 1234567890 9876543210)
;;=> 12193263111263526900N
However, the (*') returns 1 does not seem to have any use at all since you can just specify the explicit value. In the same example provided:
;; there is an implicit 1
(*')
;;=> 1
;; the implicit 1 comes into play
(*' 6)
;;=> 6
I had thought that perhaps it would be useful if the second argument is not defined, perhaps nil but:
(*' 6 nil)
Throws a NullPointerException.
Why would you use (*' 6) over 6 and (*') over 1?

Answer 1

* and *' are equivalent in this regard:
first of all - how would you otherwise handle the [] and [x] cases in *?
The source as it is written makes the most sense and AFAIK is mathematicly correct (identity value and such).
user=> (source *)
(defn *
"Returns the product of nums. (*) returns 1. Does not auto-promote
longs, will throw on overflow. See also: *'"
{:inline (nary-inline 'multiply 'unchecked_multiply)
:inline-arities >1?
:added "1.2"}
([] 1)
([x] (cast Number x))
([x y] (. clojure.lang.Numbers (multiply x y)))
([x y & more]
(reduce1 * (* x y) more)))
second, it makes it much more robust in cases other then manually writing (* 2 4). I wouldn't write (*) to mean 1.
Like the following - see the single element and emtpy vector on pos 3 and 4.
user=> (map (partial apply *) [[2 2] [2 3 2] [6] []])
(4 12 6 1)

Answer 2

Usually the 0-arity of a function is useful for a reduction or for applying to lists. For example:
(apply *' (range 5))

Answer 3

The multiplicative identity is one.
In terms of code and clojure, birdspider and Alejandro C. both answered about the (apply * []) case, in which it is indeed useful for (*) to equal 1.
However, I want to point out another case where (*) is useful. When passed to transduce as a reducing function.
transduce docstring:
clojure.core/transduce
[xform f coll]
[xform f init coll]
Added in 1.7
reduce with a transformation of f (xf). If init is not
supplied, (f) will be called to produce it. f should be a reducing
step function that accepts both 1 and 2 arguments, if it accepts
only 2 you can add the arity-1 with 'completing'. Returns the result
of applying (the transformed) xf to init and the first item in coll,
then applying xf to that result and the 2nd item, etc. If coll
contains no items, returns init and f is not called. Note that
certain transforms may inject or skip items.
The relevant part here is "If init is not supplied, (f) will be called to produce it.".
So using * as the rf without an init value will use an init value of 1. Which is probably what you want.
Similarly (+) ;=> 0 (additive identity) and (conj) ;=> [].
I think this is a neat example of things coming together nicely, as (*) was decided long before transducers were a thing.

Answer 4

The default value (*) => 1 is there to avoid a NullPointerException in the event you don't know how many items you want to multiply. That is:
=> (apply * [1 2 3])
6
=> (apply * [3])
3
=> (apply * [])
1
=> (apply * nil)
1
=> (* nil)
nil
=> (*)
1
Wow! I am surprised! I couldn't force a NPE even when I tried!
I still think this behavior provides a false sense of security. If I am expecting to multiply some numbers and one (or more) are missing, I'd rather have the default be to detect the error via an Exception. As it is, the default is for Clojure to cover-up the error by being "helpful" and trying to guess what I may have meant.
Update
I did finally generate an NPE:
> (* 5 nil) => NullPointerException clojure.lang.Numbers.ops (Numbers.java:1013)
I find this even more surprising. If (* nil) => nil, I would have bet money that (* 5 nil) => nil would also be true. Strange!