30970-medium-shitariteraru

Back 

// your answers
type IsUnion<T, O = T> = T extends any
  ? Equal<Exclude<O, T>, never> extends true
    ? false
    : true
  : false;
type String2Tuple<T> = T extends `${infer T}${infer R}`
  ? [T, ...String2Tuple<R>]
  : [T];
type IndexOf<T extends any[], U, C extends any[] = []> = T extends [
  infer F,
  ...infer R
]
  ? Equal<F, U> extends true
    ? C["length"]
    : IndexOf<R, U, [...C, any]>
  : -1;
type PrimitiveIndex<
  S extends string,
  T extends Primitive = Primitive
> = T extends any
  ? IndexOf<String2Tuple<S>, `${T}`> extends -1
    ? false
    : true
  : never;
type HasPrimitive<S extends string> = Equal<PrimitiveIndex<S>, boolean>;
type Primitive =
  | string
  | number
  | bigint
  | true
  | false
  | null
  | undefined
  | (string & {});
type IsFixedStringLiteralType<S extends string> = Equal<S, never> extends true
  ? false
  : IsUnion<S> extends true
  ? false
  : HasPrimitive<S> extends true
  ? false
  : true;

Solution by unixy24 #37977

type IsFixedStringLiteralType = {} extends Record<S, 1> ? false : Equal<[S], S extends unknown ? [S] : never>

Solution by mxniliuc #37549 

type IsFixedStringLiteralType<S extends string> = {} extends Record<S, 1>
  ? false
  : Equal<[S], S extends unknown ? [S] : never>

Solution by BruceYuj #35423 

type IsUnion<T, U = T> = [T] extends [never]
  ? false
  : T extends T
  ? [U] extends [T]
    ? false
    : true
  : never;

type IsFixedStringLiteralType<S extends string> = IsUnion<S> extends true
  ? false
  : { [P: string]: unknown } extends {
      [P in S]: unknown;
    }
  ? false
  : true;

Solution by yukicountry #34493 

type IsFixedStringLiteralType<S extends string> = {} extends Record<S, 1> ? false : Equal<[S], S extends unknown ? [S] : never>

Solution by ahmed-omegup #33984 

type IsNumOrBool<S extends string> = S extends `${infer _ extends number}${any}` ? true :
  S extends `${infer _ extends bigint}${any}` ? true :
    S extends `${infer F extends boolean}${any}` ? F extends true | false ? false : true : false

type IsConst<S extends string> = S extends '' ? true :
  IsNumOrBool<S> extends false ? S extends `${infer F}${infer Rest}` ? string extends F ?  false : `${string & {}}` extends F ? false : IsConst<Rest> : false : false

type IsUnion<S extends string, T = S> = S extends T ? [T] extends [S] ? false : true : never

type IsFixedStringLiteralType<S extends string> = [S] extends [never] ? false : IsUnion<S> extends false ? IsConst<S> : false

Solution by moonshadow-miao #33926 

type IsFixedStringLiteralType<S extends string>
  = {} extends {[K in S as [S] extends [K] ? K : never]: 1} ? false : true

Playground

image

Solution by teamchong #32985 

// your answers
import type { Equal, NotEqual } from '@type-challenges/utils'

type IsNever<T> = [T] extends [never] ? true : false;
type IsUnion<T> = NotEqual<[T] & T, (T extends T ? [T] : never) & T>;

type IsFixedStringLiteralType<S extends string> = true extends
  | IsNever<S>
  | IsUnion<S>
  | Equal<S, string>
  ? false
  : S extends `${infer First}${infer Rest}`
    ? true extends
      | Equal<First, string>
      | Equal<First, `${string & {}}`>
      | Equal<First, `${number}`>
      | Equal<First, `${number & {}}`>
      | Equal<First, `${bigint}`>
      | Equal<First, `${bigint & {}}`>
      | Equal<First, `${any}`>
      ? false
      : IsFixedStringLiteralType<Rest>
    : true;

Solution by wubrafiq807 #32614 

type IsUnion<T, U = T> = [T] extends [never] ? false : T extends T ? [U] extends [T] ? false : true : false

type IsEmbedded<T> = Equal<T, string> extends true
  ? true
  : Equal<T, `${bigint}`> extends true
    ? true
    : Equal<T, `${number}`> extends true
      ? true
      : Equal<T, `${boolean}`> extends true
        ? true
        : Equal<T, `${string & {}}`> extends true // Additional, `${number & {}}` etc.
          ? true
          : false

type IsFixedStringLiteralType<S extends string> =
  [S] extends [never]
    ? false // 1. never type
    : IsUnion<S> extends true
      ? false // 2. union
      : S extends `${infer F}${ infer Rest extends string}`
        ? IsEmbedded<F> extends true // 3. embedded types
          ? false
          : Rest extends ''
            ? true
            : IsFixedStringLiteralType<Rest>
        : false

Solution by lvjiaxuan #31978 

type SingleCheck<S> = S extends ''
  ? true
  : S extends `${infer C}${infer T}`
    ? '0' | '1' extends C
      ? false
      : SingleCheck<T>
    : false;

type IsFixedStringLiteralType<S extends string, T = S> = [S] extends [never]
  ? false
  : S extends unknown
    ? [T] extends [S]
      ? SingleCheck<S>
      : false
    : false;

Solution by alexandroppolus #31666 

import type { Equal, NotEqual } from '@type-challenges/utils'

type IsNever<T> = [T] extends [never] ? true : false;
type IsUnion<T> = NotEqual<[T] & T, (T extends T ? [T] : never) & T>;

type IsFixedStringLiteralType<S extends string> = true extends
  | IsNever<S>
  | IsUnion<S>
  | Equal<S, string>
  ? false
  : S extends `${infer First}${infer Rest}`
    ? true extends
      | Equal<First, string>
      | Equal<First, `${string & {}}`>
      | Equal<First, `${number}`>
      | Equal<First, `${number & {}}`>
      | Equal<First, `${bigint}`>
      | Equal<First, `${bigint & {}}`>
      | Equal<First, `${any}`>
      ? false
      : IsFixedStringLiteralType<Rest>
    : true;

Playground

Solution by sugoroku-y #31481