Демонстрация ковариантности и контравариантности через runtime примеры: безопасные и небезопасные замены типов

// Вариантность — теоретическая концепция TypeScript,
// но мы можем показать её принципы через runtime-примеры.

// Иерархия типов:
// Animal ← Dog ← GoldenRetriever

class Animal {
  constructor(name) {
    this.name = name
  }
  breathe() {
    return `${this.name} дышит`
  }
  toString() {
    return `Animal(${this.name})`
  }
}

class Dog extends Animal {
  bark() {
    return `${this.name} лает: Гав!`
  }
}

class GoldenRetriever extends Dog {
  fetch() {
    return `${this.name} принёс мяч!`
  }
}

class Cat extends Animal {
  meow() {
    return `${this.name} мяукает`
  }
}

// Ковариантность: Producer<Dog> совместим с Producer<Animal>
// Производители возвращают тип — можно идти "вверх по иерархии"

class DogProducer {
  produce() { return new Dog('Rex') }
}

class AnimalProducer {
  produce() { return new Animal('Generic') }
}

// В TypeScript: const p: Producer<Animal> = new DogProducer()  — OK (ковариантно)
function useAnimalProducer(producer) {
  const animal = producer.produce()
  // Мы ожидаем Animal — Dog тоже Animal, всё безопасно
  console.log(animal.breathe())
}

console.log('=== Ковариантность (Producer) ===')
useAnimalProducer(new AnimalProducer())  // OK — Animal
useAnimalProducer(new DogProducer())     // OK — Dog тоже Animal (ковариантно)

// Контравариантность: Consumer<Animal> совместим с Consumer<Dog>
// Потребители принимают тип — можно идти "вниз по иерархии"

const consumeAnimal = (animal) => {
  // Работает с любым Animal
  console.log(`Обработка животного: ${animal.breathe()}`)
}

const consumeDog = (dog) => {
  // Требует Dog — вызывает bark()
  console.log(`Обработка собаки: ${dog.bark()}`)
}

console.log('\n=== Контравариантность (Consumer) ===')
function useDogConsumer(consumer) {
  const dog = new Dog('Buddy')
  // Передаём Dog в consumer
  consumer(dog)
}

// Безопасно: consumeAnimal работает с любым Animal (в т.ч. Dog)
useDogConsumer(consumeAnimal)  // OK — контравариантно

// НЕБЕЗОПАСНО: consumeDog требует Dog.bark(), но может получить Cat
function useAnimalConsumer(consumer) {
  const cat = new Cat('Whiskers')
  // Опасность: если consumer ожидает Dog, а получает Cat — bark() не существует!
  try {
    consumer(cat)
  } catch (e) {
    console.log(`Ошибка контравариантности: ${e.message}`)
  }
}

console.log('\n=== Небезопасная замена (нарушение контравариантности) ===')
useAnimalConsumer(consumeDog)  // ОШИБКА: cat.bark не является функцией

// Инвариантность: Transformer<Dog> ≠ Transformer<Animal>
// Если тип и читается, и записывается — замена невозможна

class AnimalTransformer {
  transform(animal) {
    animal.isTransformed = true
    return animal
  }
}

class DogTransformer {
  transform(dog) {
    dog.isTransformed = true
    dog.bark()  // требует Dog!
    return dog
  }
}

console.log('\n=== Инвариантность (Transformer) ===')
const at = new AnimalTransformer()
const dog = new Dog('Max')
console.log(at.transform(dog).breathe())  // OK — принимает любой Animal

const dt = new DogTransformer()
try {
  const cat = new Cat('Felix')
  dt.transform(cat)  // Опасно — cat не имеет bark()
} catch (e) {
  console.log('Ошибка инвариантности:', e.message)
}

console.log('\n=== Безопасная цепочка (ковариантность функций) ===')
// Функция принимает широкий тип, возвращает узкий — безопасно
const animalToString = (a) => a.breathe()   // Animal → string
const dogToString    = (d) => d.bark()       // Dog → string

// map ковариантен по возвращаемому типу
const animals = [new Dog('Rex'), new GoldenRetriever('Buddy')]
console.log(animals.map(animalToString))  // OK — используем широкий предикат