Explain structural typing.

Structural typing is a core concept in TypeScript that determines type compatibility based on the 'shape' or 'structure' of an object, rather than its declared name. It's often referred to as 'duck typing' because if two types have compatible members, they are considered compatible, regardless of their nominal relationship.

What is Structural Typing?

In a structural type system, the compatibility of types is determined by their members (properties and methods) rather than by explicit declarations or inheritance hierarchies. If Type A has all the required properties and methods of Type B, then Type A is considered compatible with Type B.

This contrasts sharply with nominal typing (found in languages like Java or C#), where two types are considered compatible only if they have the same name, are explicitly related through inheritance, or implement the same interface by name.

The 'Duck Typing' Principle

Structural typing is often summarized by the 'duck typing' adage: 'If it walks like a duck and quacks like a duck, then it's a duck.' In TypeScript, this means if an object has the same properties and methods as a target type, it can be used where that target type is expected, even if there's no explicit declaration linking them.

TypeScript performs a property-by-property check. For a type 'X' to be assignable to a type 'Y', 'Y' must have a subset of 'X's properties. In other words, 'X' must have at least all the properties of 'Y', and those properties must be compatible (same name, same type). Extra properties in 'X' are generally ignored.

Illustrative Example

interface Point2D {
  x: number;
  y: number;
}

interface Point3D {
  x: number;
  y: number;
  z: number;
}

let p2d: Point2D = { x: 0, y: 1 };
let p3d: Point3D = { x: 5, y: 10, z: 15 };

// Structural typing in action:
// p3d has all the properties of Point2D (x, y) with compatible types.
// The 'z' property is ignored for compatibility with Point2D.
p2d = p3d; // This is allowed!

console.log(p2d); // Output: { x: 5, y: 10 } (p2d now refers to p3d's structure)

// Conversely, this is NOT allowed because p2d lacks the 'z' property.
// p3d = p2d; // Error: Property 'z' is missing in type 'Point2D' but required in type 'Point3D'.

interface Named {
  name: string;
}

class Person {
  name: string;
  age: number;

  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }
}

let namedItem: Named = new Person("Alice", 30);
console.log(namedItem.name); // Output: Alice

In the example, an object of type Point3D can be assigned to a variable of type Point2D because Point3D structurally satisfies the Point2D interface (it has x and y properties of type number). The extra z property in Point3D is simply ignored. Similarly, an instance of the Person class can be assigned to a variable of type Named because it possesses the name property required by Named.

Key Characteristics

• Compatibility based on member presence and type, not declaration name.
• Extra properties in the source type are generally allowed when assigning to a target type with fewer properties.
• Missing properties in the source type (that are required by the target type) result in a type error.
• Function compatibility is based on parameter types and return types; parameters are checked contravariantly, return types covariantly.

Benefits

• Seamless JavaScript Interoperability: TypeScript can easily work with existing JavaScript libraries and patterns that often rely on implicit interfaces.
• Flexibility: It allows for more flexible code design where types don't need to be explicitly related through extends or implements keywords.
• Refactoring Safety: Changes to an interface or class automatically propagate compatibility checks without needing to update every class that 'implements' it by name.
• Gradual Typing: Facilitates a smoother transition from untyped JavaScript to typed TypeScript.

Considerations

• Accidental Compatibility: Two entirely unrelated types might coincidentally have the same structure, leading to unintended assignments that compile but might cause logical errors at runtime.
• Debugging Complexity: In large codebases, it can sometimes be less obvious why two types are considered compatible or incompatible, as the relationship isn't always explicitly declared.
• Security Concerns (rare): In specific scenarios, if an object with sensitive internal properties accidentally matches the structure of a public interface, it could expose data.

Structural typing is a powerful feature that makes TypeScript highly adaptable and integrates well with JavaScript's dynamic nature, enabling developers to write more robust and maintainable code without sacrificing flexibility.