Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
/* 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);
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment