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

Let's have a look at the following example. Imagine that you're fetching a collection of objects from some backend service and you need to map this collection to an array of identifiers.

```typescript
interface Person {
  id: string;
  name: string;
  birthYear: number;
}

function getIds(persons: Person[]) {
    return persons.map(person => person.id);
}
```

Next, you decide to generalize the `getIds` function so that it works on any collection of objects that have the `id` property.

function getIds<T extends Record<'id', string>>(elements: T[]) {
  return elements.map(el => el.id);
}

Fair enough. However, the code for this simple function is quite verbose. Can we make it more concise?

# Pointfree style

We can do this by taking advantage of a functional programming technique called **pointfree style**. [Ramda](http://ramdajs.com) is a nice library that will let us compose this function from other functions: `map` and `prop`.

```typescript
import * as R from 'ramda';

const getIds = R.map(R.prop('id'));
```

This lesson talks about an interesting language feature related to generic functions introduced in TypeScript 3.4.

Strict types

Generics

Composing types

Advanced types

TypeScript in practice

Conclusion

Type Argument Propagation

Overview #