template-function-syntax.re

/* Template for proposals to update the syntax. Base template: https://gist.github.com/jordwalke/6935739b74eb9b8496670cc7860f5acf */

let a = 10;

let b = 20;

/* A */
let nonNamed = (a, b) => a + b;

type nonNamed = (int, int) => int;


/* B */
let nonNamedAnnotated = (a: int, b: int): int => a + b;

type nonNamedAnnotated = (int, int) => int;


/* C */
let named = (:a, :b) => a + b;

type named = (:a: int, :b: int) => int;


/* D */
let namedAlias = (:a aa, :b bb) => aa + bb;

type namedAlias = (:a: int, :b: int) => int;


/* E */
let namedAnnot = (:a: int, :b: int) => 20;


/* F */
let namedAliasAnnot = (:a aa: int, :b bb: int) => 20;


/* G: three args mixed */
let mixedNamedAndNot = (:a, :b, c) => a + b + c;

type mixedNamedAndNot = (:a: int, :b: int, int) => int;


/* G2: three args mixed and annotated */
let mixedNamedAndNotAnnot = (:a: int, :b: int, c: int): int => a + b + c;

type mixedNamedAndNotAnnot = (:a: int, :b: int, int) => int;


/* G3: four args mixed */
let mixedNamedAndNot = (:a, :b, c, d) => a + b + c + d;

type mixedNamedAndNot = (:a: int, :b: int, int, int) => int;


/* G4: four args mixed and annotated */
let mixedNamedAndNotAnnot = (:a: int, :b: int, c: int, d: int): int => a + b + c + d;

type mixedNamedAndNotAnnot = (:a: int, :b: int, int, int) => int;


/* G5: named args and unit */
let namedAndUnit = (:a, :b, ()) => a + b;

type namedAndUnit = (:a: int, :b: int, unit) => int;


/* G6: named args and tuple */
let namedAndTuples = (:a, :b, (x, y), z) => a + b + x + y + z;

type namedAndTuples = (:a: int, :b: int, (int, int), int) => int;


/* G7: named args and tuple annotated */
let namedAndTuples = (:a: int, :b: int, (x: int, y: int): (int, int), z: int): int => a + b + x + y + z;

type namedAndTuples = (:a: int, :b: int, (int, int), int) => int;


/* G8: named args and tuple */
let namedAndTuples = (:a, :b, z, (x, y)) => a + b + x + y + z;

type namedAndTuples = (:a: int, :b: int, int, (int, int)) => int;


/* G9: named args and tuple */
let namedAndTuples = ((x, y), :a, :b)  => x + y + a + b;

type namedAndTuples = ((int, int), :a: int, :b: int) => int;


/* G10: named args with first unnamed */
let func = (x, :a, :b) => x + a + b;

type func = (int, :a: int, :b: int) => int;


/* G11: named args with first unnamed */
let func = (x, y, :a, :b) => x + y + a + b;

type func = (int, int, :a: int, :b: int) => int;


/* H optional named args (optional args are always named) */
let myOptional = (:a=?, :b=?, ()) => 10;

type named = (:a: ?int, :b: ?int, unit) => int;


/* I */
let optionalAlias = (:a aa=?, :b bb=?, ()) => 10;


/* J */
let optionalAnnot = (:a: option(int)=?, :b: option(int)=?, ()) => 10;
type optionalAnnot = (:a: ?int, :b: ?int, unit) => int;
/* J alternative */
let optionalAnnot = (:a=?: int, :b=?: int, ()) => 10;
type optionalAnnot = (:a=?: int, :b=?: int, unit) => int;
/* unifies inline type annotation & type decl; though subtle conversion to `option int` under the hood in the binding case */

/* K */
let optionalAliasAnnot = (:a aa: option(int)=?, :b bb: option(int)=?, ()) => 10;
type optionalAliasAnnot = (:a: ?int, :b ?int, unit) => int;
/* K alternative */
let optionalAliasAnnot = (:a aa=?: int, :b bb=?: int, ()) => 10;
type optionalAliasAnnot = (:a=?: int, :b=?: int, unit) => int;

/* L */
let defOptional = (:a=10 :b=10, ()) => 10;
type defOptional = (:a: ?int, :b: ?int, unit) => int;
/* L alternative */
let defOptional = (:a=10: int :b=10: int, ()) => 10;
type defOptional = (:a=?: int, :b=?: int, unit) => int;


/* M */
let defOptionalAlias = (:a aa=10, :b bb=10) => 10;


/* N */
let defOptionalAnnot = (:a: int=10, :b: int=10, ()) => 10;


/* O */
let defOptionalAliasAnnot = (:a aa: int=10, :b bb: int=10, ()) => 10;


/* P: Invoking them - Punned */
let resNotAnnotated = named(:a, :b);


/* Q */
let resAnnotated: int = named(:a, :b);


/* R */
let aa = 1;
let bb = 2;
let resNotAnnotated = named(:a=aa, :b=bb);


/* S */
let resAnnotated: int = named(:a=aa, :b=bb);


/* T */
let resAnnotated = named(:a, :b);


/* U: Proof that there are no ambiguities with return values being annotated */
let resAnnotated: ty = named(:a, :b=b);


/* V: Explicitly passed optionals are a nice way to say "use the default value"*/
let explictlyPassed = myOptional(:a=?None, :b=?None);


/* W: Explicitly passing optional with identifier expression */
let a = None;
let explictlyPassed = myOptional(:a=?a, :b=?None);
/* punned */
let explictlyPassed = myOptional(:a?, :b=?None);
let explictlyPassedAnnotated: int = myOptional(:a?, :b=?None, ());

/* X: tuples */
let receiveTuples = ((x, y, z)) => x + y + z;

type receiveTuples = ((int, int, int)) => int;

/* X2: calling syntax */
let d = receiveTuples((1, 2, 3));
let d : int = receiveTuples((1, 2, 3));


/* Y */
let receiveTuplesDestructure = (:vec (x, y, z)) => x + y + z;

type receiveTuples = (:vec: (int, int, int)) => int;

/* Y2: calling syntax */
let vec = (1, 2, 3);
let d = receiveTuplesDestructure(:vec);
let d: int = receiveTuplesDestructure(:vec=(1, 2, 3));

/* Z */
let takesUnit1 = () => 4;
let takesUnit2 = (:a, ()) => a;

/* Z2 */
let randomNumber = takesUnit1();
let randomNumber = takesUnit2(:a, ());

/* ------------------------------------------------------- */
/*                anonymous function syntax                */
/* ------------------------------------------------------- */

/* A */
let func = (a, b, c) => a + b + c;

type func = (int, int, int) => int;

/* A2: compared to normal function */
let func = (a, b, c) => a + b + c;
type func = (int, int, int) => int;

let func = (a) => (b) => (c) => a + b + c;
type func = (int, int, int) => int;


/* B */
let func = (:a, :b, :c) => a + b + c;

type func = (:a: int, :b: int, :c: int) => int;

/* C */
let func: (:a: int, :b: int, int) => int = (:a: int, :b bb: int, c: int): int => a + bb + c;

/* D */
let func: (:vec: (int, int, int), :num: int) => (int, int, int) =
   (:vec (x, y, z), :num) => (x + num, y + num, z + num);

/* D2: same calling syntax */
let vew = (1, 2, 3);
let newVec = func(:vec, 10);
let newVec = func(:vec=(2, 3, 4), 10);