Обмеження дженериків та теорія варіативності (Variance)

+-------------------------------------------------------------------------+
|                        ІЄРАРХІЯ ПІДТИПІВ (Subtyping)                    |
|                        Admin  <:  User  <:  Entity                      |
+-------------------------------------------------------------------------+
| 1. КОВАРІАНТНІСТЬ (out T) - Напрямок зберігається:                      |
|    Producer<Admin>       <:   Producer<User>      <:  Producer<Entity>  |
|    (Безпечно: читач User гарантовано отримає поля User)                 |
+-------------------------------------------------------------------------+
| 2. КОНТРАВАРІАНТНІСТЬ (in T) - Напрямок ОБЕРТАЄТЬСЯ:                    |
|    Consumer<Entity>      <:   Consumer<User>      <:  Consumer<Admin>   |
|    (Безпечно: обробник Entity готовий прийняти і User, і Admin)         |
+-------------------------------------------------------------------------+
| 3. ІНВАРІАНТНІСТЬ (in out T) - Приведення ЗАБОРОНЕНО:                   |
|    Box<Admin>            !=   Box<User>           !=  Box<Entity>       |
|    (Захист від мутацій: запис Entity в Box<Admin> зламав би типи)       |
+-------------------------------------------------------------------------+

export interface Entity {
  id: string;
}

export interface User extends Entity {
  email: string;
}

export interface Admin extends User {
  permissions: string[];
}

// Дженерик позначений анотацією 'out': T використовується тільки на вивід
export interface ReadonlyCollection<out T> {
  getById(id: string): T | undefined;
  getAll(): readonly T[];
}

declare let adminCollection: ReadonlyCollection<Admin>;
declare let userCollection: ReadonlyCollection<User>;

// КОВАРІАНТНІСТЬ: Admin <: User => ReadonlyCollection<Admin> <: ReadonlyCollection<User>
// Це повністю безпечно: будь-який метод повертає як мінімум поля User!
userCollection = adminCollection; // Валідно

const user = userCollection.getById("user-1");
if (user) {
  console.log(user.email); // Коректний доступ
}

import { Entity, User, Admin } from './covariance';

// Дженерик позначений анотацією 'in': T використовується тільки на вхід
export interface Serializer<in T> {
  serialize(data: T): string;
}

declare let entitySerializer: Serializer<Entity>;
declare let userSerializer: Serializer<User>;
declare let adminSerializer: Serializer<Admin>;

// КОНТРАВАРІАНТНІСТЬ: Entity <: User => Serializer<Entity> <: Serializer<User>
// Серіалізатор Entity вміє працювати з будь-яким Entity.
// Отже, йому можна безпечно передати User або Admin!
userSerializer = entitySerializer; // Валідно!

// Зворотне присвоювання НЕДОПУСТИМЕ і викличе помилку типів:
// entitySerializer = userSerializer; // Помилка TS2322!
// userSerializer очікує поля email, яких немає у базового Entity.

import { User, Admin } from './covariance';

export interface Storage<in out T> {
  read(id: string): T;
  write(item: T): void;
}

declare let adminStorage: Storage<Admin>;
declare let userStorage: Storage<User>;

// ІНВАРІАНТНІСТЬ: Присвоювання заборонено в обидва боки!
// userStorage = adminStorage; // Помилка TS2322!
// adminStorage = userStorage; // Помилка TS2322!

// ЧОМУ? Аналіз руйнування системи типів при гіпотетичному припущенні:
function unsafeDemonstration(store: Storage<User>, plainUser: User) {
  // Якби присвоювання 'userStorage = adminStorage' було валідним,
  // то через посилання userStorage ми змогли б записати звичайного User у сховище Admin!
  store.write(plainUser); 
  // Тепер adminStorage містить звичайного User, у якого відсутнє поле permissions.
  // При виклику adminStorage.read().permissions виник би runtime TypeError!
}

import { User, Admin } from './covariance';

// 1. Метод інтерфейсу: історично БІВАРІАНТНИЙ
interface EventListenerMethod<T> {
  handle(event: T): void;
}

// 2. Функціональна властивість: суворо КОНТРАВАРІАНТНА
interface EventListenerProperty<T> {
  handle: (event: T) => void;
}

declare let adminMethodListener: EventListenerMethod<Admin>;
declare let userMethodListener: EventListenerMethod<User>;

declare let adminPropListener: EventListenerProperty<Admin>;
declare let userPropListener: EventListenerProperty<User>;

// Методна біваріантність допускає небезпечне присвоювання:
adminMethodListener = userMethodListener; // Валідно (контраваріантно)
userMethodListener = adminMethodListener; // Валідно! (БІВАРІАНТНІСТЬ - потенційний runtime crash)

// Сувора функціональна властивість блокує небезпечне присвоювання:
adminPropListener = userPropListener; // Валідно (контраваріантно: User <: Admin)
// userPropListener = adminPropListener; // ПОМИЛКА TS2322! Заблоковано компілятором.