How to constrain a generic type.
Tell the compiler what T can do.

// ─── The problem: unconstrained T ────────────
function badLength(x: T): number {
// return x.length;
// ❌ Property 'length' does not exist on type 'T'.
// T could be a number, an object, anything — no guarantee
// it has 'length'.
return 0;
}

// ─── The fix: constrain T ────────────────────
function getLengthextends { length: number }>(x: T): number {
return x.length; // ✅ T guaranteed to have length: number
}

getLength('hello'); // ✅ string has length
getLength([1, 2, 3]); // ✅ array has length
getLength({ length: 5 }); // ✅ any object with length
// getLength(42); // ❌ number doesn't have length
// getLength({ name: 'x' }); // ❌ no length property

// ─── Constrain to a named interface ──────────
interface HasId {
id: string;
}

function findByIdextends HasId>(items: T[], id: string): T | undefined {
return items.find(item => item.id === id);
}

interface User { id: string; name: string }
interface Post { id: string; title: string }

const users: User[] = [{ id: '1', name: 'Alice' }];
const posts: Post[] = [{ id: 'p1', title: 'Hello' }];

findById(users, '1'); // ✅ returns User | undefined
findById(posts, 'p1'); // ✅ returns Post | undefined

// ─── Multiple constraints via & ──────────────
interface HasName { name: string }

function greetByIdextends HasId & HasName>(item: T): string {
return ${item.id}: ${item.name};
}

console.log(getLength('hello'), findById(users, '1'));

interface User {
id: string;
name: string;
age: number;
email: string;
}

// ─── The typed getter ────────────────────────
function getextends keyof T>(obj: T, key: K): T[K] {
return obj[key];
}

const user: User = { id: '1', name: 'Alice', age: 28, email: 'a@x.com' };

const n = get(user, 'name'); // n: string — exact type
const a = get(user, 'age'); // a: number — exact type
const e = get(user, 'email'); // e: string
// get(user, 'foo'); // ❌ 'foo' not a key of User

// ─── Pluck — pull a field from an array ──────
function pluckextends keyof T>(items: T[], key: K): T[K][] {
return items.map(item => item[key]);
}

const users: User[] = [
{ id: '1', name: 'Alice', age: 28, email: 'a@x.com' },
{ id: '2', name: 'Bob', age: 34, email: 'b@x.com' }
];

const names = pluck(users, 'name'); // string[]
const ages = pluck(users, 'age'); // number[]
// pluck(users, 'foo'); // ❌

// ─── Set a property by key ───────────────────
function setPropextends keyof T>(obj: T, key: K, value: T[K]): T {
return { ...obj, [key]: value };
}

const updated = setProp(user, 'name', 'Alicia'); // ✅ value must be string
// setProp(user, 'name', 42); // ❌ must be string
// setProp(user, 'age', 'x'); // ❌ must be number

// ─── Omit by key at runtime ──────────────────
function omitKeyextends keyof T>(obj: T, key: K): Omit {
const { [key]: _, ...rest } = obj;
return rest as Omit;
}

const noEmail = omitKey(user, 'email');
// noEmail: Omit = { id, name, age }

console.log(n, a, names, ages);

// ─── Constrain to primitives ─────────────────
type Sortable = string | number;

function sortArrayextends Sortable>(arr: T[]): T[] {
return [...arr].sort();
}

sortArray([3, 1, 2]); // ✅ number[]
sortArray(['c', 'a', 'b']); // ✅ string[]
// sortArray([{ id: 1 }]); // ❌ object not Sortable

// ─── Constrain to a literal union ────────────
type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE';

function requestextends HttpMethod>(url: string, method: M): void {
console.log(method, url);
}

request('/api/users', 'GET'); // ✅
request('/api/users', 'POST'); // ✅
// request('/api/users', 'PATCH'); // ❌ 'PATCH' not in HttpMethod

// ─── Constrain to "has callable method" ──────
function callItextends { (): void }>(fn: T): void {
fn(); // ✅ T is guaranteed callable
}

callIt(() => console.log('hi')); // ✅
// callIt('not a function'); // ❌

// ─── Constraint referencing another param ────
function hasKeyextends keyof T>(obj: T, key: K): boolean {
return key in obj;
}

// K's constraint depends on T — that's fine.
// TypeScript fills in T first, then constrains K.

const user = { id: '1', name: 'Alice' };
hasKey(user, 'name'); // ✅ K='name'
// hasKey(user, 'foo'); // ❌ 'foo' not a key

// ─── Constraints compose with utility types ──
function ensureIdextends { id?: string }>(obj: T): T & { id: string } {
return { ...obj, id: obj.id ?? crypto.randomUUID() };
}

const withId = ensureId({ name: 'x' });
// withId: { name: string; id: string }

console.log(sortArray([3, 1, 2]), withId);