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

Unlike OOP, objects don't have behavior in Functional Programming. Interfaces are used not to enumerate methods of an object, but to describe the shape of the data contained by the object.

In this context, generic interfaces are used to describe a data shape when you don't know or care about the exact type of some properties of the interface. It often makes sense when the data types _contain_ some value.

You can find an example of such an interface below. It represents a form field that could be part of some dynamic form implementation. We want to store certain information about a form field while we don't care about the type of data stored in that field. That's why we introduced the generic type parameter `T`.

```typescript
interface FormField<T> {
    value?: T;
    defaultValue: T;
    isValid: boolean;
}
```

This lesson talks about generic interfaces from the perspective of Functional Programming.

Strict types

Generics

Composing types

Advanced types

TypeScript in practice

Conclusion

Generic Interfaces - FP Perspective

Overview