dry-types

Apply DRY (Don't Repeat Yourself) to types, not just code.

Type duplication causes the same problems as code duplication: inconsistency, maintenance burden, and bugs. Use TypeScript's type operations to derive types from other types.

• Copying fields between interfaces
• Multiple types share common properties
• Want one type to be a subset of another
• Types should stay in sync automatically
• Need to create optional/partial versions of types

```

NEVER copy-paste type definitions. Derive types from a single source of truth.

```

Remember:

• extends for adding fields
• Pick for selecting fields
• Partial for making fields optional
• keyof for getting key types
• typeof for deriving types from values

If you see similar types diverging:

```typescript

// ❌ Duplicated type definitions

interface Person {

firstName: string;

lastName: string;

}

interface PersonWithBirthDate {

firstName: string; // Duplicated!

lastName: string; // Duplicated!

birth: Date;

}

```

What if you add middleName to Person? Now they're out of sync.

Use `extends` to Add Fields

```typescript

// ✅ Derive from base type

interface Person {

firstName: string;

lastName: string;

}

interface PersonWithBirthDate extends Person {

birth: Date;

}

```

Use `Pick` to Select Fields

```typescript

interface State {

userId: string;

pageTitle: string;

recentFiles: string[];

pageContents: string;

}

// ✅ Select only the fields you need

type TopNavState = Pick;

```

Use `Partial` for Optional Versions

```typescript

interface Options {

width: number;

height: number;

color: string;

}

class UIWidget {

constructor(init: Options) { / ... / }

// ✅ All fields optional for updates

update(options: Partial) { / ... / }

}

```

Use `keyof` for Key Types

```typescript

type OptionsKeys = keyof Options;

// ^? type OptionsKeys = "width" | "height" | "color"

```

Use `typeof` to Derive from Values

```typescript

const DEFAULTS = {

width: 640,

height: 480,

color: '#00FF00',

};

// ✅ Type derived from value

type Options = typeof DEFAULTS;

// ^? type Options = { width: number; height: number; color: string; }

```

| Utility | Purpose | Example |

|---------|---------|---------|

| Pick | Select properties | Pick |

| Omit | Remove properties | Omit |

| Partial | Make all optional | Partial |

| Required | Make all required | Required |

| Readonly | Make all readonly | Readonly |

| ReturnType | Function return type | ReturnType |

| Parameters | Function params | Parameters |

Mapped Types

```typescript

// Create optional version manually

type OptionsUpdate = {

[K in keyof Options]?: Options[K]

};

// Equivalent to Partial

```

Indexing into Union Types

```typescript

interface SaveAction { type: 'save'; / ... / }

interface LoadAction { type: 'load'; / ... / }

type Action = SaveAction | LoadAction;

// ✅ Extract discriminant type

type ActionType = Action['type'];

// ^? type ActionType = "save" | "load"

```

ReturnType for Function Results

```typescript

function getUserInfo(userId: string) {

return {

userId,

name,

age,

// ... many fields

};

}

// ✅ Derive type from function

type UserInfo = ReturnType;

```

Key Remapping with `as`

```typescript

interface ShortToLong {

q: 'search';

n: 'numberOfResults';

}

// Invert the mapping

type LongToShort = {

[K in keyof ShortToLong as ShortToLong[K]]: K

};

// ^? type LongToShort = { search: "q"; numberOfResults: "n"; }

```

Mapped types preserve modifiers when using keyof:

```typescript

interface Customer {

/* How the customer would like to be addressed. /

title?: string;

/* Complete name as entered in the system. /

readonly name: string;

}

// ✅ Preserves optional and readonly

type PickTitle = Pick;

// ^? type PickTitle = { title?: string; }

type PickName = Pick;

// ^? type PickName = { readonly name: string; }

```

Don't factor out types that are only coincidentally similar:

```typescript

// ❌ Don't do this - coincidental similarity

interface NamedAndIdentified {

id: number;

name: string;

}

interface Product extends NamedAndIdentified {

priceDollars: number;

}

interface Customer extends NamedAndIdentified {

address: string;

}

```

Why not? Product.id and Customer.id are semantically different:

• Customer.id might become a UUID
• Product.name and Customer.name might evolve differently

Rule of thumb: If you can't name it meaningfully, it's probably premature abstraction.

Base + Extensions

```typescript

// Shared base

interface Vertebrate {

weightGrams: number;

color: string;

isNocturnal: boolean;

}

// Specific extensions

interface Bird extends Vertebrate {

wingspanCm: number;

}

interface Mammal extends Vertebrate {

eatsGardenPlants: boolean;

}

```

Input/Output Types

```typescript

// Full type

interface User {

id: string;

email: string;

name: string;

createdAt: Date;

}

// Input type derived

type CreateUserInput = Pick;

// Or with Omit

type UpdateUserInput = Partial>;

```

Function Signatures

```typescript

// ✅ Factor out common signatures

type HTTPFunction = (url: string, opts: Options) => Promise;

const get: HTTPFunction = (url, opts) => { / ... / };

const post: HTTPFunction = (url, opts) => { / ... / };

```

1. "Copy-Paste Is Faster"

Pressure: "Just duplicate the type, it's quicker"

Response: Technical debt accumulates. Types will drift apart.

Action: Take the time to use extends, Pick, or other derivations.

2. "The Types Are Different Enough"

Pressure: "They share fields by coincidence"

Response: Good point - verify they're semantically the same first.

Action: Only factor out types that represent the same concept.

• Copy-pasting interface fields
• Multiple types with identical property subsets
• Updating one type but forgetting another
• Types named "...WithX" that duplicate base type

| Excuse | Reality |

|--------|---------|

| "It's just a few fields" | A few fields × many types = maintenance nightmare |

| "I'll remember to update both" | You won't, or your teammates won't |

| "The derivation is confusing" | Less confusing than debugging drift |

```typescript

// Adding fields

interface Extended extends Base { newField: T; }

// Selecting fields

type Subset = Pick;

// Removing fields

type WithoutPassword = Omit;

// Making optional

type Updates = Partial;

// Getting return type

type Result = ReturnType;

// Getting key union

type Keys = keyof MyInterface;

```

Derive types from a single source of truth.

Use TypeScript's type operations (extends, Pick, Partial, keyof, typeof, mapped types) to express relationships between types. This keeps types in sync and reduces maintenance burden. But only apply DRY when types are semantically related, not just structurally similar.

Based on "Effective TypeScript" by Dan Vanderkam, Item 15: Use Type Operations and Generic Types to Avoid Repeating Yourself.