stronglytyped

Strongly typed describes a property of a programming language’s type system in which operations on values are restricted to those that are semantically consistent with their types. In a strongly typed language, type errors are typically caught either at compile time or at runtime, and many implicit type conversions are avoided or restricted. The goal is to prevent operations that could lead to type-related bugs by enforcing clear type distinctions.

Strong typing can be implemented statically or dynamically. Static strong typing checks types during compilation, as in Java, Rust, Go, and Haskell. Dynamic strong typing performs checks at runtime, as in Python and Ruby. The term is sometimes used loosely, since some languages mix strict type rules with limited forms of implicit conversion, while others prohibit most implicit conversions entirely.

Strong typing is often contrasted with weak typing, where the language permits more implicit coercions or reinterpretations of values across types. For example, in languages considered weakly typed, adding a number to a string might yield a coerced result rather than an error. However, the boundary is nuanced: dynamically typed languages can still enforce type discipline at runtime, while some statically typed languages allow explicit casts or conversions that bypass simple type checks.

Overall, strong typing emphasizes preventing operations on incompatible types and catching type errors early, contributing to type safety and program reliability. It does not by itself guarantee the absence of runtime failures, but it formalizes how types constrain program behavior.