Om.next: apply vs directly passing children

Question

In the Om.next wiki, there is example code like this (code listing at the bottom of the linked page):

(apply dom/ul nil
    (map person list))

Since dom/ul takes a variable number of arguments, what is the benefit of using apply vs this:

(dom/ul nil (map person list))

This second approach seems more analogous to passing an array as children in vanilla React, which is supported.

Actual question (response to comment): Is apply necessary? If so, why doesn't the latter approach work? If not, what benefit is gained from using apply like in the example?

are you asking why `apply` is necessary? Or why they defined the api such that apply is necessary? Or something else? — ez121sl, Feb 16 '16 at 21:00

ez121sl · Accepted Answer · 2016-03-26T14:18:51.523

The ClojureScript signature of dom/ul is apparently something like (defn ul [attrs & children] ...). Here children is a vararg. The caller can pass in 0 or more children. Therefore, the following invocations are valid:

(dom/ul nil (person jack))
(dom/ul nil (person jack) (person jill))
(dom/ul nil)

Now suppose you have a collection of elements that you'd like to wrap in a ul. The collection maybe comes from (map person list), which returns a sequence of elements. If ul is invoked like (dom/ul nil (map person list)), only a single child argument is passed to ul, and it is of the wrong type. Each child is expected to be an element, but a collection of element is passed in instead.

apply to the rescue. The job of apply is deal with the situation where we have a collection of arguments, which must be passed in individually. So, (dom/ul nil (person jack) (person jill)) is equivalent to (apply dom/ul nil (map person [jack jill])). apply is necessary in this case to make sure the arguments are passed to ul as that function is expecting them. Skipping apply is not an option.

Ok, that makes sense. I was thrown off because in vanilla React, multiple `children` are specified as a single array. Currently appears that, because of that, either approach works in this case — FeifanZ, Feb 17 '16 at 00:32

score 1 · Answer 2 · answered Feb 17 '16 at 00:36

In Lisp you can't pass a list or collection in place of individual variadic arguments and expect the same behavior.

If you do so anyway, the collection argument will be interpreted as a first of all variadic arguments. To spread a collection as function arguments, you have to use apply.

Om.next: apply vs directly passing children

2 Answers2