Линзы и оптики (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 (незатронутые узлы сохранили ссылки)