Discover advanced TypeScript concepts: Gain insights into compiler flags, generic types, and discriminated unions. Delve into writing error-free code and mastering complex error messages with confidence.

typescript-3.7.5.tar.gz

TypeScript 3.7.5 Strict

TypeScript 3.7.5

Are you using TypeScript, but feel like you’re not making the most out of it? Do you find some advanced TypeScript concepts confusing? Do you get lost looking at complex type errors?

If you answered “yes” to any of these questions, then this course is for you! It introduces you to the world of advanced TypeScript concepts including: compiler flags for catching more errors, generic types, and how to compose types with discriminated unions. 

After finishing this course, you’ll feel more confident in your TypeScript skills. You will be able to write types that detect whole classes of possible runtime errors at compile time. Typing even the most untypeable JavaScript code will be a no brainer for you, and you’ll be fluent in TypeScript error messages.

Advanced TypeScript Masterclass

# Overview

Subtyping is a form of type polymorphism that is very popular in Object-Oriented Programming. If you're familiar with OOP languages such as Java or C#, then you very likely know it already.

Subtyping offers an alternative to Algebraic Data Types (discriminated unions). In this lesson, I'd like to compare these two approaches.

# Defining types

Let's go back to the example of a discriminated union representing a binary tree. It could, for example, be a tree of product categories in an e-commerce web application.

```typescript
type Tree = 
      | { type: 'empty' }
      | { type: 'leaf', value: number }
      | { type: 'node', left: Tree, right: Tree };
```

A tree can either be:

* a node with references to left and right subtrees
* a leaf containing a numerical value
* empty

We can represent the same data structure using the OOP approach. We define an abstract class `Tree` and three concrete classes extending from `Tree`.

```typescript
abstract class Tree {}

class Empty extends Tree { }

class Leaf extends Tree {
  constructor(private value: number) {
    super();
  }
}

class Node extends Tree {
  constructor(
    private left: Tree,
    private right: Tree,
  ) {
    super();
  }
}
```

# Adding an operation

Now, let's say that we want to create a textual representation of the tree. Let's see how the implementation would look in both approaches.

This lesson discusses the differences between the two approaches of expressing choice in the type system.

Strict types

Generics

Composing types

Advanced types

TypeScript in practice

Conclusion

Discriminated Unions vs Subtyping

Overview

Defining types