Challenge 3: Phantom Types vs. Branded Types Across Type-System Philosophies — Possible Solution
====================================================================

// Haskell is a NOMINAL type system -- two types are considered the
// same only if they were explicitly DECLARED as the same type,
// regardless of what data they actually contain. Because of this,
// Haskell can achieve type distinction using a phantom type parameter
// that is never even stored anywhere real -- `data Tagged tag a =
// Tagged a` -- since the type CHECKER tracks `tag` purely as part of
// the type's own name/identity, entirely separate from what data
// actually exists at runtime. The tag doesn't need to leave any
// runtime trace at all for the compiler to still tell two
// differently-tagged values apart, because nominal typing already
// treats "same shape, different declared type" as genuinely different
// types by definition.
//
// TypeScript, by contrast, is a STRUCTURAL type system -- two types
// are considered compatible if they have the same SHAPE (the same
// fields with the same types), regardless of how they were declared.
// This is exactly why ts4-5's own branded types need to ADD something
// real to the type's structure -- typically a fake, unused property
// like `{ __brand: "UserId" }` merged onto the underlying type -- since
// without some ACTUAL structural difference, TypeScript's own
// structural comparison would consider two same-shaped types
// (e.g. two branded numbers) fully interchangeable. The "brand" has to
// become part of the type's own STRUCTURE for TypeScript's structural
// comparison to have anything to distinguish.
//
// So the core idea -- add a compiler-only tag purely to prevent
// accidental mixing of otherwise-identical values -- is genuinely the
// same in both languages. But the MECHANISM each language needs to
// achieve it differs because of the underlying type-system philosophy:
// Haskell's nominal typing gets this almost for free, needing no real
// structural trace at all; TypeScript's structural typing has to
// simulate the same distinction by adding a genuine (if fake, unused)
// structural marker, since structural typing has no other way to tell
// two same-shaped types apart.

WHY THIS WORKS AS AN ANSWER
------------------------------
This correctly identifies WHY the mechanisms differ despite the
shared core idea -- Haskell's nominal typing needs no real structural
trace, while TypeScript's structural typing must add an actual (if
fake) structural marker -- directly addressing what the chapter's own
comparison names as a convergence across genuinely different type-
system philosophies.