Revised syntax labelled function argument. **The only difference is between ~ and :**

alternative1.re

/* == definition == */

/* two labelled arguments, one unlabelled */
let display = (~message, ~person, time) => 1;
/* with default value */
let display = (~message="hello", ~person="Reason", time) => 1;
/* with type annotation */
let display = (~message: string, ~person: string, time: float) => 1;
/* type annoation and with default */
let display = (~message: string="hello", ~person: string="Reason", time: float) => 1;

/* == call == */

/* normal */
display(~message="hey", ~person="Reason", 2.0);
/* call with punning, aka ~message=message */
display(~message, ~person, 2.0);

/* == type definition == */

/* normal */
type d = (~message: string, ~person: string, float) => int;
/* with default */
type d = (~message: string=?, ~person: string=?, float) => int;

alternative2.re

/* == definition == */

/* two labelled arguments, one unlabelled */
let display = (:message, :person, time) => 1;
/* with default value */
let display = (:message="hello", :person="Reason", time) => 1;
/* with type annotation */
let display = (:message: string, :person: string, time: float) => 1;
/* type annoation and with default */
let display = (:message: string="hello", :person: string="Reason", time: float) => 1;

/* == call == */

/* normal */
display(:message="hey", :person="Reason", 2.0);
/* call with punning, aka :message=message */
display(:message, :person, 2.0);

/* == type definition == */

/* normal */
type d = (:message: string, :person: string, float) => int;
/* with default */
type d = (:message: string=?, :person: string=?, float) => int;

Maybe consider the possibility to use one of the both for an other sugar, this might make the decision for this one easier.

Calling a function using parenthesis destroys the beauty of currying syntax

Agree with @fstiffo : Why create more verbose syntax ?

About the initial question I prefer the first one (~) like in OCaml
The second (:) may be confusing about the meaning of ':' symbol in ReasonML

I prefer ~ over : only because : is already meaningful for types - wouldn't want to overload that meaning.

I vote for

/* two labelled arguments, one unlabelled */
let display = (@message, @person, time) => 1;
/* with default value */
let display = (@message="hello", @person="Reason", time) => 1;
/* with type annotation */
let display = (@message: string, @person: string, time: float) => 1;
/* type annoation and with default */
let display = (@message: string="hello", @person: string="Reason", time: float) => 1;

/* == call == */

/* normal */
display(@message="hey", @person="Reason", 2.0);
/* call with punning, aka @message=message */
display(@message, @person, 2.0);

/* == type definition == */

/* normal */
type d = (@message: string, @person: string, float) => int;
/* with default */
type d = (@message: string=?, @person: string=?, float) => int;

Tilde please. Like others have said, I think overloading the meaning of symbols is not a wise thing to do. The tilde is unique and while it might seem weird the first 5 times a newcomer looks at it, it is easy to digest. Thowing : everywhere is awfully confusing.