May 26, 2020

# Agenda

In the next ten minutes, I aim to:

• Demonstrate costs and benefits of TypeScript
• Argue that TypeScript is worth the investment

# Types crypt

The fundamental problem addressed by a type theory is to ensure that programs have meaning.

-- Mark Manasse

# Identity crisis

What does this function do?

``````function foo(x) {
// implementation hidden
}``````

# Parametricity

What does this function do?

``````function foo<A>(x: A): A {
// implementation hidden
}``````

# Possibilities Possibility

There's only one possible implementation*: `identity`.

``````function foo<A>(x: A): A {
return x;
}``````
* If we ignore `null`, `undefined`, and `throw`.

# Numeric product?

``````function multiply(x, y) {
// implementation hidden
}

var z = multiply(6, 7);``````

What is `z`?

``function multiply(x, y) { return x * y; } // 42``
``function multiply(x, y) { return x + y; } // 13``
``function multiply(x, y) { x * y; } // undefined``
``function multiply(x, y) { return x; } // 6``
``function multiply(x, y) { return 'lol'; } // 'lol'``
``function multiply(x, y) { } // undefined``
``function multiply(x, y) { return arguments[2]; } // undefined``

╯°□°）╯︵ ┻━┻

# Numeric product...

``````function multiply(x: number, y: number): number {
// implementation hidden
}

var z: number = multiply(6, 7);``````

Now what is `z`?

``function multiply(x: number, y: number): number { return x * y; } // 42``
``function multiply(x: number, y: number): number { return x + y; } // 13``
``// function multiply(x: number, y: number): number { x * y; }``
``function multiply(x: number, y: number): number { return x; } // 6``
``// function multiply(x: number, y: number): number { return 'lol'; }``
``function multiply(x: number, y: number): number { return arguments[2]; } // undefined``
``// function multiply(x: number, y: number): number { return 'lol'; }``

┬─┬ノ( º _ ºノ)

# Numeric product!

``````interface Monoid<A> {
unit: A;
concat(x: A, y: A): A;
}``````

Testable laws: identity, associativity

``````var multiplicationMonoid: Monoid<number> = {
unit: 1,
concat: (x: number, y: number) => {
return x * y
},
};``````
``````var multiply: (x: number, y: number) => number =
multiplicationMonoid.concat;``````
``var z: number = multiply(6, 7); // 42``

\o/

# It's complicated

Web browsers don't know what TypeScript is. They need JavaScript.

multiply.ts:

``````var multiplicationMonoid: Monoid<number> = {
unit: 1,
concat: (x: number, y: number) => {
return x * y
},
};

var multiply: (x: number, y: number) => number =
multiplicationMonoid.concat;``````

multiply.js:

``````var multiplicationMonoid = {
product: function (x, y) {
return x * y;
}
};
var multiply = multiplicationMonoid.product;``````

# Conclusion

### Cons

• Yet another language and suite of tools to learn
• More indirection between the developer and the user

### Pros

• Eliminate certain errors before they're run
• Write code that's easier to read