Paris TypeScript January 8th 2018

Premier Field Engineer @spontoreau In ❤️ with Co-organizer

No content

No content

No content

type MyFunctionType = { (value: string): boolean; }; // or interface MyFunctionInterface { (value: string): boolean; };

No content

let total = 0; let add = (nb: number) => total += nb; add(1); // total equals 1 add(2); // total equals 3 add(3); // total equals 6

let total = 0; let isNegative = () => total < 0; let result1 = isNegative(); // false total--; let result2 = isNegative(); // true

let add = (nb1: number, nb2: number) => nb1 + nb2; let result1 = add(1, 2); // result1 equals 3 let result2 = add(result1, 3); // result2 equals 6 let result3 = add(result2, 4); // result3 equals 10 let result4 = add(result2, 4); // result4 equals 10

No content

const total = 0; const add = (nb: number) => total += nb; type Person = { firstName: string, lastName: string }; const p: Person = { firstName: "Sylvain", lastName: "Pontoreau" }; p.firstName = "anotherFirstName";

type Person = Readonly<{ firstName: string, lastName: string }>; const p: Person = { firstName: "Sylvain", lastName: "Pontoreau" }; p.firstName = "anotherFirstName";

const personArray: ReadonlyArray = [{ firstName: "Sylvain", lastName: "Pontoreau" }, { firstName: "Bill", lastName: "Gates" }]; personArray.push({ firstName: "Satya", lastName: "Nadella" });

type Person = Readonly<{ firstName: string, lastName: string }>; const person: Person = { firstName: "Sylvain", lastName: "Pontoreau" }; const clone: Person = { ...person, firstName: "anotherFirstName" }; https://github.com/facebook/immutable-js

const sum = (numbers: ReadonlyArray) => { let result = 0; numbers.forEach((n: number) => { result += n; }); return result; }; const result = sum([1, 2, 3, 4]); // result equals 10

const sum = (numbers: ReadonlyArray): number => { return numbers.length ? numbers[0] + sum(numbers.slice(1)) : 0; }; const result = sum([1, 2, 3, 4]); // result equals 10

const handleCase1 = () => "Returns a result for case 1"; const handleCase42 = () => "Returns a result for case 42"; const handleDefaultCase = () => "Returns a default result"; const valueToCheck = Math.random() * 42; const result = ((check) => { switch(check) { case 1: return handleCase1(); case 42: return handleCase42(); default: return handleDefaultCase(); } })(valueToCheck);

type Condition = { (value: TValue): boolean; }; type Execute = { (value: TValue): TResult; }; type Pattern = { condition: Condition, execute: Execute }; const when = ( condition: Condition, execute: Execute) => { return { condition, execute }; };

const match = function( value: TValue, defaultExecute: Execute, ...patterns: Pattern[]): TResult { if (patterns.length > 0) { const when = patterns[0]; return !when.condition(value) ? match( value, defaultExecute, ... patterns.slice(1)) : when.execute(value); } else { return defaultExecute(value); } }

const handleCase1 = () => "Returns a result for case 1"; const handleCase42 = () => "Returns a result for case 42"; const handleDefaultCase = () => "Returns a default result"; const valueToCheck = Math.random() * 42; const result = match( valueToCheck, handleDefaultCase, when((v) => v === 1, handleCase1), when((v) => v === 42, handleCase42) );

const result = case (valueToCheck) { when 1 -> { return handleCase1(); } when 42 -> { return handleCase42(); } when value if (value !== 1 && value !== 42) -> { return handleDefaultCase(); } };

const post = (url: string) => { return (value: TValue) => { return fetch(url, { headers: { "Accept": "application/json", "Content-Type": "application/json", }, method: "POST", body: JSON.stringify(value), }); }; }; type Person = { firstName: string, lastName: string, } const postPerson = post("url"); postPerson({ firstName: "Sylvain", lastName: "Pontoreau", }).then((response) => { // Do something }); const promise = post("url")(person);

interface FormatResult { (n: number): string; } interface Square { (n: number): number } const formatResult = (n: number) => `Result is ${ n }`; const square = (n: number) => n * n; const pipe = (format: FormatResult, square: Square) => { return (n: number) => format(square(n)) }; const result = pipe(formatResult, square)(42);

declare global { interface Object { pipe(this: T, next:(value:T) => TResult): TResult; } } Object.prototype.pipe = function(this:T, next:(value:T) => TResult): TResult { return next(this); }; const nb = Math.random() * 100; const pipeResult = nb.pipe(square).pipe(formatResult);

const nb = Math.random() * 100; const result = nb |> square |> formatResult;

const compose = ( function1: (value: TFirstReturn) => TSecondReturn, function2: (value: TValue) => TFirstReturn ) => (value: TValue) => function1(function2(value)); const kebabToSnakeCase = (s: string) => s.replace("-", "_"); const toUpper = (s: string) => s.toUpperCase(); const toScreamingSnakeCase = compose(kebabToSnakeCase, toUpper); const result = toScreamingSnakeCase("kebab-case"); // result: KEBAB_CASE

class Composition { private constructor(private readonly func : (x : TValue) => TResult) { } static compose(func : (x : TValue) => TResult) { return new Composition(func); } compose(f : (x : TNextValue) => TValue) : Composition { return new Composition(x => this.func(f(x))) } execute(value: TValue) : TResult { return this.func(value); } } const result = Composition.compose(kebabToSnakeCase).compose(toUpper).execute("kebab-case");

No content

No content

No content