Learn how to unleash the full potential of the Turing Complete type system of TypeScript!

Introduction

Type-level TypeScript is an online course to take your TypeScript skills from intermediate to advanced. It will give you a solid understanding of the type system's fundamentals and guide you through its most advanced features. You will find everything you need to become a TypeScript Expert — not only in-depth content, but also fun challenges to practice your new skills, like this one right here.

Let's see if you can solve it!

Challenge

Solution

Congratulation! 🎉

Over the years, the type system of TypeScript has grown from basic type annotations to a large and complex programming language.

If you have ever looked into the code of an open-source library you may have found types that looked intimidating and foreign, like some esoteric language coming from another planet. Library code often needs to be much more abstract than the code we are used to writing; that's why it makes extensive usage of advanced TypeScript features such as Generics, Conditional Types, Mapped Types or even Recursive Types.

I mastered these concepts while working on TS-Pattern, a widely-used open-source library that has the particularity of being extremely hard to type. In this course, I hope to share what I've learned by reading too much source code and tinkering for hundreds of hours with the type system.

Types are awesome.

Not only can good types catch your mistakes and typos, but they also make you more proficient by documenting your code and providing you with smart suggestions. The more your types know about your code, the better they are at helping you!

Once you're fluent in the language of types, everything becomes possible. You will be able to quickly build the abstractions you need, and stop feeling like the type system is getting in your way.

Wish you had a type-safe navigate function that'd make sure your route parameters are correct? Here you go 👇

This isn't magic. The type system is just a real programming language!

To get better at this, you first need to acknowledge that TypeScript's type system is a full-fledged programming language in itself! It's more than worth learning its fundamentals, just like you would with any other new programming language.

Throughout this course, I'll try to show the correspondence between programming concepts you already know like code branching, variable assignment, loops and data structures, and their type-level equivalent.

By assembling these building blocks, you will be able to create powerful type-level algorithms that make sure the abstractions you create are always used properly in your entire codebase.

Let's take your TypeScript skills to the next level!

Types & Values
Free

How can we cross the bridge between types and values? Let’s better understand type inference.

👉 Generic functions

👉 Using type parameters

👉 Type-level functions

Types are just data
Free

It turns out that types aren’t so different from values. Let’s shift perspective and start seeing types as another form of data.

👉 Primitive & Literal types

👉 unknown & never

👉 The dreaded any

Objects & Records
Free

Objects are the most common data structures in TypeScript. Let’s learn how to create and transform object types.

👉 Objects vs Records

👉 Transforming & Merging Objects

👉 Open vs closed objects

👉 The amazing keyof keyword

Arrays & Tuples
Free

Let’s take a look at the real arrays of the type-level language: Tuples!

👉 Tuples vs Arrays

👉 Transforming Arrays & Tuples

👉 The power of Variadic Tuples

Conditional Types

The type-level programming journey begins! Let's create our first type-level algorithms using Conditional Types for code branching.

👉 The extends keyword

👉 The infer keyword

👉 Type constraints and as const

Loops with Recursive Types

Computer are great at repetitive tasks. There is no reason we shouldn't take advantage of their power for types too! Let’s learn how to loop through lists of types using recursion.

👉 Imperative vs Recursive loops

👉 Looping through Tuples

👉 Type-level Map, Filter and Reduce functions

Template Literal Types

Did you know TypeScript’s type system can parse strings? Let’s learn how to use Template Literal Types to generate unions of strings, parse them and write type-safe Domain-Specific Languages.

👉 Generating unions of strings

👉 Parsing strings with recursion!

👉 Our first type-safe DSL

The Union Type Multiverse

Union types are super common, and yet one of the hardest part of the language to wrap your head around. Let’s deepen our understanding of unions to better predict their behavior in generic code.

👉 The nature of union types

👉 Transforming & filtering unions

👉 Type narrowing

Loops with Mapped Types

Most TypeScript code is about transforming objects, so we often end up with many object variants in our codebases. Let’s learn how to generate object types by looping through the keys and values of existing ones.

👉 Looping through objects and tuples

👉 Transforming unions into objects

👉 Dealing with ?: and other property modifiers

👉 Object index signatures

Assignability Quiz

Type Assignability is at the core of TypeScript. Let’s explore how it works through the best way I know — playing a game!

👉 readonly types

👉 Assignability of functions

👉 Type variance

👉 Assignability pitfalls

Designing Type-Safe APIs

So much of programming is about using the code of other people. Let's learn how to design delightful type-safe interfaces from the best open-source TypeScript libraries!

👉 Custom error messages

👉 Custom autocomplete suggestions

👉 The Type Builder pattern

Conclusion

It is time to let you continue your TypeScript journey on your own. Before we say good bye, let's pause to consider how far you've gone, and what you can do next to get the most out of your shiny new TypeScript skills.

👉 Solving real-world problems

👉 Mentoring

👉 Contributing to libraries

Finally, we will discuss the tradeoffs of moving more of your code complexity to the type level. We will talk about compile time performance, type errors, type-level debugging and other challenges of type-level programming. It will help you reflect and take the right decision when using these techniques.

This course isn't a collection of TypeScript tricks! I believe that building a good mental model of the fundamentals is more empowering because it will help you solve problems we haven't covered. Knowing a few tricks can only get you so far, but mastering the building blocks of the language and the way they interact together will enable you to solve your real-world problems.

Don't take my word for it.