Master literal preservation with the as const keyword and enhance your TypeScript skills, ensuring type safety and precision in your code.

Preserve Literals 

[00:00] Alright. Let's get into this. We've got this roles object, admin, editor, viewer, can be delete or can ban, can delete, can ban all on all of these. Alright? This makes sense.

[00:10] If I hover over this, you're gonna see roles admin can delete users' Boolean, can ban users' Boolean, etcetera on each one of these. Now that's interesting because we actually, know that admins will always be able to delete users. It's it's never going to change. This is the way that our roles are going to be for the entire lifetime of the program. Now, of course, I could change the code, but, that will change the program.

[00:33] So, if we can assume safely that, these values will never change, well then, maybe it would be nice if the type explicitly said can delete users true as a literal type. So here before I do that though, let's make a role that is gonna give me all of the different roles that we have available. This is using the key of type of words. So this or type of, roles. Key of is a specific, TypeScript feature or TypeScript keyword.

[01:04] You're not gonna find this in JavaScript. Type of works both in JavaScript and in TypeScript. And in this case, type of is going to give us, the the, type of can be seen as a mechanism, not only in JavaScript for, like, determining the type of something, but it also can take a a value that's in or a variable that's in the JavaScript world and pull it into the TypeScript world. So now we can turn that thing into types. And then the key of is going to, take the type here.

[01:36] So effectively, type of is turning roles into this, what we're looking at here. Key of is going to take that object and take each one of these keys and turn that into a union type. And so now if we look at role, it's gonna be admin, editor, or viewer. So we use this quite a lot and it's quite nice, to be able to take a value that's a run time value like roles and bring it into the type world so that we can, get things typed nicely. Okay.

[02:02] So, I'm gonna get rid of this comment and we're gonna see an error here. And so what this is saying is admin can delete, and we're explicitly saying that this has to be true. The admin can delete it. Absolutely, 100%, it's true. But the problem is, as I described earlier, this admin, the type for the admin just says has a boolean.

[02:23] We don't actually know because it could be modified. It could be, changed in some way. And even though we have it hard coded up there like that, TypeScript is just doing the best it can. It doesn't really know, that it's not gonna be modified. So the best it knows is that it's a boolean.

[02:38] By adding as const to this, now we are saying, no. No. No. This type isn't just Boolean. It is read only.

[02:47] Like, these things will not change. Roles will only ever have an admin, an editor, and a a viewer. Those things will not change. And the admin will only ever have, delete users as true and ban users as true, etcetera, etcetera, etcetera. You could actually also ask const these individually.

[03:08] So if you just wanted to ask const the admin, now we're getting read only true on these, but the rest of these aren't read only true. But in our case, it makes much much more sense to as const, const, on the roles object itself. Okay. So let's make a can delete users that's gonna take a role and decide whether or not, those users can be deleted. So that's why we needed this, role union right here.

[03:34] So that's cool. We could have also just said, admin or editor or viewer, but by deriving it from the object itself, we don't, have to worry about that which is pretty nice. If we didn't have the as const, this actually this piece would actually still work. So the as const is mostly useful for, knowing whether or not or or having, like, the the structure of that object be the structure of our type as well. Okay.

[04:05] So we export this, and everything is looking good. We can, console log. Yeah. I can delete users admin editor and viewer. We get true, false, false.

[04:15] K. Very good. Okay. I think that's everything that I wanted to show you with this one. So as const, I use it relatively regularly.

[04:25] It can be pretty useful also with discriminated unions. I'll I'll show you actually really quick. I'll show you one other example. In React router, there is a function called, an action function. And what this does is it returns a, a response or a a JSON object, based on whatever action you're trying to accomplish.

[04:46] So somebody's making a request to your server, you do something and then you return a response. And often, that response is either gonna be success. I did it. Hooray. Or it's gonna be error and here's the problem.

[04:55] So often, I will use as const for something like that where I'll say, if, did thing then return, status success. And then, otherwise, I'll return status error and did not do thing. Okay? And so here we get our result is the action, and the result here is saying, that it's a status that has a string or an error that's undefined or it's a status that's a string with an error, that is a string. And there's not really a great way for me to know whether it was an error or not.

[05:30] And so this is another case where I will add as const to both of these And now the, result is going to be it's either status success and the error is definitely undefined or the status is error and it, did nothing. And so now I can say result status equals error. Now I know, I can console log the result error I know for sure. Whereas if it's a success, I know that the error is gonna be undefined. And in fact, sometimes I will even say error is null to be very explicit.

[06:05] Like, no. No. This this error should not exist in this case. So as const can be used for that as well. Okay.

[06:13] Great. Hopefully, that was fun and interesting for you, and, let's continue on to learn more about this.

Preserve Literals

[00:00] Alright. Now we're going to do some literal preserve preservation, using the as const keywords. This is actually something I use pretty regularly, so I'm excited for you to learn all about it. Let's jump into it and explore the types.

In TypeScript, every variable, every function parameter, every return value carries a type. When those types are wrong, you get bugs that surface at the worst possible moment. Runtime crashes, silent data corruption, and hours spent debugging issues that the compiler could have caught before you ever hit save.

The problem is that you haven't built the mental model for how its type system actually works. You annotate a few variables, sprinkle in some `any` when things get frustrating, and move on, never realizing you've turned off the very safety net that makes TypeScript worth using.

The Type Safety Workshop takes you deep into TypeScript's type system. You'll learn how to model your data precisely with type aliases, union types, and generics, then use that precision to catch entire categories of bugs at compile time instead of in production.

In this workshop, you'll work through real patterns like discriminated unions for API responses, type guards for runtime narrowing, and `as const` for deriving types from your source code, the same techniques used in production TypeScript codebases every day.

## Type Aliases

Every time you duplicate a type annotation across multiple variables or functions, you're creating a maintenance problem. Change the shape in one place, forget the other, and you've got a type mismatch that might not surface for weeks. Type aliases let you define a type once and reference it everywhere.

In this section, you'll create reusable types and learn how to compose them from smaller building blocks:

- Creating type aliases for objects with `type User = { id: string; name: string }`
- Using `typeof` to derive types from existing runtime values
- Composing types from primitive aliases like `ID`, `Timestamp`, and `Email` to communicate intent
- Using `Record` to type objects with dynamic string keys
- Choosing between explicit type definitions and inference with `typeof`

## Union Types

Real application data is rarely just one thing. An API response might be a success object or an error. A user ID might be a string or a number. Without union types, you're forced to use `any` or write separate functions for every possible shape-- neither of which scales.

This section covers one of TypeScript's most powerful features and the patterns that make it practical:

- Defining types that accept multiple shapes with the `|` operator
- Narrowing unions with `typeof` and `instanceof` checks
- Using the `in` operator to distinguish between object shapes
- Writing custom type guard functions with the `value is Type` syntax
- Building discriminated unions with a shared status or type property
- Exhaustive checking with `switch` statements and the `never` type

## Literal Types

TypeScript infers `const x = "hello"` as the literal type `"hello"`, but `let y = "hello"` becomes just `string`. That distinction matters more than you'd think-- especially when you want your types to reflect the exact values in your code rather than broad categories.

Here you'll learn how to preserve and leverage literal types in your programs:

- Using `as const` to preserve literal types on objects and arrays
- Deriving union types from object keys with `keyof typeof`
- Extracting value types from constant objects for precise unions
- Building a single source of truth where types flow from runtime values
- Practical patterns like typed route maps and discriminated return types

## Intersection Types

Union types let a value be one of several shapes. Intersection types go the other direction-- combining multiple types into one that has all their properties. It's the type-level equivalent of spreading objects together.

This section teaches you how to compose types from reusable pieces:

- Combining types with the `&` operator to build composite shapes
- Creating reusable building blocks like `WithID`, `WithTimestamps`, and `WithAuthor`
- Assembling entity types (`User`, `Post`, `Comment`) from shared base types
- Understanding how intersection differs from union in practice

## Any vs Unknown

When TypeScript gets in your way, it's tempting to reach for `any` and move on. The problem is that `any` doesn't just silence one error-- it turns off type checking for everything that value touches. It's an escape hatch that defeats the purpose of using TypeScript in the first place.

This section shows you the safer alternative and when each escape hatch is appropriate:

- Understanding why `any` disables all type checking on a value
- Using `unknown` as a type-safe alternative that requires narrowing before use
- Narrowing `unknown` values with `typeof` checks and error throwing
- Processing values of different types through runtime checks
- When you'll encounter `any` in library code and why it exists for backward compatibility

## Generics

Without generics, you'd need a separate function for every type you want to support-- `firstNumber`, `firstString`, `firstUser`-- or you'd give up and use `any`. Generics let you write a single function that works with any type while preserving full type safety through the entire call chain.

This section takes you from basic generic syntax through real-world patterns with constraints:

- Writing generic functions with type parameters (`<Value>`)
- Letting TypeScript infer generic types from function arguments
- Creating generic types for reusable patterns like loading states
- Constraining generics with `extends` to require specific shapes
- Building a type-safe `getProperty` function using `keyof` constraints
- Merging objects with fully typed intersection return values

## Interfaces

Interfaces look almost identical to type aliases-- and for most purposes, they behave the same way. So why do they exist? Historical reasons, mostly. But interfaces have one unique capability that types can't replicate: declaration merging.

Here you'll learn when interfaces matter and when to stick with types:

- Defining object shapes with `interface` syntax
- Extending interfaces to build up from base types
- Understanding declaration merging and how interfaces combine across modules
- Augmenting global interfaces for plugin systems and library configuration
- Why types are preferred for day-to-day code and when interfaces earn their place

## Enums

Enums give you a way to define a set of named constants-- `OrderStatus.Pending`, `OrderStatus.Active`, `OrderStatus.Completed`. They're one of the few TypeScript features that generate actual runtime code, which makes them unique in the type system and controversial in the community.

In this section, you'll learn how enums work and why union types are often the better choice:

- Creating string enums for order statuses and log levels
- Using enums in switch statements and type-safe functions
- Understanding the runtime code that enums generate after compilation
- Migrating from enums to union types for simpler, cleaner code
- Comparing the developer experience of enums vs. unions for autocomplete and type safety


TypeScript's type system: learn type aliases, unions, generics, intersections, and more to catch bugs at compile time instead of in production.

Type Safety

Programming Foundations

Structured Data

Object Oriented TypeScript

Advanced TypeScript

Practical TypeScript: Foundations to Fluency

Master TypeScript's type safety and enhance your coding skills with practical exercises on type aliases, generics, and more. Dive into advanced concepts today!

Intro to Type Safety

Introduction to Type Safety

Master Type Aliases in TypeScript to simplify your code, enhance reusability, and effectively manage complex data types with ease.

Intro to Type Aliases

Master TypeScript by creating and using type aliases to enhance your coding efficiency and clarity in this hands-on workshop.

Naming Types

Master type composition by creating effective type aliases for primitives and objects, enhancing your TypeScript skills for cleaner, more maintainable code.

Composition

Master record types and generics in this engaging exercise, enhancing your object handling skills for dynamic applications. Dive in and elevate your coding expe

Record Type

Break Type Aliases

1. Type Aliases

Master TypeScript union types to enhance your coding skills. Discover how to manage multiple types effectively and streamline your logic.

Intro to Union Types

Master union types in this exercise by working with strings, errors, and numbers to enhance your TypeScript skills and streamline your functions.

Multiple Types

Master TypeScript type guards and user handling to efficiently manage strings and arrays, enhancing your JavaScript coding skills today!

Narrowing

Master type guards in TypeScript to streamline type checking and enhance your code's reliability. Create custom functions for effective type validation.

Type Guards

Master the discriminated unions pattern in TypeScript to enhance your coding skills and streamline complex data handling in your applications.

Discriminated Unions

Master union types and type narrowing in this engaging lesson, enhancing your coding skills and retention while enjoying a light-hearted approach.

Break Union Types

2. Union Types

Master literal types in TypeScript by leveraging 'as const' for type safety and precision. Enhance your coding with powerful type narrowing techniques.

Intro to Literal Types

Master the concept of a single source of truth by deriving types from code using as const, enhancing your TypeScript skills and code accuracy.

Single Source Of Truth 

Master breaking literal types to enhance your coding skills, boost retention, and build robust applications. Dive in and elevate your development game!

Break Literal Types

3. Literal Types

Master intersection types by combining multiple types effortlessly. Enhance your TypeScript skills and streamline your coding with practical examples.

Intro to Intersection Types

Master intersection types in TypeScript to enhance your coding skills and streamline your development process. Join us to unlock powerful type combinations!

Combining Types 

Master intersection types in web development while enjoying a refreshing break. Boost your skills and retain knowledge effectively for real-world applications.

Break Intersection Types

4. Intersection Types

Master the differences between Any and Unknown in TypeScript to enhance your coding skills, improve type safety, and optimize your development process.

Intro to Any vs Unknown

Master the nuances of JavaScript's "any" vs. "unknown" types and enhance your coding skills with practical insights in this engaging exercise.

Escape Hatches 

Master the concepts of breaking any and unknown variables, boost your coding skills, and unlock your potential as a developer in this engaging lesson.

Break Any vs Unknown

5. Any vs Unknown

Unlock the power of TypeScript generics to create flexible, type-safe functions that work with any data type. Enhance your coding skills today!

Intro to Generics

Master generic functions by creating two practical examples, enhancing your coding skills and understanding of syntax for real-world applications.

Generic Functions 

Master generic types in programming with practical examples and enhance your coding skills to create more flexible and reusable code.

Generic Types

Master advanced generics in programming by exploring constraints that enhance type safety and streamline function usability. Unlock powerful coding techniques n

Constraints

Master generics in web development and boost your coding skills with practical exercises and insights that enhance your programming efficiency.

Break Generics

6. Generics

Master interfaces in web development and discover their unique advantages, including declaration merging and practical syntax. Elevate your coding skills now!

Intro to Interfaces

Master object shapes with interfaces in this hands-on exercise, enhancing your TypeScript skills and building robust, type-safe applications.

Object Shapes 

Master interface extension in TypeScript and enhance your coding skills by combining types effectively with the extends keyword. Join us now!

Extending Interfaces 

Master declaration merging in TypeScript interfaces across modules and unlock powerful library design techniques for your projects.

Declaration Merging 

Revitalize your coding skills with a refreshing break! Discover the importance of posture and movement for enhanced focus and productivity in development.

Break Interfaces

7. Interfaces

Master enums with this concise guide, exploring their syntax, unique values, and practical applications to enhance your coding skills effectively.

Intro to Enums

Master string enums in TypeScript through a hands-on order management system exercise and enhance your coding skills for better type safety.

String Enums 

Master the differences between enums and unions while migrating your code. Discover why unions may be the better choice for your development projects.

Enum Vs Union 

Master enum concepts and enhance your coding skills with practical exercises and retention techniques to boost your development knowledge effectively.

Break Enums

8. Enums

Congratulations on mastering type safety! Solidify your skills with practical examples and build your confidence in TypeScript's powerful features.

Type Safety

Type Safety

Transcript

Preserve Literals

Transcript