Type hinting and Union Types

Type hinting and union types provide ways to specify expected data types, improving code readability and enabling early error detection. Their implementation varies significantly between dynamically typed languages (JavaScript, Python) and statically typed ones (Java, C#). 

1. Python

• Type Hinting: Introduced in Python 3.5 (PEP 484), type hints allow you to annotate variables and function signatures (e.g., def greet(name: str) -> str:).
• Union Types: These specify that a value can be one of several types.
  • Old Syntax: Union[int, str] (requires from typing import Union).
  • New Syntax (3.10+): Use the | operator, such as int | str.
• Enforcement: By default, Python's interpreter ignores these hints at runtime. They are primarily used by static analysis tools like mypy or IDEs to catch bugs. 

2. JavaScript (and TypeScript)

• Type Hinting: Standard JavaScript does not have native type hinting. Developers often use JSDoc comments (e.g., /** @type {string} */) to provide hints for editors like VS Code.
• TypeScript: Most "type hinting" in the JS ecosystem occurs via TypeScript, which adds a full static type system.
• Union Types: TypeScript uses the | symbol (e.g., string | number) to describe a value that can be one of several types.
• Enforcement: Like Python, these are removed during compilation and are not enforced by the JavaScript engine at runtime. 

3. C#

• Type Hinting: C# is statically typed, meaning types are usually mandatory and enforced by the compiler.
• Union Types: Traditionally, C# lacked native union types, forcing developers to use inheritance or discriminated union patterns with records.
• Upcoming Feature: Modern C# (previewed for C# 15) is introducing native union declarations using the union keyword, allowing a closed set of types that the compiler can exhaustively check in switch expressions. 

4. Java

• Type Hinting: Java requires explicit type declarations for all variables and method signatures (e.g., int count = 5;), which the compiler strictly enforces.
• Union Types: Java does not have native union types.
  • Workarounds: Developers simulate them using sealed classes or interfaces (introduced in Java 17) combined with pattern matching to handle different possible subtypes safely.
• Exception: The only native "union-like" behavior is in multi-catch blocks: catch (IOException | SQLException e). 

Comparison Summary

Language	Type Hinting Style	Union Type Support	Runtime Enforcement
Python	Optional annotations	int | str (3.10+)	No (Static only)
JavaScript	JSDoc (Native) / TS	string | number (TS)	No (Static only)
C#	Static & mandatory	union (Upcoming)	Yes (Compiler)
Java	Static & mandatory	Sealed classes (Simulated)	Yes (Compiler)