Data type

Primitive data types are typically types that are built-in or basic to a language implementation.

All data in computers based on digital electronics is represented as bits (alternatives 0 and 1) on the lowest level. The smallest addressable unit of data is usually a group of bits called a byte (usually an octet, which is 8 bits). The unit processed by machine code instructions is called a word (as of 2011, typically 32 or 64 bits). Most instructions interpret the word as a binary number, such that a 32-bit word can represent unsigned integer values from 0 to ${\displaystyle 2^{32}-1}$ or signed integer values from ${\displaystyle -2^{31}}$ to ${\displaystyle 2^{31}-1}$. Because of two's complement, the machine language and machine doesn't need to distinguish between these unsigned and signed data types for the most part.

Floating-point numbers used for floating-point arithmetic use a different interpretation of the bits in a word. See Floating-point arithmetic for details.

Machine data types need to be exposed or made available in systems or low-level programming languages, allowing fine-grained control over hardware. The C programming language, for instance, supplies integer types of various widths, such as short and long. If a corresponding native type does not exist on the target platform, the compiler will break them down into code using types that do exist. For instance, if a 32-bit integer is requested on a 16 bit platform, the compiler will tacitly treat it as an array of two 16 bit integers.

In higher level programming, machine data types are often hidden or abstracted as an implementation detail that would render code less portable if exposed. For instance, a generic numeric type might be supplied instead of integers of some specific bit-width.

The Boolean type represents the values true and false. Although only two values are possible, they are rarely implemented as a single binary digit for efficiency reasons. Many programming languages do not have an explicit Boolean type, instead interpreting (for instance) 0 as false and other values as true. Boolean data refers to the logical structure of how the language is interpreted to the machine language. In this case a Boolean 0 refers to the logic False. True is always a non zero, especially a one which is known as Boolean 1.

The enumerated type has distinct values, which can be compared and assigned, but which do not necessarily have any particular concrete representation in the computer's memory; compilers and interpreters can represent them arbitrarily. For example, the four suits in a deck of playing cards may be four enumerators named CLUB, DIAMOND, HEART, SPADE, belonging to an enumerated type named suit. If a variable V is declared having suit as its data type, one can assign any of those four values to it. Some implementations allow programmers to assign integer values to the enumeration values, or even treat them as type-equivalent to integers.

Such as:

• The integer data types, or "non-fractional numbers". May be sub-typed according to their ability to contain negative values (e.g. unsigned in C and C++). May also have a small number of predefined subtypes (such as short and long in C/C++); or allow users to freely define subranges such as 1..12 (e.g. Pascal/Ada).
• Floating point data types, usually represent values as high-precision fractional values (rational numbers, mathematically), but are sometimes misleadingly called reals (evocative of mathematical real numbers). They usually have predefined limits on both their maximum values and their precision. Typically stored internally in the form a × 2^b (where a and b are integers), but displayed in familiar decimal form.
• Fixed point data types are convenient for representing monetary values. They are often implemented internally as integers, leading to predefined limits.
• Bignum or arbitrary precision numeric types lack predefined limits. They are not primitive types, and are used sparingly for efficiency reasons.

Composite types are derived from more than one primitive type. This can be done in a number of ways. The ways they are combined are called data structures. Composing a primitive type into a compound type generally results in a new type, e.g. array-of-integer is a different type to integer.

• An array (also called vector, list, or sequence) stores a number of elements and provides random access to individual elements. The elements of an array are typically (but not in all contexts) required to be of the same type. Arrays may be fixed-length or expandable. Indices into an array are typically required to be integers (if not, one may stress this relaxation by speaking about an associative array) from a specific range (if not all indices in that range correspond to elements, it may be a sparse array).
• Record (also called tuple or struct) Records are among the simplest data structures. A record is a value that contains other values, typically in fixed number and sequence and typically indexed by names. The elements of records are usually called fields or members.
• Union. A union type definition will specify which of a number of permitted primitive types may be stored in its instances, e.g. "float or long integer". Contrast with a record, which could be defined to contain a float and an integer; whereas, in a union, there is only one type allowed at a time.
  • A tagged union (also called a variant, variant record, discriminated union, or disjoint union) contains an additional field indicating its current type for enhanced type safety.
• A set is an abstract data structure that can store certain values, without any particular order, and no repeated values. Values themselves are not retrieved from sets, rather one tests a value for membership to obtain a boolean "in" or "not in".
• An object contains a number of data fields, like a record, and also a number of subroutines for accessing or modifying them, called methods.

Strings are a sequence of characters used to store words or plain text, most often textual markup languages representing formatted text. Characters may be a letter of some alphabet, a digit, a blank space, a punctuation mark, etc. Character are drawn from a character set such as ASCII. Character and string types can have different subtypes according to the character encoding. The original 7-bit wide ASCII was found to be limited, and superseded by 8, 16 and 32-bit sets, which can encode a wide variety of non-Latin alphabets (such as Hebrew and Chinese) and other symbols. Strings may be of either variable length or fixed length, and some programming languages have both types. They may also be subtyped by their maximum size.

Since most character sets include the digits, it is possible to have a numeric string, such as "1234". These numeric strings are usually considered distinct from numeric values such as 1234, although some languages automatically convert between them.

Many other types are possible, but they tend to be further variations and compounds of the above. In particular, if a field of a record can be a pointer to another record, then quite complicated types can be constructed. Arbitrary use of pointers in a data structure can cause just as much confusion as arbitrary jumps in program code.

For example, a linked list can store the same data as an array, but provides sequential access rather than random and is built up of records in dynamic memory. Such a linked list can be used to represent a queue. Another frequently used type is a binary tree, which can allow quite fast searching. A stack can be implemented using either a list or an array, and can be used in dealing with Last-In-First-Out situations.

Any data type that does not specify the concrete representation of the data is an abstract data type. Instead, a formal specification based on the data type's operations is used to describe it. Any implementation of a specification must fulfill the rules given. Abstract data types are used in formal semantics and program verification and, less strictly, in design.

Beyond verification, a specification might immediately be turned into an implementation. The OBJ family of programming languages for instance bases on this option using equations for specification and rewriting to run them. Algebraic specification[3] was an important subject of research in CS around 1980 and almost a synonym for abstract data types at that time. It has a mathematical foundation in Universal algebra.[4] The specification language can be made more expressive by allowing other formulas than only equations.

A typical example is the Boom hierarchy of the binary tree, list, bag and set data types.[5] All these data types can be declared by three operations: null, which constructs the empty container, single, which constructs a container from a single element and append, which combines two containers of the same type. The complete specification for the four data types can then be given by successively adding the following rules over these operations:

Access to the data can be specified by pattern-matching over the three operations, e.g. a member function for these containers by:

Care must be taken to ensure that the function is invariant under the relevant rules for the data type.

Types can be based on, or derived from, the basic types explained above. In some languages, such as C, functions have a type derived from the type of their return value.

The main non-composite, derived type is the pointer, a data type whose value refers directly to (or "points to") another value stored elsewhere in the computer memory using its address. It is a primitive kind of reference. (In everyday terms, a page number in a book could be considered a piece of data that refers to another one). Pointers are often stored in a format similar to an integer; however, attempting to dereference or "look up" a pointer whose value was never a valid memory address would cause a program to crash. To ameliorate this potential problem, pointers are considered a separate type to the type of data they point to, even if the underlying representation is the same.

While functions can be assigned a type, too, their type is not considered a data type in the setting of this article. Here, data is viewed as being distinct from algorithms. In programming, functions are strongly related to the latter. But, because a central tenet of universal data processing is that algorithms can be represented as data, e.g., textual description and binary programs, the contrast between data and functions has limits. In fact, not only can functions be represented by data, but functions can also be used to encode data. Many contemporary type systems focus strongly on function types and many modern languages allow functions to operate as first-class citizens.

To exclude functions from the being treated as data types is not uncommon in related fields. Predicate logic for instance does not allow the application of quantifiers on function or predicate names.

Some programming languages represent the type information as data, enabling type introspection and reflection. In contrast, higher order type systems, while allowing types to be constructed from other types and passed to functions as values, typically avoid basing computational decisions on them.

For convenience, high-level languages and databases may supply ready-made "real world" data types, for instance times, dates, and monetary values (currency).[6][7] These may be built-in to the language or implemented as composite types in a library.[8]