Lambda Calculus Argument Delimiter So I've been looking into lambda calculus on and off for months simply trying to understand the numerical system and the successor function.  I understand that it's basically just argument evaluation, but the syntax confused me for the longest time.  Finally, I found this:

S0 = (λ abc.b(abc)) (λ sz.z)
     = λ bc.b((λ sz.z) bc)
     = λ bc.b((λ z.z) c)
     = λ bc.b(c)

from this URL: http://palmstroem.blogspot.com/2012/05/lambda-calculus-for-absolute-dummies.html

and realized that I didn't understand how this worked because there seems to be no delimiter indicating the start of argument space.  My question is: Is there an acceptable delimiter for this in lambda calculus, and, if not, how can I verbalize this when writing or viewing  it?  

EDIT: Some people seem to have misunderstood this, so let me explain better.  How do I indicate that a function is being called on a specific set of arguments?  For example, in most programming languages the indicator is just parenthesis

function(arg0,arg1,arg3...)


Is there an equivalent to this in untyped lambda calculus?  

ANOTHER EDIT: Okay, it's still misunderstood as to what I mean.  Let's talk about the successor function again.  The wikipedia pages shows something like the following:

Succ=La.Lb.Lc.b (a b c)
               ^


The marked whitespace is annoying since It's not clear that the part in parenthesis is still part of the function itself, and instead looks like an argument is being passed to the function.  Is there a delimiting character that separates the body of the function from the  arguments on which it is to be called?  Example:

Succ=((La.(Lb.(Lc.(b,((a,b),c))))),),,


The problem that I think I'm having is that since functions can be returned as primary values, the syntax doesn't express that very clearly.  However, in the example that I gave, we can see that there are three commas without trailing inputs, indicating that the function takes 3 values (the function to find the successor of and the successor's potential arguments).  Is there a good convention to express the point where a function's body ends and the values that it needs to be evaluated begin?  

*A VERY IMPORTANT EDIT: * This is not about currying.
So, I think part of the problem is that the resource you're using is not using standard lambda calculus notation.

In most texts, there is a space between arguments. I would write $\lambda x\ y\ z\ldotp z$ in place of $\lambda x y z\ldotp z$. But, if you assume a convention that variables are always single letters, you can omit the space without ambiguity.

But I can't imagine one would ever write whole programs this way. Rather, this is more likely to show up in examples, code snippets, and small proofs, where there aren't many variables and the names don't matter.

Basically it boils down to this:


A minimal lambda calculus only allows one argument per function, so there's no need for a delimiter. The dot denotes the function body.
There is common syntactic sugar for multiple arguments, which abbreviates $\lambda x \ldotp (\lambda y \ldotp (\lambda z\ldotp z))$ as $\lambda x\ y\ z\ldotp z$.
In a situation where variable names are assumed to be single letters, one could use $\lambda x y z\ldotp z$ in place of $\lambda x\ y\ z\ldotp z$. 


There is no delimiter, other than the space, that I know of for arguments. Commas would be frowned upon, since they indicate tuples, rather than curried arguments.

EDIT: to respond to the OPs edit:

There is no such thing as multiple arguments in an untyped lambda calculus, at least not in standard ones. There are two ways to simulate multiple-argument functions.


Tuples: you can use a Church encoding to pass a single argument, which can be decomposed into multiple values. So you would write $f (&lt;x,y&gt;)$, where $&lt;x,y&gt;$ is some special syntax for making a pair, and then decompose it as $HD\ t$ and $TL\ t$ inside your function to get at each argument.
Currying: When, in an imperative language, you would write f(x,y,z), you write $(f\ x\ y\ z)$, which is syntactic sugar for $(((f\ x)\ y)\ z)$. A function accepting multiple arguments is just a function which returns another function.


It turns out that these two are basically isomorphic, so which you do doesn't much matter.

Some languages, like Scheme, have built in syntax for multiple-argument functions, but I haven't seen anything like that in a formal lambda calculus. Usually they're intended to be minimal, and so when you don't need multiple-argument functions, you don't put them in.