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 as aa, ~b as bb) => aa + bb;

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


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


/* F */
let namedAliasAnnot = (~a as aa: int, ~b as 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 as aa=?, ~b as bb=?, ()) => 10;


/* J */
let optionalAnnot = (~a: option(int)=?, ~b: option(int)=?, ()) => 10;
type optionalAnnot = (~a: int=?, ~b: int=?, unit) => int;


/* K */
let optionalAliasAnnot = (~a as aa: option(int)=?, ~b as bb: option(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;


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


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


/* O */
let defOptionalAliasAnnot = (~a as aa: int=10, ~b as 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 as (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 as bb: int, c: int): int => a + bb + c;

/* D */
let func: (~vec: (int, int, int), ~num: int) => (int, int, int) =
   (~vec as (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);