Skip to content
TheChatArchiveThe Chat Archive
DeepSeekdeepseek-v3.1· DeepSeekHugging 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. DeepSeek Assistant

    Оценка кода: 8/10

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

    1. Типовая безопасность - Отличное использование TypeScript generics и conditional types
    2. Гибкая архитектура - Поддерживает различные конфигурации вариантов (payload, forbidden, strictFields)
    3. Брендированные типы - Использование unique symbol для предотвращения подмены типов
    4. Валидация с guard-функциями - Поддержка кастомных валидаторов для payload
    5. Strict mode - Опция для проверки лишних полей
    6. Композиция - Генерация предикатов для каждого варианта
    7. Обработка ошибок - safeValidate защищает от исключений в guard-функциях

    Области для улучшения ⚡

    1. Документация - Не хватает JSDoc комментариев для сложных типов
    2. Производительность - Множественные проверки hasOwn могут быть оптимизированы
    3. Обработка edge cases - Нет проверки на циклические ссылки при strictFields
    4. Конфигурация - Можно добавить опцию для кастомного поля type (не только 'type')

    Пример улучшения:

    // Добавить JSDoc для сложных типов
    /**
     * Represents a refined result variant with validated payload
     */
    type Refined<V extends Variant, TPayloads extends Partial<Record<PayloadKeys<V>[number], unknown>> = {}> = 
      Extract<AnyResult, { type: V }> & Readonly<TPayloads>;
    

    Рекомендации:

    1. Добавить comprehensive тесты
    2. Рассмотреть использование Map для кэширования allowed fields
    3. Добавить опцию для кастомного naming convention предикатов

    Отличная работа! Код демонстрирует глубокое понимание TypeScript type system.

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