The zero-argument anonymous function name

julia> bar(a,b,x...) = (a,b,x)
bar (generic function with 1 method)

julia> bar(1,2)

Is () a zero-argument anonymous function that takes in varargs, making zero really mean any-argument anonymous function? If yes, then to me, the name zero-argument name just doesn’t fully capture/represent what it is. Anyone else feel this way?

If the zero-argument name changed to any-argument, I wouldn’t see the need to also use the name varargs. Or if zero changed to var-arguments, wouldn’t see the need to use zero and varargs.

No, it’s an empty tuple.

1 Like

So can () take var-args?

Below, can ()->3 also take varargs?

julia> o = ()->3 # ()->3 officially named as zero-argument
(::#1) (generic function with 1 method)

julia> o()

Is () an empty tuple that takes var-args?

The () in ()->3 is not a name. It is also akin to an empty tuple. Tuples represent the arguments of functions; an empty tuple means that the function takes no arguments.

f() = 3 and const f = ()->3 are basically defining the same thing.

1 Like

() is just parenthesis. In general it’s used when the syntax can otherwise be ambiguous.

In most cases it’s optional. You can write x->x instead of (x)->x, x, y instead of (x, y). Zero element tuples and zero argument functions needs the () since it’ll be hard to represent otherwise.


No, it’s wrong. You can try it yourself.


So (1,2,()) means bar won’t take any other args other than 1,2, that’s all it means?

julia> bar(a,b,x...) = (a,b,x)
bar (generic function with 1 method)

julia> bar(1,2)

No it means you didn’t give it “any other args other than 1, 2”

Okay, so it states the obvious, could’ve been bar(1,2) => (1,2)?

Try bar(1, 2, 3) and bar(1, 2, 3, 4, 5) to understand what the splat (...) does.

No. for bar(1, 2) x = (). Please read the full section of

Yup, that exact Doc section led me here. Your previous comment about representing a zero element tuple drove the point home. It must be represented, even though there’s nothing you can do with it. Thanks.

julia> x = ()

julia> typeof(x)

julia> length(x)
1 Like

Why does bar(1,2,3) => (1,2,(3,)), but

bar(1,2,3,4) => (1,2,(3,4)) instead of => (1,2,(3,4,))?

Because one element tuples need the additional comma to distinguish them from regular parentheses. Two element tuples are not ambiguous so the extra comma is not required. For example:

julia> 1 # just an integer

julia> (1) # also just an integer

julia> (1,) # one element tuple

julia> (1, 2) # two element tuple

julia> (1, 2,) # also a two element tuple

On the flip side, it is often handy to “splice” the values contained in an iterable collection into a function call as individual arguments. To do this, one also uses … but in the function call instead:

x = (3,4);
bar(1,2,x...) => (1,2,(3,4))

How is it handy and why is splice quoted?

Because you might want to do this?

Nothing is quoted. You are just passing more than one argument for the vararg part. It’s the same as bar(1, 2, 3, 4) so x === (3, 4) and (a, b, x) === (1, 2, (3, 4)).

How is it handy: can you give an example?

Why is splice quoted: I pasted the blockquote directly from the Julia Doc. Does splice here differ from splice in the original sense?

Despite the definition of bar(a,b,x...) = (a,b,x), when x = (2,3,4), why does calling bar(1,x...) => (1,2,(3,4)) and not => (1,(2,3,4))? Is the function definition assigning b = 2, first iterable of the collection x? If yes, what’s the point of that?

You are already using it, i.e. bar(1, 2, x...). As for why you need it in a program that depends on what you are writing.

It’s unclear what you mean by splice and quote here.

Because calling bar(1, x...) is identical with bar(1, 2, 3, 4).

How have you used it?

Why was it written in the Doc as

On the flip side, it is often handy to “splice” the values contained

instead of On the flip side, it is often handy to splice the values contained?

I don’t follow. The explanation I came up with is that bar(1,x...) => (1,2,(3,4)) where x = (2,3,4) is so because bar(a,b,x...) = (a,b,x) was defined as such, where b must be assigned to something. Is that a correct interpretation?

Have you read What does the … operator do? in the FAQ?

1 Like