Typsystems

Type systems are formal frameworks in programming languages that assign types to values and expressions and enforce rules about how those values can be used. They aim to prevent certain kinds of errors, document intent, and sometimes enable optimizations and safer interfaces. A type system typically includes rules for composing values, function application, and data structures, and a mechanism for checking or inferring types.

Static versus dynamic: static type systems decide types at compile time; dynamic type systems decide at run time. Some languages mix both (gradual typing). Strong versus weak: strong systems restrict implicit conversions; weak systems permit more ad hoc coercions. Nominal versus structural typing describes how type compatibility is determined: nominal uses declared names and declared relationships; structural (aka duck typing) uses the actual shape of types.

Subtyping and polymorphism: subtyping allows a value of a subtype to be used where a supertype is expected. Parametric polymorphism (generics) enables writing code that works for any type; ad-hoc polymorphism (interfaces, type classes) enables operations that depend on the type.

Type inference can deduce types automatically, reducing annotations, as in ML or Haskell. Dependent types generalize type systems by letting types depend on values, increasing expressiveness and complexity. Gradual typing blends static and dynamic checks to ease migration.

Languages illustrate the spectrum: Java, C, C++, C#, and TypeScript feature static types with varying degrees of type inference; Python and Ruby are dynamically typed; Haskell and OCaml are statically typed with strong type systems; Rust emphasizes safety, ownership, and lifetime tracking.

Ultimately, a well-designed type system balances safety and expressiveness, providing guarantees about program behavior while remaining practical for developers.