Drop String

A type-level filter over characters: one recursion builds the drop set, another walks the string against it.

DropString<S, R> removes every character that appears in R from the string S. Two techniques carry the solution, and both show up all over advanced TypeScript: converting a string type into a union of its characters (a type-level set), and walking a string character by character while rebuilding it.

For example:

[object Object]

[object Object]

Detailed Explanation

Start with the finished types:

type StringToUnion<S extends string> =
  S extends `${infer Ch}${infer Rest}` ? Ch | StringToUnion<Rest> : never
 
type DropString<S extends string, R extends string> =
  S extends `${infer Ch}${infer Rest}`
    ? Ch extends StringToUnion<R>
      ? DropString<Rest, R>
      : `${Ch}${DropString<Rest, R>}`
    : ''

Two small recursive types cooperate: one turns the characters to drop into a set, the other filters the input against that set.

Sub-problem 1: StringToUnion, a string as a set of characters

To ask whether a character should be dropped you need R in a form you can test membership against. In the type system, that form is a union. StringToUnion peels characters off one at a time:

[object Object]

The pattern `${infer Ch}${infer Rest}` uses a key inference rule: when two infer placeholders are adjacent, the first matches exactly one character and the second takes the remainder. So 'but' splits into Ch = 'b', Rest = 'ut', and the result is 'b' | StringToUnion<'ut'>, unfolding to 'b' | 'u' | 't' | never. The trailing never comes from the base case (the empty string doesn't match the pattern), and never vanishes from any union it joins.

Two properties of unions make this the right representation:

• Membership testing is just X extends Union. No loops needed.
• Duplicates collapse automatically: StringToUnion<'tub'> and StringToUnion<'but'> are the same type, which is why the tests expect identical results for 'but' and 'tub'. Order and repetition in R are irrelevant.

Sub-problem 2: the filtering walk

DropString uses the same one-character split on S and makes a decision per character:

• Ch extends StringToUnion<R>: the character is in the drop set, so it contributes nothing. Recurse with DropString<Rest, R>.
• Otherwise it's kept: `${Ch}${DropString<Rest, R>}` glues the character onto the front of whatever the rest of the string produces.

Tracing DropString<'foobar!', 'fb'>:

// 'f' → in 'f' | 'b'  → dropped
// 'o' → not in set    → 'o' + ...
// 'o' → not in set    → 'o' + ...
// 'b' → in set        → dropped
// 'a' → 'a' + ...  'r' → 'r' + ...  '!' → '!' + ...
// ''  → base case     → ''
// result: 'ooar!'

The base case returns '', the identity element for string concatenation. Every kept character stacks on top of it.

The empty R edge case

The first test demands DropString<'butter fly!', ''> stay 'butter fly!'. It works without any special handling: StringToUnion<''> is never, and no concrete character satisfies Ch extends never, so every character is kept. This is a nice example of choosing a base case (never, the empty union) that makes the general logic degrade gracefully instead of needing a guard.

Other edge cases in the tests

• Whitespace is a character like any other: DropString<' b u t t e r f l y ! ', ' '> strips every space, producing 'butterfly!'.
• Dropping 'but' from ' b u t t e r f l y ! ' removes all occurrences of each character. Both ts go, not just the first, because the walk visits every character independently.
• Since only set membership matters, 'but' and 'tub' produce identical results, as noted above.

The broader lesson: when a type-level problem says "any of these characters", reach for a union as your set type and pair it with the adjacent-infer single-character walk. The same combination powers most other string-transformation challenges, from Trim to CamelCase.