Лінзи та оптики (Optics/Lenses): типобезпечна імутабельність глибоких структур

// Крихке, громіздке ручне копіювання 4 рівнів вкладеності:
const nextState = {
  ...state,
  workspace: {
    ...state.workspace,
    project: {
      ...state.workspace.project,
      settings: {
        ...state.workspace.project.settings,
        theme: 'dark',
      },
    },
  },
};

+-------------------------------------------------------------------------+
|                  АРХІТЕКТУРА ФОКУСУВАННЯ ЧЕРЕЗ ЛІНЗИ                    |
+-------------------------------------------------------------------------+
| Вихідна глибока структура: S (RootState)                                |
+-------------------------------------------------------------------------+
       |
       | lensUser = prop('user')
       v
| Фокус: User                                                             |
       |
       | lensAddress = prop('address')
       v
| Фокус: Address                                                          |
       |
       | lensCity = prop('city')
       v
+-------------------------------------------------------------------------+
| Композитна лінза: cityLens = compose(lensUser, lensAddress, lensCity)   |
|                                                                         |
| |-- Читання: cityLens.get(state) -> 'Berlin'                            |
| `-- Запис:   cityLens.set('Munich')(state) -> Новий RootState           |
|              (Усі проміжні посилання оновлені імутабельно!)             |
+-------------------------------------------------------------------------+

Ієрархія функціональних оптик:
               +------------+
               |   Optic    |
               +------------+
               /            \
              v              v
      +------------+    +------------+
      |    Lens    |    |   Prism    |
      | (Рівно 1)  |    | (0 або 1)  |
      +------------+    +------------+
              \              /
               v            v
             +----------------+
             |   Traversal    |
             |  (Від 0 до N)  |
             +----------------+

/**
 * Контракт чистої функціональної лінзи.
 * S — тип вихідного об'єкта (Source).
 * A — тип внутрішнього цільового значення у фокусі (Target).
 */
export interface Lens<S, A> {
  readonly get: (source: S) => A;
  readonly set: (value: A) => (source: S) => S;
}

/**
 * Трансформація цільового значення через функцію-модифікатор.
 */
export function over<S, A>(lens: Lens<S, A>, fn: (val: A) => A): (source: S) => S {
  return (source: S) => lens.set(fn(lens.get(source)))(source);
}

/**
 * Створює лінзу, сфокусовану на конкретній властивості об'єкта.
 */
export function prop<S, K extends keyof S>(key: K): Lens<S, S[K]> {
  return {
    get: (source: S) => source[key],
    set: (value: S[K]) => (source: S) => {
      // Захист від зайвих алокацій: якщо значення не змінилося, повертаємо вихідний source
      if (Object.is(source[key], value)) {
        return source;
      }
      return {
        ...source,
        [key]: value,
      };
    },
  };
}

/**
 * Композиція двох лінз: Lens<A, B> + Lens<B, C> = Lens<A, C>
 */
export function compose<A, B, C>(lensAB: Lens<A, B>, lensBC: Lens<B, C>): Lens<A, C> {
  return {
    get: (source: A) => lensBC.get(lensAB.get(source)),
    set: (value: C) => (source: A) => {
      const currentB = lensAB.get(source);
      const nextB = lensBC.set(value)(currentB);
      return lensAB.set(nextB)(source);
    },
  };
}

export interface Prism<S, A> {
  readonly preview: (source: S) => A | undefined;
  readonly set: (value: A) => (source: S) => S;
}

/**
 * Створює призму для опціональної властивості об'єкта.
 */
export function optionalProp<S, K extends keyof S>(
  key: K
): Prism<S, NonNullable<S[K]>> {
  return {
    preview: (source: S) => {
      const val = source[key];
      return (val === null || val === undefined ? undefined : val) as NonNullable<S[K]>;
    },
    set: (value: NonNullable<S[K]>) => (source: S) => {
      if (source[key] === null || source[key] === undefined) {
        return source; // Цільовий вузол відсутній: повертаємо без змін
      }
      if (Object.is(source[key], value)) {
        return source;
      }
      return {
        ...source,
        [key]: value,
      };
    },
  };
}

import { prop, compose, over } from '../optics/lens';

export interface Address {
  readonly city: string;
  readonly zipCode: string;
}

export interface UserSettings {
  readonly theme: 'light' | 'dark';
  readonly address: Address;
}

export interface UserAccount {
  readonly id: string;
  readonly settings: UserSettings;
}

export interface RootAppState {
  readonly account: UserAccount;
  readonly version: number;
}

// 1. Оголошуємо атомарні перевикористовувані лінзи
export const accountLens = prop<RootAppState, 'account'>('account');
export const settingsLens = prop<UserAccount, 'settings'>('settings');
export const addressLens = prop<UserSettings, 'address'>('address');
export const cityLens = prop<Address, 'city'>('city');

// 2. Компонуємо шлях фокусу: RootAppState -> city
export const accountCityLens = compose(
  compose(accountLens, settingsLens),
  compose(addressLens, cityLens)
);

// 3. Тестовий стан застосунку
const initialState: RootAppState = {
  version: 1,
  account: {
    id: 'acc_777',
    settings: {
      theme: 'dark',
      address: {
        city: 'Hamburg',
        zipCode: '20095',
      },
    },
  },
};

// 4. Імутабельне зчитування:
const currentCity = accountCityLens.get(initialState); // 'Hamburg'

// 5. Імутабельна модифікація одним рядком:
const updatedState = accountCityLens.set('Munich')(initialState);

// 6. Модифікація через функцію over (переведення до верхнього регістру):
const capitalizedState = over(accountCityLens, (c) => c.toUpperCase())(initialState);

// Перевірка посилальної цілісності:
console.log(updatedState.account.settings.address.city); // 'Munich'
console.log(initialState.account.settings.address.city); // 'Hamburg' (вихідний стан не змінено!)
console.log(initialState.version === updatedState.version); // true (незаймані гілки зберегли посилання)