Unleashing the Power of Typescript's Mapped Types

nukeop — Wed, 22 Feb 2023 01:19:46 +0000

As developers, we all love the power and flexibility that Typescript brings to our code. But did you know that Typescript's mapped types allow you to create dynamic types that change based on the values of your variables? In this post, I'm going to dive into this lesser-known Typescript feature and show you how it can help you write even more powerful and flexible code.

Mapped types allow you to create new types by transforming properties of an existing type. In essence, they're like a map function, but for types. For example, say you have an interface like this:

interface MyInterface {
  foo: string;
  bar: number;
  baz: boolean;
}

You can use a mapped type to create a new type that transforms all the property types to string:

type MyStringInterface = {
  [K in keyof MyInterface]: string;
}

This creates a new type called MyStringInterface that has the same properties as MyInterface, but with all the property types set to string. So if you have a variable of type MyInterface, you can assign it to a variable of type MyStringInterface:

const myInterface: MyInterface = {
  foo: "hello",
  bar: 42,
  baz: true
};

const myStringInterface: MyStringInterface = myInterface;

This is a powerful feature that can save you a lot of time and effort. But what if you want to create a type that only transforms some of the properties, based on their values? That's where things get really interesting.

Say you have a list of properties that you want to transform to string:

const propertiesToTransform = ["foo", "baz"] as const;

You can use a conditional type to create a new type that transforms only the properties in the list to string:

type MyConditionalStringInterface = {
  [K in keyof MyInterface]: K extends typeof propertiesToTransform[number] ? string : MyInterface[K];
}

This creates a new type called MyConditionalStringInterface that has the same properties as MyInterface, but with only the properties in propertiesToTransform set to string.

const myConditionalStringInterface: MyConditionalStringInterface = {
  foo: "hello",
  bar: 42,
  baz: true
};

This is just scratching the surface of what you can do with mapped types. You can use them to create types that depend on the values of your variables, types that filter out certain properties, and much more. With a little creativity, you can unleash the full power of Typescript's type system and write even more robust and flexible code.

So the next time you're working with Typescript, keep mapped types in mind. They might just be the key to unlocking the next level of your code.

If Copilot generates postcardware, where should you send the post card?

nukeop — Sat, 25 Jun 2022 23:32:34 +0000

I was recently asked a question that stumped me: where should one send a postcard if an artificial intelligence coding assist tool accidentally generates license stating that the code it made is postcardware?

I'm not sure what the answer is, but I thought I'd share my thoughts on the matter.

It seems to me that there are two possible options. First, you could send the postcard to the company that made the tool. After all, they're the ones who released the code into the world, and they should be held responsible for its actions.

Alternatively, you could send the postcard to the person who wrote the code that the tool generated. They're the ones who actually created the code, so they should be the ones to get the credit (or blame) for it.

Personally, I lean towards the latter option. It seems only fair that the person who created the code should be the one to receive the postcard. But ultimately, the decision is up to you.

So, where should you send your postcard? I'm not sure. But I hope this article has given you something to think about.

DEV Community: nukeop

Unleashing the Power of Typescript's Mapped Types

If Copilot generates postcardware, where should you send the post card?