TheInfoList

In
programming language A programming language is a formal language In logic, mathematics, computer science, and linguistics, a formal language consists of string (computer science), words whose symbol (formal), letters are taken from an alphabet (computer science) ...

s, a type system is a
logical system A formal system is an abstract structure used for inferring theorems from axioms according to a set of rules. These rules, which are used for carrying out the inference of theorems from axioms, are the logical calculus of the formal system. A form ...
comprising a set of rules that assigns a property called a
type Type may refer to: Science and technology Computing * Typing, producing text via a keyboard, typewriter, etc. * Data type, collection of values used for computations. * File type * TYPE (DOS command), a command to display contents of a file. * Type ...
to the various constructs of a
computer program In imperative programming, a computer program is a sequence of instructions in a programming language that a computer can execute or interpret. In declarative programming, a ''computer program'' is a Set (mathematics), set of instructions. A comp ...
, such as variables,
expressions Expression may refer to: Linguistics * Expression (linguistics), a word, phrase, or sentence * Fixed expression, a form of words with a specific meaning * Idiom, a type of fixed expression * Metaphor#Common types, Metaphorical expression, a parti ...
,
functions Function or functionality may refer to: Computing * Function key A function key is a key on a computer A computer is a machine that can be programmed to carry out sequences of arithmetic or logical operations automatically. Modern comp ...
or
modules Broadly speaking, modularity is the degree to which a system's components may be separated and recombined, often with the benefit of flexibility and variety in use. The concept of modularity is used primarily to reduce complexity by breaking a syst ...
. These types formalize and enforce the otherwise implicit categories the programmer uses for
algebraic data type In computer programming Computer programming is the process of designing and building an executable computer program to accomplish a specific computing result or to perform a particular task. Programming involves tasks such as analysis, gener ...
s, data structures, or other components (e.g. "string", "array of float", "function returning boolean"). The main purpose of a type system is to reduce possibilities for bugs in computer programs by defining
interfaces Interface or interfacing may refer to: Academic journals * Interface (journal), ''Interface'' (journal), by the Electrochemical Society * ''Interface, Journal of Applied Linguistics'', now merged with ''ITL International Journal of Applied Lin ...
between different parts of a computer program, and then checking that the parts have been connected in a consistent way. This checking can happen statically (at
compile time In computer science Computer science deals with the theoretical foundations of information, algorithms and the architectures of its computation as well as practical techniques for their application. Computer science is the study of co ...
), dynamically (at run time), or as a combination of both. Type systems have other purposes as well, such as expressing business rules, enabling certain
compiler optimization In computing Computing is any goal-oriented activity requiring, benefiting from, or creating computing machinery. It includes the study and experimentation of algorithmic processes and development of both computer hardware , hardware and softw ...
s, allowing for
multiple dispatch Multiple dispatch or multimethods is a feature of some programming language A programming language is a formal language In logic, mathematics, computer science, and linguistics, a formal language consists of string (computer science), words ...
, providing a form of documentation, etc. A type system associates a type with each computed value and, by examining the flow of these values, attempts to ensure or prove that no
type error In programming language A programming language is a formal language In logic, mathematics, computer science, and linguistics, a formal language consists of string (computer science), words whose symbol (formal), letters are taken from a ...
s can occur. The given type system in question determines what constitutes a type error, but in general, the aim is to prevent operations expecting a certain kind of value from being used with values for which that operation does not make sense (validity errors). Type systems are often specified as part of
programming language A programming language is a formal language In logic, mathematics, computer science, and linguistics, a formal language consists of string (computer science), words whose symbol (formal), letters are taken from an alphabet (computer science) ...

s and built into interpreters and compilers, although the type system of a language can be extended by optional tools that perform added checks using the language's original type syntax and grammar.

# Usage overview

An example of a simple type system is that of the
C language C (, as in the C, letter ''c'') is a General-purpose language, general-purpose, procedural programming, procedural computer programming language supporting structured programming, lexical variable scope, and Recursion (computer science), recurs ...
. The portions of a C program are the
function Function or functionality may refer to: Computing * Function key A function key is a key on a computer A computer is a machine that can be programmed to carry out sequences of arithmetic or logical operations automatically. Modern comp ...
definitions. One function is invoked by another function. The interface of a function states the name of the function and a list of parameters that are passed to the function's code. The code of an invoking function states the name of the invoked, along with the names of variables that hold values to pass to it. During execution, the values are placed into temporary storage, then execution jumps to the code of the invoked function. The invoked function's code accesses the values and makes use of them. If the instructions inside the function are written with the assumption of receiving an
integer An integer (from the Latin Latin (, or , ) is a classical language A classical language is a language A language is a structured system of communication Communication (from Latin ''communicare'', meaning "to share" or "to ...
value, but the calling code passed a floating-point value, then the wrong result will be computed by the invoked function. The C compiler checks the types of the arguments passed to a function when it is called against the types of the parameters declared in the function's definition. If the types do not match, the compiler throws a compile-time error. A
compiler In computing, a compiler is a computer program that Translator (computing), translates computer code written in one programming language (the ''source'' language) into another language (the ''target'' language). The name "compiler" is primarily ...

may also use the static type of a value to optimize the storage it needs and the choice of algorithms for operations on the value. In many C compilers the ''float''
data type In computer science Computer science deals with the theoretical foundations of information, algorithms and the architectures of its computation as well as practical techniques for their application. Computer science is the study of , ...
, for example, is represented in 32
bit The bit is a basic unit of information in computing Computing is any goal-oriented activity requiring, benefiting from, or creating computing machinery. It includes the study and experimentation of algorithm of an algorithm (Euclid's algo ...
s, in accord with the IEEE specification for single-precision floating point numbers. They will thus use floating-point-specific microprocessor operations on those values (floating-point addition, multiplication, etc.). The depth of type constraints and the manner of their evaluation affect the ''typing'' of the language. A
programming language A programming language is a formal language In logic, mathematics, computer science, and linguistics, a formal language consists of string (computer science), words whose symbol (formal), letters are taken from an alphabet (computer science) ...

may further associate an operation with various resolutions for each type, in the case of
type polymorphism In programming language A programming language is a formal language In logic, mathematics, computer science, and linguistics, a formal language consists of string (computer science), words whose symbol (formal), letters are taken from an a ...
.
Type theory In mathematics Mathematics (from Greek: ) includes the study of such topics as numbers ( and ), formulas and related structures (), shapes and spaces in which they are contained (), and quantities and their changes ( and ). There is no gene ...
is the study of type systems. The concrete types of some programming languages, such as integers and strings, depend on practical issues of computer architecture, compiler implementation, and language design.

# Fundamentals

Formally,
type theory In mathematics Mathematics (from Greek: ) includes the study of such topics as numbers ( and ), formulas and related structures (), shapes and spaces in which they are contained (), and quantities and their changes ( and ). There is no gene ...
studies type systems. A programming language must have the opportunity to type check using the ''type system'' whether at compile time or runtime, manually annotated or automatically inferred. As
Mark Manasse Mark may refer to: Currency * Bosnia and Herzegovina convertible mark The Bosnia and Herzegovina convertible mark (Bosnian Bosnian may refer to: *Anything related to the state of Bosnia and Herzegovina or its inhabitants *Anything related to Bo ...
concisely put it: Assigning a data type, termed ''typing'', gives meaning to a sequence of
bit The bit is a basic unit of information in computing Computing is any goal-oriented activity requiring, benefiting from, or creating computing machinery. It includes the study and experimentation of algorithm of an algorithm (Euclid's algo ...
s such as a value in
memory Memory is the faculty of the brain A brain is an organ Organ may refer to: Biology * Organ (anatomy) An organ is a group of Tissue (biology), tissues with similar functions. Plant life and animal life rely on many organs that co-exis ...
or some
object Object may refer to: General meanings * Object (philosophy) An object is a philosophy, philosophical term often used in contrast to the term ''Subject (philosophy), subject''. A subject is an observer and an object is a thing observed. For mo ...
such as a variable. The hardware of a general purpose computer is unable to discriminate between for example a
memory address In computing Computing is any goal-oriented activity requiring, benefiting from, or creating computing machinery. It includes the study and experimentation of algorithmic processes and development of both computer hardware , hardware and softwa ...
and an
instruction code In computing, an opcode (abbreviated from operation code, also known as instruction machine code, instruction code, instruction syllable, instruction parcel or opstring) is the portion of a machine code, machine language instruction (computer sci ...
, or between a
character Character(s) may refer to: Arts, entertainment, and media Literature * ''Character'' (novel), a 1936 Dutch novel by Ferdinand Bordewijk * ''Characters'' (Theophrastus), a classical Greek set of character sketches attributed to Theophrastus M ...
, an
integer An integer (from the Latin Latin (, or , ) is a classical language A classical language is a language A language is a structured system of communication Communication (from Latin ''communicare'', meaning "to share" or "to ...
, or a
floating-point number In computing, floating-point arithmetic (FP) is arithmetic using formulaic representation of real numbers as an approximation to support a trade-off between range and precision. For this reason, floating-point computation is often used in system ...
, because it makes no intrinsic distinction between any of the possible values that a sequence of bits might ''mean''. Associating a sequence of bits with a type conveys that
meaning Meaning most commonly refers to: * Meaning (linguistics), meaning which is communicated through the use of language * Meaning (philosophy), definition, elements, and types of meaning discussed in philosophy * Meaning (non-linguistic), a general ter ...
to the programmable hardware to form a ''
symbolic system In mathematics Mathematics (from Ancient Greek, Greek: ) includes the study of such topics as quantity (number theory), mathematical structure, structure (algebra), space (geometry), and calculus, change (mathematical analysis, analysis). I ...
'' composed of that hardware and some program. A program associates each value with at least one specific type, but it also can occur that one value is associated with many
subtype Subtype may refer to: * Viral subtypes, such as Subtypes of HIV One of the obstacles to treatment of the human immunodeficiency virus The human immunodeficiency viruses (HIV) are two species of ''Lentivirus ''Lentivirus'' is a genus ...
s. Other entities, such as
objects Object may refer to: General meanings * Object (philosophy) An object is a philosophy, philosophical term often used in contrast to the term ''Subject (philosophy), subject''. A subject is an observer and an object is a thing observed. For mo ...
,
modules Broadly speaking, modularity is the degree to which a system's components may be separated and recombined, often with the benefit of flexibility and variety in use. The concept of modularity is used primarily to reduce complexity by breaking a syst ...
, communication channels, and dependencies can become associated with a type. Even a type can become associated with a type. An implementation of a ''type system'' could in theory associate identifications called ''
data type In computer science Computer science deals with the theoretical foundations of information, algorithms and the architectures of its computation as well as practical techniques for their application. Computer science is the study of , ...
'' (a type of a value), ''
class Class or The Class may refer to: Common uses not otherwise categorized * Class (biology), a taxonomic rank * Class (knowledge representation), a collection of individuals or objects * Class (philosophy), an analytical concept used differently f ...
'' (a type of an object), and '' kind'' (a ''type of a type'', or metatype). These are the abstractions that typing can go through, on a hierarchy of levels contained in a system. When a programming language evolves a more elaborate type system, it gains a more finely grained rule set than basic type checking, but this comes at a price when the type inferences (and other properties) become undecidable, and when more attention must be paid by the programmer to annotate code or to consider computer-related operations and functioning. It is challenging to find a sufficiently expressive type system that satisfies all programming practices in a type safe manner. The more type restrictions that are imposed by the compiler, the more ''strongly typed'' a programming language is. Strongly-typed languages often require the programmer to make explicit conversions in contexts where an implicit conversion would cause no harm. Pascal's type system has been described as "too strong" because, for example, the size of an array or string is part of its type, making some programming tasks difficult. Haskell is also strongly typed but its types are automatically inferred so that explicit conversions are often unnecessary. A programming language compiler can also implement a ''
dependent type In computer science Computer science deals with the theoretical foundations of information, algorithms and the architectures of its computation as well as practical techniques for their application. Computer science is the study of Algori ...
'' or an ''
effect system In computing Computing is any goal-oriented activity requiring, benefiting from, or creating computing machinery. It includes the study and experimentation of algorithmic processes and development of both computer hardware , hardware and softwa ...
'', which enables even more program specifications to be verified by a type checker. Beyond simple value-type pairs, a virtual "region" of code is associated with an "effect" component describing ''what'' is being done ''with what'', and enabling for example to "throw" an error report. Thus the symbolic system may be a ''type and effect system'', which endows it with more safety checking than type checking alone. Whether automated by the compiler or specified by a programmer, a type system makes program behavior illegal if outside the type-system rules. Advantages provided by programmer-specified type systems include: * ''Abstraction'' (or ''modularity'') – Types enable programmers to think at a higher level than the bit or byte, not bothering with low-level implementation. For example, programmers can begin to think of a string as a set of character values instead of as a mere array of bytes. Higher still, types enable programmers to think about and express
interface Interface or interfacing may refer to: Academic journals * Interface (journal), ''Interface'' (journal), by the Electrochemical Society * ''Interface, Journal of Applied Linguistics'', now merged with ''ITL International Journal of Applied Li ...
s between two of ''any''-sized subsystems. This enables more levels of localization so that the definitions required for interoperability of the subsystems remain consistent when those two subsystems communicate. * ''Documentation'' – In more expressive type systems, types can serve as a form of
documentation Documentation is any communicable material that is used to describe, explain or instruct regarding some attributes of an object, system or procedure, such as its parts, assembly, installation, maintenance and use. Documentation can be provided ...

clarifying the intent of the programmer. For example, if a programmer declares a function as returning a timestamp type, this documents the function when the timestamp type can be explicitly declared deeper in the code to be an integer type. Advantages provided by compiler-specified type systems include: * ''Optimization'' – Static type-checking may provide useful compile-time information. For example, if a type requires that a value must align in memory at a multiple of four bytes, the compiler may be able to use more efficient machine instructions. * ''Safety'' – A type system enables the
compiler In computing, a compiler is a computer program that Translator (computing), translates computer code written in one programming language (the ''source'' language) into another language (the ''target'' language). The name "compiler" is primarily ...

to detect meaningless or invalid code. For example, we can identify an expression 3 / "Hello, World" as invalid, when the rules do not specify how to divide an
integer An integer (from the Latin Latin (, or , ) is a classical language A classical language is a language A language is a structured system of communication Communication (from Latin ''communicare'', meaning "to share" or "to ...
by a
string String or strings may refer to: *String (structure), a long flexible structure made from threads twisted together, which is used to tie, bind, or hang other objects Arts, entertainment, and media Films * Strings (1991 film), ''Strings'' (1991 fil ...
. Strong typing offers more safety, but cannot guarantee complete ''
type safety In computer science, type safety is the extent to which a programming language discourages or prevents type errors. A type error is erroneous program behaviour caused by a discrepancy between differing data types for the program's constants, variabl ...
''.

## Type errors

A type error is an unintended condition which might manifest in multiple stages of a program's development. Thus a facility for detection of the error is needed in the type system. In some languages, such as Haskell, for which
type inference Type inference refers to the automatic detection of the type Type may refer to: Science and technology Computing * Typing, producing text via a keyboard, typewriter, etc. * Data type, collection of values used for computations. * File type * TYPE ...
is automated, lint might be available to its compiler to aid in the detection of error. Type safety contributes to
program correctness In theoretical computer science Theoretical computer science (TCS) is a subset of general computer science Computer science deals with the theoretical foundations of information, algorithms and the architectures of its computation as we ...
, but might only guarantee correctness at the cost of making the type checking itself an
undecidable problem In computability theory Computability theory, also known as recursion theory, is a branch of mathematical logic Mathematical logic is the study of formal logic within mathematics. Major subareas include model theory, proof theory, set the ...
. In a ''type system'' with automated type checking a program may prove to run incorrectly yet produce no compiler errors.
Division by zero In mathematics Mathematics (from Greek: ) includes the study of such topics as numbers (arithmetic and number theory), formulas and related structures (algebra), shapes and spaces in which they are contained (geometry), and quantities a ...
is an unsafe and incorrect operation, but a type checker running at
compile time In computer science Computer science deals with the theoretical foundations of information, algorithms and the architectures of its computation as well as practical techniques for their application. Computer science is the study of co ...
only does not scan for division by zero in most languages, and then it is left as a
runtime error In computer science Computer science deals with the theoretical foundations of information, algorithms and the architectures of its computation as well as practical techniques for their application. Computer science is the study of Alg ...
. To prove the absence of these defects, other kinds of
formal method In computer science Computer science deals with the theoretical foundations of information, algorithms and the architectures of its computation as well as practical techniques for their application. Computer science is the study of compu ...
s, collectively known as program analyses, are in common use. Alternatively, a sufficiently expressive type system, such as in dependently-typed languages, can prevent these kinds of errors (for example, expressing ''the type of non-zero numbers''). In addition
software testing #REDIRECT Software testing#REDIRECT Software testing Software testing is an investigation conducted to provide stakeholders with information about the quality of the software product or service under test. Software testing can also provide an ob ...
is an
empirical Empirical evidence for a proposition In logic and linguistics, a proposition is the meaning of a declarative sentence (linguistics), sentence. In philosophy, "Meaning (philosophy), meaning" is understood to be a non-linguistic entity which is s ...
method for finding errors that the type checker cannot detect.

# Type checking

The process of verifying and enforcing the constraints of types—''type checking''—may occur at
compile time In computer science Computer science deals with the theoretical foundations of information, algorithms and the architectures of its computation as well as practical techniques for their application. Computer science is the study of co ...
(a static check) or at run-time. If a language specification requires its typing rules strongly (i.e., more or less allowing only those automatic
type conversion In computer science Computer science deals with the theoretical foundations of information, algorithms and the architectures of its computation as well as practical techniques for their application. Computer science is the study of co ...
s that do not lose information), one can refer to the process as ''strongly typed'', if not, as ''weakly typed''. The terms are not usually used in a strict sense.

## Static type checking

Static type checking is the process of verifying the
type safety In computer science, type safety is the extent to which a programming language discourages or prevents type errors. A type error is erroneous program behaviour caused by a discrepancy between differing data types for the program's constants, variabl ...
of a program based on analysis of a program's text (
source code In computing Computing is any goal-oriented activity requiring, benefiting from, or creating computing machinery. It includes the study and experimentation of algorithmic processes and development of both computer hardware , hardware and ...

). If a program passes a static type checker, then the program is guaranteed to satisfy some set of type safety properties for all possible inputs. Static type checking can be considered a limited form of
program verification In the context of hardware and software system A software system is a system of intercommunicating software component, components based on software forming part of a computer system (a combination of Computer hardware, hardware and software). It ...
(see
type safety In computer science, type safety is the extent to which a programming language discourages or prevents type errors. A type error is erroneous program behaviour caused by a discrepancy between differing data types for the program's constants, variabl ...
), and in a type-safe language, can be considered also an optimization. If a compiler can prove that a program is well-typed, then it does not need to emit dynamic safety checks, allowing the resulting compiled binary to run faster and to be smaller. Static type checking for
Turing-complete In computability theory Computability theory, also known as recursion theory, is a branch of mathematical logic Mathematical logic is the study of formal logic within mathematics. Major subareas include model theory, proof theory, set t ...
languages is inherently conservative. That is, if a type system is both ''sound'' (meaning that it rejects all incorrect programs) and ''decidable'' (meaning that it is possible to write an algorithm that determines whether a program is well-typed), then it must be ''incomplete'' (meaning there are correct programs, which are also rejected, even though they do not encounter runtime errors). For example, consider a program containing the code: :if then else  Even if the expression always evaluates to true at run-time, most type checkers will reject the program as ill-typed, because it is difficult (if not impossible) for a static analyzer to determine that the else branch will not be taken. Consequently, a static type checker will quickly detect type errors in rarely used code paths. Without static type checking, even
code coverage In computer science, test coverage is a measure (in percent) of the degree to which the source code of a computer program, program is executed when a particular test suite is run. A program with high test coverage has more of its source code execu ...
tests with 100% coverage may be unable to find such type errors. The tests may fail to detect such type errors, because the combination of all places where values are created and all places where a certain value is used must be taken into account. A number of useful and common programming language features cannot be checked statically, such as
downcasting In class-based programming, downcasting or type refinement is the act of type conversion, casting a reference of a base class to one of its derived classes. In many programming languages, it is possible to check through type introspection to dete ...
. Thus, many languages will have both static and dynamic type checking; the static type checker verifies what it can, and dynamic checks verify the rest. Many languages with static type checking provide a way to bypass the type checker. Some languages allow programmers to choose between static and dynamic type safety. For example, C# distinguishes between ''statically-typed'' and ''dynamically-typed'' variables. Uses of the former are checked statically, whereas uses of the latter are checked dynamically. Other languages allow writing code that is not type-safe; for example, in C, programmers can freely cast a value between any two types that have the same size, effectively subverting the type concept. For a list of languages with static type checking, see the category for statically-typed languages.

## Dynamic type checking and runtime type information

Dynamic type checking is the process of verifying the type safety of a program at runtime. Implementations of dynamically type-checked languages generally associate each runtime object with a ''type tag'' (i.e., a reference to a type) containing its type information. This runtime type information (RTTI) can also be used to implement
dynamic dispatch In computer science Computer science deals with the theoretical foundations of information, algorithms and the architectures of its computation as well as practical techniques for their application. Computer science is the study of co ...
,
late binding Late binding, dynamic binding, or dynamic linkage—though not an identical process to dynamically linking imported code libraries—is a computer programming mechanism in which the method being called upon an object, or the function being calle ...
,
downcasting In class-based programming, downcasting or type refinement is the act of type conversion, casting a reference of a base class to one of its derived classes. In many programming languages, it is possible to check through type introspection to dete ...
,
reflection Reflection or reflexion may refer to: Science and technology * Reflection (physics), a common wave phenomenon ** Specular reflection, reflection from a smooth surface *** Mirror image, a reflection in a mirror or in water ** Signal reflection, in s ...
, and similar features. Most type-safe languages include some form of dynamic type checking, even if they also have a static type checker. The reason for this is that many useful features or properties are difficult or impossible to verify statically. For example, suppose that a program defines two types, A and B, where B is a subtype of A. If the program tries to convert a value of type A to type B, which is known as
downcasting In class-based programming, downcasting or type refinement is the act of type conversion, casting a reference of a base class to one of its derived classes. In many programming languages, it is possible to check through type introspection to dete ...
, then the operation is legal only if the value being converted is actually a value of type B. Thus, a dynamic check is needed to verify that the operation is safe. This requirement is one of the criticisms of downcasting. By definition, dynamic type checking may cause a program to fail at runtime. In some programming languages, it is possible to anticipate and recover from these failures. In others, type-checking errors are considered fatal. Programming languages that include dynamic type checking but not static type checking are often called "dynamically-typed programming languages". For a list of such languages, see the category for dynamically-typed programming languages.

## Combining static and dynamic type checking

Some languages allow both static and dynamic typing. For example, Java and some other ostensibly statically-typed languages support
downcasting In class-based programming, downcasting or type refinement is the act of type conversion, casting a reference of a base class to one of its derived classes. In many programming languages, it is possible to check through type introspection to dete ...
types to their
subtypes In programming language theory Programming language theory (PLT) is a branch of computer science that deals with the design, implementation, analysis, characterization, and classification of formal languages known as programming languages and ...

, querying an object to discover its dynamic type and other type operations that depend on runtime type information. Another example is C++ RTTI. More generally, most programming languages include mechanisms for dispatching over different 'kinds' of data, such as
disjoint union In mathematics Mathematics (from Greek: ) includes the study of such topics as numbers (arithmetic and number theory), formulas and related structures (algebra), shapes and spaces in which they are contained (geometry), and quantities an ...

s, runtime polymorphism, and
variant type In computer science Computer science deals with the theoretical foundations of information, algorithms and the architectures of its computation as well as practical techniques for their application. Computer science is the study of compu ...
s. Even when not interacting with type annotations or type checking, such mechanisms are materially similar to dynamic typing implementations. See
programming language A programming language is a formal language In logic, mathematics, computer science, and linguistics, a formal language consists of string (computer science), words whose symbol (formal), letters are taken from an alphabet (computer science) ...

for more discussion of the interactions between static and dynamic typing. Objects in object-oriented languages are usually accessed by a reference whose static target type (or manifest type) is equal to either the object's run-time type (its latent type) or a supertype thereof. This is conformant with the
Liskov substitution principle The Liskov substitution principle (LSP) is a particular definition of a subtyping relation, called strong behavioral subtyping, that was initially introduced by Barbara Liskov Barbara Liskov (born November 7, 1939 as Barbara Jane Huberman) is ...
, which states that all operations performed on an instance of a given type can also be performed on an instance of a subtype. This concept is also known as subsumption or
subtype polymorphism In programming language theory Programming language theory (PLT) is a branch of computer science that deals with the design, implementation, analysis, characterization, and classification of formal languages known as programming languages and ...
. In some languages subtypes may also possess covariant or contravariant return types and argument types respectively. Certain languages, for example
Clojure Clojure (, like ''closure'') is a dynamic programming language, dynamic and functional programming, functional dialect (computing), dialect of the Lisp (programming language), Lisp programming language on the Java (software platform), Java plat ...
,
Common Lisp Common Lisp (CL) is a dialect of the Lisp programming language Lisp (historically LISP) is a family of programming language A programming language is a formal language In mathematics Mathematics (from Ancient Greek, Greek: ) incl ...
, or
Cython Cython is a programming language that aims to be a superset of the Python programming language, designed to give C (programming language), C-like performance with code that is written mostly in Python with optional additional C-inspired syntax. ...
are dynamically type checked by default, but allow programs to opt into static type checking by providing optional annotations. One reason to use such hints would be to optimize the performance of critical sections of a program. This is formalized by
gradual typing Gradual typing is a type system In programming language A programming language is a formal language In mathematics Mathematics (from Ancient Greek, Greek: ) includes the study of such topics as quantity (number theory), mathemat ...
. The programming environment '' DrRacket'', a pedagogic environment based on Lisp, and a precursor of the language is also soft-typed. Conversely, as of version 4.0, the C# language provides a way to indicate that a variable should not be statically type checked. A variable whose type is dynamic will not be subject to static type checking. Instead, the program relies on runtime type information to determine how the variable may be used. In
Rust Rust is an iron oxide, a usually reddish-brown oxide formed by the reaction of iron and oxygen in the catalytic presence of water or air moisture. Rust consists of hydrous ferric oxides, hydrous iron(III) oxides (Fe2O3·nH2O) and iron(III) oxi ...
, the type provides dynamic typing of types.

## Static and dynamic type checking in practice

The choice between static and dynamic typing requires certain
trade-off A trade-off (or tradeoff) is a situational decision that involves diminishing or losing one quality, quantity, or property of a set or design in return for gains in other aspects. In simple terms, a tradeoff is where one thing increases, and another ...
s. Static typing can find type errors reliably at compile time, which increases the reliability of the delivered program. However, programmers disagree over how commonly type errors occur, resulting in further disagreements over the proportion of those bugs that are coded that would be caught by appropriately representing the designed types in code. Static typing advocates believe programs are more reliable when they have been well type-checked, whereas dynamic-typing advocates point to distributed code that has proven reliable and to small bug databases. The value of static typing increases as the strength of the type system is increased. Advocates of
dependent typing In computer science and logic, a dependent type is a type whose definition depends on a value. It is an overlapping feature of type theory and type systems. In intuitionistic type theory, dependent types are used to encode logic's Generalized qua ...
, implemented in languages such as
Dependent ML Dependent ML is an experimental functional programming language proposed by Hongwei Xi and Frank Pfenning. Dependent ML extends ML programming language, ML by a restricted notion of dependent types: types may be dependent on static indices of typ ...
and
Epigram An epigram is a brief, interesting, memorable, and sometimes surprising or satirical statement. The word is derived from the Ancient Greek, Greek "inscription" from "to write on, to inscribe", and the literary device has been employed for o ...
, have suggested that almost all bugs can be considered type errors, if the types used in a program are properly declared by the programmer or correctly inferred by the compiler. Static typing usually results in compiled code that executes faster. When the compiler knows the exact data types that are in use (which is necessary for static verification, either through declaration or inference) it can produce optimized machine code. Some dynamically-typed languages such as
Common Lisp Common Lisp (CL) is a dialect of the Lisp programming language Lisp (historically LISP) is a family of programming language A programming language is a formal language In mathematics Mathematics (from Ancient Greek, Greek: ) incl ...
allow optional type declarations for optimization for this reason. By contrast, dynamic typing may allow compilers to run faster and
interpreters Interpreting is a Translation studies, translational activity in which one produces a first and final translation on the basis of a one-time exposure to an expression in a Source language (translation), source language. The most common two modes ...
to dynamically load new code, because changes to source code in dynamically-typed languages may result in less checking to perform and less code to revisit. This too may reduce the edit-compile-test-debug cycle. Statically-typed languages that lack
type inference Type inference refers to the automatic detection of the type Type may refer to: Science and technology Computing * Typing, producing text via a keyboard, typewriter, etc. * Data type, collection of values used for computations. * File type * TYPE ...
(such as C and
Java Java ( id, Jawa, ; jv, ꦗꦮ; su, ) is one of the Greater Sunda Islands in Indonesia. It is bordered by the Indian Ocean to the south and the Java Sea to the north. With a population of 147.7 million people, Java is the world's List of ...
prior to version 10) require that programmers declare the types that a method or function must use. This can serve as added program documentation, that is active and dynamic, instead of static. This allows a compiler to prevent it from drifting out of synchrony, and from being ignored by programmers. However, a language can be statically typed without requiring type declarations (examples include Haskell, Scala,
OCaml OCaml ( , formerly Objective Caml) is a general-purpose, multi-paradigm programming language Programming paradigms are a way to classify programming languages based on their features. Languages can be classified into multiple paradigms. S ...
, F#, and to a lesser extent C# and
C++ C, or c, is the third Letter (alphabet), letter in the English alphabet, English and ISO basic Latin alphabets. Its name in English is English alphabet#Letter names, ''cee'' (pronounced ), plural ''cees''. History "C" comes from the same ...

), so explicit type declaration is not a necessary requirement for static typing in all languages. Dynamic typing allows constructs that some (simple) static type checking would reject as illegal. For example, ''
eval In some programming language A programming language is a formal language In logic, mathematics, computer science, and linguistics, a formal language consists of string (computer science), words whose symbol (formal), letters are taken fro ...

'' functions, which execute arbitrary data as code, become possible. An ''eval'' function is possible with static typing, but requires advanced uses of
algebraic data types In computer programming Computer programming is the process of designing and building an executable computer program to accomplish a specific computing result or to perform a particular task. Programming involves tasks such as analysis, gener ...
. Further, dynamic typing better accommodates transitional code and prototyping, such as allowing a placeholder data structure (
mock object In object-oriented programming Object-oriented programming (OOP) is a programming paradigm Programming paradigms are a way to classify programming languages based on their features. Languages can be classified into multiple paradigms. ...
) to be transparently used in place of a full data structure (usually for the purposes of experimentation and testing). Dynamic typing typically allows
duck typing Duck typing in computer programming is an application of the duck test The duck test is a form of abductive reasoning Abductive reasoning (also called abduction,For example: abductive inference, or retroduction) is a form of logical inference ...
(which enables easier code reuse). Many languages with static typing also feature
duck typing Duck typing in computer programming is an application of the duck test The duck test is a form of abductive reasoning Abductive reasoning (also called abduction,For example: abductive inference, or retroduction) is a form of logical inference ...
or other mechanisms like
generic programming Generic programming is a style of computer programming Computer programming is the process of designing and building an executable computer program to accomplish a specific computing result or to perform a particular task. Programming invol ...
that also enable easier code reuse. Dynamic typing typically makes
metaprogramming Metaprogramming is a programming technique in which computer program In imperative programming, a computer program is a sequence of instructions in a programming language that a computer can execute or interpret. In declarative programming, a ...
easier to use. For example, C++ templates are typically more cumbersome to write than the equivalent
Ruby A ruby is a pink-ish red to blood-red colored gemstone A gemstone (also called a fine gem, jewel, precious stone, or semi-precious stone) is a piece of mineral In geology and mineralogy, a mineral or mineral species is, broadly spea ...
or
Python Python may refer to: * Pythonidae The Pythonidae, commonly known as pythons, are a family of nonvenomous snakes found in Africa, Asia, and Australia. Among its members are some of the largest snakes in the world. Ten genera and 42 species ...
code since
C++ C, or c, is the third Letter (alphabet), letter in the English alphabet, English and ISO basic Latin alphabets. Its name in English is English alphabet#Letter names, ''cee'' (pronounced ), plural ''cees''. History "C" comes from the same ...

has stronger rules regarding type definitions (for both functions and variables). This forces a developer to write more
boilerplate code In computer programming, boilerplate code or just boilerplate are sections of code that are repeated in multiple places with little to no variation. When using languages that are considered ''verbose'', the programmer must write a lot of code to a ...
for a template than a Python developer would need to. More advanced run-time constructs such as
metaclass In object-oriented programming, a metaclass is a Class (computer science), class whose instances are classes. Just as an ordinary class defines the behavior of certain objects, a metaclass defines the behavior of certain classes and their instance ...
es and
introspection Introspection is the examination of one's own conscious , an English Paracelsian Paracelsianism (also Paracelsism; German: ') was an early modern History of medicine, medical movement based on the theories and therapies of Paracelsus. It de ...
are often harder to use in statically-typed languages. In some languages, such features may also be used e.g. to generate new types and behaviors on the fly, based on run-time data. Such advanced constructs are often provided by
dynamic programming language In computer science Computer science deals with the theoretical foundations of information, algorithms and the architectures of its computation as well as practical techniques for their application. Computer science is the study of c ...
s; many of these are dynamically typed, although ''dynamic typing'' need not be related to ''dynamic programming languages''.

## Strong and weak type systems

Languages are often colloquially referred to as ''strongly typed'' or ''weakly typed''. In fact, there is no universally accepted definition of what these terms mean. In general, there are more precise terms to represent the differences between type systems that lead people to call them "strong" or "weak".

## Type safety and memory safety

A third way of categorizing the type system of a programming language is by the safety of typed operations and conversions. Computer scientists use the term ''type-safe language'' to describe languages that do not allow operations or conversions that violate the rules of the type system. Computer scientists use the term ''memory-safe language'' (or just ''safe language'') to describe languages that do not allow programs to access memory that has not been assigned for their use. For example, a memory-safe language will check array bounds, or else statically guarantee (i.e., at compile time before execution) that array accesses out of the array boundaries will cause compile-time and perhaps runtime errors. Consider the following program of a language that is both type-safe and memory-safe: var x := 5; var y := "37"; var z := x + y; In this example, the variable will have the value 42. Although this may not be what the programmer anticipated, it is a well-defined result. If were a different string, one that could not be converted to a number (e.g. "Hello World"), the result would be well-defined as well. Note that a program can be type-safe or memory-safe and still crash on an invalid operation. This is for languages where the type system is not sufficiently advanced to precisely specify the validity of operations on all possible operands. But if a program encounters an operation that is not type-safe, terminating the program is often the only option. Now consider a similar example in C: int x = 5; char y[] = "37"; char* z = x + y; printf("%c\n", *z); In this example will point to a memory address five characters beyond , equivalent to three characters after the terminating zero character of the string pointed to by . This is memory that the program is not expected to access. It may contain garbage data, and it certainly doesn't contain anything useful. As this example shows, C is neither a memory-safe nor a type-safe language. In general, type-safety and memory-safety go hand in hand. For example, a language that supports pointer arithmetic and number-to-pointer conversions (like C) is neither memory-safe nor type-safe, because it allows arbitrary memory to be accessed as if it were valid memory of any type. For more information, see
memory safety Memory safety is the state of being protected from various software bugs A software bug is an error, flaw or fault Fault commonly refers to: *Fault (geology), planar rock fractures showing evidence of relative movement *Fault (law), blamewor ...
.

## Variable levels of type checking

Some languages allow different levels of checking to apply to different regions of code. Examples include: * The use strict directive in
JavaScript JavaScript (), often abbreviated JS, is a programming language A programming language is a formal language In mathematics Mathematics (from Ancient Greek, Greek: ) includes the study of such topics as quantity (number theory), ma ...

and
Perl Perl is a family of two high-level High-level and low-level, as technical terms, are used to classify, describe and point to specific Objective (goal), goals of a systematic operation; and are applied in a wide range of contexts, such as, for ...
applies stronger checking. * The declare(strict_types=1) in
PHP PHP is a general-purpose scripting language A scripting language or script language is a programming language A programming language is a formal language comprising a Instruction set architecture, set of instructions that produce various k ...

on a per-file basis allows only a variable of exact type of the type declaration will be accepted, or a TypeError will be thrown. * The Option Strict On in
VB.NET Visual Basic, originally called Visual Basic .NET (VB.NET), is a multi-paradigm Programming paradigms are a way to classify programming languages based on their features. Languages can be classified into multiple paradigms. Some paradigm ...
allows the compiler to require a conversion between objects. Additional tools such as lint and
IBM Rational Purify PurifyPlus is a memory debugger program used by software developers to detect memory access errors in programs, especially those written in C (programming language), C or C++. It was originally written by Reed Hastings of Pure Software.
can also be used to achieve a higher level of strictness.

## Optional type systems

It has been proposed, chiefly by
Gilad Bracha Gilad Bracha is the creator of the Newspeak programming language, a software engineer A software engineer is a person who applies the principles of software engineering to the design, development, maintenance, testing, and evaluation of comput ...
, that the choice of type system be made independent of choice of language; that a type system should be a module that can be ''plugged'' into a language as needed. He believes this is advantageous, because what he calls mandatory type systems make languages less expressive and code more fragile. The requirement that the type system does not affect the semantics of the language is difficult to fulfill. Optional typing is related to, but distinct from,
gradual typing Gradual typing is a type system In programming language A programming language is a formal language In mathematics Mathematics (from Ancient Greek, Greek: ) includes the study of such topics as quantity (number theory), mathemat ...
. While both typing disciplines can be used to perform static analysis of code (
static typing In programming languages, a type system is a logical system comprising a set of rules that assigns a property called a type (computer science), type to the various constructs of a computer program, such as variable (computer science), variables ...
), optional type systems do not enforce type safety at runtime (
dynamic typing In programming language A programming language is a formal language In logic, mathematics, computer science, and linguistics, a formal language consists of string (computer science), words whose symbol (formal), letters are taken from a ...
).

# Polymorphism and types

The term ''polymorphism'' refers to the ability of code (especially, functions or classes) to act on values of multiple types, or to the ability of different instances of the same data structure to contain elements of different types. Type systems that allow polymorphism generally do so in order to improve the potential for code re-use: in a language with polymorphism, programmers need only implement a data structure such as a list or an
associative array In computer science Computer science deals with the theoretical foundations of information, algorithms and the architectures of its computation as well as practical techniques for their application. Computer science is the study of , ...
once, rather than once for each type of element with which they plan to use it. For this reason computer scientists sometimes call the use of certain forms of polymorphism ''
generic programming Generic programming is a style of computer programming Computer programming is the process of designing and building an executable computer program to accomplish a specific computing result or to perform a particular task. Programming invol ...
''. The type-theoretic foundations of polymorphism are closely related to those of
abstraction Abstraction in its main sense is a conceptual process where general rules Rule or ruling may refer to: Human activity * The exercise of political Politics (from , ) is the set of activities that are associated with Decision-making, mak ...
,
modularity Broadly speaking, modularity is the degree to which a system A system is a group of Interaction, interacting or interrelated elements that act according to a set of rules to form a unified whole. A system, surrounded and influenced by its ...
and (in some cases)
subtyping In programming language theory Programming language theory (PLT) is a branch of computer science Computer science deals with the theoretical foundations of information, algorithms and the architectures of its computation as well as pract ...
.

# Specialized type systems

Many type systems have been created that are specialized for use in certain environments with certain types of data, or for out-of-band
static program analysis Static program analysis is the analysis of computer software performed without executing any programs, in contrast with dynamic analysis, which is performed on programs during their execution. The term is usually applied to analysis performed ...
. Frequently, these are based on ideas from formal
type theory In mathematics Mathematics (from Greek: ) includes the study of such topics as numbers ( and ), formulas and related structures (), shapes and spaces in which they are contained (), and quantities and their changes ( and ). There is no gene ...
and are only available as part of prototype research systems. The following table gives an overview over type theoretic concepts that are used in specialized type systems. The names range over terms and the names $\sigma, \tau$ range over types. The notation

## Dependent types

Dependent type In computer science Computer science deals with the theoretical foundations of information, algorithms and the architectures of its computation as well as practical techniques for their application. Computer science is the study of comp ...
s are based on the idea of using scalars or values to more precisely describe the type of some other value. For example, $\mathrm\left(3, 3\right)$ might be the type of a $3 \times 3$ matrix. We can then define typing rules such as the following rule for matrix multiplication: : $\mathrm_ : \mathrm\left(k, m\right) \times \mathrm\left(m, n\right) \to \mathrm\left(k, n\right)$ where , , are arbitrary positive integer values. A variant of ML called
Dependent ML Dependent ML is an experimental functional programming language proposed by Hongwei Xi and Frank Pfenning. Dependent ML extends ML programming language, ML by a restricted notion of dependent types: types may be dependent on static indices of typ ...
has been created based on this type system, but because type checking for conventional dependent types is undecidable, not all programs using them can be type-checked without some kind of limits. Dependent ML limits the sort of equality it can decide to
Presburger arithmetic Presburger arithmetic is the first-order theory of the natural number In mathematics, the natural numbers are those numbers used for counting (as in "there are ''six'' coins on the table") and total order, ordering (as in "this is the ''thir ...
. Other languages such as
Epigram An epigram is a brief, interesting, memorable, and sometimes surprising or satirical statement. The word is derived from the Ancient Greek, Greek "inscription" from "to write on, to inscribe", and the literary device has been employed for o ...
make the value of all expressions in the language decidable so that type checking can be decidable. However, in general proof of decidability is undecidable, so many programs require hand-written annotations that may be very non-trivial. As this impedes the development process, many language implementations provide an easy way out in the form of an option to disable this condition. This, however, comes at the cost of making the type-checker run in an
infinite loop In computer programming Computer programming is the process of designing and building an executable computer program to accomplish a specific computing result or to perform a particular task. Programming involves tasks such as analysis, ge ...
when fed programs that do not type-check, causing the compilation to fail.

## Linear types

Linear type Substructural type systems are a family of type systems analogous to substructural logics where one or more of the structural rules are absent or only allowed under controlled circumstances. Such systems are useful for constraining access to syste ...
s, based on the theory of
linear logic Linear logic is a substructural logic In logic Logic (from Ancient Greek, Greek: grc, wikt:λογική, λογική, label=none, lit=possessed of reason, intellectual, dialectical, argumentative, translit=logikḗ)Also related to (''log ...
, and closely related to
uniqueness type In computing Computing is any goal-oriented activity requiring, benefiting from, or creating computing machinery. It includes the study and experimentation of algorithmic processes and development of both computer hardware , hardware and software ...
s, are types assigned to values having the property that they have one and only one reference to them at all times. These are valuable for describing large immutable values such as files, strings, and so on, because any operation that simultaneously destroys a linear object and creates a similar object (such as 'str= str + "a"') can be optimized "under the hood" into an in-place mutation. Normally this is not possible, as such mutations could cause side effects on parts of the program holding other references to the object, violating referential transparency. They are also used in the prototype operating system Singularity (operating system), Singularity for interprocess communication, statically ensuring that processes cannot share objects in shared memory in order to prevent race conditions. The Clean (programming language), Clean language (a Haskell-like language) uses this type system in order to gain a lot of speed (compared to performing a deep copy) while remaining safe.

## Intersection types

Intersection types are types describing values that belong to ''both'' of two other given types with overlapping value sets. For example, in most implementations of C the signed char has range -128 to 127 and the unsigned char has range 0 to 255, so the intersection type of these two types would have range 0 to 127. Such an intersection type could be safely passed into functions expecting ''either'' signed or unsigned chars, because it is compatible with both types. Intersection types are useful for describing overloaded function types: for example, if " → " is the type of functions taking an integer argument and returning an integer, and " → " is the type of functions taking a float argument and returning a float, then the intersection of these two types can be used to describe functions that do one or the other, based on what type of input they are given. Such a function could be passed into another function expecting an " → " function safely; it simply would not use the " → " functionality. In a subclassing hierarchy, the intersection of a type and an ancestor type (such as its parent) is the most derived type. The intersection of sibling types is empty. The Forsythe language includes a general implementation of intersection types. A restricted form is refinement types.

## Union types

Union types are types describing values that belong to ''either'' of two types. For example, in C, the signed char has a -128 to 127 range, and the unsigned char has a 0 to 255 range, so the union of these two types would have an overall "virtual" range of -128 to 255 that may be used partially depending on which union member is accessed. Any function handling this union type would have to deal with integers in this complete range. More generally, the only valid operations on a union type are operations that are valid on ''both'' types being unioned. C's "union" concept is similar to union types, but is not typesafe, as it permits operations that are valid on ''either'' type, rather than ''both''. Union types are important in program analysis, where they are used to represent symbolic values whose exact nature (e.g., value or type) is not known. In a subclassing hierarchy, the union of a type and an ancestor type (such as its parent) is the ancestor type. The union of sibling types is a subtype of their common ancestor (that is, all operations permitted on their common ancestor are permitted on the union type, but they may also have other valid operations in common).

## Existential types

Existential quantifier, Existential types are frequently used in connection with Record (computer science), record types to represent module (programming), modules and abstract data types, due to their ability to separate implementation from interface. For example, the type "T = ∃X " describes a module interface that has a data member named ''a'' of type ''X'' and a function named ''f'' that takes a parameter of the ''same'' type ''X'' and returns an integer. This could be implemented in different ways; for example: * intT = * floatT = These types are both subtypes of the more general existential type T and correspond to concrete implementation types, so any value of one of these types is a value of type T. Given a value "t" of type "T", we know that "t.f(t.a)" is well-typed, regardless of what the abstract type ''X'' is. This gives flexibility for choosing types suited to a particular implementation while clients that use only values of the interface type—the existential type—are isolated from these choices. In general it's impossible for the typechecker to infer which existential type a given module belongs to. In the above example intT could also have the type ∃X . The simplest solution is to annotate every module with its intended type, e.g.: * intT = as ∃X Although abstract data types and modules had been implemented in programming languages for quite some time, it wasn't until 1988 that John C. Mitchell and Gordon Plotkin established the formal theory under the slogan: "Abstract [data] types have existential type". The theory is a second-order typed lambda calculus similar to System F, but with existential instead of universal quantification.

Gradual typing is a type system in which variables may be assigned a type either at compile-time (which is static typing) or at Run time (program lifecycle phase), run-time (which is dynamic typing), allowing software developers to choose either type paradigm as appropriate, from within a single language. In particular, gradual typing uses a special type named ''dynamic'' to represent statically-unknown types, and gradual typing replaces the notion of type equality with a new relation called ''consistency'' that relates the dynamic type to every other type. The consistency relation is symmetric but not transitive.

# Explicit or implicit declaration and inference

Many static type systems, such as those of C and Java, require ''type declarations'': the programmer must explicitly associate each variable with a specific type. Others, such as Haskell's, perform ''
type inference Type inference refers to the automatic detection of the type Type may refer to: Science and technology Computing * Typing, producing text via a keyboard, typewriter, etc. * Data type, collection of values used for computations. * File type * TYPE ...
'': the compiler draws conclusions about the types of variables based on how programmers use those variables. For example, given a function that adds and together, the compiler can infer that and must be numbers—since addition is only defined for numbers. Thus, any call to elsewhere in the program that specifies a non-numeric type (such as a string or list) as an argument would signal an error. Numerical and string constants and expressions in code can and often do imply type in a particular context. For example, an expression might imply a type of floating-point, while might imply a list of integers—typically an array data structure, array. Type inference is in general possible, if it is Computable_function, computable in the type system in question. Moreover, even if inference is not computable in general for a given type system, inference is often possible for a large subset of real-world programs. Haskell's type system, a version of Type inference#Hindley–Milner type inference algorithm, Hindley–Milner, is a restriction of System F-omega, System Fω to so-called rank-1 polymorphic types, in which type inference is computable. Most Haskell compilers allow arbitrary-rank polymorphism as an extension, but this makes type inference not computable. (Type checking is decidability (logic), decidable, however, and rank-1 programs still have type inference; higher rank polymorphic programs are rejected unless given explicit type annotations.)

# Decision problems

A type system that assigns types to terms in type environments using type rule, type rules is naturally associated with the Decision_problem, decision problems of type checking, typability, and type inhabitation. * Given a type environment $\Gamma$, a term $e$, and a type $\tau$, decide whether the term $e$ can be assigned the type $\tau$ in the type environment. * Given a term $e$, decide whether there exists a type environment $\Gamma$ and a type $\tau$ such that the term $e$ can be assigned the type $\tau$ in the type environment $\Gamma$. * Given a type environment $\Gamma$ and a type $\tau$, decide whether there exists a term $e$ that can be assigned the type $\tau$ in the type environment.

# Unified type system

Some languages like C# or Scala have a unified type system. This means that all C# types including primitive types inherit from a single root object. Every type in C# inherits from the Object class. Some languages, like
Java Java ( id, Jawa, ; jv, ꦗꦮ; su, ) is one of the Greater Sunda Islands in Indonesia. It is bordered by the Indian Ocean to the south and the Java Sea to the north. With a population of 147.7 million people, Java is the world's List of ...
and Raku (programming language), Raku, have a root type but also have primitive types that are not objects. Java provides wrapper object types that exist together with the primitive types so developers can use either the wrapper object types or the simpler non-object primitive types. Raku automatically converts primitive types to objects when their methods are accessed.

# Compatibility: equivalence and subtyping

A type checker for a statically-typed language must verify that the type of any expression (programming), expression is consistent with the type expected by the context in which that expression appears. For example, in an assignment statement of the form x := ''e'', the inferred type of the expression ''e'' must be consistent with the declared or inferred type of the variable x. This notion of consistency, called ''compatibility'', is specific to each programming language. If the type of ''e'' and the type of x are the same, and assignment is allowed for that type, then this is a valid expression. Thus, in the simplest type systems, the question of whether two types are compatible reduces to that of whether they are ''equal'' (or ''equivalent''). Different languages, however, have different criteria for when two type expressions are understood to denote the same type. These different ''equational theories'' of types vary widely, two extreme cases being ''structural type systems'', in which any two types that describe values with the same structure are equivalent, and ''nominative type systems'', in which no two syntactically distinct type expressions denote the same type (''i.e.'', types must have the same "name" in order to be equal). In languages with
subtyping In programming language theory Programming language theory (PLT) is a branch of computer science Computer science deals with the theoretical foundations of information, algorithms and the architectures of its computation as well as pract ...
, the compatibility relation is more complex. In particular, if B is a subtype of A, then a value of type B can be used in a context where one of type A is expected (Covariance and contravariance (computer science), covariant), even if the reverse is not true. Like equivalence, the subtype relation is defined differently for each programming language, with many variations possible. The presence of parametric or ad hoc polymorphism (computer science), polymorphism in a language may also have implications for type compatibility.

* Comparison of type systems * Covariance and contravariance (computer science) * Polymorphism in object-oriented programming * Type rules * Type signature *
Type theory In mathematics Mathematics (from Greek: ) includes the study of such topics as numbers ( and ), formulas and related structures (), shapes and spaces in which they are contained (), and quantities and their changes ( and ). There is no gene ...