Skip to content
TheChatArchiveThe Chat Archive
Claudeclaude-opus-4-1-20250805-thinking-16k· AnthropicHugging Face Arena Expert 5K

оцени (0/10) isResult v24 [code]

  1. User

    оцени (0/10)

    isResult v24

    function hasOwn<T extends object, K extends PropertyKey>(
      obj: T,
      key: K
    ): obj is T & Record<K, unknown> {
      return Object.prototype.hasOwnProperty.call(obj, key);
    }
    
    function isObject(x: unknown): x is Record<string, unknown> {
      return typeof x === 'object' && x !== null && !Array.isArray(x);
    }
    
    function safeValidate<T>(
      guard: (payload: unknown) => payload is T,
      value: unknown
    ): value is T {
      try {
        return guard(value);
      } catch {
        return false;
      }
    }
    
    export function createResultValidator<
      const TConfig extends Record<
        string,
        { payload: string | string[] | 'never'; forbidden: string; strictFields?: boolean }
      >
    >(variantMap: TConfig) {
      type Variant = keyof TConfig;
      type PayloadKeys<V extends Variant> = TConfig[V]['payload'] extends 'never'
        ? never[]
        : TConfig[V]['payload'] extends string
        ? [TConfig[V]['payload']]
        : TConfig[V]['payload'];
      type ForbiddenKey<V extends Variant> = TConfig[V]['forbidden'];
    
      declare const ResultBrand: unique symbol;
      type Brand<V extends Variant> = { readonly [ResultBrand]: V };
    
      type ResultShape<V extends Variant> = Brand<V> &
        Readonly<{ type: V }> &
        (TConfig[V]['payload'] extends 'never'
          ? {}
          : { [K in PayloadKeys<V>[number]]: unknown }) &
        Partial<Readonly<Record<ForbiddenKey<V>, never>>>;
    
      type AnyResult = { [V in Variant]: ResultShape<V> }[Variant];
    
      type Refined<V extends Variant, TPayloads extends Partial<Record<PayloadKeys<V>[number], unknown>> = {}> = Extract<
        AnyResult,
        { type: V }
      > &
        Readonly<TPayloads>;
    
      type ValidatorMap = Partial<{
        [V in Variant]: Partial<Record<PayloadKeys<V>[number], (payload: unknown) => payload is unknown>>;
      }>;
    
      type ValidatedResult<TValidators extends ValidatorMap> = {
        [V in keyof TValidators]: TValidators[V] extends infer TV
          ? TV extends Partial<Record<infer K, (p: unknown) => p is infer T>>
            ? Refined<Extract<V, Variant>, { [P in K]: T }>
            : never
          : never;
      }[keyof TValidators];
    
      function isResult<TValidators extends ValidatorMap>(
        x: unknown,
        validators: TValidators
      ): x is ValidatedResult<TValidators>;
      function isResult(x: unknown): x is AnyResult;
      function isResult(
        x: unknown,
        validators?: ValidatorMap
      ): x is AnyResult | ValidatedResult<ValidatorMap> {
        if (!isObject(x) || !hasOwn(x, 'type') || typeof x.type !== 'string') {
          return false;
        }
    
        const variant = x.type as Variant;
        if (!hasOwn(variantMap, variant)) {
          return false;
        }
    
        const config = variantMap[variant];
        const { payload, forbidden, strictFields = false } = config;
    
    
        if (hasOwn(x, forbidden)) return false;
    
        if (payload === 'never') {
          // Ничего не нужно
        } else if (typeof payload === 'string') {
          if (!hasOwn(x, payload)) return false;
          const validator = validators?.[variant]?.[payload];
          if (validator && !safeValidate(validator, x[payload])) return false;
        } else {
          // payload — массив
          for (const key of payload) {
            if (!hasOwn(x, key)) return false;
            const validator = validators?.[variant]?.[key];
            if (validator && !safeValidate(validator, x[key])) return false;
          }
        }
    
        if (strictFields) {
          const allowed = new Set(['type', forbidden]);
          if (payload !== 'never') {
            if (typeof payload === 'string') {
              allowed.add(payload);
            } else {
              payload.forEach((k) => allowed.add(k));
            }
          }
          for (const key in x) {
            if (!allowed.has(key)) return false;
          }
        }
    
        return true;
      }
    
      const variantPredicates = Object.fromEntries(
        (Object.keys(variantMap) as Variant[]).map((variant) => {
          const predicateName = `is${variant.charAt(0).toUpperCase()}${variant.slice(1)}`;
          const predicate = <TPayloads extends Partial<Record<PayloadKeys<typeof variant>[number], unknown>> = {}>(
            x: unknown,
            validators?: Partial<Record<PayloadKeys<typeof variant>[number], (payload: unknown) => payload is unknown>>
          ): x is Refined<typeof variant, TPayloads> => {
            return isResult(x, { [variant]: validators } as any) && x.type === variant;
          };
          return [predicateName, predicate];
        })
      ) as {
        [K in Variant as `is${Capitalize<K>}`]: <TPayloads extends Partial<
          Record<PayloadKeys<K>[number], unknown>
        > = {}>(
          x: unknown,
          validators?: Partial<Record<PayloadKeys<K>[number], (payload: unknown) => payload is unknown>>
        ) => x is Refined<K, TPayloads>;
      };
    
      return {
        isResult,
        ...variantPredicates,
        AnyResult,
        Refined,
      } as const;
    }
    
    export const { isResult, isOk, isErr } = createResultValidator({
      ok: { payload: 'value', forbidden: 'error' },
      err: { payload: 'error', forbidden: 'value' },
    } as const);
    
  2. Claude Assistant

    Оценка: 7/10

    Сильные стороны ✅

    1. Отличная типобезопасность

      • Брендированные типы для различения вариантов
      • Умное использование conditional и mapped types
      • Корректная работа с type guards
    2. Гибкая архитектура

      • Поддержка разных конфигураций payload
      • Автогенерация типизированных предикатов (isOk, isErr)
      • Возможность добавления кастомных валидаторов
    3. Безопасность

      • Object.prototype.hasOwnProperty.call для защиты от прототипов
      • safeValidate обрабатывает исключения
      • Правильная проверка объектов

    Проблемы ⚠️

    1. Критический баг в strictFields
    // Баг: forbidden добавляется как строка, а не исключается
    const allowed = new Set(['type', forbidden]); // ❌
    
    // Должно быть:
    const allowed = new Set(['type']); // ✅
    
    1. Избыточная сложность типов
    // Слишком сложно для понимания
    type ValidatedResult<TValidators extends ValidatorMap> = {
      [V in keyof TValidators]: TValidators[V] extends infer TV
        ? TV extends Partial<Record<infer K, (p: unknown) => p is infer T>>
          ? Refined<Extract<V, Variant>, { [P in K]: T }>
          : never
        : never;
    }[keyof TValidators];
    
    1. Производительность

      • Set создается на каждый вызов с strictFields
      • Множественные вызовы hasOwn
    2. Отсутствие валидации конфига

    // Нет проверки, что payload и forbidden не пересекаются
    createResultValidator({
      bad: { payload: 'data', forbidden: 'data' } // Должна быть ошибка
    });
    

    Предложения по улучшению

    // 1. Добавить валидацию конфига
    function validateConfig(config: TConfig) {
      for (const [variant, { payload, forbidden }] of Object.entries(config)) {
        const payloadKeys = payload === 'never' ? [] : 
          typeof payload === 'string' ? [payload] : payload;
        
        if (payloadKeys.includes(forbidden)) {
          throw new Error(`Conflict in ${variant}: ${forbidden} is both payload and forbidden`);
        }
      }
    }
    
    // 2. Оптимизировать strictFields
    const allowedFieldsCache = new WeakMap<object, Set<string>>();
    
    // 3. Добавить JSDoc
    /**
     * Creates a type-safe Result validator with custom variants
     * @example
     * const { isResult, isOk, isErr } = createResultValidator({
     *   ok: { payload: 'value', forbidden: 'error' },
     *   err: { payload: 'error', forbidden: 'value' }
     * });
     */
    

    Итог: Продвинутая реализация с впечатляющей типобезопасностью, но с критическим багом и излишней сложностью. Требует исправления бага и рефакторинга для лучшей поддерживаемости.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.