Hard Challenges

Hard challenges push your understanding of TypeScript’s type system to advanced levels. You’ll implement complex parsers, framework patterns, and sophisticated type transformations.

Total Challenges: 56 | Recommended for: Advanced TypeScript developers with strong fundamentals

Challenge Categories

Framework Patterns (5 challenges)

#6 - Simple Vue

Vue-like type inference

#213 - Vue Basic Props

Vue props typing

#1290 - Pinia

State management typing

Type Parsers (8 challenges)

#147 - C-printf Parser

Parse printf format strings

#545 - printf

Full printf implementation

#2822 - Split

String splitting at type level

Advanced String Manipulation (12 challenges)

#114 - CamelCase

Convert to camelCase

#112 - Capitalize Words

Capitalize all words

#19458 - SnakeCase

Convert to snake_case

#1383 - Camelize

Deep object key camelization

All Hard Challenges

View Complete List (55 challenges)

#6 - Simple Vue
#17 - Currying 1
#55 - Union to Intersection
#57 - Get Required
#59 - Get Optional
#89 - Required Keys
#90 - Optional Keys
#112 - Capitalize Words
#114 - CamelCase
#147 - C-printf Parser
#213 - Vue Basic Props
#223 - IsAny
#270 - Typed Get
#300 - String to Number
#399 - Tuple Filter
#472 - Tuple to Enum Object
#545 - printf
#553 - Deep object to unique
#651 - Length of String 2
#730 - Union to Tuple
#847 - String Join
#956 - DeepPick
#1290 - Pinia
#1383 - Camelize
#2059 - Drop String
#2822 - Split
#2828 - ClassPublicKeys
#2857 - IsRequiredKey
#2949 - ObjectFromEntries
#3376 - InorderTraversal
#4037 - IsPalindrome
#5181 - Mutable Keys
#5423 - Intersection
#6141 - Binary to Decimal
#7258 - Object Key Paths
#8804 - Two Sum
#9155 - ValidDate
#9160 - Assign
#9384 - Maximum
#9775 - Capitalize Nest Object Keys
#13580 - Replace Union
#14080 - FizzBuzz
#14188 - Run-length encoding
#15260 - Tree path array
#19458 - SnakeCase
#25747 - IsNegativeNumber
#28143 - OptionalUndefined
#30178 - Unique Items
#30575 - BitwiseXOR
#31797 - Sudoku
#31824 - Length of String 3
#32427 - Unbox
#32532 - Binary Addition
#33763 - Union to Object from key
#34286 - Take Elements
#35314 - Valid Sudoku

Challenge yourself

Open Type Challenges playground

Featured Challenges

#6 - Simple Vue

Description

Implement a simplified version of Vue-like typing support. Provide proper type inference for this inside computed and methods.

Example

const instance = SimpleVue({
  data() {
    return {
      firstname: 'Type',
      lastname: 'Challenges',
      amount: 10,
    }
  },
  computed: {
    fullname() {
      return this.firstname + ' ' + this.lastname
    }
  },
  methods: {
    hi() {
      alert(this.fullname.toLowerCase())
    }
  }
})

Key Concepts

this type inference
Multiple context merging
Computed vs method return types

Try this challenge

Open in TypeScript Playground

#17 - Currying 1

Description

Implement the type for a curried function. The function should accept arguments one at a time and return another function until all arguments are provided.

Example

const add = (a: number) => (b: number) => (c: number) => a + b + c
const three = add(1)(2)(3) // 6

type Curried = Currying<typeof add>
// (a: number) => (b: number) => (c: number) => number

Key Concepts

Function type inference
Recursive function types
Parameter extraction

Try this challenge

Open in TypeScript Playground

#55 - Union to Intersection

Description

Implement a type that converts a union type to an intersection type.

Example

type Union = { a: string } | { b: number }
type Intersection = UnionToIntersection<Union>
// Result: { a: string } & { b: number }

Key Concepts

Contravariance in function parameters
Inference from function types
Advanced type manipulation

Try this challenge

Open in TypeScript Playground

#114 - CamelCase

Description

Implement CamelCase<T> that converts a string from kebab-case or snake_case to camelCase.

Example

type camelCase1 = CamelCase<'hello-world-foo-bar'> // 'helloWorldFooBar'
type camelCase2 = CamelCase<'user_id'> // 'userId'

Key Concepts

Complex template literal parsing
Character-by-character processing
State tracking in types

Try this challenge

Open in TypeScript Playground

#300 - String to Number

Description

Convert a string literal type to a number type.

Example

type Result1 = ToNumber<'42'> // 42
type Result2 = ToNumber<'0'> // 0
type Result3 = ToNumber<'123'> // 123

Key Concepts

Type-level string parsing
Accumulator pattern with tuples
Digit-by-digit processing

Try this challenge

Open in TypeScript Playground

#730 - Union to Tuple

Description

Convert a union type into a tuple type maintaining all members.

Example

type Union = 'a' | 'b' | 'c'
type Result = UnionToTuple<Union>
// ['a', 'b', 'c'] (order may vary)

Key Concepts

Union manipulation
Tuple accumulation
Advanced inference techniques

Try this challenge

Open in TypeScript Playground

Advanced Patterns

1. Contravariant Inference

Use function parameter contravariance for type transformations:

type UnionToIntersection<U> = (
  U extends any ? (x: U) => void : never
) extends (x: infer I) => void
  ? I
  : never

2. Complex String Parsing

Build state machines in the type system:

type CamelCase<S extends string> = S extends `${infer Head}-${infer Tail}`
  ? `${Head}${CamelCase<Capitalize<Tail>>}`
  : S extends `${infer Head}_${infer Tail}`
  ? `${Head}${CamelCase<Capitalize<Tail>>}`
  : S

3. Type-Level Arithmetic

Implement mathematical operations:

type StringToNumber<S extends string, Acc extends any[] = []> = 
  S extends `${Acc['length']}`
    ? Acc['length']
    : StringToNumber<S, [...Acc, any]>

4. Deep Object Transformation

Recursively transform nested structures:

type Camelize<T> = T extends any[]
  ? T
  : T extends object
  ? { [K in keyof T as CamelCase<K & string>]: Camelize<T[K]> }
  : T

5. Framework Type Patterns

Merge multiple type contexts:

type SimpleVue<D, C, M> = {
  data(): D
  computed: C & ThisType<D>
  methods: M & ThisType<D & MapComputed<C> & M>
}

Tips for Hard Challenges

Study TypeScript's variance

Understanding variance (especially contravariance) is crucial:

// Functions are contravariant in their parameter types
type Contra<T> = (x: T) => void
// This property is used in UnionToIntersection

Break down complex problems

Hard challenges often require multiple helper types:

// Main type
type CamelCase<S> = ...

// Helpers
type IsLowerCase<S> = ...
type CapitalizeAfterDelimiter<S> = ...
type RemoveDelimiters<S> = ...

Use ThisType for context inference

Framework patterns often need ThisType:

type Methods<T> = {
  [K: string]: (this: T, ...args: any[]) => any
} & ThisType<T>

Test incrementally

Build your solution step by step:

Handle the simplest case
Add one feature at a time
Test each addition
Refactor for edge cases

Study existing utility types

TypeScript’s built-in utilities use these patterns:

// Study how these work
type ReturnType<T> = ...
type Parameters<T> = ...
type ConstructorParameters<T> = ...

Understand type distribution

Control when unions distribute:

// Distributes
type Dist<T> = T extends any ? [T] : never

// Doesn't distribute
type NoDist<T> = [T] extends [any] ? [T] : never

Common Pitfalls

Infinite Type Instantiation: Recursive types without proper base cases can cause TypeScript to error. Always ensure recursion terminates.

Type Depth Limits: TypeScript has a maximum type instantiation depth. Very deep recursion may hit this limit.

Union Ordering: Union to Tuple conversions may produce different orders in different TypeScript versions.

Learning Path

Master Inference (17, 55, 270)

Start with advanced inference patterns

Object Key Utilities (57, 59, 89, 90)

Learn to extract and analyze object keys

String Parsers (114, 147, 300)

Build complex string manipulation types

Framework Patterns (6, 213, 1290)

Tackle real-world framework typing

Advanced Algorithms (730, 4037, 8804)

Implement sophisticated type-level algorithms

Next Steps

Ready for the ultimate challenge?

Extreme Challenges

17 challenges that push TypeScript to its limits

Advanced Types

TypeScript handbook on advanced types

Get Started

Challenges

Learning Resources

Guides

​Hard Challenges

​Challenge Categories

​Framework Patterns (5 challenges)

#6 - Simple Vue

#213 - Vue Basic Props

#1290 - Pinia

​Type Parsers (8 challenges)

#147 - C-printf Parser

#545 - printf

#2822 - Split

​Advanced String Manipulation (12 challenges)

#114 - CamelCase

#112 - Capitalize Words

#19458 - SnakeCase

#1383 - Camelize

​All Hard Challenges

Challenge yourself

​Featured Challenges

​Description

​Example

​Key Concepts

Try this challenge

​Description

​Example

​Key Concepts

Try this challenge

​Description

​Example

​Key Concepts

Try this challenge

​Description

​Example

​Key Concepts

Try this challenge

​Description

​Example

​Key Concepts

Try this challenge

​Description

​Example

​Key Concepts

Try this challenge

​Advanced Patterns

​1. Contravariant Inference

​2. Complex String Parsing

​3. Type-Level Arithmetic

​4. Deep Object Transformation

​5. Framework Type Patterns

​Tips for Hard Challenges

​Common Pitfalls

​Learning Path

​Next Steps

Extreme Challenges

Advanced Types

Build docs developers (and LLMs) love

Hard Challenges

Challenge Categories

Framework Patterns (5 challenges)

Type Parsers (8 challenges)

Advanced String Manipulation (12 challenges)

All Hard Challenges

Featured Challenges

Description

Example

Key Concepts

Description

Example

Key Concepts

Description

Example

Key Concepts

Description

Example

Key Concepts

Description

Example

Key Concepts

Description

Example

Key Concepts

Advanced Patterns

1. Contravariant Inference

2. Complex String Parsing

3. Type-Level Arithmetic

4. Deep Object Transformation

5. Framework Type Patterns

Tips for Hard Challenges

Common Pitfalls

Learning Path

Next Steps