Types

Using the operator :: you can add type annotations to expressions and variables in the code. There may be two main reasons for this:

When added to an expression intended for calculating a value, the operator :: means "is an instance of the type". Thus, he claims that the value of the expression on the left side is an instance of the type on the right. If the type on the right is specific, the value on the left must be implemented by that type. Recall that all concrete types are finite, so an implementation of a type cannot be a subtype of another implementation. If the type on the right is abstract, it is sufficient that the value is implemented by a specific type, which is a subtype of this abstract type. If the type statement is not true, an exception is thrown; otherwise, the value of the expression on the left is returned.

This allows you to add a type statement to any expression in place.

When added to a variable on the left side of an assignment or as part of a local declaration, the :: operator has a slightly different meaning: it declares that the variable always has the specified type, similar to type declarations in statically typed languages such as C. Any value assigned to a variable is converted to the declared type using the function convert.

This application allows you to avoid performance problems as a result of assigning a variable of an unexpected type.

This option (type declaration) is used only in certain situations.:

and it applies to the entire current area even before the announcement.

Starting with Julia 1.8, type declarations can be used in the global scope, meaning that type annotations can be added to global variables so that they can be accessed in a type-stable manner.

Declarations can also be applied to function definitions.

When this function returns a value, the same thing happens as when assigning a value to a variable with a declared type: the value is always converted to the Float64 type.

Abstract types do not allow instantiation, but simply serve as nodes in the type graph, describing sets of related concrete types - types that are descendants of this abstract type. Although abstract types do not involve instantiation, we will start with them, since they are the backbone of the type system. They form a conceptual hierarchy, thanks to which the Julia type system is more than just a set of object implementations.

As you may remember, in the chapter Integers and floating point numbers various specific types of numeric values were introduced: Int8, UInt8, Int16, UInt16, Int32, UInt32, Int64, UInt64, Int128, UInt128, Float16, Float32 and Float64. Although the types Int8, Int16, Int32, Int64 and Int128 have different representation sizes, what unites them is that they are all signed integer types. In turn, UInt8, UInt16, UInt32, UInt64 and UInt128 are unsigned integer types, while Float16, Float32 and Float64 are floating-point types. Often, in a certain part of the code, it may be important that the arguments are, for example, some integers, but it doesn’t matter which ones are named. So, the algorithm for finding the greatest common divisor will work with any integers, but not with floating-point numbers. Abstract types allow you to build a hierarchy of types into which specific types fit. For example, it makes it easy to write an algorithm that will work with any integer type without restrictions.

Abstract types are declared using a keyword abstract type. The standard syntactic constructions for declaring an abstract type look like this:

The keyword abstract type introduces a new abstract type named "name". After this name, you can specify <: and any existing type. This means that the abstract type being declared is a subtype of this parent type.

If no supertype is specified, by default it is Any — a predefined abstract type, of which all objects are instances, and all other types are subtypes. In type theory, the type Any is usually called the highest type because it is located at the very top of the type graph. Julia also has a predefined abstract base type, which is located at the lowest point of the type graph. It is written as Union{}. Этот тип является прямой противоположностью типу Any: ни один объект не является экземпляром Union{}, and all types are supertypes of `Union{}'.

Let’s consider a number of abstract types that make up the Julia numeric type hierarchy.

Type Number is a direct descendant of type Any', and `Real is its descendant. In turn, the Real has two descendants (actually there are more of them, but only two are presented here; we will return to the rest later). Integer and AbstractFloat. They represent integers and real numbers, respectively. Representations of real numbers include floating-point types, but there are also other types, such as rational ones. 'AbstractFloat` only includes representations of floating`point real numbers. Integer types are further subdivided into Signed (with a sign) and Unsigned (unsigned).

The operator `<: in a general sense, it means "is a subtype" and declares that the type on the right is a direct supertype of the type being declared. It can also be used as a subtype operator in expressions that return `true' if the left operand is a subtype of the right one.

An important purpose of abstract types is to provide default implementations for specific types. Here is a simple example.

First, you should pay attention to the fact that the above argument declarations are equivalent to x::Any and y::Any. When calling this function, for example, myplus(2,5), the dispatcher selects the most specific method named myplus, corresponding to the arguments passed. (For more information about multiple dispatching, see the chapter Methods.)

If a method more specific than the above is not found, Julia creates an internal definition and compiles a method named myplus for two arguments of type Int based on the above universal function. In other words, the following method is implicitly defined and compiled.

Finally, this specific method is called.

Thus, abstract types allow developers to write universal functions that can later be used as default methods for various combinations of specific types. Thanks to multiple dispatching, the programmer can fully control which method is used: the default method or a more specific one.

It is important to note that using a function with arguments of abstract types does not affect performance, because the function is compiled repeatedly for each tuple of arguments of specific types with which it is called. (However, performance problems are possible if the function arguments are containers of abstract types; see the chapter Performance Tips.)

A primitive type is a specific type consisting of ordinary bits. Classical examples of primitive types are integers and floating-point values. Unlike most languages, where only a fixed set of built-in primitive types is available, Julia allows you to define your own such types. In fact, all the standard primitive types are defined in the language itself.

The standard syntactic constructions for declaring a primitive type look like this:

The bits element indicates how many bits are needed to store the type, and the name element defines the name of the new type. You can also declare a primitive type as a subtype of a supertype. If no supertype is specified, then the immediate default supertype is Any'. Thus, the above declaration `Bool means that eight bits are needed to store a boolean value, and its immediate supertype is the type Integer. Currently, only sizes that are multiples of 8 bits are supported, and LLVM errors are likely when using sizes other than those listed above. Therefore, although only one bit is sufficient to represent a boolean value, it cannot be declared to be less than 8 bits in size.

Types Bool, Int8 and 'UInt8` have identical representations in memory: they all occupy 8 bits. However, since the Julia type system is nominative, despite the identical structure, these types are not interchangeable. The fundamental difference between them is that they have different supertypes: Bool direct supertype — Integer, y Int8 — Signed, and y UInt8 — Unsigned. Otherwise, the difference between Bool, Int8 and 'UInt8` boils down to what behavior is defined for functions when passing objects of these types as arguments. That’s why a nominative type system is necessary: if the structure defined the type, and it, in turn, dictated behavior, it would be impossible to implement for Bool different behavior than for Int8 or UInt8.

In different languages https://en.wikipedia.org/wiki/Composite_data_type [composite types] are called in different ways: records, structures, objects. A composite type is a collection of named fields, and you can work with its instance as a single value. In many languages, users can only define composite types, but in Julia, most user-defined types are composite.

In popular object-oriented languages such as C++ In Java, Python, and Ruby, named functions are also associated with composite types: collectively, this is called an object. In cleaner object-oriented languages such as Ruby or Smalltalk, objects are all values, whether composite or not. In less pure object-oriented languages, including C++ and Java, some values, such as integers and floating points, are not objects. True objects are instances of custom composite types with associated methods. In Julia, objects are any values, but functions are not bound to the objects they operate on. This is due to the fact that in Julia, the required function method is selected through multiple dispatching, which means that when choosing a method, the types of all arguments of the function are taken into account, and not just the first one (for more information about methods and dispatching, see the chapter Methods). Therefore, it would be wrong to depend on the function only on the first argument. Organizing methods as function objects instead of named sets of methods within each object turns out to be an extremely useful feature of the language design.

Compound types are declared using a keyword struct, followed by a block of field names with optional type annotations via the :: operator.

Fields without type annotations are of type Any by default and, accordingly, can contain any type of value.

New objects of type Foo are created by applying type `Foo' as a function to field values.

When a type is used as a function, it is called a constructor. Two constructors are created automatically (they are called constructors by default). One of them takes any arguments and calls the function convert to convert them to field types, and the other takes arguments that exactly match the field types. Both of these constructors are created to make it easier to add new definitions without accidentally replacing the default constructor.

Since the type of the bar field is unlimited, any value will do. However, the value of baz must be such that it can be converted to Int.

The list of field names can be obtained using the function fieldnames.

The values of the fields of a composite object can be accessed using the generally accepted notation `foo.bar'.

Composite objects declared using the keyword struct are not change_: they cannot be changed after creation. It may seem strange at first, but this approach has several advantages.

The fields of an immutable object can contain mutable objects, such as arrays. Such nested objects remain mutable: you cannot change only the fields of the immutable object itself so that they point to other objects.

If necessary, you can declare mutable composite objects using a keyword. mutable struct. This will be discussed in the next section.

If all fields of an immutable structure are indistinguishable from each other (===), then two immutable values with such fields are also indistinguishable.

Creating instances of composite types has a number of other important features, however, they relate to parametric types and methods, and therefore it makes sense to put their discussion in a separate chapter.: Constructors.

For many custom X types, you may need to define a method Base.broadcastable(x::X) = Ref(x), so that instances of the type act as 0-dimensional "scalars" for the purposes of broadcasts.

If a composite type is declared using the keyword mutable struct rather than struct, then its instances can be modified.

An additional interface between the fields and the user can provide instance properties. They give you more control over which elements will be available for viewing and changing using the bar.baz notation.

To support modification, such objects are usually placed on the heap and have fixed memory addresses. A mutable object is like a small container that can contain different values throughout its existence and is therefore reliably identified only by its address in memory. On the contrary, an instance of a mutable type is associated with certain field values that fully describe it. When deciding whether a type should be mutable, consider whether two instances with the same field values will be considered identical or whether they may change independently over time. If they are considered identical, most likely, the type should be immutable.

To summarize, immutability in Julia is characterized by two main qualities.

If it is known that only some fields of a mutable structure are immutable, these fields can be declared as such using the keyword const, as shown below. This provides a number of optimizations for immutable structures and allows you to apply invariants to certain fields marked as `const'.

The three categories of types that were discussed in the previous sections (abstract, primitive, and composite) are actually closely related to each other. They all have important properties in common.

Because of these common properties, all these types are represented internally as instances of the DataType — the type to which all these types belong.

The DataType' type can be abstract or concrete. If it is specific, it has a specific size, memory layout, and (optionally) field names. Thus, the primitive type is a non-zero-size `DataType type, but without field names. A composite type is a DataType type with field names or an empty one (zero size).

Each specific value in the system is an instance of some type of `DataType'.

A type union is a special abstract type that includes all instances of all argument types as objects. It is created using a special keyword Union.

Compilers of many languages provide an internal structure for combining, allowing you to define types; in Julia, it is available to programmers. The Julia compiler can generate efficient code when there are Union unions that include a small number of footnote types.:1[The "small number" is determined by the max_union_splitting configuration, which currently has a default value of 4.] To do this, specialized code is generated for each possible type in a separate branch.

A particularly useful application of the Union type is the Union{T, Nothing}, where T can be any type, and Nothing' is a single type, the only instance of which is an object. `nothing. Such a template in Julia is the equivalent of types https://en.wikipedia.org/wiki/Nullable_type [Nullable, Option, or Maybe] in other languages. If you declare a function argument or field as a Union{T, Nothing}, they can be assigned either a value like T or nothing, which means there is no value. For more information, see in this FAQ section.

An important and useful feature of the Julia type system is that it is parametric: types can accept parameters, so when declaring a type, a whole family of new types is introduced, one for each possible combination of parameter values. In many languages, it is supported in one form or another https://en.wikipedia.org/wiki/Generic_programming [universal programming], which allows you to define data structures and algorithms for working with them without specifying the exact types. For example, universal programming is implemented in one way or another in ML, Haskell, Ada, Eiffel, C++, Java, C#, F#, Scala and other languages. Some of these languages (e.g. ML, Haskell, Scala) support true parametric polymorphism, while others (e.g. C++ Java) — special styles of universal programming based on templates. Due to such a variety of approaches to universal programming and parametric types, we will not even try to compare Julia with other languages in this regard. Instead, we will focus on looking at this system in Julia proper. However, we note that many of the difficulties typical of static parametric type systems can be relatively easily overcome, since Julia is a dynamically typed language that does not require defining all types at compile time.

All declared types (varieties of `DataType') can be parameterized using the same syntax. We will consider them in the following order: first, parametric composite types, then parametric abstract types, and finally parametric primitive types.

We have already noted that a parametric type, such as Ptr, acts as a supertype for all its instances (Ptr{Int64}, etc.). How does it work? By itself, the Ptr type cannot be an ordinary data type: it cannot be used for memory operations if the type of the corresponding data is unknown. The explanation is that Ptr (or other parametric types, such as Array) is a special kind of type called UnionAll. This type means an iterable combination of types for all values of a certain parameter.

The types of unionAll' are usually written using the keyword `where'. For example, `Ptr could be more accurately written as Ptr{T} where T, which corresponds to all values of type Ptr{T} for some value of T. In this context, the parameter T' is also often referred to as a type variable, since it acts as a variable whose values can be a specific set of types. Each `where keyword introduces a single type variable, so such expressions can be nested for types with multiple parameters, such as Array{T,N} where N where T.

Syntax for using type A{B,C}`requires `A to be of type unionAll', and first `B is substituted into an external type variable in A. The result should be a different type of unionAll, which is then substituted with C. Thus, A{B,C} equivalent to A{B}{C}. This explains why partial instantiation of a type such as Array' is possible.{Float64}: the value of the first parameter is fixed, but the second one still accepts all possible values. When using the where syntax Any subset of parameters can be explicitly fixed. For example, the type of all one-dimensional arrays can be written as Array{T,1} where T.

Type variables can be limited through subtype relationships. Array{T} where T<:Integer means all arrays with element types that are some subtypes. Integer. For the syntactic construction Array{T} where T<:Integer has a convenient short form of writing: Array{<:Integer}. Variables of types can have lower and upper bounds. Array{T} where Int<:T<:Number means all arrays of elements Number, which can contain Int (the size of T must be at least Int). Using the where T> syntax:Int can also specify only the lower bound of a type variable, and Array'{>:Int}`equivalent to `+Array{T} where T>:Int+.

Since where expressions can be nested, the boundaries of a type variable can relate to external type variables. For example, Tuple{T,Array{S}} where S<:AbstractArray{T} where T<:Real means two-element tuples, the first element of which belongs to a certain subtype Real, and the second element is any array whose elements are of the type of the first element of the tuple.

The where keyword itself can be embedded in more complex ads. For example, consider two types created through the following declarations.

The type T1 defines a one-dimensional array of one-dimensional arrays; each internal array consists of objects of the same type, but these types of objects in the internal arrays may be different. In turn, the type T2 defines a one-dimensional array of one-dimensional arrays in which the objects of all internal arrays belong to the same type. Note that T2 is an abstract type (for example, Array{Array{Int,1},1} <: T2), and T1 is specific. For this reason, an instance of T1 can be created using the constructor without arguments (a=T1()), but an instance of T2 cannot.

There is a convenient syntax for naming such types, similar to the short form of defining functions.

This is equivalent to const Vector = Array{T,1} where T. Record Vector{Float64} is equivalent to Array{Float64,1}, and instances of the general type Vector are all objects of Array, in which the second parameter - the number of dimensions of the array - is equal to 1, regardless of the type of elements. In languages where parametric types must always be specified in full, this is not particularly useful, but in Julia, thanks to this, you can simply write a Vector to define an abstract type that includes all one-dimensional dense arrays with elements of any type.

Immutable composite types without fields are called single types. Formally speaking, if

the T is a single type.^[1] To check whether the type is single, use the function Base.issingletontype. Abstract types cannot be singular by their nature.

By definition, a single type can have only one instance.

Function '=== confirms that the created instances of `NoFields are identical to each other.

Parametric types can be single if the above condition is met. Examples:

Each function has its own type, which is a subtype of `Function'.

Note that the output of the call is `typeof(foo41)`similar to the challenge itself. This is just a convention, since this object is completely independent and can be used as any other value.

The types of functions defined at the top level are single. If necessary, they can be compared using the operator ===.

At closures also have their own types, whose names are usually output with #<number> at the end. Functions defined in different places have unique names and types, and the output may vary from session to session.

Closure types are not necessarily single.

For each type T Type{T} is an abstract parametric type, the only instance of which is the object T. They haven’t been reviewed yet parametric methods and transformations, the purpose of this construction is difficult to explain, but, in short, it allows you to specialize the behavior of a function for certain types as _values. This is useful for writing methods (especially parametric ones) whose behavior depends on the type passed explicitly as an argument, rather than being derived from the type of one of the arguments.

Since this definition can be a bit difficult to understand, let’s look at some examples.

In other words, isa(A, Type{B}) is true if and only if A and B are the same object and this object is a type.

In particular, since parametric types invariant:

Without the 'Type` parameter, it is just an abstract type, of which all objects of types are instances.

Any object other than a type is not an instance of Type.

Although Type is part of the Julia type hierarchy, like any other abstract parametric type, it is usually not used outside of method signatures, except in a number of special cases. Another important use of Type is to specify field types that would otherwise be less accurate, for example DataType in the example below. In this case, the default constructor could lead to performance problems for code that uses the exact type enclosed in the shell (similarly parameters of abstract types).

Sometimes it is convenient to enter a new name for an already expressible type. This can be done using a simple assignment operator. For example, an alias for UInt can be UInt32 or UInt64 depending on the size of the pointers in the system.

For this purpose, in base/boot.jl uses the following code.

Of course, it depends on which type of Int the alias is created for, but it must be the correct type: either Int32, or Int64.

(Note that, unlike Int, Float is not an alias for the type. AbstractFloat of a certain size. Unlike integer registers, where the size of an Int corresponds to the size of a machine pointer in the system, the sizes of floating-point registers are defined in the IEEE-754 standard.)

Type aliases can be parameterized:

Since types in Julia are objects themselves, ordinary functions can operate on them. You have already familiarized yourself with some functions designed to work with types or analyze them. These include the operator <:, indicating that the left operand is a subtype of the right one.

Function 'isa` checks whether an object belongs to a certain type and returns true or false.

Function typeof, which has already been used in the examples in this guide, returns the type of its argument. Since, as mentioned earlier, types are objects, they themselves have types and can be recognized.

But what if we repeat this operation? What type does the type type belong to? It turns out that all types are composite values and thus have the type `DataType'.

The `DataType' is a type for itself.

Another operation applicable to some types is supertype. It defines the type’s supertype. Only declared types (DataType) have uniquely defined supertypes.

When applying the function supertype an exception is raised for other objects of types (or for objects that are not types). MethodError.

Sometimes you need to configure the display of type instances. To do this, overload the function show. For example, let’s assume that we have defined a type for representing complex numbers in polar form.

Here we have added a custom constructor function that can accept arguments of different types. Real and promote them to a general type (see chapters Constructors and Transformation and promotion). (Of course, we would also have to define many other methods so that the type could be used as Number, for example +, *, ` one`, zero, promotion rules, etc.) By default, instances of this type are displayed quite simply: the type name and field values are displayed, for example Polar{Float64}(3.0,4.0).

If we wanted information to be output as 3.0 * exp(4.0im) instead, we would define the following method to output information to the specified output object `io' (representing a file, terminal, buffer, etc.; see the section Network and Streaming).

More detailed control over the display of Polar objects is also possible. In particular, sometimes you need both a detailed multi-line format for displaying information about a single object in REPL and other interactive environments, and a shorter one-line format for a function. print or to display an object as part of another object (for example, an array). Although the show(io, z) function is called by default in both cases, you can define another multiline format for displaying an object using an overload of the show function with three arguments, where the second argument is the MIME type `text/plain' (see section Multimedia data input/output).

(Note that by using print(..., z), the show(io, z) method is called here with two arguments.) The result will be as follows:

Here, the one-line option show(io, z) is still used for the array of Polar values. Strictly speaking, the REPL environment calls display(z) to display the result of string execution, which by default corresponds to the call show(stdout, MIME("text/plain"), z), and it, in turn, corresponds to the call show(stdout, z)'. However, you should not define new methods. `display, unless you define a new handler for displaying multimedia data (see section Multimedia data input/output).

Moreover, you can also define show methods for other MIME types to ensure that information about objects with more complex formatting (HTML markup, images, etc.) is displayed in environments that support this feature (for example, IJulia). For example, you can define the display of information about Polar objects in HTML format with superscripts and italics as follows:

As a result, in environments that support HTML, information about the Polar object will be automatically displayed using HTML, however, if desired, you can manually call the show function to get the output data in HTML format.

An HTML renderer would display this as: Polar{Float64} complex number: 3.0 e^4.0 i^

As a general rule, the one-line show' method should output a valid Julia expression to create the displayed object. If this `show method contains infix operators, for example the multiplication operator (*) in the one-line show method for the Polar type above, it may be incorrectly analyzed when output as part of another object. To illustrate this, let’s take an expression object (see section Program Representation), which squares a specific instance of the type `Polar'.

Since the operator ^ takes precedence over * ( See the section Operator precedence and associativity), this output incorrectly represents the expression a^2, which should correspond to the expression (3.0*exp(4.0im)) ^ 2. To solve this problem, you need to create a custom method for Base.show_unquoted(io::IO, z::Polar, indent::Int, precedence::Int), which will be automatically called by the expression object when information is output.

The method defined above encloses the show call in parentheses when the priority of the calling operator is higher than or equal to the multiplication priority. This check allows you to omit parentheses when outputting an expression that is correctly parsed without them (for example, :($a + 2) and :($a == 2)).

In some cases, it may be useful to customize the behavior of the show methods depending on the context. To do this, you can use the type 'IOContext`, which allows passing contextual properties along with the wrapped I/O stream. For example, the show' method can produce a more concise representation when the `:compact property has the value true, or a complete representation when this property has the value false or is not set.

This new short representation will be used when the input/output stream being transmitted is an IOContext object with the specified :compact property. In particular, this will happen when outputting arrays with multiple columns (when the width is limited).

In the documentation for 'IOContext` provides a list of frequently used properties that can be applied to customize the output.

In Julia, dispatching by _value, such as true or false, is not possible. However, parametric type dispatching is possible, and Julia allows you to include simple bit values (types, characters, integers, floating-point numbers, tuples, etc.) as type parameters. A common example is the dimension parameter in an Array{T,N}, where T is the type (for example, Float64), but N is just an `Int'.

You can create your own custom types that take values as parameters and use them to manage the dispatching of custom types. To illustrate this concept, we introduce the parametric type Val{x} and its constructor Val(x) = Val{x}(), which allows you to use this technique in cases where a more developed hierarchy is not required.

Val is defined as follows:

The implementation of Val is limited to this. Some functions in the Julia standard library accept instances of Val as arguments, and you can use this type to write your own functions. For example:

For consistency purposes, in Julia, the example Val should always be passed at the call location, not the type, that is, foo(Val(:bar)) should be used, not foo(Val{:bar}).

It is worth noting that parametric value types, including Val, are very easy to use incorrectly and, in the worst case, code performance can significantly decrease. In particular, you should never write code as shown above. For more information about appropriate (and inappropriate) applications of Val, see performance tips.